NIMHcharge.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 "battery.h"
#include "charge.h"
#include "chargefunc.h"
#include "main.h"
#include "menu.h"
#include "NIMHspecs.h"
#include "PWM.h"
#include "time.h"

#ifndef NIMH
#error NIMH not defined in main.h!
#endif // NIMH


//******************************************************************************
// Functions
//******************************************************************************
unsigned char Charge(unsigned char inp)
{
        unsigned char NextState;

        switch (CurrentState) {
        // First stage is a prequalification. Attempt to charge battery to 1 V,
        // using a 0.1 C current, within 2 minutes.
        // If this fails, the battery is likely damaged.
        // If it succeeds, start a fast charge.
        case ST_PREQUAL:
                
                // Set up charge current and next state.
                ChargeParameters.Current = BattData.Capacity / 10;
                ChargeParameters.NextState = ST_FASTCHARGE;
                
                // Halt charge on voltage limit or timeout.
                // Timeout means battery exhaustion.
                HaltParameters.HaltFlags = (HALT_VOLTAGE_MAX | HALT_TIME |
                                            HALT_FLAG_EXHAUSTION);
                
                // Set up voltage limit and temperature limits.
                HaltParameters.VoltageMax = BAT_VOLTAGE_PREQUAL;
                HaltParameters.TemperatureMin = BAT_TEMPERATURE_MIN;
                HaltParameters.TemperatureMax = 35;
                
                // Reset temperature measurement for HaltNow().
                HaltParameters.LastNTC = 0;
                
                // Start PWM and charge timer before calling the charge function.
                PWM_Start();
                Time_Set(TIMER_CHG, BAT_TIME_PREQUAL, 0, 0);
                
                // Call charge function, get next state.
                NextState = ConstantCurrent();
        break;


        // Second stage is a fast charge. Charge at 1.0 C for at most 1.5 hours,
        // until either rate of temperature increase or voltage reaches limit, or
        // the voltage drops sufficiently.
        // Timeout doesn't mean battery exhaustion now.
        case ST_FASTCHARGE:

                // Set up charge current and next state.
                ChargeParameters.Current = BattData.Capacity;
                ChargeParameters.NextState = ST_LOWRATECHARGE;
                
                // Halt charge on voltage limit, timeout, voltage drop or rate of 
                // temperature increase.
                HaltParameters.HaltFlags = (HALT_VOLTAGE_MAX | HALT_TIME |
                                            HALT_VOLTAGE_DROP | HALT_TEMPERATURE_RISE);
                
                // Set up limits for voltage, voltage drop, temperature and rate of 
                // temperature increase (1 degree C per minute).
                HaltParameters.VoltageMax = BAT_VOLTAGE_MAX;
                HaltParameters.VoltageDrop = BAT_VOLTAGE_DROP;
                HaltParameters.TemperatureMax = BAT_TEMPERATURE_MAX;
                HaltParameters.TemperatureRise = 1;
                
                // Reset maximum voltage measurement for HaltNow().
                HaltParameters.VBATMax = 0;

                // Start timer, PWM should still be running.
                Time_Set(TIMER_CHG, BattData.MaxTime, 0, 0);

                // Call charge function, get next state.
                NextState = ConstantCurrent();
        break;


        // Last stage is a trickle charge. Charge at 0.1 C for at most 30 minutes,
        // until either rate of temperature increase or voltage reaches limit.
        case ST_LOWRATECHARGE:
                
                // Set up charge current and next state.
                ChargeParameters.Current = BattData.Capacity / 10;
                ChargeParameters.NextState = ST_ENDCHARGE;
                
                // Halt charge on voltage limit, timeout or temperature rise.
                // Use the same requirements as during the last stage (ST_FASTCHARGE).
                HaltParameters.HaltFlags = (HALT_VOLTAGE_MAX | HALT_TIME |
                                            HALT_TEMPERATURE_RISE);

                // Start timer, 30 minutes.
                Time_Set(TIMER_CHG, 30, 0, 0);
                
                // Call charge function, get next state.
                NextState = ConstantCurrent();
        break;


        // Charging is done!
        case ST_ENDCHARGE:

                // Stop the PWM output and flag battery as charged.
                PWM_Stop();
                BattData.Charged = TRUE;
                
                // If the other battery is enabled go to ST_BATCON, otherwise
                // go to ST_SLEEP.
                if (BattControl[(BattActive+1)%2].Enabled) {
                        NextState = ST_BATCON;
                } else {
                        NextState = ST_SLEEP;
                }               
        break;


        default:  // Shouldn't end up here. Reinitialize for safety.
                NextState = ST_INIT;
                break;
        }

        // Return the next state to main().
        return(NextState);
}

---