NIMHcharge.c File Reference

---

Detailed Description

Charge state function for NiMH batteries.

Contains the charge state function, in which the NiMH charging algorithm is, plus the associated functions.

Application note:

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

2255

$RCSfile$

URL

http://svn.norway.atmel.com/AppsAVR8/avr463_Charging_NiMH_Batteries_with_BC100/trunk/code/IAR/NIMHcharge.c

Date

2007-08-09 14:47:58 +0200 (to, 09 aug 2007)

Definition in file NIMHcharge.c.

#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"

Include dependency graph for NIMHcharge.c:

Go to the source code of this file.

Functions
unsigned char	Charge (unsigned char inp)
	Controls the charging.

---

Function Documentation

unsigned char Charge

(

unsigned char

inp

)

Controls the charging.

This function contains the charging algorithm itself, divided into stages.
For each stage the PWM may be started/stopped, and the timer, halt-requirements and charge parameters may be set.
The charging functions return whatever state is next, and as long as no errors occur this is the next charging stage.

Note:

If more stages are needed simply define more states in menu.h, include them in menu_state[] in menu.c, then add the cases to this function.

This algorithm is for NiMH batteries.

Definition at line 64 of file NIMHcharge.c.

References BAT_TEMPERATURE_MAX, BAT_TEMPERATURE_MIN, BAT_TIME_PREQUAL, BAT_VOLTAGE_DROP, BAT_VOLTAGE_MAX, BAT_VOLTAGE_PREQUAL, BattActive, BattControl, BattData, Batteries_struct::Capacity, Batteries_struct::Charged, ChargeParameters, ConstantCurrent(), ChargeParameters_struct::Current, CurrentState, HALT_FLAG_EXHAUSTION, HALT_TEMPERATURE_RISE, HALT_TIME, HALT_VOLTAGE_DROP, HALT_VOLTAGE_MAX, HaltParameters_struct::HaltFlags, HaltParameters, HaltParameters_struct::LastNTC, Batteries_struct::MaxTime, ChargeParameters_struct::NextState, PWM_Start(), PWM_Stop(), ST_BATCON, ST_ENDCHARGE, ST_FASTCHARGE, ST_INIT, ST_LOWRATECHARGE, ST_PREQUAL, ST_SLEEP, HaltParameters_struct::TemperatureMax, HaltParameters_struct::TemperatureMin, HaltParameters_struct::TemperatureRise, Time_Set(), TIMER_CHG, TRUE, HaltParameters_struct::VBATMax, HaltParameters_struct::VoltageDrop, and HaltParameters_struct::VoltageMax.

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

Here is the call graph for this function:

---