BQ32002: BQ32002 time update not happening

Rizwan syed

Part Number: BQ32002

Am working on BQ32002 rtc module.

Am just writing some values to hour , min and sec .

Then when i try to read the values , values are not getting updated. Whatever i have written same values are being displayed.

What is the issue please suggest.

over 8 years ago

0 Patrick Kammermayer over 8 years ago

TI__Expert 5325 points

Hello Rizwan,
can you please share more information about your setup?
Are you using a TI design which integrates this part?
Do you see the device is consuming enough current?
Which microcontroller are you using?
What are the pull-ups to the supply rail?
Does the device repeatedly ACK your reads and writes?

Thanks!

Best regards,
Patrick

0 Rizwan syed over 8 years ago in reply to Patrick Kammermayer

Prodigy 30 points

Hi Patrick,

Am using Renesas synergy S7G2 Micro controller development kit.

We are using 4.7K pull up to 3.3 V .

We have not checked the ACK but I2C read write is happening.whatever i write , same values are displayed on terminal always.

I have attached my c file in which am currently working.

Thanks and Regards

Rizwan Syed

Fullscreen rtc.c Download

#include "rtc_thread.h"
#include "r_i2c_api.h"
#include "r_rtc_api.h"
#include <stdio.h>
#define SEMI_HOSTING
#define BQ32000__CAL_S          0x05
#ifdef SEMI_HOSTING
    #ifdef __GNUC__
    extern void initialise_monitor_handles(void);
    #endif
#endif
    void periodicIrqRate( );
#define BQ32000_CAL_CFG1        0x07
#define BQ32K_TCH2              0x08    /* Trickle charge enable */
#define BQ32K_CFG2              0x09    /* Trickle charger control */



#define BQ32K_SECONDS       0x00    /* Seconds register address */
#define BQ32K_SECONDS_MASK  0x7F    /* Mask over seconds value */
#define BQ32K_STOP      0x80    /* Oscillator Stop flat */

#define BQ32K_MINUTES       0x01    /* Minutes register address */
#define BQ32K_MINUTES_MASK  0x7F    /* Mask over minutes value */
#define BQ32K_OF        0x80    /* Oscillator Failure flag */

#define BQ32K_HOURS_MASK    0x3F    /* Mask over hours value */
#define BQ32K_CENT      0x40    /* Century flag */
#define BQ32K_CENT_EN       0x80    /* Century flag enable bit */

static const unsigned char rtc_days_in_month[] = {
    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};

static inline bool is_leap_year(unsigned int year)
{
    return (!(year % 4) && (year % 100)) || !(year % 400);
}

#if 0
#define BQ32K_CENT_HOURS       0x02    /* CENT_HOURS register address */
#define BQ32K_DAY              0x03    /* DAY register address */
#define BQ32K_DATE             0x04    /* DATE register address */
#define BQ32K_MONTH            0x05    /* MONTH register address */
#define BQ32K_YEARS            0x06    /* YEARS register address */
#define BQ32K_CAL_CFG1         0x07    /* CENT_HOURS register address */
#define BQ32K_CFG2             0x08    /* CENT_HOURS register address */
#endif
struct bq32k_regs {
    uint8_t     seconds;
    uint8_t     minutes;
    uint8_t     cent_hours;
    uint8_t     day;
    uint8_t     date;
    uint8_t     month;
    uint8_t     years;
};

const i2c_master_instance_t g_i2c2;
void bq32kinitialize();
int bq32kRead(uint8_t reg, void *buf, uint8_t count );
int bq32kWrite(void *data, uint8_t off, uint8_t len);
int bq32kinit();
unsigned bcd2bin(unsigned char val);
unsigned char bin2bcd(unsigned val);
int rtc_valid_tm(struct tm *tm);
int rtc_month_days(unsigned int month, unsigned int year);
static int bq32k_rtc_set_time(struct tm *tm1);
static int bq32k_rtc_set_time(struct tm *tm1);
bool setIRQLevel(bool level);
bool setCalibration(int8_t value);

int bq32kRead(uint8_t reg, void *buf, uint8_t count )
{

  R_BSP_SoftwareDelay(100,BSP_DELAY_UNITS_MICROSECONDS);
  g_i2c2.p_api->write(g_i2c2.p_ctrl, &reg, 1 , true);

  R_BSP_SoftwareDelay(100,BSP_DELAY_UNITS_MICROSECONDS);
  g_i2c2.p_api->read(g_i2c2.p_ctrl, buf, count , false);
  return 0;




}

int bq32kWrite(void *data, uint8_t off, uint8_t len)
{
    uint8_t buffer[len + 1];

        buffer[0] = off;
        memcpy(&buffer[1], data, len);
    R_BSP_SoftwareDelay(100,BSP_DELAY_UNITS_MICROSECONDS);
  g_i2c2.p_api->write(g_i2c2.p_ctrl, buffer, (uint32_t)len+1 , false);
   return 0;

}

int bq32kinit()
{
    int error;
    uint8_t reg=0;
    unsigned char regbat;

#ifdef SEMI_HOSTING
#ifdef __GNUC__
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        initialise_monitor_handles();
    }
#endif
#endif

    error = bq32kRead(BQ32K_SECONDS,&reg, 1);

#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        printf("reg: %d\t\t\r\n", reg);
        printf("\r\nCalendar Set_time\r\n");
        printf("error: %d\t\t\r\n", error);
    }
#endif

    /* Check Oscillator Stop flag */



    if (!error && (reg & BQ32K_STOP))
    {
        /*Oscillator was halted. Restarting...*/
            reg &= (uint8_t)~BQ32K_STOP;

            error = bq32kWrite(&reg, BQ32K_SECONDS, 1);
    }
    if (error)
            return error;
#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        printf("reg: %d\t\t\r\n", reg);
        printf("error: %d\t\t\r\n", error);
    }
#endif


    /* Check Oscillator Failure flag */
    error = bq32kRead(BQ32K_MINUTES,&reg, 1);
    if (!error && (reg & BQ32K_OF))
    {
        /*Oscillator Failure. Check RTC battery*/
        reg &= (uint8_t)~BQ32K_OF;
        error = bq32kWrite(&reg, BQ32K_MINUTES, 1);
    }
        if (error)
                return error;
#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        printf("error: %d\t\t\r\n", error);
    }
#endif


   /* regbat = 0x45; //This enables charging without the diode - we don't need no stinkin' diodes!
    error = bq32kWrite(&regbat, BQ32K_CFG2, 1);
    if (error)
            return error;
    regbat = 0x20;
    error = bq32kWrite(&regbat, BQ32K_TCH2, 1);
    if (error)
            return error;*/

        return 0;

}

unsigned bcd2bin(unsigned char val)
{
    return (unsigned int)((val & 0x0f) + (val >> 4) * 10);
}

int rtc_month_days(unsigned int month, unsigned int year)
{
    return rtc_days_in_month[month] + (is_leap_year(year) && month == 1);
}
int rtc_valid_tm(struct tm *tm)
{
    if (tm->tm_year < 70
        || ((unsigned)tm->tm_mon) >= 12
        || tm->tm_mday < 1
        || tm->tm_mday > rtc_month_days((unsigned int)tm->tm_mon, (unsigned int)tm->tm_year + 1900)
        || ((unsigned)tm->tm_hour) >= 24
        || ((unsigned)tm->tm_min) >= 60
        || ((unsigned)tm->tm_sec) >= 60)
        return -1;

    return 0;
}

static int bq32k_rtc_read_time(struct tm *tm1)
{

    int error;
    //rtc_time_t  read_time;
    struct bq32k_regs regs;

    error = (int) bq32kRead( &regs, 0 , sizeof(regs));
    if (error)
        return error;

    tm1->tm_sec  =  (int) bcd2bin(regs.seconds & BQ32K_SECONDS_MASK);
    tm1->tm_min  =  (int) bcd2bin(regs.minutes & BQ32K_MINUTES_MASK);
    tm1->tm_hour =  (int) bcd2bin(regs.cent_hours & BQ32K_HOURS_MASK);
    tm1->tm_mday =  (int) bcd2bin(regs.date);
    tm1->tm_wday =  (int) bcd2bin(regs.day) - 1;
    tm1->tm_mon  =  (int) bcd2bin(regs.month) - 1;
#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        printf("\r\nREad rtime\r\n");
        printf("Hour: %x\tMin: %x\tSec: %x\t\r\n", tm1->tm_hour, tm1->tm_min, tm1->tm_sec);
    }
#endif


    tm1->tm_year =  (int) bcd2bin(regs.years) +
                ((regs.cent_hours & BQ32K_CENT) ? 100 : 0);


    return rtc_valid_tm(tm1);
}

unsigned char bin2bcd(unsigned val)
{
    return ((val / 10) << 4) + val % 10;
}

static int bq32k_rtc_set_time(struct tm *tm1)
{

    struct bq32k_regs regs;

    regs.seconds = bin2bcd((unsigned int)tm1->tm_sec);
        regs.minutes = bin2bcd((unsigned int)tm1->tm_min);
        regs.cent_hours = bin2bcd((unsigned int)tm1->tm_hour) | BQ32K_CENT_EN;
        regs.day = bin2bcd((unsigned int)tm1->tm_wday + 1);
        regs.date = bin2bcd((unsigned int)tm1->tm_mday);
        regs.month = bin2bcd((unsigned int)tm1->tm_mon + 1);

    if ((unsigned int)tm1->tm_year >= 100) {
        regs.cent_hours |= BQ32K_CENT;
        regs.years = bin2bcd((unsigned int)tm1->tm_year - 100);
    } else
        regs.years = bin2bcd((unsigned int)tm1->tm_year);

#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        printf("\r\nwrite_time\r\n");
        printf("Hour: %x\tMin: %x\tSec: %x\t\r\n", regs.cent_hours, regs.minutes, regs.seconds);
        //R_BSP_SoftwareDelay(10,BSP_DELAY_UNITS_SECONDS);
        printf("hour1: %x\tMin1: %x\sec1: %x\t\r\n", tm1->tm_hour, tm1->tm_min,tm1->tm_sec);
    }
#endif

    return bq32kWrite( &regs, 0, sizeof(regs));
}

void bq32kinitialize()
{
    struct tm tm12={0};
    struct tm *tm1;
    tm1 = &tm12;
    struct tm tm123={0};
    struct tm *tm2;
    tm2 = &tm123;

    tm1->tm_hour =0x5;
    tm1->tm_min =0x8;
    tm1->tm_sec=0x16;
    int error1=0;
    uint8_t reg=0;
    g_i2c2.p_api->open(g_i2c2.p_ctrl, g_i2c2.p_cfg);
    R_BSP_SoftwareDelay(100,BSP_DELAY_UNITS_MILLISECONDS);
    g_i2c2.p_api->reset(g_i2c2.p_ctrl);
    R_BSP_SoftwareDelay(100,BSP_DELAY_UNITS_MILLISECONDS);



    bq32kinit();


#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        printf("\r\n  reg error1 =%d\r\n",reg);

    }
#endif

    bq32k_rtc_read_time(tm2);
    tm123.tm_sec = 0;
    tm123.tm_min = 0;
    tm123.tm_hour = 0;
    tm123.tm_mday = 0;
    tm123.tm_mon = 0;
    tm123.tm_year = 0;
    tm123.tm_wday = 0;
    tm123.tm_yday = 0;
    tm123.tm_isdst = 0;

    bq32k_rtc_set_time(tm1);
    tm123.tm_sec = 0;
    tm123.tm_min = 0;
    tm123.tm_hour = 0;
    tm123.tm_mday = 0;
    tm123.tm_mon = 0;
    tm123.tm_year = 0;
    tm123.tm_wday = 0;
    tm123.tm_yday = 0;
    tm123.tm_isdst = 0;



    while (1)
        {
        tm123.tm_sec = 0;
        tm123.tm_min = 0;
        tm123.tm_hour = 0;
        tm123.tm_mday = 0;
        tm123.tm_mon = 0;
        tm123.tm_year = 0;
        tm123.tm_wday = 0;
        tm123.tm_yday = 0;
        tm123.tm_isdst = 0;

        bq32k_rtc_read_time(tm2);

        }


}

/* rtc Thread entry function */
void rtc_thread_entry(void)
{
    /* TODO: add your own code here */

    bq32kinitialize();
    while (1)
    {
        tx_thread_sleep (1);
    }
}

0 Lane Boyd over 8 years ago in reply to Rizwan syed

TI__Genius 16845 points

Hi Rizwan,

Are you operating from VCC or Vback? If you are operating from the backup supply then I2C communication will be halted until VCC returns. See datasheet section 8.2.2.1 for more information (Condition 2).

Kind regards,
Lane

Clock & timing

Clock & timing forum

BQ32002: BQ32002 time update not happening