root/trunk/HighVoltageControllerIMPROVED.c

#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/sleep.h>
#include <avr/wdt.h>

//#define MAX_THROTTLE 511
//#define MIN_THROTTLE 0


#define F_OSC 16000000                     /* oscillator-frequency in Hz */
#define UART_BAUD_RATE 19200
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)


#define PRE_SCALED_ZERO_THROTTLE 712 // Anything bigger than 989 means 0% throttle. 
#define PRE_SCALED_MAX_THROTTLE 413 // Anything smaller than 683 means 100% throttle.
#define PRE_SCALED_OPEN_CIRCUIT_THROTTLE        150     // Indicates a bad throttle.  Over ?? kOhms.
//#define MIN_TEMP 744                          // Start limiting current at 69 degC
//#define MAX_TEMP 808                          // Max temperature allowed is 80 degC
#define MAX_CURRENT 506
#define THERMAL_CUTBACK_START 780       // start at 75 degC, end at 85 degC.

//#define MAX_THROTTLE

// FOR CURRENT, using the LEM HASS 300, the 10 bit A/D converter outputs:

// It makes for a range of 213.
// I also want the throttle to have the same range as the current.
// Right now, 0 throttle is 0, and max throttle is 511.
// I need to map the current onto 0, 511.
// 500 amps -----> 725
// 0 amps   -----> 512

// READ CURRENT.
// IT'S IN [512, 512+213]
// subtract 512
// now its in [0, 213]
// times 24
// divide by 10.
// Now it's in the range [0, 511.2]



// There are 4 Analog to Digital Voltages.  The input of each will range from 0 to 5v.
// After the A/D conversion, the value will be between 0 and 1023.
// 0 will mean 0 volts was measured.  1023 will mean that 5v was measured.
volatile int16_t throttlePos=0; // the desired current.  in [0, 255].
volatile int16_t _throttlePos = 0;
volatile int16_t pwmDuty = 0;
volatile int16_t temperature = 0;       // temperature measurement. Monitor the MOSFETs with a thermistor.
volatile int16_t current = 0;   // How much current is being used on a moment by moment basis.
volatile int16_t _current = 0;
volatile int16_t tempCurrent = 0;


volatile int16_t currentSum = 0;
volatile int16_t aveCurrent = 0;
volatile int16_t vRef = 512;                    // vRef is the average measurement of the current sensor at 0 volts.
volatile int16_t tempCounter = 0; // counter for temperature, so it will only be checked every couple seconds.
volatile int16_t j = 0;
volatile int16_t i = 0;
volatile int16_t dummy = 0;
volatile uint16_t ISRCounter = 0;
volatile int16_t innerDelay = 0;

//volatile int16_t temp = 0;

volatile int16_t overshoot = 0;

volatile char relayLow = 1;
volatile char cSREG;

volatile unsigned char onesPlace=0, tensPlace=0, hundredsPlace=0, timeForChrisStuff = 0;



void InitUSART(void) {
        // set baud rate
        UBRRH = (uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
        UBRRL = (uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

        // Enable receiver and transmitter; enable RX interrupt
//      UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
        UCSRB = (1 << TXEN);// | (1 << RXCIE);

        //asynchronous 8N1
        UCSRC = (1 << URSEL) | (3 << UCSZ0);
}

// INTERRUPT can be interrupted
// SIGNAL can't be interrupted
//SIGNAL (SIG_UART_RECV) { // USART RX interrupt
//      unsigned char c;
//      c = UDR;
//      PutCharUSART(c);
//}

void PutCharUSART(unsigned char c) {
   // wait until UDR ready
        while(!(UCSRA & (1 << UDRE)));  // wait until the USART data register is empty.
        UDR = c;    // send character
}


// Initialize the Pulse Width Modulator timer.
// Let's use timer 1, the 16 bit timer.  The others are 8 bit.
// 1.  Select the bits that you want set in TCCR1A.  See pg. 98 for help with this.
// 2.  Set the speed of your pwm by setting the bits you want in TCCR1B.  See pg. 100.
// 3.  Enable Pin B1 as the output for the pwm signal that you made.  See pg. 97.
// 4.  Initialize the value of the pwm to 0.  (may not be necessary)

// *TESTED PREVIOUSLY*
void InitPWM (void)
{
        // Note:  _BV means the bit value.  So, _BV(COM1A1) is 128, because COM1A1 is bit 7 (2^7) in the TCCR1A register.
        // Non-inverted mode!
//      TCCR1A = _BV(COM1A1) | _BV(WGM10); // Pg. 98. Phase correct PWM Mode, TOP = 511.
        TCCR1A = 128 + 2;  // set COM1A1 and WGM11

        //TCCR1B &= (128+64+32);        // This turns the binary number 111xxxxx into 11100000
        //TCCR1B |= _BV(CS10); // pg. 100. Pre-scaler = 1.
        TCCR1B = 1;  // pg. 100.  Pre-scaler = 1.

        // Enable OC1A (the Output Compare Match A Output Pin) as the output pin of the PWM at pin B1.
        // DDRB (Port B Data Direction Register) bit 1 must be set to 1 to make Pin B1 act as the 
        //   Output Pin for the PWM.
        PORTB &= (128 + 64 + 32 + 16 + 8 + 4 +    1); // this sets PB1 (the pwm output) to 0 at startup.  Notice '2' is missing!
        DDRB = _BV(PINB1); // Enable pin b1 to act as an output.  Pg. 52.

    // OCR1A is the throttle value.  
        // Set Initial PWM duty value to 0, both high and low bytes.
    OCR1A = 0; 

        TIMSK = _BV(TOIE1);     // make an interrupt happen each time the timer reaches the bottom.
        sei(); // set global interrupt enable bit.
}

// This initializes the analog to digital converter.
// 1.  Enable the converter by setting the ADEN bit in ADCSRA
// 2.  Choose the sample speed, by messing with ADPS0, ADPS1, and ADPS2.
// 3.  Choose what voltage you want the converter to view as the highest.  The lowest will be 0.
//              To do that, you must mess with the REFS bits in the ADMUX register.
// 4.  Choose which A/D channel you want to use by messing with the MUX bits in ADMUX register.
// 5.  To start a conversion, you must set the ADSC bit in the ADCSRA.  Then you have to wait
//      for it to finish.  The result is in the ADC data register, so save it in some variable.

// *TESTED PREVIOUSLY*
void InitADC(void) {    
        ADCSRA = _BV(ADEN) | _BV(ADPS2);// | _BV(ADPS0);// pg. 208. How fast to sample ADC? 16MHz/16

        ADMUX = _BV(REFS0);     // Use AVcc as the reference voltage for the ADC, pg. 206
}


void DoChrisStuff(void) {
        // toggle relay every second.
        if (relayLow) {
                PORTD &= 0b01111111; // bring pin d7 low
                PORTD &= 0b10111111; // Bring pin d6 low
                relayLow = 0; // now switch it for next time.
        }
        else {
                PORTD |= 0b10000000; // bring pin d7 high
                PORTD |= 0b01000000; // Bring pin d6 high
                relayLow = 1;
        }
        // current is in the range of 0 to 512, which is 0 to 500 amps.  Pretend it's 512 amps.
        // ex:  current = 218 =  
        // I need to output '2', '1', '8', 0x0D, 0x0A

        onesPlace = (tempCurrent & 15) + 48;  // add 48 to make it a character instead of a number.  See ascii table.
        tempCurrent = tempCurrent >> 4;  // now we're onto the 10's place.
        tensPlace = (tempCurrent & 15) + 48;  // add 48 to make it a character instead of a number.  See ascii table.
        tempCurrent = tempCurrent >> 4;  // now we're onto the 100's place.
        hundredsPlace = (tempCurrent & 15) + 48;  // add 48 to make it a character instead of a number.  See ascii table.

        PutCharUSART(hundredsPlace);
        PutCharUSART(tensPlace);
        PutCharUSART(onesPlace);
        PutCharUSART(0x0D);     // carriage return, line feed
        PutCharUSART(0x0A);
}

// This checks the Analog to Digital Converter Throttle input.
// 1.  Choose which ADC channel (which pin on the chip) you want to convert the voltage of. Pg. 206.
// 2.  Set the ADSC bit to 1.  This starts the conversion.
// 3.  Wait for the conversion to finish.  (Do nothing until it's done)
// 4.  The result is saved in ADC.  Move that result to a variable for later.

void ReadThrottle(void) {
        // Select channel 0.

        ADMUX &= (128+64+32+16);        // = 11110000.  So, this sets MUX to 0000, and leaves the top 4 bits unchanged.
                                                                // pg. 206

        // Read throttle position.
        // Pg. 198.

        ADCSRA |= 64;   // 64  = 01000000.  So, this sets the ADSC Start Conversion Bit.
        while (ADCSRA & 64);    // Do nothing until the conversion is done.
        throttlePos = ADC;

// zero throttle is 989 OR GREATER.  That's a 10% dead zone.
// Full throttle is 683

//      if (throttlePos < PRE_SCALED_OPEN_CIRCUIT_THROTTLE) {   // Bad Throttle!  More than ??kOhms from a 5k pot!
//              throttlePos = 0;
//              for (i = 0; i < 16; i++) {
//                      ADCSRA |= 64;   // 64  = 01000000.  So, this sets the ADSC Start Conversion Bit.
//                      while (ADCSRA & 64);    // Do nothing until the conversion is done.
//                      dummy = ADC;
//                      throttlePos += dummy;
//              }
//              throttlePos >>= 4; // find the average of the 16 throttle reads, to make sure it wasn't just a bad read.
//              if (throttlePos < PRE_SCALED_OPEN_CIRCUIT_THROTTLE) {  // if the average of 16 throttle reads was bad...
//                      OCR1A = 0;  // make sure PWM duty is 0.  Kill the throttle.
//                      while (1) {
//                              wdt_reset();  // get a new dang throttle!  hahaha!
                                                                // don't let the watchdog reset the program.
//                      }
//              }
//      }

        if (throttlePos < PRE_SCALED_MAX_THROTTLE) // 683 is max throttle this time.
                throttlePos = PRE_SCALED_MAX_THROTTLE; // 683


        if (throttlePos > PRE_SCALED_ZERO_THROTTLE) // 989, allowing for 10% dead zone.
                throttlePos = PRE_SCALED_ZERO_THROTTLE; // 989.

        throttlePos -= PRE_SCALED_MAX_THROTTLE;
        // Now throttlePos is in [0, 306].
        throttlePos = (PRE_SCALED_ZERO_THROTTLE - PRE_SCALED_MAX_THROTTLE) - throttlePos;
        // Now, 0 throttle is 0, and max throttle is 306.
        // 
        //throttlePos *= 1.66;
        // do throttlePos*53/32.

        //throttlePos += (2*throttlePos)/3;
        throttlePos *= 53;
        throttlePos >>= 5;      // divide by 32.
        // now throttlePos is in [0, 507], about identical to current range.
        // this is important because the PWM range is 0 to 511, where 0 means 0% duty, and 511 means 100% duty.
}

// *TESTED IN SIMULATOR*
void ReadCurrent(void) {

        // Select channel 2.
        ADMUX &= (128+64+32+16);        // = 11110000.  So, this sets MUX to 0000, and leaves the top 4 bits unchanged.
                                                                // pg. 206
        ADMUX+=2;               // This sets MUX to 0002, setting the A/D converter input to PIN 25, the current monitor
                                        // on the chip.

        // Read current
        // Pg. 198.
        ADCSRA |= 64;   // 64  = 01000000.  So, this sets the ADSC Start Conversion Bit.
        while (ADCSRA & 64);    // Do nothing until the conversion is done.
        current = ADC;


        // Current starts in [512, 512 + 213]  (if it's in 0 to 500 amps for the LEM 300)
        if (current < vRef) // if slightly below 0, just call it 0.
                current = vRef;
        current -= vRef;
        // Now current is in the range [0, 213] or so...
        current *= 19; // (19/8 is almost 2.4)
        current >>= 3;
//      current <<= 2; // now it's in [0, 512] for LEM 500.
        // Now current is in [0, 506] or so, close to same as throttle range.
}

// *TESTED PREVIOUSLY*

void ReadTemperature(void) {
        ADMUX &= (128+64+32+16);        // = 11110000.  So, this sets MUX to 0000, and leaves the top 4 bits unchanged.
                                                                // pg. 206
        ADMUX++;                // This sets MUX to 0001, setting the A/D converter input to PIN 24, the temperature monitor.
                                        // on the chip.

        // Read temperature.
        // Pg. 198.
        ADCSRA |= 64;   // 64  = 01000000.  So, this sets the ADSC Start Conversion Bit.
        while (ADCSRA & 64);    // Do nothing until the conversion is done.
        temperature = ADC;
}

// *TESTED PREVIOUSLY*
void HighPedalLockout(void) {
//      pwmDuty = 0;
        OCR1A = 0;
        do {
                ReadThrottle();
                wdt_reset();  
        } while (throttlePos > 0);
}

// At 8 MHz, a 'for' loop of 100 iterations takes 280 microseconds according to the debugging simulator.
// To call the function takes 4.6 microseconds.
// So, a delay of 21 is about one PWM period.  2 nand gates in series need 1 microsecond to change
// their state, so at least a delay of 1 is fine for resetting the flip flop. 

// It is important to have Optimization turned off in Configuration Options.
// The optimizations don't let you do a loop for no reason.
// *TESTED IN SIMULATOR*
// watch out for the watchdog timeout if you use too large of a delay.
void Delay(int k) {
        //volatile int m;
        int m;
        for (m = 0; m < k; m++);
        return;
}

void BigDelay(int k) {
        int m, n;
        
        for (m = 0; m < k; m++) {
                for (n = 0; n < 1000; n++);
        }
}

// This checks for and deals with an over current event!  haha.  If there is an overcurrent event,
// it delays, and then clears the overcurrent event by pulsing port b2 low for a moment.

// *TESTED IN SIMULATOR*
// Nothing bad happens as far as I can tell if the interrupt happens at any point in this function.
/*
void CheckForAndDealWithOverCurrentEvent(void) {
// for things configured as inputs, to read the value of the input, you read pinb, not portb!
// TO SET VALUES, YOU MUST USE PORTB, NOT PINB!

        // if pin b0 is 1, then an overcurrent event has occurred.  Turn on the mosfet driver once
        // the current has dropped below MAX_CURRENT, and after a small extra delay.

        if (PINB & 1) { 
//              do {
//                      ReadCurrent();
                        //wdt_reset();
//              } while (current > MAX_CURRENT);
//              Delay(50);
                // Fran suggests to delay for at least 4 periods.
//              Delay(100); // slightly over ?? periods.
                // One period is 62.5 us.


                // At this point, portb2 is high.  It was initialized high at the beginning.
                // clear the overcurrent event.  Bring port b2 low...
                PORTB &= 128 + 64 + 32 + 16 + 8     + 2 + 1; // Set port b2 to 0.
                Delay(2);
                // Now bring port b2 high again...  This clears the overcurrent event.
                PORTB |= 4; // Set port b2 to 1.
        }
        // else, everything is fine!  Do nothing!
        return;
}
*/


ISR (TIMER1_OVF_vect) {
        ReadCurrent();

        ISRCounter++;
//      currentSum += current;
//      if (ISRCounter % 32 == 0) {
//              _current = currentSum >> 5;  // the average of the last 32 reads!
                                                                                // the very first read will be current = 0. but who cares.
//              currentSum = 0;  // reset currentSum.
//      }

        if (PINB & 1) { // clear overcurrent event.
                // At this point, portb2 is high.  It was initialized high at the beginning.
                // clear the overcurrent event.  Bring port b2 low...
                PORTB &= 128 + 64 + 32 + 16 + 8     + 2 + 1; // Set port b2 to 0.
                Delay(2);
                // Now bring port b2 high again...  This clears the overcurrent event.
                PORTB |= 4; // Set port b2 to 1.
                if (pwmDuty)
                        pwmDuty--;
        }

        if ((ISRCounter & 16383) == 16383) {
                ReadTemperature();
                //ISRCounter = 0;
                timeForChrisStuff = 1;
        }
        //else if ((ISRCounter & 16383) == 16383) {
                //DoChrisStuff();
        //      timeForChrisStuff = 1;
        //}
        else if ((ISRCounter & 15) == 15) {
                ReadThrottle();
                _throttlePos = throttlePos;


                // The temperature is an input from the A/D converter.  It is in the range of 0 to 1023.
                // These numbers are specific to the Thermistor Part# B57862S103F40 from Digikey.

                // 25 degC      327
                // 30 degC      377
                // 35 degC      429
                // 40 degC      480
                // 45 degC      537
                // 50 degC      580
                // 55 degC      626
                // 60 degC      670
                // 65 degC      710
                // 70 degC      746
                // 75 degC      779
                // 80 degC      808
                // 85 degC      834
                // 90 degC      857
                // 95 degC      877
                // 100 degC     895
                // This shifts the current limit down based on how hot the controller is.
                // If the temperature is about 70 degC, the current limit is 437 amps.
                // If the temperature is about 75 degC, the current limit is about 250 amps.
                // At around 80 degC, the current limit is 0.

                if (temperature > THERMAL_CUTBACK_START) {      // start of thermal cutback.
                        if (temperature < THERMAL_CUTBACK_START+8) // throttlePos = 7/8*throttlePos.
                                _throttlePos = (7*throttlePos) >> 3;

                        else if (temperature < THERMAL_CUTBACK_START + 16)      // throttlePos = 6/8*throttlePos;
                                _throttlePos = (6*throttlePos) >> 3;            

                        else if (temperature < THERMAL_CUTBACK_START + 24)      // throttlePos = 5/8*throttlePos;
                                _throttlePos = (5*throttlePos) >> 3;
        
                        else if (temperature < THERMAL_CUTBACK_START + 32)      // throttlePos = 4/8*throttlePos;
                                _throttlePos = throttlePos >> 1;                
        
                        else if (temperature < THERMAL_CUTBACK_START + 40)      // throttlePos = 3/8*throttlePos;
                                _throttlePos = 3*(throttlePos >> 3);
        
                        else if (temperature < THERMAL_CUTBACK_START + 48)      // throttlePos = 2/8*throttlePos;
                                _throttlePos = throttlePos >> 2;

                        else if (temperature < THERMAL_CUTBACK_START + 56)      // throttlePos = 1/8*throttlePos;
                                _throttlePos = throttlePos >> 3;

                        else
                                _throttlePos = 0;
                }
                if (pwmDuty > _throttlePos) {
                        if (pwmDuty)
                                pwmDuty--;
                }
                else if (_current > _throttlePos) {  // if current > max_current
                        if (pwmDuty)
                                pwmDuty--;
                }
                else if (pwmDuty < _throttlePos) {
                        pwmDuty++;
                }
                OCR1A = pwmDuty;
        }
        return;
}

// *TESTED IN SIMULATOR*
// Pin b0 is going to be a flag to let the controller know that the hardware shut off the mosfets.
// Pin b0 is 0 if the hardware has not shut off the mosfets.  If you read the value of pin b0 is
// 1, then a hardware overcurrent shutdown has occurred.  You then have a delay, and clear the
// hardware overcurrent event by changing port b2 from 1 to 0, and then back to 1.
// First pin b0 needs to be initialized as an input and pin b2 initialized as an output.

// *TESTED IN SIMULATOR*
void InitializeIOPins(void) {

        DDRB |= 4;      // Configure PINB2 as output
        // The stupid documentation says this next step might be necessary.  See pg. 52.
        PORTB &= 128 + 64 + 32 + 16 + 8     + 2 + 1; // Set pin b2 to 0.

        // Pulsing pin b2 low for a moment guarantees that the state of the flip flop in the hardware overcurrent
        // shutdown circuit is known.
        PORTB |= 4;     // set pin b2 to 1.
        Delay(5);
        PORTB &= 128 + 64 + 32 + 16 + 8     + 2 + 1; // Set Pinb2 to 0.
        Delay(5);
        PORTB |= 4;     // set it to 1.

        DDRD |= _BV(PD7);  // configure pin d7 for output.  It is a relay that turns on the main contactor.
        DDRD |= _BV(PD6);  // configure pin d6 for output.  It is the IDLE LED.  Pulse it every second for Chris.

        // Now configure pin b0 as an input pin.  It will be the indicator of when a hardware overcurrent
        // shutdown has occurred.  Reading a 0 from this pin means there has NOT been an
        // overcurrent shutdown, so everything is working normally.  Reading a 1 from this pin means
        // that an overcurrent shutdown has happened.  So, you will have to delay for a bit, and then
        // output a trip reset at port b2 to turn the mosfet driver back on.
        
        // setting DDRB bit 'n' to 0 makes that bit configured for input.
        DDRB &= 128 + 64 + 32 + 16 + 8 + 4 + 2; // DDRB = XXXXXXX0  Configure PINB0 as input.
        PORTB |= 1;     // Maybe unnecessary intermediate step.  See page 52.
        PORTB &= 128 + 64 + 32 + 16 + 8 + 4 + 2; // PORTB = XXXXXXX0 Turn off the pull-up resistor at pin b0.
        return;
}

int main (void) {
        InitADC();      // initialize the analog to digital converter
        InitializeIOPins(); // pin b0 acts as an input, pin b2 acts as an output.
        InitUSART();
//      wdt_enable(WDTO_2S);
//      HighPedalLockout();

    InitPWM();  // initialize the pulse width modulator.  Set up the interrupt last!!! idiot!
        // Some time tests...
        // with A/D clock = system clock / 64, it takes about 362 microseconds per loop below.
        // with A/D clock = system clock / 16, it takes about 129 microseconds per loop below.
        // with A/D clock = system clock / 16, it takes about 28  microseconds per A/D conversion.
    while (1) { // do this forever      
                tempCurrent = current; // 
                if (timeForChrisStuff) {
                        DoChrisStuff();
                        timeForChrisStuff = 0;
                }
//              wdt_reset();
        }
    return (0);
}