chargefunc.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include <ioavr.h>

#include "enums.h"
#include "structs.h"

#include "ADC.h"
#include "battery.h"
#include "chargefunc.h"
#include "main.h"
#include "menu.h"
#include "PWM.h"
#include "statefunc.h"
#include "time.h"

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

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


//******************************************************************************
// Variables
//******************************************************************************
ChargeParameters_t ChargeParameters;

HaltParameters_t HaltParameters;


//******************************************************************************
// Functions
//******************************************************************************
unsigned char ConstantCurrent(void)
{
        unsigned char error = FALSE,
                      wasStopped = FALSE;
        
        do      {
      // Wait for ADC conversions to complete.
                ADC_Wait();

                // If Master has flagged for a charge inhibit, pause charging.
                // (This is to prevent damage during prolonged serial communication.)
                if (BattControl[BattActive].ChargeInhibit) {
                        wasStopped = TRUE;
                        Time_Stop();
                        OCR1B = 0;
                } else {
                        // Continue charging!
                        if (wasStopped) {
                                wasStopped = FALSE;
                                
                                // Timer variables are not reset by this.
                                Time_Start();
                        }
         
                        // Adjust the charge current to within ChargeParameters.Current
                        // +/- BAT_CURRENT_HYST.
                        if ((ADCS.avgIBAT < 0) ||
                            (ADCS.avgIBAT < (ChargeParameters.Current - BAT_CURRENT_HYST))) {
                                         
                                if(!PWM_IncrementDutyCycle()) {
#ifdef ABORT_IF_PWM_MAX
                                // If the duty cycle cannot be incremented, flag error and
                                // go to error state.
                                        SetErrorFlag(ERR_PWM_CONTROL);
                                        ChargeParameters.NextState = ST_ERROR;
                                        error = TRUE;
#endif
                                }
                        } else if ((ADCS.avgIBAT >= 0) &&
                                 (ADCS.avgIBAT > (ChargeParameters.Current + BAT_CURRENT_HYST))) {
                                         
                                if(!PWM_DecrementDutyCycle()) {
#ifdef ABORT_IF_PWM_MIN
                                        // If the duty cycle cannot be decremented, flag error and
                                        // go to error state.
                                        SetErrorFlag(ERR_PWM_CONTROL);
                                        ChargeParameters.NextState = ST_ERROR;
                                        error = TRUE;
#endif
                                }
                        }
                }
        } while (!HaltNow() && !error);

        // Return the next state to Charge(). If an error has occured, this will
        // point to some other state than the next state of charging.
        return(ChargeParameters.NextState);
}


unsigned char ConstantVoltage(void)
{
        unsigned char error = FALSE,
                      wasStopped = FALSE;
        
        do{
                
                // Wait for ADC conversions to complete.
                ADC_Wait();
                
                // If Master has flagged for a charge inhibit, pause charging.
                // (This is to prevent damage during prolonged serial communication.)
                if (BattControl[BattActive].ChargeInhibit) {
                        wasStopped = TRUE;
                        Time_Stop();
                        OCR1B = 0;
                }
                
                else {
                        // Continue charging!
                        if (wasStopped) {
                                wasStopped = FALSE;
                                
                                // Timer variables aren't reset by this.
                                Time_Start();
                        }
                        
                        // Adjust the charge voltage to within ChargeParameters.Voltage
                        // +/- BAT_VOLTAGE_HYST.
                        if (ADCS.VBAT < (ChargeParameters.Voltage - BAT_VOLTAGE_HYST)) {

                                if(!PWM_IncrementDutyCycle()) {
#ifdef ABORT_IF_PWM_MAX
                                // Flag PWM control error and go to error-state if the duty
                                // cycle cannot be incremented.
                                        SetErrorFlag(ERR_PWM_CONTROL);
                                        ChargeParameters.NextState = ST_ERROR;
                                        error = TRUE;
#endif
                                }
                        } else if (ADCS.VBAT > (ChargeParameters.Voltage + BAT_VOLTAGE_HYST)) {

                                if(!PWM_DecrementDutyCycle()) {
#ifdef ABORT_IF_PWM_MIN
                                        // Flag PWM control error and go to error-state if duty
                                        // cycle cannot be decremented.
                                        SetErrorFlag(ERR_PWM_CONTROL);
                                        ChargeParameters.NextState = ST_ERROR;
                                        error = TRUE;
#endif
                                }
                        }
                }

        } while (!HaltNow() && !error);

        // Return the next state to Charge(). If an error has occured, this will
        // point to some other state than the next state of charging.
        return(ChargeParameters.NextState);
}


unsigned char HaltNow(void)
{
        unsigned char i, halt = FALSE;
        
        // Wait for a full ADC-cycle to finish.
        ADC_Wait();

        // Evaluate ADC readings according to HaltFlags. Flag errors if selected.
        // If an error is flagged, ChargeParameters.NextState is set to ST_ERROR.
        // (Gets overridden if either mains is failing, or the battery changes.)
        for (i = 0x01; i != 0; i <<= 1) {
                if (HaltParameters.HaltFlags & i) {
                        switch (i) {
                        // Is VBAT less than the recorded maximum?
                        case HALT_VOLTAGE_DROP:

                                // Update VBATMax if VBAT is higher. Evaluate for halt otherwise.
                                if (ADCS.VBAT > HaltParameters.VBATMax) {
                                        HaltParameters.VBATMax = ADCS.VBAT;
                                } else if((HaltParameters.VBATMax - ADCS.VBAT) >= 
                                          HaltParameters.VoltageDrop) {
                                        halt = TRUE;
                                }
                        break;

                        
                        // Has VBAT reached the maximum limit?
                        case HALT_VOLTAGE_MAX:  
                                
                                if (ADCS.VBAT >= HaltParameters.VoltageMax) {
                                        halt = TRUE;
                                }
                                break;


                        // Has IBAT reached the minimum limit?
                        case HALT_CURRENT_MIN:
                                
                                if (ADCS.avgIBAT <= HaltParameters.CurrentMin) {
                                        halt = TRUE;
                                }
                                break;
        
                                
                        // Is the temperature rising too fast?
                        case HALT_TEMPERATURE_RISE:

                                // If rawNTC has increased, the temperature has dropped.
                                // We can store this value for now, and start the timer.
                                // Otherwise, check if NTC has changed too fast.
                                if (ADCS.rawNTC > HaltParameters.LastNTC) {
                                        HaltParameters.LastNTC = ADCS.rawNTC;
                                        Time_Set(TIMER_TEMP,0,30,0);
                                        
                                // Is the increase in temperature greater than the set threshold?
                                } else  if ((HaltParameters.LastNTC - ADCS.rawNTC) >=
                                  (BattData.ADCSteps * HaltParameters.TemperatureRise)) {
                                        
                                        // If this happened within a timeframe of 30 seconds, the 
                                        // temperature is rising faster than we want.
                                        // If not, update LastNTC and reset timer.
                                        if (Time_Left(TIMER_TEMP))  {
                                                halt = TRUE;
                                        } else {
                                                HaltParameters.LastNTC = ADCS.rawNTC;
                                                Time_Set(TIMER_TEMP,0,30,0);
                                        }
                                }
                        break;
        
                        
                        // Is there any time left?
                        case HALT_TIME:  
                                
                                if (!Time_Left(TIMER_CHG)) {
                                        halt = TRUE;
                                        
                                        // If exhaustion flagging is selected, stop the PWM, disable the 
                                        // battery and flag it as exhausted. Make ST_ERROR next state.
                                        if (HaltParameters.HaltFlags & HALT_FLAG_EXHAUSTION) {
                                                        PWM_Stop();
                                                        BattControl[BattActive].Enabled = FALSE;
                                                        BattData.Exhausted = TRUE;
                                                        SetErrorFlag(ERR_BATTERY_EXHAUSTED);
                                                        ChargeParameters.NextState = ST_ERROR;
                                        }
                                }
                        break;
                        
                        
                        default:  // Shouldn't end up here, but is needed for MISRA compliance.
                        break;
                        }
                }
        }

        // Standard checks:

        // Battery too cold or hot?
        if ((BattData.Temperature <= HaltParameters.TemperatureMin) ||
            (BattData.Temperature >= HaltParameters.TemperatureMax)) {
                        
                PWM_Stop();
                SetErrorFlag(ERR_BATTERY_TEMPERATURE);
                ChargeParameters.NextState = ST_ERROR;
                halt = TRUE;
        }

        // Battery not OK?
        if (!BatteryCheck()) {
                PWM_Stop();
                ChargeParameters.NextState = ST_INIT;
                halt = TRUE;
        }

        // Is mains voltage OK?
        if (!ADCS.Mains) {
                PWM_Stop();
                ChargeParameters.NextState = ST_SLEEP;
                halt = TRUE;
        }

        return(halt);
}

---