BQ34210-Q1: Learning Phase failed

Vinay K L

Part Number: BQ34210-Q1
Other Parts Discussed in Thread: BQSTUDIO, , EV2400

Tool/software:

Hello Team,

I have Started Learning cycle

But when I read the EOSLearnStatus() register continuously in loop I was able to see that LUCD and LFAULT flags are being raised.

I have a battery of 10000mAh capacity

And Charging current is 2000mA

And Charging voltage is set to 4.2V

And Charge Detection threshold set for 500 and discharge detection threshold set for 200mA

Learn Discharge Current Set to 512mA and Learn Discharge Current Boundary set to 50%

We have charged the battery to full and we tried Discharge-Before-Charge learning method

Kindly let me know why LUCD and LFAULT flags are being asserted.

Thank you

1 month ago

0 Adrian 1 month ago

TI__Mastermind 23426 points

Hello Vinay,

Can you share with us a log file of you attempting the learning phase?

Regards,

Nick

0 Vinay K L 1 month ago in reply to Adrian

Prodigy 50 points

Hello Nick,

We are controlling the fuel gauge from TI MCU. We are not using BQStudio. Sorry I cant generate log file for that!

Thank you

0 Vinay K L 1 month ago in reply to Vinay K L

Prodigy 50 points

Hello Nick,

Why LAPAI and LAPAT and LAPAM flags whenever it enters LDSG.

I am still not understanding the scenario. I have checked Current() and Temperature() those values looks fine.

Still why I am getting these flags.

Kindly let me know my mistake

I am adding my battery specification document with this response

Thank you2.1091 A&S Power Li-ion 21700 3.6V 10000mAh (126-1.1)中英文版-(PCM+10kNTC+100kNTC+ID+引线) 240513 2 (1).pdf

0 Adrian 1 month ago in reply to Vinay K L

TI__Mastermind 23426 points

Hello Vinay,

We will need to see a log file to been able to point you in the right direction of why those flags are being raised. Is it possible to do periodic register dumps from your TI MCU?

Regards,

Nick Richards

0 Vinay K L 1 month ago in reply to Adrian

Prodigy 50 points

Hello Nick,

Sorry to Say that we dont have EV2300 programmer to use BQStudio. So building log file and srec file we need the configurator. So from the compiler it is hard to do periodic register dumps.

Kindly need your help

Thank you

0 Diego 1 month ago in reply to Vinay K L

TI__Genius 16145 points

Hi,

It is not possible for us to explain why certain flags are setting and not setting, without a log file of what the gauge is reporting.

We will need a log file to help you further debug.

Regards,

Diego

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hello Diego,

Thats fine because its hard to tell without any gauge log files. But without EV2300 its impossible to generate log file for BQ34210-q1. I just wanted to know one thing. Begore going to the EOS modes, whether the current thresholds are currectly configured or not.

So we are trying DISCHARGE-BEFORE-CHARGE learning phase but for the below configuration will it be possible to complete learning cycle?

Design Capacity - 10000mAh

Charging Voltage - 4.2V

Discharge Detecion Threshold - 260mA

Charge Detection Threshold - 500mA

Quit current - 180mA

Learn Discharge Current - 500mA

Learn Discharge Current Boundery - 50%

Kindly let me know if these configurations will work?

Thank you

0 Vinay K L 1 month ago in reply to Vinay K L

Prodigy 50 points

This is my battery Specification

Thabk you

0 Diego 1 month ago in reply to Vinay K L

TI__Genius 16145 points

Hi,

You can use any mcu to read reported parameters from the gauge, log these parameters and an elapsed time to create a useable log file.

Thanks for the battery specs, your configuration appears correct.

Regards,

Diego

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hello Diego,

Thanks for the response

I am using TM4C MCU and I am able to write the configuration with the required value to the memory. Like I have changed Design Capacity and other values too as mentioned in previous chat.

My problem here is that I am able to Start the learning phase and it is moving to Pre Relax phase. and even REST bit is asserted. Actually it takes more than 13 minutes to completely relax. But after relaxation it is not entering Learn Discharge Phase. I have waited for more than 1 hour. There is no error shown EOSLearnStatus Register. But it still be there in LRLX mode.

Kindly let me know why it is not entering Learn Discharge Phase?

Regards,

Vinay

0 Diego 1 month ago in reply to Vinay K L

TI__Genius 16145 points

Hi Vinay,

The learning discharge current value is set by external components and is not directly controlled by the bq34210-Q1 device. However, this current is monitored throughout the Learn Discharge Phase and evaluated to ensure it is close to the intended value.

Once the device detects a discharge the flags should flip.

Regards,

Diego

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hello Diego,

Learning Discharge Current is set by external components but we have to configure Learn Discharge Current right?

My question is that from LRLX (Learning Relaxation) to LDSG ( Learning Discharge) is not flipping. After waiting 1 hour also the state is not changed. Even {REST] bit been raised. But Discharge nit started.

Kindly let me know why it is not flipping.

Thank you

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hello Diego,

Kindly let me know when I have to turn on the load.? In which phase. After reaching relaxation or after reaching Discharge phase?

And should I need to change the value of Learn Discharge Current values in memory parameters?

And how much I have to set for Discharge detection threshold? Because of this only I am not entering the LSDG phase, as of my understanding

I have set Discharge detection threshold to 200mA but current will never reach 200mA until I turn on load.

Thank you

0 Diego 1 month ago in reply to Vinay K L

TI__Genius 16145 points

Hi,

I cannot tell you why flags are or are not setting without a log file, I need to understand what values the gauge is reporting.

Please apply the load and discharge the battery.

Regards,

Diego

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hi Diego,

My question was "In which phase I have to turn on the load".

Like there are 4 phases

1. Learn Charge Phase.

2. Learn Pre Relax Phase.

3. Learn Discharge Phase.

4. Learn Post Relax Phase

Kindly let me know when I have to turn on the load?

Thank you

0 Vinay K L 1 month ago in reply to Vinay K L

Prodigy 50 points

Hi Diego,

The current fluctuates from Discharge State to Charge State. I am reading Current() value continuously. But after few seconds some random value will be read like 0x1010 (4112mA) this is completely wrong. I believe because of this current changes it is not entering in any other phases.

Kindly let me know is it common to read Current() readings like this?

Thank you

0 Diego 1 month ago in reply to Vinay K L

TI__Genius 16145 points

Hi,

Learn Discharge Phase

Is your communication stable?

Has there been any other errors when reporting current?

Is this current spike seen on your system?

Regards,

Diego

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hi Diego,

Curren() and Design Capacity() values both are flipping. The same value will be updated in both the readings 4112. Thats weird because Design Capacity() value once changed it should not change whenever we read that register it should be the same right? But I am observing 1/5 times, the 4112 value will be updated. Why could be these readings going wrong.

Will you please let me know how much should be the external load for 10000 mAh battery and waiting to be discharged at the rate of 500mA.

Thank you

0 Diego 1 month ago in reply to Vinay K L

TI__Genius 16145 points

Hi,

The Design Capacity value should not change, this parameter is set by the user. There may be an issue with how you are reading from the device or you could be reading the wrong register.

C/4 discharge rate should be ok.

Regards,

Diego

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hello Diego,

No I am very much sure that I am reading the correct register in correct way.

Because the values what I am reading for Design Capacity and Current() is correct. And what exactly it should read also I am able to read. I am reading it by polling method. So after 5-6 iterations there will be an error in the reading. Its the same value I am getting for both Design Capacity and Current() as 4112. Both Current() and Design Capacity values will be changed to 4112.

Lets assume I am reading the Current() and Design Capacity values in wrong way. But when Current() value changed to 4112 I will get LABRT flag been raise in EOSLearnStatus()

The operation being aborted by Something

Please let me know why this errors are occuring.

Thank you

0 Adrian 1 month ago in reply to Vinay K L

TI__Mastermind 23426 points

Hello Vinay,

Can you please attempt the learning cycle and log data throughout the process. Log all the registers on the gauge when you do this? Once we can see how registers are changing throughout the learning cycle process we will be able to determine why the flag keeps getting set.

Regards,

Adrian

0 Vinay K L 1 month ago in reply to Adrian

Prodigy 50 points

Hello Adrian,

Sorry to say that we dont have EV2300 or EV2400. So it will be not possible to log the learning cycle.

Kindly provide any other solution if possible.

Thank you

0 Vinay K L 1 month ago in reply to Vinay K L

Prodigy 50 points

Hello Team,

My fuel gauge will be reading the Design Capacity() and Current() values as expected. But in between some errors will be read I dont know why exactly.

We probed the Sense resistors (SRN,SRP) and also current spike cannot be seen on Oscilloscope. But can be seen in Software.

I am reading the Current() and DesignCapacity() registers every 1 seconds. But still we are observing the errors being read.

1st image normal reading

2nd Image Errors being read

This error is random.

Kindly let me know what is causing this error being read. Because we cant see any spike in hardware which we are probing using Oscilloscope when it reaches 4112 reading.

Thank you

0 Diego 1 month ago in reply to Vinay K L

TI__Genius 16145 points

Hi,

Could be related to noise in your system.

Are you seeing this issue on the EVM as well?

Regards,

Diego

0 Vinay K L 1 month ago in reply to Diego

Prodigy 50 points

Hello Diego,

Sorry to say that we don't have EVM with us.

Recreating this issue with EVM is not possible.

Noise should be visible in Oscilloscope as well, right?

But we cant see any difference in the Oscilloscope readings.

This readings are directly read from Fuel gauge registers.

There is no dependency or configurations for Read only registers right?

Whatever value it is reading it should reflect.

But my question is what exactly causing this issue.

Noise means it should read other values also not only 4112. But the error value 4112 will only be read randomly.

The readings will either be correct or 4112. No other noise value can be read

This is making me think more now. How come the same error readings can be seen in two different registers.

My other question is, we are setting Design Capacity value to 10000mAh in the beginning.

But how come the error reading 4112 can be read at random intervals in Design Capacity() register readings.

If you are reading Current() and Design Capacity() every one second, 2 out of 10 times it would read the value 4112 either in Current() or in Design Capacity() but other 8 times it will be normal like Current() be at -128mA and Design Capacity() be 10000mAh.

Please let me know if I am missing anything

Thank you

0 Adrian 1 month ago in reply to Vinay K L

TI__Mastermind 23426 points

Hello Vinay,

Can you send the code you are using for the TI MCU to do these read instructions.

Regards,

Adrian

0 Vinay K L 1 month ago in reply to Adrian

Prodigy 50 points

Hi Adrian,

Where can I share the code I am using for TI MCU.?

Is there any link or I have to share my files directly here?

Thank you

0 Adrian 1 month ago in reply to Vinay K L

TI__Mastermind 23426 points

Hello Vinay,

You can share the file directly on the forum.

Regards,

Adrian

0 Vinay K L 1 month ago in reply to Adrian

Prodigy 50 points

fuel_guage.c

 /*
 * fuel_guage.c
 *
 *  Created on: 13-Mar-2024
 *      Author: 10368
 */



#include <stdint.h>
#include <stdbool.h>
#include "BSP/pinmux.h"
#include "inc/hw_types.h"
#include "inc/hw_memmap.h"
#include "inc/hw_gpio.h"
#include "driverlib/sysctl.h"
#include "driverlib/pin_map.h"
#include "driverlib/rom_map.h"
#include "driverlib/gpio.h"
#include "driverlib/i2c.h"
#include "BSP/bsp.h"
#include "I2c_Drv/drvi2c.h"
#include "inc/tm4c1230h6pm.h"
#include "driverlib/rom.h"
#include "driverlib/debug.h"
#include "fuel_guage.h"


//#define CHARGE      1
#define DISCHARGE   1


#define DELAY_FUEL_GAUGE    660
#define FUEL_GAUGE_INIT_DELAY   500000
#define FUEL_READ_DELAY  6000

#define OPRTN_CONFG_A_REG       0x9263
#define OPRTN_CONFG_A_VAL       0x7B84
#define CHRG_RLX_TM_REG         0x928C
#define CHRG_RLX_TM_VAL         0x0001
#define DSG_RLX_TM_REG          0x928A
#define DSG_RLX_TM_VAL          0x0001
#define DESIGN_VOLT_REG         0x934D
#define DESIGN_VOLT_VAL         0x1068
#define CHRG_DTCN_THRSHLD_REG   0x9286
#define CHRG_DTCN_THRSHLD_VAL   0x0064
#define DSG_DTCN_THRSHLD_REG    0x9284
#define DSGG_DTCN_THRSHLD_VAL   0x0064
#define LRN_DSCHRGE_CRNT_REG    0x9317
#define LRN_DSCHRGE_CRNT_VAL    0x0208
#define LRN_DSCHRGE_BRD_REG     0x9319
//#define LRN_DSCHRGE_BRD_VAL     0x0032
#define EOS_CONFIGURATION_REG   0x930A
//#define EOS_CONFIGURATION_VAL   0x0200
#define GAUGING_CONF_REG        0x9347
#define GAUGING_CONF_VAL        0x0108
#define NEAR_FULL_REG           0x92D8
#define NEAR_FULL_VAL           0x26AC
#define QUIT_CUR_REG            0x9288
#define QUIT_CUR_VAL            0x0050
#define QUIT_RLX_TM_REG         0x928D
#define QUIT_RLX_TM_VAL         0x0100
#define OVRLD_CRNT_REG          0x92D1
#define OVRLD_CRNT_VAL          0x0200
#define NOMINAL_VOL             0x0E10
#define TAPER_CURRENT_REG       0x924F
#define TAPER_CURRENT_VAL       0x0166
#define TAPER_RATE              ((uint32_t) (DES_VALUE / (0.1 * TAPER_CURRENT)))
#define AUTO_LEARN_TIME_REG     0x930B
#define AUTO_LEARN_TIME_VAL     0x0001
#define LRN_MIN_TEMP_REG        0x9313
//#define LRN_MIN_TEMP_VAL        0x0064
#define LRN_MAX_TEMP_REG        0x9320
#define LRN_MAX_TEMP_VAL        0x0190
#define SET_VOL_THRSHLD_REG_FD  0x92F0
#define SET_VOL_THRSHLD_VAL_FD  0x0A28
#define CLR_VOL_THRSHLD_REG_FD  0x92F2
#define CLR_VOL_THRSHLD_VAL_FD  (SET_VOL_THRSHLD_VAL_FD + 100)
#define SET_VOL_THRSHLD_REG_FC  0x92F6
#define SET_VOL_THRSHLD_VAL_FC  0x1068
#define CLR_VOL_THRSHLD_REG_FC  0x92F8
#define CLR_VOL_THRSHLD_VAL_FC  (SET_VOL_THRSHLD_VAL_FC + 100)
#define SET_VOL_THRSHLD_REG_TD  0x92FC
#define SET_VOL_THRSHLD_VAL_TD  (SET_VOL_THRSHLD_VAL_FD + 1)
#define CLR_VOL_THRSHLD_REG_TD  0x92FE
#define CLR_VOL_THRSHLD_VAL_TD  (CLR_VOL_THRSHLD_VAL_FD + 1)
#define SET_VOL_THRSHLD_REG_TC  0x9302
#define SET_VOL_THRSHLD_VAL_TC  (SET_VOL_THRSHLD_VAL_FC)
#define CLR_VOL_THRSHLD_REG_TC  0x9304
#define CLR_VOL_THRSHLD_VAL_TC  (CLR_VOL_THRSHLD_VAL_FC)

uint32_t Auto_Learn_Time = 0;

EOSLEARNMODE mode = NONE;
uint8_t EOSCmplt = 0;

FUEL_GAUGE_STR fuelGauge;


uint8_t CONTROL_STATUS[2] = {0x00,0x01};
uint8_t DEV_NUM[2]= {0x01,0x00};
uint8_t FW_VRN[2] = {0x02,0x00};
uint8_t BAT_STATUS[2] = {0x0A,0x0B};
uint8_t VOLT_STATUS[2] = {0x08,0x09};
uint8_t Read_addr1[2] = {0x3E,0x3F};
uint8_t Read_addr2[2] = {0x40,0x41};
uint8_t SS_BAT_CAP[2] = {0x27,0x10};
uint8_t SS_DES_CAP[2] = {0x27,0x10};
uint8_t FULL_CHRG_CPCTY[2] = {0x93,0x47};
uint8_t DESIGN_CPCTY[2] = {0x93,0x49};

uint16_t LRN_DSCHRGE_BRD_VAL =  0x0032;
//uint16_t LRN_MIN_TEMP_VAL = 0x0064;
//uint16_t LRN_MAX_TEMP_VAL = 0x0190;
uint16_t EOS_CONFIGURATION_VAL = 0x0000;


uint16_t DESIGN_CPCTY_1 = 0x9349;
uint16_t DES_VALUE  = 0x2710;


STAT_BAT battery_state =
        {
         .BLTChargeSet = 0,
         .BLTDischargeSet = 0,
         .BLTSOH = 0,
         .BLTTemp = 0,
         .Bat_Current = 0,
         .Bat_Design_Capacity = 0,
         .Bat_Full_Charge_Capacity = 0,
         .Bat_Remaining_Capacity = 0,
         .Bat_Voltage = 0,
         .ChargingVoltage = 0,
         .Bat_average_Current = 0,
         .RelativeStateOfCharge = 0,
         .DevIDTrue = false
        };


void bq34210_fuel_init(void);

void fuel_gauge_manager(void)
{
    switch(fuel_mode.fuel_state)
    {
        case FUEL_NONE:
            fuel_mode.fuel_state = FUEL_INIT;
            battery_state.DevIDTrue = false;
            break;
        case FUEL_INIT:
            bq34210_fuel_init();
            fuel_mode.fuel_state = FUEL_READ;
            break;
        case FUEL_READ:
            fuelGauge_Start();
            break;
        case FUEL_WRITE:
            break;
        default:
            fuel_mode.fuel_state = FUEL_NONE;
    }
}

uint8_t bq34210_fuel_gauge_write(uint8_t regAdr,uint16_t regData,uint32_t base,uint8_t NoBytes)
{
    _I2C_Handle fuel_gauge;
    uint8_t uiBuffer[10];
    uint8_t Result = 0;

    uiBuffer[0] = regData;

    fuel_gauge.i2cbase = base;
    fuel_gauge.locAdr = regAdr;
    fuel_gauge.buf = &uiBuffer[0];
    fuel_gauge.bufLen = NoBytes;
    fuel_gauge.slaveAdr = BQ34210_ADDRESS;

    Result = i2c_writeFG(&fuel_gauge);

    return Result;

}

uint16_t bq34210_fuel_gauge_read(uint8_t regAdr,uint8_t *regData, uint32_t base, uint8_t noBytes)
{
    _I2C_Handle fuel_handle;
    uint32_t Result = 0;
    fuel_handle.i2cbase = base;
    fuel_handle.locAdr = regAdr;
    fuel_handle.buf = regData;
    fuel_handle.bufLen = noBytes;
    fuel_handle.slaveAdr = BQ34210_ADDRESS;


    i2c_read(&fuel_handle);
    int i;
    for(i = 0; i < noBytes; i++)
    {
        regData[i] = fuel_handle.buf[i];
    }

    return Result;
}

void bq34210_fuel_init(void)
{
    port_control(GPIO_PORTB_BASE, SOC_LRN_LD_EN, 0);
    port_control(GPIO_PORTC_BASE, FG_ALERT_CTL, FG_ALERT_CTL);
    port_control(GPIO_PORTE_BASE, CHARGER_EN, 0);
    SysCtlDelay(100000);
    port_control(GPIO_PORTC_BASE, FG_ALERT_CTL, 0);
    SysCtlDelay(100000);
    port_control(GPIO_PORTC_BASE, FG_ALERT_CTL, FG_ALERT_CTL);
    SysCtlDelay(2500000);

//    port_control(GPIO_PORTE_BASE, CHARGER_EN, CHARGER_EN);

    uint16_t eosLearnStatRead;
    SysCtlDelay(20000);
    update_config(OPRTN_CONFG_A_REG, OPRTN_CONFG_A_VAL);
    SysCtlDelay(20000);
    SysCtlDelay(4000000);
    resetFuelGuage();
    SysCtlDelay(1000000);
#ifdef CHARGE
    EOS_CONFIGURATION_VAL = 0x0000;
    update_config(EOS_CONFIGURATION_REG, EOS_CONFIGURATION_VAL);
    SysCtlDelay(20000);
#elif DISCHARGE
    EOS_CONFIGURATION_VAL = 0x0200;
    update_config(EOS_CONFIGURATION_REG, EOS_CONFIGURATION_VAL);
    SysCtlDelay(20000);
#else

#endif
    update_config(DSG_DTCN_THRSHLD_REG, DSGG_DTCN_THRSHLD_VAL);
    SysCtlDelay(20000);
    update_config(DSG_RLX_TM_REG, DSG_RLX_TM_VAL);
    SysCtlDelay(20000);
    update_config(CHRG_DTCN_THRSHLD_REG, CHRG_DTCN_THRSHLD_VAL);
    SysCtlDelay(20000);
    update_config(CHRG_RLX_TM_REG, CHRG_RLX_TM_VAL);
    SysCtlDelay(20000);
    update_config(LRN_DSCHRGE_CRNT_REG, LRN_DSCHRGE_CRNT_VAL);
    SysCtlDelay(20000);
    update_config(LRN_DSCHRGE_BRD_REG, LRN_DSCHRGE_BRD_VAL);
    SysCtlDelay(20000);
    update_config(DESIGN_CPCTY_1, DES_VALUE);
    SysCtlDelay(20000);
//    update_config(DESIGN_VOLT_REG, DESIGN_VOLT_VAL);
//    SysCtlDelay(20000);
    update_config(GAUGING_CONF_REG, GAUGING_CONF_VAL);
    SysCtlDelay(20000);
    update_config(NEAR_FULL_REG, NEAR_FULL_VAL);
    SysCtlDelay(20000);
    update_config(QUIT_CUR_REG, QUIT_CUR_VAL);
    SysCtlDelay(20000);
//    update_config(QUIT_RLX_TM_REG, QUIT_RLX_TM_VAL);
    SysCtlDelay(20000);
    update_config(OVRLD_CRNT_REG, OVRLD_CRNT_VAL);
    SysCtlDelay(20000);
    update_config(TAPER_CURRENT_REG, TAPER_CURRENT_VAL);
    SysCtlDelay(20000);
//    update_config(AUTO_LEARN_TIME_REG, AUTO_LEARN_TIME_VAL);
//    SysCtlDelay(2000000);
//    update_config(SET_VOL_THRSHLD_REG_FD, SET_VOL_THRSHLD_VAL_FD);
//    SysCtlDelay(2000000);
//    update_config(CLR_VOL_THRSHLD_REG_FD, CLR_VOL_THRSHLD_VAL_FD);
//    SysCtlDelay(2000000);
//    update_config(SET_VOL_THRSHLD_REG_FC, SET_VOL_THRSHLD_VAL_FC);
//    SysCtlDelay(2000000);
//    update_config(CLR_VOL_THRSHLD_REG_FC, CLR_VOL_THRSHLD_VAL_FC);
//    SysCtlDelay(2000000);
//    update_config(SET_VOL_THRSHLD_REG_TD, SET_VOL_THRSHLD_VAL_TD);
//    SysCtlDelay(2000000);
//    update_config(CLR_VOL_THRSHLD_REG_TD, CLR_VOL_THRSHLD_VAL_TD);
//    SysCtlDelay(2000000);
//    update_config(SET_VOL_THRSHLD_REG_TC, SET_VOL_THRSHLD_VAL_TC);
//    SysCtlDelay(2000000);
//    update_config(CLR_VOL_THRSHLD_REG_TC, CLR_VOL_THRSHLD_VAL_TC);
//    SysCtlDelay(2000000);
}


void fuelGauge_Start(void)
{
    fullChargeCapacity();

    gaugeReadings();
    //    autoLearnTimeRead(AUTO_LEARN_TIME_REG);

    enterCalibration();
    SysCtlDelay(10000000);
    exitCalibration();

    SysCtlDelay(1000000);

    LearningPhase();
}
void batteryStatus(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t batStat_HighByte,batStatLowByte;
    uint8_t regAdd[2];
    uint8_t devAdd = BAT_STATUS[0];
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    batStat_HighByte = regAdd[1];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = BAT_STATUS[1];
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    batStatLowByte = regAdd[0];
    fuelGauge.batteryStatus.highByte.HighByte = batStat_HighByte;
    fuelGauge.batteryStatus.lowByte.LowByte = batStatLowByte;
}

void voltage(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t regAdd[2];
    uint8_t devAdd = VOLT_STATUS[0];
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 2);
    battery_state.Bat_Voltage = (regAdd[1] << 8) | regAdd[0];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x30;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 2);
    battery_state.ChargingVoltage = (regAdd[1] << 8) | regAdd[0];
}

void current(void)
{
    int8_t signNP;
    uint8_t regData[2];
    uint8_t devAdd;
    devAdd = 0x0C;
    uint16_t tempVal;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 2);
    battery_state.Bat_Current = (regData[1] << 8) | regData[0];
//    if(battery_state.Bat_Cur & 0x8000)
//        signNP = -1;
//    else
//        signNP = 1;
//    tempVal = battery_state.Bat_Cur;
//    battery_state.Bat_Cur = twoScomplimant(tempVal);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x14;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 2);
    battery_state.Bat_average_Current = (regData[1] << 8) | regData[0];
}

void averageTToEmpty(void)
{
    uint8_t regData[2];
    uint8_t devAdd;
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x16;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 2);
    battery_state.BLTAverageTimeToEmpty = (regData[1] << 8) | regData[0];
    SysCtlDelay(FUEL_READ_DELAY);
}

void devId_Read(void)
{
    uint16_t devId;
    uint8_t regAdd[4];
    uint8_t dummy = 0;
    uint16_t ret_value = 0;
    uint8_t devAdd = CONTROL_STATUS[0];
    uint8_t devData = DEV_NUM[0];
    SysCtlDelay(FUEL_GAUGE_INIT_DELAY);
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = CONTROL_STATUS[1];
    devData = DEV_NUM[1];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_GAUGE_INIT_DELAY);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = Read_addr1[0];
    ret_value = bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 4);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devId = regAdd[3] << 8;
    devId |= regAdd[2];

    while(devId != BQ34210_DEV_NUM)
    {
    }

    if(devId == BQ34210_DEV_NUM)
    {
        battery_state.DevIDTrue = true;
    }
}

void fwVersionRead(void)
{
    uint16_t fwVer;
    uint8_t regAdd[4];
    uint8_t dummy = 0;
    uint16_t ret_value = 0;
    uint8_t devAdd = CONTROL_STATUS[0];
    uint8_t devData = FW_VRN[0];
    SysCtlDelay(FUEL_GAUGE_INIT_DELAY);
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = CONTROL_STATUS[1];
    devData = FW_VRN[1];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_GAUGE_INIT_DELAY);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x40;
    ret_value = bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 4);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    fwVer = regAdd[3] << 8;
    fwVer |= regAdd[2];

//    while(fwVer != BQ34210_DEV_NUM)
//    {
//    }
//
//    if(fwVer == BQ34210_DEV_NUM)
//    {
//        battery_state.DevIDTrue = true;
//    }
}


void autoLearnTimeRead(uint16_t regAddress)
{
    uint8_t readData[4];
    uint8_t regAdd[2];
    uint8_t regData[2];
    regAdd[1] = regAddress >> 8;
    regAdd[0] = regAddress & 0xFF;
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t OLD_MSB,NEW_MSB,OLD_LSB,NEW_LSB,OLD_CHCKSUM,NEW_CHCKSUM;
    uint8_t OLD_LEN,NEW_LEN;
    uint16_t temp;
    unsealAccess();
    enterConfigMode();
    do
    {
        operationalStatus();
    }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    uint8_t devAdd = 0x3E;
    uint8_t devData = regAdd[0];
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = regAdd[1];
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x60;
    bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
    OLD_CHCKSUM = readData[0];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x61;
    bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
    OLD_LEN = readData[0];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3E;
    devData = regAdd[0];
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = regAdd[1];
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x40;
    bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
    OLD_MSB = readData[0];

    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x41;
    bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
    OLD_LSB = readData[0];
    Auto_Learn_Time = (OLD_MSB << 8) | OLD_LSB;


    exitConfigMode();
    do
    {
        operationalStatus();
    }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    sealAccess();
}

void remainingCapacity(void)
{
    uint8_t HighByte,LowByte;
    SysCtlDelay(DELAY_FUEL_GAUGE);
    uint8_t regAdd[2];
    uint8_t devAdd = 0x10;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    LowByte = regAdd[0];
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x11;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    HighByte = regAdd[1];
    SysCtlDelay(DELAY_FUEL_GAUGE);
    battery_state.Bat_Remaining_Capacity = (HighByte << 8) | LowByte;
}

void fullChargeCapacity(void)
{
    uint8_t HighByte,LowByte;
    SysCtlDelay(DELAY_FUEL_GAUGE);
    uint8_t regAdd[2];
    uint8_t devAdd = 0x3C;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    LowByte = regAdd[0];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3D;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    HighByte = regAdd[0];
    SysCtlDelay(DELAY_FUEL_GAUGE);
    battery_state.Bat_Design_Capacity = (HighByte << 8) | LowByte;
    devAdd = 0x12;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    LowByte = regAdd[0];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x13;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    HighByte = regAdd[0];
    SysCtlDelay(DELAY_FUEL_GAUGE);
    battery_state.Bat_Full_Charge_Capacity = (HighByte << 8) | LowByte;
}

void relativeStateOfCharge(void)
{
    uint8_t HighByte,LowByte;
    SysCtlDelay(DELAY_FUEL_GAUGE);
    uint8_t regAdd[2];
    uint8_t devAdd = 0x2C;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    LowByte = regAdd[0];
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x2D;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 1);
    HighByte = regAdd[0];
    SysCtlDelay(DELAY_FUEL_GAUGE);
    battery_state.RelativeStateOfCharge = (HighByte << 8) | LowByte;
}

void resetFuelGuage(void)
{
    uint8_t devAdd;
    uint8_t devData;
    uint8_t readData[2];
    uint16_t opStat;

    unsealAccess();

    enterConfigMode();
    do
    {
        SysCtlDelay(10000);
        SysCtlDelay(10000);
        operationalStatus();
    }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    /* Resetting fuel gauge 0x0041 */
    SysCtlDelay(FUEL_GAUGE_INIT_DELAY);
    devAdd = 0x3E;
    devData = 0x41;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
//    /* Acumulated Reset 0x004B */
//    devAdd = 0x00;
//    devData = 0x4B;
//    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
//    SysCtlDelay(FUEL_READ_DELAY);
//    devAdd = 0x01;
//    devData = 0x00;
//    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
//    SysCtlDelay(FUEL_READ_DELAY);

    exitConfigMode();
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);

    do
    {
        SysCtlDelay(FUEL_READ_DELAY);
        operationalStatus();
    }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);

    sealAccess();
}

void controlStatus(void)
{
    sealAccess();
    SysCtlDelay(FUEL_GAUGE_INIT_DELAY);
    uint8_t devAdd = 0x00;
    uint8_t devData = 0x00;
    bq34210_fuel_gauge_read(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_read(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    unsealAccess();
 }

void setProfile(uint8_t profile)
{
    uint8_t devAdd;
    uint8_t devData;
    uint8_t readData[2];
    do
   {
        unsealAccess();
        enterConfigMode();

        operationalStatus();
   }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);

    if(profile == 1)
    {
        devAdd = 0x00;
        devData = 0x15;
        bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x01;
        devData = 0x00;
        bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
        SysCtlDelay(FUEL_READ_DELAY);
    }
    else if(profile == 2)
    {
        devAdd = 0x00;
        devData = 0x16;
        bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x01;
        devData = 0x00;
        bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
        SysCtlDelay(FUEL_READ_DELAY);
    }
    else
    {

    }
    exitConfigMode();

    do
    {
        operationalStatus();
    }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);

    unsealAccess();
}

void eosStartLearning(void)
{
    unsealAccess();
    uint8_t writeData[2];
    uint8_t devAdd;
    uint8_t devData;
    devAdd = 0x3E;
    devData = 0x39;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    sealAccess();
}

void eosEndLearning(void)
{
    unsealAccess();
    uint8_t writeData[2];
    uint8_t devAdd;
    uint8_t devData;
    devAdd = 0x3E;
    devData = 0x3A;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    sealAccess();
}

void sealAccess(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd = 0x00;
    uint8_t devData = 0x30;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
}

void unsealAccess(void)
{
    uint8_t devAdd = 0x00;
    uint8_t devData = 0x14;
    uint16_t opStat;
    uint8_t readData[2];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x04;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x00;
    devData = 0x72;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x36;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
}

void enterConfigMode(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd = 0x00;
    uint8_t devData = 0x90;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
}

void exitConfigMode(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd = 0x00;
    uint8_t devData = 0x92;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
}

void operationalStatus(void)
{
    uint8_t devAdd;
    uint8_t readData[2];
    uint8_t lowByte,highByte;
    uint16_t result;

    devAdd = 0x3A;
    bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 2);

    fuelGauge.operationalStatus.lowByte.LowByte = readData[0];
    fuelGauge.operationalStatus.highByte.HighByte = readData[1];

    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
}

void mnfctrAcsCntrlWrt(uint8_t *regData)
{
    uint8_t devAdd = 0x3E;
    uint8_t devData = regData[1];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    /* Write 0x93 to 0x3F to access the LSB of Design Capacity. */
    devAdd = 0x3F;
    devData = regData[0];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
}

void macDataRead(uint8_t *regData, uint8_t bytesToRead)
{
    int8_t devAdd = 0x40;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, bytesToRead);
    SysCtlDelay(DELAY_FUEL_GAUGE);
}

void macDataWrite(int8_t *regData)
{
    int8_t devAdd = 0x40;
    int8_t devData = regData[0];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x41;
    devData = regData[1];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
}

void eosENable(void)
{
    uint8_t readData[2];
    unsealAccess();
    do
    {
        /*UNSEAL the device */
        unsealAccess();
        /*Send ENTER_CGF_UPDATE command */
        enterConfigMode();
        /*Confirm CFGUPDATE mode by polling OperationStatus() register
        until bit 2 is set. May take up to 1 second.*/
        operationalStatus();
    }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd = 0x3E;
    uint8_t devData = 0x21;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    exitConfigMode();
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    do
    {
        operationalStatus();
    }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    sealAccess();
}


void accumDSGEn(void)
{
    uint8_t readData[2];

    SysCtlDelay(1000000);
    unsealAccess();
    do
    {
        /*UNSEAL the device */
        unsealAccess();
        /*Send ENTER_CGF_UPDATE command */
        enterConfigMode();
        /*Confirm CFGUPDATE mode by polling OperationStatus() register
        until bit 2 is set. May take up to 1 second.*/
        operationalStatus();
    }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd = 0x3E;
    uint8_t devData = 0x1E;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    exitConfigMode();
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    do
    {
        operationalStatus();
    }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    sealAccess();
}

void accumCHGEn(void)
{
    uint8_t readData[2];

    SysCtlDelay(1000000);
    unsealAccess();
    do
    {
        /*UNSEAL the device */
        unsealAccess();
        /*Send ENTER_CGF_UPDATE command */
        enterConfigMode();
        /*Confirm CFGUPDATE mode by polling OperationStatus() register
        until bit 2 is set. May take up to 1 second.*/
        operationalStatus();
    }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd = 0x3E;
    uint8_t devData = 0x1F;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    exitConfigMode();
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    do
    {
        operationalStatus();
    }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    sealAccess();
}

void manufacturingStatus(void)
{
    uint8_t readData[2];

    uint8_t regData[4];
    uint8_t devAdd;
    devAdd = 0x00;
    uint8_t devData;
    devData = 0x57;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3E;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 4);
    SysCtlDelay(FUEL_READ_DELAY);
    fuelGauge.manufacturingStatus.lowByte.LowByte = regData[2];
    fuelGauge.manufacturingStatus.highByte.HighByte = regData[3];

}

uint16_t eosLearnStatus(void)
{
    uint8_t regData[4];
    uint8_t devAdd = 0x64;
    uint16_t status;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 2);
    fuelGauge.eosLearnStatusStr.lowByte.LowByte = regData[0];
    SysCtlDelay(1000);
//    devAdd = 0x65;
//    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 1);
    fuelGauge.eosLearnStatusStr.highByte.HighByte = regData[1];
    SysCtlDelay(1000);
}

void elctrncsLoad(void)
{
    uint8_t writeReg;
    uint8_t readReg[4];
    uint8_t devAdd = 0x00;
    writeReg = 0xD6;
    unsealAccess();
    bq34210_fuel_gauge_write(devAdd, writeReg, FUEL_I2C, 1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x01;
    writeReg = 0x92;
    bq34210_fuel_gauge_write(devAdd, writeReg, FUEL_I2C, 1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x3E;
    writeReg = 0xC8;
    bq34210_fuel_gauge_write(devAdd, writeReg, FUEL_I2C, 1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x3F;
    writeReg = 0x00;
    bq34210_fuel_gauge_write(devAdd, writeReg, FUEL_I2C, 1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x00;
    writeReg = 0xD6;
    unsealAccess();
    bq34210_fuel_gauge_write(devAdd, writeReg, FUEL_I2C, 1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x01;
    writeReg = 0x92;
    bq34210_fuel_gauge_write(devAdd, writeReg, FUEL_I2C, 1);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    devAdd = 0x3E;
    bq34210_fuel_gauge_read(devAdd, readReg, FUEL_I2C, 4);
    SysCtlDelay(DELAY_FUEL_GAUGE);
    sealAccess();
}

void eosRCELLRRTARELearn(void)
{
    uint8_t devAdd;
    unsealAccess();
    devAdd = 0x3E;
    uint8_t devData;
    devData = 0x3B;
    uint8_t regData[2];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    sealAccess();
}

void eosInitialRCELRead(void)
{
    uint8_t devAdd;
    devAdd = 0x00;
    uint8_t devData;
    devData = 0x3E;
    uint8_t regData[4];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    /* Write 0x93 to 0x3F to access the LSB of Design Capacity. */
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3E;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 4);
    SysCtlDelay(FUEL_READ_DELAY);

}

void eosInitialRRATERead(void)
{
    uint8_t devAdd;
    devAdd = 0x00;
    uint8_t devData;
    devData = 0x3F;
    uint8_t regData[4];
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    /* Write 0x93 to 0x3F to access the LSB of Design Capacity. */
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3E;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 4);
    SysCtlDelay(FUEL_READ_DELAY);

}


void bltDischargeSet(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t regAdd[2];
    uint8_t devAdd = 0x34;
    uint8_t devData = 0x40;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 2);
    battery_state.BLTDischargeSet = (regAdd[1] << 8) | regAdd[0];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x34;
    bq34210_fuel_gauge_write(devAdd, devData , FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x35;
    devData = 0x06;
    bq34210_fuel_gauge_write(devAdd, devData , FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x34;
    devData = 0xA4;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 2);
    battery_state.BLTDischargeSet = (regAdd[1] << 8) | regAdd[0];
}


void bltChargeSet(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t regAdd[2];
    uint8_t devAdd = 0x36;
    uint8_t devData = 0x40;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 2);
    battery_state.BLTChargeSet = (regAdd[1] << 8) | regAdd[0];
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x36;
    devData = 0x06;
    bq34210_fuel_gauge_write(devAdd, devData , FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x37;
    devData = 0xA4;
    bq34210_fuel_gauge_write(devAdd, devData , FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x36;
    bq34210_fuel_gauge_read(devAdd, regAdd, FUEL_I2C, 2);
    battery_state.BLTChargeSet = (regAdd[1] << 8) | regAdd[0];
}


void update_config(uint16_t regAddress,uint16_t Data)
{
    uint16_t retData = 0;
    uint8_t highByte,lowByte;
    uint8_t readData[4];
    uint8_t regAdd[2];
    uint8_t regData[2];
    regAdd[1] = regAddress >> 8;
    regAdd[0] = regAddress & 0xFF;
    regData[0] = Data >> 8;
    regData[1] = Data & 0xFF;
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t OLD_MSB,NEW_MSB,OLD_LSB,NEW_LSB,OLD_CHCKSUM,NEW_CHCKSUM;
    uint8_t OLD_LEN,NEW_LEN;
    uint16_t temp;

    while(retData != Data)
    {
        unsealAccess();
        enterConfigMode();
        do
        {
            operationalStatus();
        }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
        uint8_t devAdd = 0x3E;
        uint8_t devData = regAdd[0];
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x3F;
        devData = regAdd[1];
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x60;
        bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
        OLD_CHCKSUM = readData[0];
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x61;
        bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
        OLD_LEN = readData[0];
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x3E;
        devData = regAdd[0];
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x3F;
        devData = regAdd[1];
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x40;
        bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
        OLD_MSB = readData[0];
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x41;
        bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 1);
        OLD_LSB = readData[0];

        temp = ((255 - OLD_CHCKSUM - OLD_MSB - OLD_LSB) % 256);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x40;
        devData = regData[0];
        NEW_MSB = devData;
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x41;
        devData = regData[1];
        NEW_LSB = devData;
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        NEW_CHCKSUM = (255 - ((temp + NEW_MSB + NEW_LSB) % 256));
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x60;
        devData = NEW_CHCKSUM;
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        SysCtlDelay(FUEL_READ_DELAY);
        NEW_LEN = OLD_LEN;
        devAdd = 0x61;
        devData = NEW_LEN;
        bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
        SysCtlDelay(FUEL_READ_DELAY);
        SysCtlDelay(FUEL_READ_DELAY);
        devAdd = 0x40;
        SysCtlDelay(FUEL_READ_DELAY);
        SysCtlDelay(FUEL_READ_DELAY);
        SysCtlDelay(100000);
        bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 2);
        highByte = readData[0];
        devAdd = 0x41;
        SysCtlDelay(FUEL_READ_DELAY);
        bq34210_fuel_gauge_read(devAdd, readData, FUEL_I2C, 2);
        lowByte = readData[0];
        SysCtlDelay(FUEL_READ_DELAY);
        retData = (highByte << 8) | lowByte;
        exitConfigMode();
        do
        {
            operationalStatus();
        }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
        sealAccess();
    }
}


void MACDataRead(uint16_t regAdd, uint8_t *regData, uint8_t dataLength)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd;
    uint8_t devData;

    devAdd = 0x3E;
    devData = regAdd & 0xFF;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = regAdd >> 8;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);

    devAdd = 0x40;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, dataLength);
    SysCtlDelay(FUEL_READ_DELAY);

}

void MACDataWrite(uint16_t regAdd, uint16_t regData)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd;
    uint8_t devData;

    devAdd = 0x3E;
    devData = regAdd & 0xFF;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3F;
    devData = regAdd >> 8;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);

    devAdd = 0x40;
    devData = regData >> 8;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x41;
    devData = regData & 0xFF;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);

}


void macSubCmd(uint16_t subCmd)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devAdd;
    uint8_t devData;
    devAdd = 0x00;
    devData = subCmd & 0xFF;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);

    devAdd = 0x00;
    devData = subCmd >> 8;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
}

void gaugingStatus(void)
{
    uint8_t readData[2];

    uint8_t regData[4];
    uint8_t devAdd;
    devAdd = 0x00;
    uint8_t devData;
    devData = 0x56;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd,devData,FUEL_I2C,1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x3E;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 4);
    SysCtlDelay(FUEL_READ_DELAY);
    fuelGauge.gaugingStatus.lowByte.LowByte = regData[2];
    fuelGauge.gaugingStatus.highByte.HighByte = regData[3];
}

void temperature(void)
{
    uint8_t regData[4];
    uint8_t devAdd;
    devAdd = 0x06;
    uint16_t temperature;
    float tempVal,dummy;
    bq34210_fuel_gauge_read(devAdd, regData, FUEL_I2C, 2);
    temperature = (regData[1] << 8) | regData[0];
    SysCtlDelay(FUEL_READ_DELAY);
    dummy = (temperature * 0.1) - 273;
    temperature = dummy * 100;
    tempVal = temperature / 100;
    battery_state.BLTTemp = tempVal;
}

uint16_t twoScomplimant(uint16_t hexVal)
{
    uint16_t hex_value = hexVal & 0xFFFF;

    uint16_t ones_compliment = ~hex_value;

    uint16_t twos_complement = ones_compliment + 1;

    return twos_complement;
}

void enterCalibration(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devData;
    uint8_t devAdd;
    devAdd = 0x00;
    devData = 0x81;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
}

void exitCalibration(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t devData;
    uint8_t devAdd;
    devAdd = 0x00;
    devData = 0x80;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    devAdd = 0x01;
    devData = 0x00;
    bq34210_fuel_gauge_write(devAdd, devData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
}


void gaugeReadings(void)
{
    voltage();
    current();
    temperature();
    fullChargeCapacity();
    remainingCapacity();
    averageTToEmpty();
}

void LearningPhase(void)
{
    port_control(GPIO_PORTB_BASE, SOC_LRN_LD_EN, 0);
    uint8_t LoadEnable;
    uint8_t chargeEn= 0,dischargeEn = 0;
    int8_t CurrentRead[2];
    while(!EOSCmplt)
    {
        SysCtlDelay(10000000);
        eosStartLearning();
        gaugingStatus();
        batteryStatus();
        gaugeReadings();
        manufacturingStatus();
        EOSSTatus();
//        memoryRead(AUTO_LEARN_TIME_REG);
//        alertConfigRead();

        if(!fuelGauge.manufacturingStatus.lowByte.bits.ACDSG_EN)
            accumDSGEn();
        if(fuelGauge.manufacturingStatus.lowByte.bits.ACCHG_EN)
            accumCHGEn();
        if(battery_state.Bat_Current > 0)
        {

            CurrentRead[0] = (battery_state.Bat_Current >> 8)&0xff;
            CurrentRead[0] = battery_state.Bat_Current&0xff;
            snprintf(CurrentRead, sizeof(CurrentRead), "%d%d", CurrentRead[0],CurrentRead[1]);
//            if(!chargeEn)
//            {
//                port_control(GPIO_PORTE_BASE, CHARGER_EN, CHARGER_EN);
//                if(fuelGauge.manufacturingStatus.lowByte.bits.ACCHG_EN)
//                    accumCHGEn();
//                if(fuelGauge.manufacturingStatus.lowByte.bits.ACDSG_EN)
//                    accumDSGEn();
//                chargeEn = 1;

//            }
        }
//        else if(battery_state.Bat_Cur < 0)
//        {
//            if(chargeEn)
//            {
//                port_control(GPIO_PORTE_BASE, CHARGER_EN, 0);
//                if(fuelGauge.manufacturingStatus.lowByte.bits.ACDSG_EN)
//                    accumDSGEn();
//                if(fuelGauge.manufacturingStatus.lowByte.bits.ACCHG_EN)
//                    accumCHGEn();
//                chargeEn = 0;
//            }
//        }
        switch(mode)
        {
            case NONE:
                eosENable();
                eosRCELLRRTARELearn();

                SysCtlDelay(10000);
                mode = EOSENABLE;
//                port_control(GPIO_PORTE_BASE, CHARGER_EN, CHARGER_EN);
                if(fuelGauge.manufacturingStatus.lowByte.bits.ACCHG_EN)
                    accumCHGEn();
                if(fuelGauge.manufacturingStatus.lowByte.bits.ACDSG_EN)
                    accumDSGEn();
                break;
            case EOSENABLE:
                SysCtlDelay(100000);
                if(fuelGauge.manufacturingStatus.lowByte.bits.EOS_EN_BIT)
                {
                    mode = START_LEARN;
                }
                else
                {
                    mode = NONE;
                }
                break;
            case START_LEARN:
//                eosStartLearning();
                eosLearnStatus();
                if(fuelGauge.eosLearnStatusStr.lowByte.bits.LCMD)
                {
                    mode = EOSLCMD;
                }
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LPER)
                    mode = EOSLPER;
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LFAULT)
                {
                    mode = EOSLFAULT;
                }
                else
                {
//                    eosStartLearning();
                    mode = START_LEARN;
                }
                break;
            case EOSLCMD:
//                eosLearnStatus();
                if(fuelGauge.eosLearnStatusStr.lowByte.bits.LRLX)
                {
                    mode = EOSLRLX;
                    SysCtlDelay(1181818181);
                }
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LFAULT)
                {
                    mode = EOSLFAULT;
                }
                else
                    mode = EOSLCMD;
                    //SysCtlDelay(1181818181);
                break;
            case EOSLPER:
                if(fuelGauge.eosLearnStatusStr.lowByte.bits.LRLX)
                {
                    mode = EOSLRLX;
//                    SysCtlDelay(1181818181);
                }
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LFAULT)
                {
                    mode = EOSLFAULT;
                }
                else
                    mode = EOSLPER;
                    //SysCtlDelay(1181818181);
                break;
            case EOSLRLX:

                //eosLearnStatus();
                if(fuelGauge.gaugingStatus.highByte.bits.REST)
                {
                    mode = EOSREST;
                    port_control(GPIO_PORTB_BASE, SOC_LRN_LD_EN, 0);
                }
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LFAULT)
                {
                    mode = EOSLFAULT;
                }
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LABRT)
                    mode = NONE;
                else
                    mode = EOSLRLX;
                break;
            case EOSREST:
                //eosLearnStatus();
                if(fuelGauge.eosLearnStatusStr.lowByte.bits.LDSG)
                {
                    mode = EOSLDSG;
                }
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LCHG)
                {
                    mode = EOSLCHG;
                }
                else if(fuelGauge.eosLearnStatusStr.highByte.bits.LCTLEDGE)
                {

                }
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LFAULT)
                {
                    mode = EOSLFAULT;
                }
                else
                {
                    if(fuelGauge.eosLearnStatusStr.highByte.bits.LUCD)
                        mode = EOSLUCD;
                    if(fuelGauge.eosLearnStatusStr.highByte.bits.LDPAI)
                        mode = EOSLDPAI;
                    if(fuelGauge.eosLearnStatusStr.highByte.bits.LDPAT)
                        mode = EOSLDPAT;
                }
                break;
            case EOSLDSG:
                eosLearnStatus();
                if(fuelGauge.eosLearnStatusStr.highByte.bits.LDONE)
                    EOSCmplt = 1;
                else if(fuelGauge.eosLearnStatusStr.highByte.bits.LDPAM)
                    mode = EOSLDPAM;
                else if(fuelGauge.eosLearnStatusStr.highByte.bits.LRSTOR)
                    mode = EOSLRSTOR;
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LFAULT)
                 {
                     mode = EOSLFAULT;
                 }
                else
                    mode = EOSLDSG;
                break;
            case EOSLCHG:
                if(fuelGauge.eosLearnStatusStr.highByte.bits.LDONE)
                    EOSCmplt = 1;
                else if(fuelGauge.eosLearnStatusStr.highByte.bits.LDPAM)
                    mode = EOSLDPAM;
                else if(fuelGauge.eosLearnStatusStr.highByte.bits.LRSTOR)
                    mode = EOSLRSTOR;
                else if(fuelGauge.eosLearnStatusStr.lowByte.bits.LFAULT)
                 {
                     mode = EOSLFAULT;
                 }
                else
                    mode = EOSLDSG;
                break;
            case EOSLFAULT:
                eosLearnStatus();
                if(fuelGauge.eosLearnStatusStr.highByte.bits.LUCD)
                    mode = EOSLUCD;
                else if(fuelGauge.eosLearnStatusStr.highByte.bits.LDPAI)
                    mode = EOSLDPAI;
                else if(fuelGauge.eosLearnStatusStr.highByte.bits.LDPAT)
                    mode = EOSLDPAT;
                else
                    mode = NONE;
                break;
            case EOSLDPAI:
                LRN_DSCHRGE_BRD_VAL++;
                update_config(LRN_DSCHRGE_BRD_REG, LRN_DSCHRGE_BRD_VAL);
                mode = NONE;
                break;
            case EOSLDPAT:
//                LRN_MIN_TEMP_VAL--;
//                LRN_MAX_TEMP_VAL++;
//                update_config(LRN_MIN_TEMP_REG, LRN_MIN_TEMP_VAL);
//                SysCtlDelay(10000);
//                update_config(LRN_MAX_TEMP_REG, LRN_MAX_TEMP_VAL);
                mode = NONE;
                break;
            case EOSLDPAM:
                mode = NONE;
                break;
            case EOSLRSTOR:
                mode = EOSLDSG;
                break;
            case EOSLUCD:
                mode = NONE;
                break;
            default:
                gaugeReadings();

        }
    }

}

uint16_t memoryRead(uint16_t regAddress)
{
    uint8_t alertAdd[2];
    uint8_t configAdd,configData;
    uint8_t configRead[4];
    uint8_t readData[4];
    uint16_t opStat;

    alertAdd[0] = regAddress & 0xff;
    alertAdd[1] = regAddress >> 8;
    sealAccess();
    unsealAccess();
    enterConfigMode();
    do
    {
        SysCtlDelay(10000);
        SysCtlDelay(10000);
        operationalStatus();
    }while(!fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);

    configAdd = 0x3E;
    configData = alertAdd[0];
    bq34210_fuel_gauge_write(configAdd, configData, FUEL_I2C, 1);
    SysCtlDelay(FUEL_READ_DELAY);
    configData = alertAdd[1];
    configAdd = 0x3F;
    bq34210_fuel_gauge_write(configAdd, configData, FUEL_I2C, 1);

    configAdd = 0x40;
    bq34210_fuel_gauge_read(configAdd, configRead, FUEL_I2C, 4);
    SysCtlDelay(FUEL_READ_DELAY);

    exitConfigMode();
    do
    {
        operationalStatus();
    }while(fuelGauge.operationalStatus.highByte.bits.CFGUPDATE);
    sealAccess();
    return ((configRead[2] << 8) | configRead[3]);
}

void EOSSTatus(void)
{
    SysCtlDelay(FUEL_READ_DELAY);
    uint8_t regAdd;
    uint8_t regData[2];
    regAdd = 0x68;
    bq34210_fuel_gauge_read(regAdd, regData, FUEL_I2C, 1);
   fuelGauge.eosStatus.byte.Byte = regData[0];
    SysCtlDelay(FUEL_READ_DELAY);
}

fuel_guage.h

Hello Adrian,

Added the .c and .h files with this response.

Thank you

0 Adrian 1 month ago in reply to Vinay K L

TI__Mastermind 23426 points

Hello Vinay,

Thank you, please allow me some time to look over the code.

Regards,

Adrian

0 Vinay K L 13 days ago in reply to Adrian

Prodigy 50 points

Hello Adrian,

Waiting for your update.

Thank you

0 Adrian 2 hours ago in reply to Vinay K L

TI__Mastermind 23426 points

Hello Vinay,

Sorry this thread got lost in my inbox. I looked over the code and did not see an glaring issues with the code. Since you are using a TI microcontroller, I would recommend posting a new thread for their team to see as we suspect there is a communication issue with the TM4C.

Regards,

Adrian

Power management

Power management forum

BQ34210-Q1: Learning Phase failed