battery.c File Reference

---

Detailed Description

Functions related to battery control and data acquisition.

Contains functions for enabling/disabling batteries, and looking up their status and specifications using the ADC.

Application note:

AVR458: Charging Li-Ion Batteries with BC100
AVR463: Charging NiMH Batteries with BC100

Documentation

For comprehensive code documentation, supported compilers, compiler settings and supported devices see readme.html

Author:

Atmel Corporation: http://www.atmel.com
Support email: avr@atmel.com

$Name$

Revision

2299

$RCSfile$

URL

http://svn.norway.atmel.com/AppsAVR8/avr463_Charging_NiMH_Batteries_with_BC100/tags/20070904_release_code_1.0/code/IAR/battery.c

Date

2007-08-23 12:55:51 +0200 (to, 23 aug 2007)

Definition in file battery.c.

#include <ioavr.h>
#include <inavr.h>
#include "structs.h"
#include "enums.h"
#include "ADC.h"
#include "battery.h"
#include "main.h"
#include "OWI.h"
#include "time.h"
#include "NIMHspecs.h"

Include dependency graph for battery.c:

Go to the source code of this file.

Functions
unsigned char	BatteryCheck (void)
	Checks if battery has changed.
unsigned char	BatteryDataRefresh (void)
	Refreshes battery data in the EEPROM.
unsigned char	BatteryStatusRefresh (void)
	Refreshes battery status information.
void	DisableBatteries (void)
	Disables both batteries.
void	EnableBattery (unsigned char bat)
	Enables specified battery.
void	NTCLookUp (void)
	Calculates temperature from a lookup table.
unsigned char	RIDLookUp (void)
	Looks up battery data from RID table.
Variables
unsigned char	BattActive
	Global that indicates current battery (0 = battery A, 1 = B).
__eeprom Battery_t	BattControl [2]
	Holds control data for both batteries.
Batteries_t	BattData
	Holds data for the current battery.
__eeprom unsigned char	BattEEPROM [4][32]
	Storage space for data from the batteries' own EPROMs.
const NTC_Lookup_t	NTC [NTC_TABLE_SIZE]
	NTC lookup-table.
const RID_Lookup_t	RID [RID_TABLE_SIZE]
	RID lookup-table.

---

Function Documentation

unsigned char BatteryCheck

(

void

)

Checks if battery has changed.

Stores current capacity, then attempts to refresh battery status.
If the refresh is successful, old capacity is compared with the new one.

Return values:

	FALSE	Battery is disconnected, or capacity has changed.
	TRUE	All OK.

Definition at line 136 of file battery.c.

References BattData, BatteryStatusRefresh(), Batteries_struct::Capacity, FALSE, and TRUE.

{
        unsigned char success = TRUE;
        unsigned int  oldCapacity;
        
        // Save to see if battery data has changed.
        oldCapacity = BattData.Capacity;  
        
        if (!BatteryStatusRefresh()) {
                success = FALSE;              // Battery not present or RID was invalid.
        }
        
        if (oldCapacity != BattData.Capacity) {
                success = FALSE;              // Battery configuration has changed.
        }

        return(success);
}

Here is the call graph for this function:

unsigned char BatteryDataRefresh

(

void

)

Refreshes battery data in the EEPROM.

Attempts to read 4 pages of 32 bytes each from the battery's EPROM and store these data in on-chip EEPROM.
If unsuccessful (CRC doesn't check out), the on-chip EEPROM is cleared.

Todo:

Updating BattData with these data. Specs needed.

Return values:

	FALSE	Refresh failed.
	TRUE	Refresh successful.

Definition at line 236 of file battery.c.

References BattData, BattEEPROM, Batteries_struct::Circuit, DS2505_DATA_READ, FALSE, OW_DS2505, OWI_ComputeCRC8(), OWI_DetectPresence(), OWI_ReceiveByte(), OWI_ROM_READ, OWI_SendByte(), OWIBUS, and TRUE.

Referenced by BatteryControl().

{
        unsigned char offset;
        unsigned char i, crc, family, temp, page;
        unsigned char success;
        
        // Look for EPROM and read 4 pages of 32 bytes each worth of data, if found.
        for (page = 0; page < 4; page++)        {
                success = FALSE;
        
                if (OWI_DetectPresence(OWIBUS) == OWIBUS) {
                        
                        // Presence detected, check type and CRC.
                        OWI_SendByte(OWI_ROM_READ, OWIBUS);
                        family = OWI_ReceiveByte(OWIBUS);
                        crc = OWI_ComputeCRC8(family,0);

                        for (i = 0; i < 6; i++) {
                                crc = OWI_ComputeCRC8(OWI_ReceiveByte(OWIBUS),crc);
                        }

                        // CRC ok, device found.
                        if (OWI_ComputeCRC8(OWI_ReceiveByte(OWIBUS),crc) == 0) {
                                BattData.Circuit = family;

                                // For now, we only read data from DS2505 EPROMs.
                                if (BattData.Circuit == OW_DS2505) {
                                        offset = page*32;
                                        OWI_SendByte(DS2505_DATA_READ, OWIBUS);  // Command: read data.
                                        OWI_SendByte(offset, OWIBUS);            // Data: low address.
                                        OWI_SendByte(0, OWIBUS);                 // Data: high address.

                                        // Calculate checksums.
                                        crc = OWI_ComputeCRC8(DS2505_DATA_READ,0);
                                        crc = OWI_ComputeCRC8(offset,crc);
                                        crc = OWI_ComputeCRC8(0,crc);

                                        // Command received succesfully, now start reading data
                                        // and writing it to EEPROM.
                                        if (OWI_ComputeCRC8(OWI_ReceiveByte(OWIBUS),crc) == 0) {
                                                crc = 0;
                                                
                                                // Fill page with data.
                                                for (i=0; i<32; i++) {
                                                        temp = OWI_ReceiveByte(OWIBUS);
                                                        crc = OWI_ComputeCRC8(temp, crc);
                                                        BattEEPROM[page][i] = temp;
                                                }
                                                
                                                if (OWI_ComputeCRC8(OWI_ReceiveByte(OWIBUS),crc) == 0) {
                                                                success = TRUE;  // Data read OK
                                                }
                                        } else { // Not able to start reading data.
                                        }
                                } else { // Wrong device type.
                                }
                        } else { // No device found.             
                        }
                } else { // No presence detected on one-wire bus.
                }

          // Erase local EEPROM page if there were any errors during transfer.
                if (!success) {
                        for (i=0; i<32; i++) {
                                BattEEPROM[page][i] = 0;
                        }
                }
        }

        return(success);
}

Here is the call graph for this function:

unsigned char BatteryStatusRefresh

(

void

)

Refreshes battery status information.

Refreshes battery status information, if it is present, based on RID and NTC (read by ADC).
The battery must have been enabled and a complete set of ADC data must have been collected before calling.

Return values:

	FALSE	No battery present.
	TRUE	Battery present, status refreshed.

Note:

If ALLOW_NO_RID is defined, charging will NOT stop if no fitting entry is found in the lookup table. Instead, default battery data will be used.

Todo:

If ABORT_IF_PWM_MAX is defined this last check battery presence check is redundant since charging will be aborted due to low current at max duty cycle. That is preferrable since the charge current reading is not 100% proof.

Definition at line 169 of file battery.c.

References ADCS, ADC_Status_struct::avgIBAT, BAT_VOLTAGE_LOW, BAT_VOLTAGE_MIN, BattData, Batteries_struct::Capacity, Batteries_struct::Charged, Batteries_struct::Circuit, FALSE, Batteries_struct::HasRID, Batteries_struct::Low, Batteries_struct::MaxCurrent, Batteries_struct::MaxTime, Batteries_struct::MinCurrent, NTCLookUp(), OW_NONE, Batteries_struct::Present, RIDLookUp(), Batteries_struct::Temperature, TRUE, and ADC_Status_struct::VBAT.

Referenced by BatteryCheck(), BatteryControl(), Initialize(), and Sleep().

{
        // Assume the worst..
        unsigned char success = FALSE;
        
        BattData.Present = FALSE;
        BattData.Charged = FALSE;
        BattData.Low = TRUE;
        BattData.Circuit = OW_NONE;
        BattData.Temperature = 0;
        BattData.Capacity = 0;
        BattData.MaxCurrent = 0;
        BattData.MaxTime = 0;
        BattData.MinCurrent = 0;

        NTCLookUp();
        BattData.HasRID = RIDLookUp();

        // Is the battery voltage above minimum safe cell voltage?
        if (ADCS.VBAT >= BAT_VOLTAGE_MIN) {
                BattData.Low = FALSE;
        }

        // Is the battery charged?
        if (ADCS.VBAT >= BAT_VOLTAGE_LOW) {
                BattData.Charged = TRUE;
        }

        // If we are not charging, yet VBAT is above safe limit, battery is present.
        // If we are charging and there's a current flowing, the battery is present.
        
        if (((OCR1B == 0) && (!BattData.Low)) ||
            ((OCR1B != 0) && (ADCS.avgIBAT > 0))) {
                BattData.Present = TRUE;
                success = TRUE;
        } else {
                BattData.Low = FALSE;  // (This is just a technicality..)
                success = FALSE;
        }

#ifndef ALLOW_NO_RID
        // Return FALSE if no valid RID entry was found, to stop charging.
        if(!BattData.HasRID) {
                success = FALSE;
        }
#endif

        return(success);
}

Here is the call graph for this function:

void DisableBatteries

(

void

)

Disables both batteries.

Clears PB4 and PB5 in PORTB, disabling both batteries.

Definition at line 340 of file battery.c.

Referenced by BatteryControl(), Error(), Initialize(), JumperCheck(), and Sleep().

{
        // Turn off LEDs and disconnect batteries.
        PORTB &= ~((1<<PB4)|(1<<PB5));  
}

void EnableBattery

(

unsigned char

bat

)

Enables specified battery.

Updates BattActive to specified battery, then sets PB4/PB5 and clears PB5/PB4 in PORTB, depending on which battery is specified.
The function takes 100 ms to allow the port switch to settle.

Parameters:

bat

Specifies which battery to enable (0 = battery A, 1 = B)

Definition at line 317 of file battery.c.

References BattActive, Time_Left(), Time_Set(), and TIMER_GEN.

Referenced by BatteryControl(), Initialize(), and Sleep().

{
        // Use general timer, set timeout to 100ms.
        Time_Set(TIMER_GEN,0,0,100);

        // Set specified battery as the active one.
        BattActive = bat;

        // Enable current battery in hardware, light LED & connect battery.
        PORTB |= (1 << (PB4+bat));

        // Disconnect other battery.
        PORTB &= ~(1<<(PB5-bat));     

        do { // Let port switch settle.
        } while (Time_Left(TIMER_GEN));  
}

Here is the call graph for this function:

void NTCLookUp

(

void

)

Calculates temperature from a lookup table.

Looks up the highest NTC value below or equal to the measured one.
With the current lookup table, temperature is calculated with the formula:
4*(index of entry) - 2*(measured NTC - NTC from entry) / (ADCsteps of entry)

Note:

If the NTC-measurement is saturated, with the current lookup table, the temperature will be reported as -1 C.

If no valid entry is found, battery temperature is set to 80.

Definition at line 398 of file battery.c.

References NTC_Lookup_struct::ADC, ADCS, Batteries_struct::ADCSteps, NTC_Lookup_struct::ADCsteps, BattData, FALSE, NTC, NTC_TABLE_SIZE, ADC_Status_struct::rawNTC, Batteries_struct::Temperature, and TRUE.

Referenced by BatteryStatusRefresh().

{
        unsigned char i;
        unsigned char found = FALSE;
        
        // Lookup in the NTC-table. Use the first entry which is equal or below
        // sampled NTC. Calculate temperature by using the index number, and the
        // difference between the measured NTC value and the one in the entry.
        for (i=0 ; (i < NTC_TABLE_SIZE) && (!found); i++)       {
                if (ADCS.rawNTC >= NTC[i].ADC) {
                        BattData.Temperature = (i<<2) ;
                        BattData.ADCSteps = NTC[i].ADCsteps;  
                        BattData.Temperature -= ((ADCS.rawNTC - NTC[i].ADC)<<1) / BattData.ADCSteps;
                        
                        found = TRUE;  // Could be done with a break, but that violates MISRA.
                }
        }
        
        // For safety, is temperature is greater than the NTC 
        if (!found) {
                BattData.Temperature = 80;
        }
}

unsigned char RIDLookUp

(

void

)

Looks up battery data from RID table.

Attempts to find data for the battery from the RID lookup-table.
If no valid entry is found, default data (defined in battery.h) are used.

Return values:

	TRUE	Entry found, battery data updated.
	FALSE	No entry found, using defaults for battery data.

Definition at line 356 of file battery.c.

References ADCS, BattData, Batteries_struct::Capacity, RID_Lookup_struct::Capacity, FALSE, RID_Lookup_struct::High, RID_Lookup_struct::Icharge, RID_Lookup_struct::ICutOff, RID_Lookup_struct::Low, Batteries_struct::MaxCurrent, Batteries_struct::MaxTime, Batteries_struct::MinCurrent, ADC_Status_struct::rawRID, RID, RID_TABLE_SIZE, RID_Lookup_struct::tCutOff, and TRUE.

Referenced by BatteryStatusRefresh().

{
        unsigned char i, found = FALSE;
                
        // Lookup in the RID-table. If measured RID is within the limits
        // of an entry, those data are used, and TRUE is returned.
        for (i = 0 ; i < RID_TABLE_SIZE; i++) {
                if (ADCS.rawRID >= RID[i].Low) {
                        if (ADCS.rawRID <= RID[i].High) {
                                BattData.Capacity = RID[i].Capacity;
                                BattData.MaxCurrent = RID[i].Icharge;
                                BattData.MaxTime = RID[i].tCutOff;
                                BattData.MinCurrent = RID[i].ICutOff;
                                
                                found = TRUE;
                        }
                }
        }
        
        // If no valid entry is found, use defaults and return FALSE.
        if (!found) {
                BattData.Capacity = DEF_BAT_CAPACITY;
                BattData.MaxCurrent = DEF_BAT_CURRENT_MAX;
                BattData.MaxTime = DEF_BAT_TIME_MAX;
                BattData.MinCurrent = DEF_BAT_CURRENT_MIN;
        }
        
        return(found);
}

---

Variable Documentation

unsigned char BattActive

Global that indicates current battery (0 = battery A, 1 = B).

Definition at line 75 of file battery.c.

Referenced by Charge(), ConstantCurrent(), ConstantVoltage(), EnableBattery(), Error(), Initialize(), and USI_OVF_ISR().

__eeprom Battery_t BattControl[2]

Initial value:

 {{TRUE, TRUE, FALSE},
                                     {TRUE, TRUE, FALSE}}

Holds control data for both batteries.

Note:

Stored in EEPROM.

Definition at line 60 of file battery.c.

Referenced by BatteryControl(), Charge(), ConstantCurrent(), ConstantVoltage(), Error(), and USI_OVF_ISR().

Batteries_t BattData

Holds data for the current battery.

Definition at line 64 of file battery.c.

Referenced by BatteryCheck(), BatteryControl(), BatteryDataRefresh(), BatteryStatusRefresh(), Charge(), Error(), NTCLookUp(), RIDLookUp(), Sleep(), and USI_OVF_ISR().

__eeprom unsigned char BattEEPROM[4][32]

Storage space for data from the batteries' own EPROMs.

Note:

Stored in EEPROM.

Definition at line 71 of file battery.c.

Referenced by BatteryDataRefresh(), and Initialize().

const NTC_Lookup_t NTC[NTC_TABLE_SIZE]

Initial value:

 {
        {1002, 23}, {953, 25}, {902, 26}, {849, 27}, {796, 27},
        {742, 27}, {689, 26}, {637, 26}, {587, 25}, {539, 24},
        {494, 22}, {451, 21}, {412, 19}, {375, 18}, {341, 17},
        {310, 15}, {282, 14}, {256, 13}, {233, 11}, {212, 10}
}

NTC lookup-table.

The first entry is 0 degrees. For every entry after, temperature increases with 4 degrees. With 20 entries, the last one equals (20-1)*4 = 76 degrees.
It must be sorted in descending ADC order.

Note:

This was calculated for a Mitsubishi RH16-3H103FB NTC.

NTCLookUp() must be modified if this table is changed so that:

• first entry is no longer 0 degrees.
• temperature difference between entries is no longer 4 degrees.
• ADCsteps no longer specifies ADC steps per half degree.

Definition at line 106 of file battery.c.

Referenced by NTCLookUp().

const RID_Lookup_t RID[RID_TABLE_SIZE]

Initial value:

 {
  {558, 659, 3900, 550, 260, 300, 10},
  {744, 843, 6800, 750, 360, 300, 14},
  {869, 958, 10000, 1000, 475, 300, 19},
  {1097, 1153, 24000, 2000, 475, 420, 38}
}

RID lookup-table.

Contains Resistor ID data specified by manufacturer.

Note:

Values have been calculated assuming a +/- 15% tolerance.

Definition at line 84 of file battery.c.

Referenced by RIDLookUp().

---