battery.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#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"

#ifdef NIMH
#include "NIMHspecs.h"
#endif // NIMH

#ifdef LIION
#include "LIIONspecs.h"
#endif // LIION



//******************************************************************************
// Variables
//******************************************************************************
/* Control-struct for batteries */
__eeprom Battery_t BattControl[2] = {{TRUE, TRUE, FALSE},
                                     {TRUE, TRUE, FALSE}};

/* Data-struct for battery */
Batteries_t BattData; 


/* Storage for battery EPROM */
__eeprom unsigned char BattEEPROM[4][32];


unsigned char BattActive;


const RID_Lookup_t RID[RID_TABLE_SIZE] = {
  {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}
};


// FOR VARTA POLYFLEX NTC
const NTC_Lookup_t NTC[NTC_TABLE_SIZE] = {
        {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}
};


// FOR MITSUBISHI NTC
/*
const NTC_Lookup_t NTC[NTC_TABLE_SIZE] = {
  {1004, 24}, {954, 25}, {903, 26}, {850, 27}, {796, 27},
  {742, 27}, {689, 27}, {637, 26}, {587, 25}, {539, 24},
  {493, 22}, {451, 21}, {411, 20}, {374, 18}, {340, 17},
  {309, 15}, {281, 14}, {255, 13}, {232, 11}, {211, 10}
};
*/


//******************************************************************************
// Functions
//******************************************************************************
unsigned char BatteryCheck(void)
{
        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);
}


unsigned char BatteryStatusRefresh(void)
{
        // 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);
}


unsigned char BatteryDataRefresh(void)
{
        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);
}


void EnableBattery(unsigned char bat)
{
        // 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));  
}


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


unsigned char RIDLookUp (void)
{
        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);
}


void NTCLookUp (void)
{
        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;
        }
}

---