statefunc.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 <stdlib.h>

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

#include "ADC.h"
#include "statefunc.h"
#include "battery.h"
#include "charge.h"
#include "main.h"
#include "menu.h"
#include "OWI.h"
#include "PWM.h"
#include "time.h"
#include "USI.h"


//******************************************************************************
// Variables
//******************************************************************************
unsigned char ErrorFlags;  


unsigned char ErrorState;


//******************************************************************************
// Functions
//******************************************************************************
unsigned char Initialize(unsigned char inp)
{
        unsigned char i, page;

        // Disable interrupts while setting prescaler.
        __disable_interrupt();
        
        CLKPR = (1<<CLKPCE);          // Enable CLKPS bit modification.
        CLKPR = 0;                    // Set prescaler 1 => 8 MHz clock frequency.
        
        // Init 1-Wire(R) interface.
        OWI_Init(OWIBUS);
        
        // Clear on-chip EEPROM.
        for (page = 0; page < 4; page++)        {
                for (i = 0; i < 32; i++) {
                        BattEEPROM[page][i] = 0;
                }
        }

        DDRB = (1<<PB4) | (1<<PB5);   // Set battery enable pins as outputs.
        DisableBatteries();
        SPI_Init(SPIMODE);
        ADC_Init();
        Time_Init();

        // Attempt to get ADC-readings (also gets RID-data) from both batteries.
        for (i = 0; i < 2; i++) {
                EnableBattery(i);
                ADC_Wait();
                BatteryStatusRefresh();
        }
    
        DisableBatteries();
        
        BattActive = 0;               // We have to start somewhere..
        ErrorFlags = 0;
        
        // Init complete! Go to ST_BATCON next.
        return(ST_BATCON);
}


unsigned char BatteryControl(unsigned char inp)
{
        unsigned char i;
        
        // Make sure ADC inputs are configured properly! (Will disables batteries.)
        if (!JumperCheck()) {
                return(ST_ERROR);           // Error. Exit before damage is done!
        }
        
        // If neither battery is valid, flag error and go to error state
        if ((!BattControl[0].Enabled) && (!BattControl[1].Enabled)) {
                SetErrorFlag(ERR_NO_BATTERIES_ENABLED);
                
                return(ST_ERROR);
        }

        // Get ADC-readings, try to read EPROM, and start prequalification
        // of any uncharged battery.
        for (i = 0; i < 2; i++) {
                if (BattControl[i].Enabled) {      
                        EnableBattery(i);
                        ADC_Wait();

                        if (BatteryStatusRefresh()) {
                                if (!BattData.Charged) {
                                        BatteryDataRefresh();

                                        return(ST_PREQUAL);       
                                }
                        }
                }
        }

        // If we end up here, one or two batteries are found and fully charged.
        // Disconnect, so we don't drain them, and go to sleep.
        DisableBatteries();

        return(ST_SLEEP);
}


unsigned char Discharge(unsigned char inp)
{
        return(ST_BATCON);  // Supply voltage restored, start charging
}


unsigned char Sleep(unsigned char inp)
{
        unsigned char i;

        do {
                Doze();               // Take a nap (~8 seconds).

                // If any batteries need charging, go to ST_BATCON.
                // Otherwise, keep sleeping.
                for (i = 0; i < 2; i++) {
                        EnableBattery(i);
                        ADC_Wait();
                        if ((BatteryStatusRefresh()) && (!BattData.Charged)) {
                                return(ST_BATCON);
                        }
                }
                
                DisableBatteries();  // Disable both batteries before Doze()!
        } while (TRUE);
}


void Doze(void)
{
        // Wait for this ADC cycle to complete, then halt after the next one.
        ADC_Wait();
        ADCS.Halt = TRUE;
        ADCS.Flag = FALSE;
        
        do {
        } while (ADCS.Flag == FALSE);    
        
        WDTCR = (1<<WDP3)|(1<<WDP0);            // 8.0 seconds at 5 volts VCC.
        WDTCR |= (1<<WDIF)|(1<<WDIE)|(1<<WDE);  // Clear flag and enable watchdog.
        MCUCR |= (1<<SE) | (1<<SM1)|(1<<SM0);   // Sleep enable, mode = standby.
        __sleep();                              // Go to sleep, wake up by WDT.
        
        __watchdog_reset();                     // Clear watchdog reset flag.
        MCUSR &= ~(1<<WDRF);          
        WDTCR |= (1<<WDCE)|(1<<WDE);            // Watchdog change enable.
        WDTCR = 0;                              // Turn off watchdog.
        
        ADCS.Halt = FALSE;                      // Enable consecutive runs of ADC.
        ADCSRA |= (1<<ADEN)|(1<<ADSC);          // Enable ADC & start conversion.
        
        // Wait for this cycle to complete.
        ADC_Wait();                             
}


unsigned char Error(unsigned char inp)
        {
        unsigned char i;
        
        PWM_Stop();           // Stop charging.
        DisableBatteries();   // Disable all loads.
        
        do {
                Doze();           // Take a nap.

                // For each bit in ErrorFlags, starting with LSB, handle
                // associated error, if the flag is set.
                for (i = 0x01; i!=0; i<<=1) {
                        if(i & ErrorFlags) {
                                switch (i) {
                                
                                case  ERR_JUMPER_MISMATCH:
                                        // Clear flag & recheck.
                                        ErrorFlags &= ~i;
                                        JumperCheck();
                                break;


                                case  ERR_NO_BATTERIES_ENABLED:
                                        // Clear if any battery gets enabled.
                                        if ((BattControl[0].Enabled) || (BattControl[1].Enabled)) {
                                                        ErrorFlags &= ~i;
                                        }
                                break;


                                case  ERR_PWM_CONTROL:
                                        // Clear flag.
                                        ErrorFlags &= ~i;
                                break;


                                case  ERR_BATTERY_TEMPERATURE:
                                        // Clear flag.
                                        ErrorFlags &= ~i;
                                break;


                                case  ERR_BATTERY_EXHAUSTED:
                                        // Try the other battery.
                                        BattData.Exhausted = FALSE;
                                        BattActive = (BattActive + 1) % 2;
                                        ErrorFlags &= ~i;
                                break;

                                        
                                default:
                                break;
                                }
                        }
                }
        } while (ErrorFlags);

        return(ST_INIT);
}


void SetErrorFlag(unsigned char Flag)
{
        ErrorFlags |= Flag;
        ErrorState = CurrentState;
}


unsigned char JumperCheck(void)
{
         DisableBatteries();       // Disconnect, or loads may be destroyed!
         
         PWM_Start();              // Start PWM (controls the buck charger).
        
         // Use general timer: shouldn't take longer than (6 x 255) / 2500 ~= 0.62s.
         Time_Set(TIMER_GEN,0,1,0);
        
        do {
                // If the PWM output voltage saturates the ADC, stop PWM output and
                // report a failure.
                if (ADCS.rawVBAT == 1023) {
                        PWM_Stop();
                        return(FALSE);
                }

                // If the absolute difference between measured (VIN - VBAT) and the
                // typical value are below our set maximum, everything is OK.
                if (abs((signed int)(ADCS.VIN - VIN_VBAT_DIFF_TYP - ADCS.VBAT)) <
                                     VIN_VBAT_DIFF_MAX ) {
                                 
                        PWM_Stop();
                        return(TRUE);
                }

                // Charge current is too high -> check load and jumper J405 and J406.
                if (abs(ADCS.IBAT) > 100) {
                        PWM_Stop();
                        return(FALSE);
                }

                // If the PWM output can't be increased high enough -> check jumpers
                // J400-J404, J407 and J408.
                if (!PWM_IncrementDutyCycle()) {
                        PWM_Stop();
                        return(FALSE);
                }
                
      // Wait for ADC conversions to complete
                ADC_Wait();
        } while (Time_Left(TIMER_GEN));
        

        // If we end up here, the measurements took too long.
        PWM_Stop();
        return(FALSE);
}

---