root/trunk/HighVoltageController.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>
#include "RingBuffAdv/RingBuff.h"

//#include <avr/signal.h>
//#include <avr/iom16.h>

//#define MAX_THROTTLE 511
//#define MIN_THROTTLE 0
#define F_OSC 16000000                     /* oscillator-frequency in Hz */
//#define F_OSC 3686400
#define UART_BAUD_RATE 19200
#define UART_BAUD_CALC (((float)(F_OSC))/(((float)(UART_BAUD_RATE))*16.0)-1.0+0.5)


#define PRE_SCALED_ZERO_THROTTLE 989 // Anything bigger than 989 means 0% throttle. 
#define PRE_SCALED_MAX_THROTTLE 683 // Anything smaller than 683 means 100% throttle.
#define PRE_SCALED_OPEN_CIRCUIT_THROTTLE        150     // Indicates a bad throttle.  Over ?? kOhms.

#define VREF 512  // VREF is the measurement of the current sensor at 0 volts.

#define READY 9
// Throttle Sensor connected to A/D Channel 2 (pin25 on atmega8)
#define THROTTLE 0
// Current Sensor connected to A/D Channel 2 (pin25 on atmega8)
#define CURRENT 2
// Temp sensor connected to A/D Channel 1 (pin24 on atmega8)
#define TEMPERATURE 1

#define KP 8l  // 8 corresponds to P constant of 1/4.
#define KI 4l  // 4 corresponds to I constant of 1/8.

#define K1 (KP << 10)
#define K2 (KI - K1)


#define MAX_CURRENT 506
#define THERMAL_CUTBACK_START 780       // start at 75 degC, end at 85 degC.

#define CURRENT_ARRAY_SIZE 16

#define SCALE_MUL_THROTTLE  53
#define SCALE_DIV_THROTTLE  5

// Define our IO pins and Ports
#define OVERCURRENT_TRIP  PB0
#define FLIPFLOP_RESET    PB2
#define IDLE_LED          PD6
#define MAIN_CONTACTOR    PD7

 
//#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.
int16_t volatile throttlePos=0;//       // the desired current.  in [0, 255].
int16_t volatile _throttlePos = 0;//***
int16_t volatile tmpCurrent = 0;//***
int16_t volatile tmpThrottle = 0;//***
int16_t volatile tmpTemp = 0;//
uint8_t volatile ADCMode = READY;
int16_t volatile pwmDuty = 0;
int32_t volatile pwmDutyFine = 0;//***
int16_t volatile errorNew = 0;//***
int16_t volatile errorOld = 0;//***


int16_t volatile temperature = 0;       // temperature measurement. Monitor the MOSFETs with a thermistor.
int16_t volatile current = 0;   // How much current is being used on a moment by moment basis.
int16_t volatile _current = 0;
int16_t volatile currentSum = 0;
 
int16_t volatile i = 0;
int16_t volatile dummy = 0;
uint16_t volatile ISRCounter = 0;


uint8_t volatile relayLow = 1;
uint8_t volatile cSREG;//***

int16_t volatile currentPtr = 0;

int16_t volatile currBuffer[CURRENT_ARRAY_SIZE+1];
RingBuff_t txBuffer;

void InitUSART(uint16_t ubrr) {
        // set baud rate
        UBRRH = (uint8_t) (ubrr>>8);
        UBRRL = (uint8_t) ubrr;

        // Enable transmitter UART; 
//      UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
        UCSRB = (1 << TXEN);

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



// 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)
{
// We are using Mode 2 which is phase correct PWM
// The TCNT1 starts at BOTTOM (0) and starts counting to TOP. When it reaches TOP, the counter counts back to BOTTOM
// When it reaches BOTTOM, it will trigger the Timer1 Overflow interrupt (see the ISR code further down)
// For the PWM, as TCNT1 is increasing and it matches OCR1A it will set the OC1A I/O pin to 0
//              as TCNT1 is decreasing and it matches OCR1A it will set the OC1A I/O pin to 1
        TCCR1A = _BV(COM1A1) | _BV(WGM11);  // set COM1A1 and WGM11

        // Tclk = Fosc = 16MHz
        // Tclk/1024 (from 0 to 511 and then 511 back to 0) = 16KHz freq for the Toverflow ISR
        TCCR1B = _BV(CS10);  // 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.
        // On reset all pins are set to 0 or output
        PORTB &= ~_BV(PB1); // this sets PB1 (the pwm output) to 0 at startup
        DDRB = _BV(PB1); // 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; 
}

// 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);   // Enable the analog to digital converter.
        ADCSRA |= _BV(ADPS2); // pg. 208. How fast to sample ADC? 16MHz/16
        ADMUX = _BV(REFS0);     // Use AVcc as the reference voltage for the ADC, pg. 206
}


// 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) {
        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 *= SCALE_MUL_THROTTLE;  // multiply by SCALE_MUL_THROTTLE
        throttlePos >>= SCALE_DIV_THROTTLE;     // divide by SCALE_DIV_THROTTLE
        // 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) {
        current = ADC;

        // Current starts in [512, 512 + 213]  (if it's in 0 to 500 amps for the LEM 300)
        // vRef is defined at the top. It is the calibrated "0" value.
        if (current < VREF) // if slightly below 0, just call it 0.
                current = VREF;
        current -= VREF;
        // now, for the LEM 500, it's in the range [0,128].
        currentSum -= currBuffer[currentPtr];
        currBuffer[currentPtr] = current;
        currentSum += current;
        _current = currentSum >> 2;  // "divide by 16, multiply by 4" = divide by 4
        if (currentPtr == CURRENT_ARRAY_SIZE - 1)
                currentPtr = 0;
        else 
                currentPtr++;
        //_current is average current
}

// *TESTED PREVIOUSLY*

//void ReadTemperature(void) {
//      ADMUX &= (0b11110000);  // This sets MUX to 0000, and leaves the top 4 bits unchanged.
                                                // pg. 206
                                                // I'd like to suggest defining a TEMPERATURE at the top
//  ADMUX |= TEMPERATURE;  // TEMPERATURE, the temperature monitor.                                       

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

// *TESTED PREVIOUSLY*

void HighPedalLockout(void) {
//      pwmDuty = 0;
        OCR1A = 0;
        do {
                // Select channel 0.
                ADMUX &= (0b11110000);  // = 11110000.  So, this sets MUX to 0000, and leaves the top 4 bits unchanged.
        // pg. 206

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

                ADCSRA |= _BV(ADSC);    // Start Conversion
                while (ADCSRA & 64);    // Do nothing until the conversion is done.
                throttlePos = ADC;

                wdt_reset();  
        } while (throttlePos < PRE_SCALED_ZERO_THROTTLE);  // I'm not doing all the rescaling and shifting for this part.
        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.

// http://www.nongnu.org/avr-libc/user-manual/group__util__delay.html
void Delay(int k) {
        // int m;
        int volatile 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 overcurrent event. If there is an overcurrent event,
// it clears the overcurrent event by pulsing port b2 low for a moment, which resets the hardware flip-flop.

// *TESTED IN SIMULATOR*

void ResetOverCurrentEvent() {
// 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.  
        // if (PINB & 1) {      // clear overcurrent event.
        if (PINB & _BV(OVERCURRENT_TRIP)) {     // 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 &= ~_BV(FLIPFLOP_RESET); // Clear FLIPFLOP   aka &= 11111011b
                Delay(2);
                // Now bring port b2 high again...  This clears the overcurrent event.
                PORTB |= _BV(FLIPFLOP_RESET); // Reset FLIPFLOP
                pwmDuty--;
                if (pwmDuty < 0)
                        pwmDuty = 0;
//              pwmDutyFine -= (1 << 15);
//              if (pwmDutyFine < 0)
//                      pwmDutyFine = 0;
//              OCR1A = (pwmDutyFine >> 15);
        }
        return;
}


ISR (ADC_vect) {
        if (ADCMode == CURRENT) {
                //current=ADC;
                ReadCurrent();
        }

        else if (ADCMode==THROTTLE) {
                //throttlePos=ADC; 
                ReadThrottle();
        }
//      else {  // it's temperature
//              temperature=ADC;
//      }
        ADCMode=READY; //signify that we are ready for another reading
}

// Based on the setting in the Timer1 InitPWM() function this ISR will be called at ~16KHz
ISR (TIMER1_OVF_vect) {
        ResetOverCurrentEvent();  // Maybe turn on after 'n' cycles of being off, 
                                                          //  where n is a function of PWM duty?

        if (ADCMode==READY) {           //wait for last adc request to finish
                ISRCounter++;
                ADCMode = CURRENT;  // This is the default

//              if ((ISRCounter & 32767) == 32767) { // 32767 = 0b0111111111111111.  This happens every 2 seconds.
//                      ADCMode=TEMPERATURE;
//                      ISRCounter = 0;
//              }

                if ((ISRCounter & 15) == 15) // 15 = 0b1111.
                        ADCMode = THROTTLE;

                ADMUX &= 0b11110000; // zero out the MUX
                ADMUX |= ADCMode; //select channel
                ADCSRA |= 64;//start adc conversion
        }
}


ISR (TIMER2_OVF_vect) {
                        //place 8 bit values in the tx FIFO
                    Buffer_StoreElement(&txBuffer, (uint8_t) (tmpThrottle >>8)); // Store value for throttleH into ringbuff
                    Buffer_StoreElement(&txBuffer, (uint8_t) tmpThrottle); // Store value for throttleL into ringbuff           
                    Buffer_StoreElement(&txBuffer, (uint8_t) (tmpCurrent >>8)); // Store value for currentH into ringbuff
                    Buffer_StoreElement(&txBuffer, (uint8_t) tmpCurrent); // Store value for currentL into ringbuff
                    Buffer_StoreElement(&txBuffer, (uint8_t) (pwmDuty >>8)); // Store value for currentH into ringbuff
                    Buffer_StoreElement(&txBuffer, (uint8_t) pwmDuty); // Store value for currentL into ringbuff
                        Buffer_StoreElement(&txBuffer, (uint8_t) 0xF0); // Sync Byte
                        Buffer_StoreElement(&txBuffer, (uint8_t) 0xFF); // Sync Byte


                    //enable USART "TX buffer empty" interrupt
                    UCSRB |= _BV(UDRIE);
}


// *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
        DDRB |= _BV(FLIPFLOP_RESET);    // Configure PINB2 as output
        // The stupid documentation says this next step might be necessary.  See pg. 52.
        PORTB &= ~_BV(FLIPFLOP_RESET); // Clear only B2   aka &= 11111011b

        // Pulsing pin b2 low for a moment guarantees that the state of the flip flop in the hardware overcurrent
        // shutdown circuit is known.
        PORTB |= _BV(FLIPFLOP_RESET); // Reset FLIPFLOP_RESET
        Delay(5);
        PORTB &= ~_BV(FLIPFLOP_RESET); // Clear FLIPFLOP_RESET   aka &= 11111011b
        Delay(5);
        PORTB |= _BV(FLIPFLOP_RESET); // RESET FLIPFLOP_RESET 

        DDRD |= _BV(MAIN_CONTACTOR);  // configure pin MAIN_CONTACTOR for output.  It is a relay that turns on the main contactor.
        DDRD |= _BV(IDLE_LED);  // configure pin IDLE_LED 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, 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 &= ~_BV(PB0); // DDRB = XXXXXXX0  Configure PINB0 as input.
        PORTB |= _BV(PB0);      // Maybe unnecessary intermediate step.  See page 52.
        PORTB &= ~_BV(PB0); // PORTB = XXXXXXX0 Turn off the pull-up resistor at pin b0.
        return;
}



ISR (USART_UDRE_vect) {
  if (txBuffer.Elements > 0) {
    UDR =  Buffer_GetElement(&txBuffer); //place data for transmission
        //UDR = txBuffer.Elements;
        }
  else
    UCSRB &= ~_BV(UDRIE);  //disable interrupt
}


int main (void) {
        InitADC();      // initialize the analog to digital converter
        InitializeIOPins(); // pin b0 acts as an input, pin b2 acts as an output.
        InitUSART(UART_BAUD_CALC);
        Buffer_Initialize(&txBuffer); // Init buffer (also clears/flushes/resets)

        wdt_enable(WDTO_2S);

        for (currentPtr = 0; currentPtr < CURRENT_ARRAY_SIZE; currentPtr++)
                currBuffer[currentPtr] = 0;
        currentPtr = 0;

        HighPedalLockout();
    InitPWM();

        // Finally, enable interrupts for the timer and the A/D converter.  It causes problems if you
        // enable them too early.  
        ADCSRA |= _BV(ADIE);  // Enable an interrupt to happen each time an A/D conversion is finished.
        // Enable Timer1 Overflow Interrupt
        TIMSK = _BV(TOIE1) | _BV(TOIE2);        // make an interrupt happen each time the timer reaches the bottom.
        TCCR2 = _BV(CS22) | _BV(CS21) | _BV(CS20);
    
        sei();  // Enable interrupts

        while (1) { // do this forever  
                cSREG = SREG; /* store SREG value */
                cli();  // disable interrupts

                tmpTemp = temperature;
                tmpCurrent = _current;
                tmpThrottle = throttlePos;
                SREG = cSREG;

                

                _throttlePos = tmpThrottle;

                // 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 (tmpTemp > THERMAL_CUTBACK_START) {  // start of thermal cutback.
                        if (tmpTemp < THERMAL_CUTBACK_START+8) // _throttlePos = 7/8*tmpThrottle.
                                _throttlePos = (7*tmpThrottle) >> 3;

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

                        else if (tmpTemp < THERMAL_CUTBACK_START + 24)  //                              = 5/8*tmpThrottle;
                                _throttlePos = (5*tmpThrottle) >> 3;

                        else if (tmpTemp < THERMAL_CUTBACK_START + 32)  //                              = 4/8*tmpThrottle;
                                _throttlePos = tmpThrottle >> 1;                

                        else if (tmpTemp < THERMAL_CUTBACK_START + 40)  //                              = 3/8*tmpThrottle;
                                _throttlePos = 3*(tmpThrottle >> 3);

                        else if (tmpTemp < THERMAL_CUTBACK_START + 48)  //                              = 2/8*tmpThrottle;
                                _throttlePos = tmpThrottle >> 2;

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

                        else
                                _throttlePos = 0;
                }
*/
//              errorNew = _throttlePos - tmpCurrent;
//              pwmDutyFine += (((int32_t)(errorNew - errorOld)) << 13) + (int32_t)(errorOld << 2);
//              pwmDutyFine += K1*errorNew + K2*errorOld;
//              errorOld = errorNew;


                if (pwmDuty < _throttlePos)
                        pwmDuty++;
                else if (pwmDuty > _throttlePos)
                        pwmDuty--;
//              if (pwmDutyFine > (511l << 15))
//                      pwmDutyFine = (511l << 15);
//              else if (pwmDutyFine < 0l)
//                      pwmDutyFine = 0l;

                //pwmDuty = (int16_t)(pwmDutyFine >> 15);

                OCR1A = pwmDuty;
                wdt_reset();
        }
        return (0);
}