Colony

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/sleep.h>

#include "i2c.h"

#define TRICKLE

//These are in ADC steps; if any values change in the charging

//circuitry these will have to be recalculated

#ifndef TRICKLE

        #define FAST_I 450//660 //660 fries the 5A fuse!!

#else

        #define FAST_I 20 //Works => 1.3A

#endif

#define TEST_CURR 550

#define MAX_V 1020//990 //7.75V

#define MAX_T 300

#define MIN_T 730

//range is 0 to 45 C

//cal tests:

//room temp - 25

//value ~500, varies from battery to battery, but is consistent on one battery

//freezer 737

//heat gun at a distance 461

//change in one minute

#define MAX_DT 30

#define MAX_DV 30

//The following times are in seconds

#define MAX_FAST_TIME 5400

#define MAX_TRICKLE_TIME 600

//debug pins

#define debug_time PA3

#define debug_curr PA4

#define debug_volt PA5

#define debug_temp PA6

#define debug_12in PA7

//be sure admux also sets the MUX5 bit which is in ADCSRB

#define ADMUX_I

#define ADMUX_V

#define ADMUX_T

#define ROBOT_TX PB1

#define ROBOT_RX PB2

#define PWM PB3

#define DETECT_12V PB6

#define LED1 PB4 //Green

#define LED2 PB5 //Red

//LED States:

//Red - Fast Charging

//Green - Trickle Charging

//Both steady - done charging

//Both Blinking - Error

#define INT_COUNT 2 //interrupts per second

#define AVG_COUNT 64 //number of times to count current

//To enable the PWM write :         TCCR1B = (_Bv(CS10));//enable PWM

uint8_t interrupt_count = INT_COUNT;

volatile uint32_t abs_time=1; // start at one second so it doesnt do the minute checks right away

volatile uint8_t new_second=0; //only used as a boolean

volatile uint8_t error=0;

volatile uint8_t status;

volatile uint8_t steady_current = 0;

//DT must be triggered twice in a row

volatile uint8_t last_DT = 0;

//same for DV

volatile uint8_t last_DV = 0;

#define FAST_CHARGE 1

#define TRICKLE_CHARGE 2

void wait(int ops)

{

        int i = 0;

        while(i<ops)

                i++;

}

int avg_ADC(void)

{

        int av;

        char i;

        //Calculate a average out of the next 8 A/D conversions

    for(av=0,i=8;i;--i)

    {

        ADCSRA |= _BV(ADSC);                      // start new A/D conversion

        while (!(ADCSRA & (_BV(ADIF))))        // wait until ADC is ready

            ;      

        av = av+ADC;

    }

    av = av/8;

        //ADCSRA &= ~_BV(ADEN);

        return av;

}

int get_voltage(void)

{

        ADMUX = _BV(MUX0);

        ADCSRB &= ~_BV(MUX5);

        return avg_ADC();

}

int get_current(void)

{

        ADMUX = _BV(MUX1);

        ADCSRB |= _BV(MUX5);

        return avg_ADC();

}

int get_temperature(void)

{

        ADMUX = _BV(MUX1);

        ADCSRB &= ~_BV(MUX5);

        return avg_ADC();

}

int get_avg_voltage(void)

{

        int count=0;

        uint32_t sum=0;

                //OCR1B =120;

        while(count < AVG_COUNT)

        {

                sum += get_voltage();

                count++;

        }

        return sum/AVG_COUNT;

}

int get_avg_current(void)

{

        int count=0;

        uint32_t sum=0;

                //OCR1B =120;

        while(count < AVG_COUNT)

        {

                sum += get_current();

                count++;

        }

        return sum/AVG_COUNT;

}

int get_avg_temperature(void)

{

        int count=0;

        uint32_t sum=0;

                //OCR1B =120;

        while(count < AVG_COUNT)

        {

                sum += get_temperature();

                count++;

        }

        return sum/AVG_COUNT;

}

uint8_t supply_voltage(void)

{

        return PINB & _BV(DETECT_12V);

}

void clear_err(void)

{

        error=0;

        PORTB &= ~(_BV(LED1)|_BV(LED2));

        if(status==FAST_CHARGE)

                PORTB |= _BV(LED2);

        if(status==TRICKLE_CHARGE)

                PORTB |= _BV(LED1);

}

void wait_8th(void)

{

        uint8_t start = abs_time % 8;

        while(abs_time % 8 == start)

        {

                /*if(supply_voltage())

                        PORTB |= _BV(LED1);

                else

                        PORTB &= ~_BV(LED1);

                if(get_voltage()>100)

                        PORTB |= _BV(LED2);

                else

                        PORTB &= ~_BV(LED2);*/

        }

}

void send_err(void)

{

        OCR1B=0;//turn off the PWM to be safe

        PORTB &= ~(_BV(LED1)|_BV(LED2));

        if(status!=0)//leave last error if there was one

                PORTA &= ~(_BV(debug_time)|_BV(debug_curr)|_BV(debug_volt)|_BV(debug_temp)|_BV(debug_12in)); 

        error=1;

        status=0;

}

void send_done(void)

{

        char tempData;

        //Finished, leave

        tempData = 'F';

        i2c_putpacket(0x01, &tempData, 1);

        PORTA &= ~(_BV(debug_time)|_BV(debug_curr)|_BV(debug_volt)|_BV(debug_temp)|_BV(debug_12in)); 

}

void setup(void)

{

        DDRA = (_BV(debug_time)|_BV(debug_curr)|_BV(debug_volt)|_BV(debug_temp)|_BV(debug_12in));

        PORTA = 0x00;

        DDRB = (_BV(ROBOT_TX)|_BV(PWM)|_BV(LED1)|_BV(LED2)); //confiure output pins

        PORTB = 0x00;

        ADCSRA = (_BV(ADEN)|_BV(ADPS2)|_BV(ADPS1)); //start ADC with a division factor of 64

        TCCR0B = (_BV(CS01)); //set timer 0 for realtime mode

        TCCR0A = (_BV(TCW0));

        TIMSK = (_BV(TOIE0)); //enable overflow interrupts

        TCCR1A = (_BV(COM1B1)|_BV(PWM1B)|_BV(COM1A1)|_BV(PWM1A)); //clear timer 1 on compare, set at 0x00. Fast PWM mode

        TCCR1B |= _BV(CS12)|_BV(CS10); //leave timer on and set compare to 0 to make output off        

        OCR1B = 0;

        OCR1A = 0;

        sei();

}

int regulate_current(int i)

{

        if(status==0)

        {

                OCR1B = 0;

                return 0;

        }

        PORTA ^= _BV(debug_curr);

        int curr=0;

        int count=0;

        int diff=0;

        uint32_t sum=0;

                //OCR1B =120;

        while(count < AVG_COUNT)

        {

                sum += get_current();

                count++;

        }

        curr = sum/AVG_COUNT;

        //OCR1A = curr >> 2;

         //old linear regulation

         /*

        if(OCR1B <255 && curr < i)

                        OCR1B++;

        else if(OCR1B >0 && curr > i)

                        OCR1B--;

        return curr;

        */

        //cool control law stuff

        diff=curr-i;

        OCR1B = diff/4 + curr/4; //K*Ierr + Kguess

        //1024/255

        /*if(OCR1B <255 && curr<i)

                OCR1B += (i-curr)/4;

        else if(OCR1B >0 && curr > i)

                OCR1B -= (curr-i)/4;*/

        //differential regulation (sort of)

        /*diff = i-curr;

        if(diff<8)

                steady_current=1;

        else

                steady_current=0;

        OCR1B += diff/4;*/

}

void check_voltage(void)

{

        int volt = get_avg_voltage();

        if(volt > MAX_V)

        {

                OCR1A = 128;

                send_err();

                PORTA |= _BV(debug_volt);

                status = 0;

        }

}

void check_temperature(void)

{

        int temp = get_avg_temperature();

        //temp readings are reversed

        if(temp < MAX_T || temp > MIN_T)

        {

                OCR1A = 192;

                send_err();

                PORTA |= _BV(debug_temp);

                status=0;

        }

}

//takes a 7-bit ionteger and displays it on the 7 LEDs with the Green being the MSB

void LED_out(int i)

{

        if(i & 64)

                PORTB |= _BV(LED1);

        else

                PORTB &= ~_BV(LED1);

        if(i & 32)

                PORTB |= _BV(LED2);

        else

                PORTB &= ~_BV(LED2);

        if(i & 16)

                PORTA |= _BV(PA3);

        else

                PORTA &= ~_BV(PA3);

        if(i & 8)

                PORTA |= _BV(PA4);

        else

                PORTA &= ~_BV(PA4);

        if(i & 4)

                PORTA |= _BV(PA5);

        else

                PORTA &= ~_BV(PA5);

        if(i & 2)

                PORTA |= _BV(PA6);

        else

                PORTA &= ~_BV(PA6);

        if(i & 1)

                PORTA |= _BV(PA7);

        else

                PORTA &= ~_BV(PA7);

}

void test_board(void)

{

        setup();

        abs_time = 0;

        status = 1;

        char tempData[5];

        i2c_init();

        int volt;

        int temp;

        int curr;

        int meas_count;

        int mod=0;

        sei();

        OCR1B = 0;

        while(1)

        {

                mod=abs_time%4;

                while(abs_time%4==mod);

                /*if((abs_time>>3)%3==0)

                        OCR1B=21;

                else if((abs_time>>3)%3==1)

                        OCR1B=57;

                else

                        OCR1B=85;*/

                tempData[0] = 'C';

                tempData[1] = abs_time>>8;

                tempData[2] = abs_time&0xFF;

                i2c_putpacket(0x01, tempData, 3);

                mod=abs_time%4;

                while(abs_time%4==mod)

                {

                        if(supply_voltage())

                        {

                                //curr = regulate_current(500);

                                curr = get_avg_current();

                                OCR1B = 100;

                        }

                        else

                        {

                                curr = 0;

                                OCR1B = 0;

                        }

                }

                tempData[0] = 'P';

                tempData[1] = 0;

                tempData[2] = OCR1B;

                i2c_putpacket(0x01, tempData, 3);

                tempData[0] = 'I';

                tempData[1] = curr>>8;

                tempData[2] = curr&0xFF;

                i2c_putpacket(0x01, tempData, 3);

                curr=6666;

                mod=abs_time%4;

                while(abs_time%4==mod)

                {

                        volt = get_avg_voltage();

                }

                tempData[0] = 'V';

                tempData[1] = volt>>8;

                tempData[2] = volt&0xFF;

                i2c_putpacket(0x01, tempData, 3);

                volt=6666;

                mod=abs_time%4;

                while(abs_time%4==mod)

                {

                        temp = get_avg_temperature();

                }

                tempData[0] = 'T';

                tempData[1] = temp>>8;

                tempData[2] = temp&0xFF;

                i2c_putpacket(0x01, tempData, 3);

                temp=6666;

        }

        int c=0,oc;

        oc=get_avg_temperature();

        //this will read the temperature and output it to the LEDS.

        //to read the value, enter the LEDs as binary, with the bottom green as the MSB.

        //after two second the LEDS will toggle to the next 7 bits

        /*while(1)

        {

                c=oc-get_avg_temperature();

                oc+=c;

                if(c<0)

                        c=-c;

                if(c<5)

                        break;

        }*/

/*

        while(1)

        {

                LED_out(oc>>7);

                for(c=0;c<16;c++)

                        wait_8th();

                LED_out(oc);

                for(c=0;c<16;c++)

                        wait_8th();

        }*/

        /*PORTB |= (_BV(LED1)|_BV(LED2));

        while(1)

        {

                PORTA ^= _BV(debug_time);

                wait_8th();

                c=get_current()-FAST_I;

                if(c<0)

                        c=-c;

                if(c<4)

                        PORTA |= _BV(debug_curr);

                else

                        PORTA &= ~_BV(debug_curr);

                wait_8th();

                if(get_avg_voltage() > 50)

                        PORTA |= _BV(debug_volt);

                else

                        PORTA &= ~_BV(debug_volt);

                wait_8th();

                if(get_avg_temperature() > MAX_T)

                        PORTA |= _BV(debug_temp);

                else

                        PORTA &= ~_BV(debug_temp);

                wait_8th();

                if(supply_voltage())

                        PORTA |= _BV(debug_12in);

                else

                        PORTA &= ~_BV(debug_12in);

                wait_8th();

        }*/

}

int main(void)

{

        test_board();

        new_second=0;

        char tempData[5];        //For i2c communication

        //test_board();

        char noVoltagePrintFlag = 0;

        setup();

        i2c_init();

        /*GIMSK = (_BV(PCIE0)); //enable PCINT interrupts

        PCMSK1 = (_BV(PCINT10)); //enable pin change interrupt on ROBOT_RX

        MCUCR = (_BV(SE)|_BV(SM1));// (power-down mode)

        */

        OCR1B=0;

        sei();

        tempData[0] = 'S';

        tempData[1] = 'S';

        tempData[2] = 'S';

        tempData[3] = 'S';

        tempData[4] = 'S';

        i2c_putpacket(0x01, tempData, 5);        

        int temp=0;

        int last_temp = get_avg_temperature();

        int volt=0;

        int last_volt = get_avg_voltage();

        while(1)

        {

                /*GIMSK = (_BV(PCIE0)); //enable PCINT interrupts

                sleep_cpu();*/

                PORTB=0;//clear outputs

                GIMSK = 0;

                error=0;

                OCR1B = 0;

                //wait for 12v source

                while(!supply_voltage()) {

                        if (!noVoltagePrintFlag) {

                                tempData[0] = 'N';

                                tempData[1] = 'N';

                                tempData[2] = 'N';

                                tempData[3] = 'N';

                                tempData[4] = 'N';

                                i2c_putpacket(0x01, tempData, 5);

                                noVoltagePrintFlag = 1;

                        }

                }

                noVoltagePrintFlag = 0;

                //Contact 

                tempData[0] = 'C';

                tempData[1] = 'C';

                tempData[2] = 'C';

                tempData[3] = 'C';

                tempData[4] = 'C';

                i2c_putpacket(0x01, tempData, 5);

                PORTA |= _BV(debug_12in);

                abs_time=1;

                //--------------FAST CHARGE-----------------------

                //split seconds into eights as following:

                //1: abs_volt

                //2: reg

                //3: abs_temp

                //4: reg

                //5: abs_volt

                //6: reg

                //7: abs_temp

                //between seconds: abs time and minute checks, which takes an extra 8th

                status = FAST_CHARGE;

                PORTB |= _BV(LED2);

                while(status == FAST_CHARGE)

                {

                        if(!supply_voltage())

                        {

                                send_err();

                                //Lost Contact

                                tempData[0] = 'N';

                                tempData[1] = 'N';

                                tempData[2] = 'N';

                                tempData[3] = 'N';

                                tempData[4] = 'N';

                                i2c_putpacket(0x01, tempData, 5);

                                PORTA &= ~_BV(debug_12in);

                                while(!supply_voltage());

                                //Contact again

                                tempData[0] = 'C';

                                tempData[1] = 'C';

                                tempData[2] = 'C';

                                tempData[3] = 'C';

                                tempData[4] = 'C';

                                i2c_putpacket(0x01, tempData, 5);

                                PORTA |= _BV(debug_12in);

                                clear_err();

                        }

                        check_voltage();

                        wait_8th();

                        regulate_current(FAST_I);

                        wait_8th();

                        check_temperature();

                        wait_8th();

                        regulate_current(FAST_I);

                        wait_8th();

                        check_voltage();

                        wait_8th();

                        regulate_current(FAST_I);

                        wait_8th();

                        check_temperature();

                        wait_8th();

#ifdef TRICKLE

                        if(abs_time > 9600) //90 minute time limit

                        {

                                OCR1A = 32;

                                send_done();

                                PORTA |= _BV(debug_time);

                                break;

                        }

#else

                        if(abs_time > 43200) //90 minute time limit

                        {

                                OCR1A = 32;

                                send_err();

                                PORTA |= _BV(debug_time);

                                break;

                        }

                        //minute checks

                        if( (abs_time >> 3)%55 == 0/* && steady_current*/)

                        {

                                PORTA ^= _BV(debug_time);

                                temp = get_avg_temperature();

                                wait_8th(); //to avoid interference

                                volt = get_avg_voltage(); 

                                OCR1A = volt >> 2;

                                //seems to be some random drops when connected to a power supply

                                //may need a fudge factor but maybe not becuase voltage should be climbing during charge

                                if(volt < last_volt - MAX_DV)

                                {

          PORTA |= _BV(debug_volt);

          if(last_DV)

          {

            OCR1A = 64;

            send_done();

            PORTA |= _BV(debug_volt);

            status = TRICKLE_CHARGE;

          }

          else

            last_DV=1;

                                }

        else

        {

          last_DV=0;

          PORTA &= ~_BV(debug_volt);

         }

                                if(temp < last_temp - MAX_DT)

                                {

          PORTA |= _BV(debug_temp);

          if(last_DT)

          {       

            OCR1A = 128;

            send_done();

            PORTA |= _BV(debug_temp);

            status = TRICKLE_CHARGE;

          }

          else

            last_DT=1;

                                }

        else

        {

          last_DT=0;

          PORTA &= ~_BV(debug_temp);

        }

                                last_volt = volt;

                                last_temp = temp;

                        }

#endif

                }

                if (error) {

                        //We have an error...let's bail out of this ship captain!

                        tempData[0] = 'F';

                        tempData[1] = 'F';

                        tempData[2] = 'F';

                        tempData[3] = 'F';

                        tempData[4] = 'F';

                        i2c_putpacket(0x01, tempData, 5);

                }

                //PORTB ^= _BV(LED2);

        }

        return 1;

}

ISR(TIMER0_OVF_vect)

{

        if(error)

                PORTB ^= (_BV(LED1)|_BV(LED2));

        interrupt_count--;

        if(interrupt_count==0)

        {

                abs_time++;

                new_second=1;

                interrupt_count=INT_COUNT;

        }

}

ISR(PCINT_vect){;} //so the interrupt doesnt go to the reset vector