Colony

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/sleep.h>

#include "ring_buffer.h"

#include "i2c.h"

// for i2c_byte coming from charge board

//I2C Message Codes

#define I2C_MSG_ACKNOWLEDGE       'A'

#define I2C_MSG_BATTERY_CHARGING  'C'

#define I2C_MSG_DATA              'D'

#define I2C_MSG_CONTACT_ERROR     'E'

#define I2C_MSG_BATTERY_FULL      'F'

#define I2C_MSG_NO_CONTACT        'N'

#define I2C_MSG_REQUEST_DATA      'R'

#define I2C_MSG_GO_TO_SLEEP       'Y'

#define I2C_MSG_ENTERING_SLEEP    'Z'

#define I2C_MSG_HOMING            'H'

#define SW0 PA6

#define HOMING_PIN PA7

#define DEBUG 1 //enable I2C outputs of form time, OCR, current, voltage, temp

#define USE_I2C 1

#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

#define MAX_DT -4 //this is the LOWEST ACCEPTABLE ADC value

#define MAX_DT_ABS 400

#define VOLT_PLATEAU 50

//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

RING_BUFFER_NEW(ring_buffer, 12, int, buffer);

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)

{

#if USE_I2C

        char tempData;

        //Finished, leave

        tempData = 'F';

        i2c_putpacket(0x01, &tempData, 1);

#endif

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

}

void setup(void)

{

      DDRA = _BV(PA3);

#if DEBUG

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

#endif

        PORTA = 0x00;

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

        PORTB &= ~(_BV(LED1) | _BV(LED2)); //clear LEDs without messing everything else up!

        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(CS10); //leave timer on and set compare to 0 to make output off

        //hack stuff so it will run in continuous mode

        //TIMSK |= _BV(TOIE1); //enable overflow interrupt for timer 1

        OCR1B = 0;

        OCR1A = 0;

        RING_BUFFER_CLEAR(buffer);

        RING_BUFFER_INIT(buffer, 12);

        for(int i=0;i<10;i++)

                RING_BUFFER_ADD(buffer, 0);

        sei();

}

//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(debug_12in);

}

//get the difference of the current value minues the value 10 entires ago

int ring_buffer_d10(int y)

{

        int x;

        RING_BUFFER_REMOVE(buffer, x);

        RING_BUFFER_ADD(buffer, y);

        return y-x;

}

uint8_t read_homing(void)

{

    uint8_t ret = PINA & _BV(HOMING_PIN);

    if(ret)

        PORTA |= _BV(PA3);

    else

        PORTA &= ~_BV(PA3);

    return ret;

}

//copied from scheduler/seeking.c

uint8_t get_delay(void)

{

    uint8_t count = 0;

        PORTB|=_BV(LED2);

    while(read_homing())

    {

        delay_ms(1);

        count++;

        if (count >= 100)

            return 1;

    } //wait a beacon cycle to make sure we aren't starting the count in the middle of one

        PORTB&=~_BV(LED2);

    count = 0;

    PORTB|=_BV(LED1);

    while(!read_homing())

    {

        delay_ms(1);

        count++;

        if(count==255)

          return 2;

    }

    PORTB&=~_BV(LED1);

  /*RECH_PUTS("\n\rCount: ");

        RECH_PUTI(count);

        RECH_PUTC('.');*/

    return count;

}

void trickle_charge(void)

{

        abs_time = 0;

        status = 0;

        char tempData[5];

        char data[2];

        data[0]='D';

        int volt = 0;

        int temp = 0;

        int curr = 0;

        int meas_count = 0;

        int mod=0;

        OCR1B = 0;

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

        while(status!=2)

        {

                mod=abs_time%4;

                PORTB ^= _BV(LED2);

                if(supply_voltage())

                  while(abs_time%4==mod);

    /* TIME TERMINATION */

                if(abs_time>12000) //12000=25 minutes

                {

                        //SEND_DONE

                        OCR1B=0;

                        break;

                }

#if DEBUG

                tempData[0] = 'C';

                tempData[1] = abs_time>>8;

                tempData[2] = abs_time&0xFF;

        delay_ms(50);

                i2c_putpacket(0x01, tempData, 3);

        delay_ms(50);

#endif

                mod=abs_time%4;

                while(abs_time%4==mod)

                {

      /* CONTACT */

                        if(supply_voltage())

                        {

                                PORTB |= _BV(LED1);

                                //curr = regulate_current(500);

                                curr = get_avg_current();

                                if(status==0)

                                {

                                        status=1;

#if USE_I2C

                                        data[1]='a';

                                        i2c_putpacket(0x01, data, 2);

                                        data[1]=I2C_MSG_BATTERY_CHARGING;

                                        i2c_putpacket(0x01, data, 2);

#endif

                                }

        /* Trickle Charge */

                                if(status==1)

                                        OCR1B = 100;

                        }

      /* NO CONTACT */

                        else

                        {

                                PORTB &= ~_BV(LED1);

                                if(status==1)

                                {

                                        status=0;

#if USE_I2C

                                        data[1]=I2C_MSG_CONTACT_ERROR;

                                        i2c_putpacket(0x01, data, 2);

#endif

                                }

                                else

                                {

          /*get_delay(); //reject the first reading //homing import stuff, uncomment this!!!!!!

                                        data[0]=I2C_MSG_HOMING;

                                        data[1]=get_delay();

          i2c_putpacket(0x01, data, 2);*/

          data[0]='D';

                                }

                                curr = 0;

                                OCR1B = 0;

                        }

                }

#if DEBUG

                tempData[0] = 'P';

                tempData[1] = 0;

                tempData[2] = OCR1B;

        delay_ms(50);

                i2c_putpacket(0x01, tempData, 3);

        delay_ms(50);

                tempData[0] = 'I';

                tempData[1] = curr>>8;

                tempData[2] = curr&0xFF;

        delay_ms(50);

                i2c_putpacket(0x01, tempData, 3);

        delay_ms(50);

#endif

                curr=6666;

    /* Absolute Voltage Termination */

                mod=abs_time%4;

                while(abs_time%4==mod)

                {

                        volt = get_avg_voltage();

                }

                if(volt>1010)

                {

                        //SEND ERROR

                        status=0;

                }

#if DEBUG

                tempData[0] = 'V';

                tempData[1] = volt>>8;

                tempData[2] = volt&0xFF;

        delay_ms(50);

                i2c_putpacket(0x01, tempData, 3);

        delay_ms(50);

#endif

                volt=6666;

    /* Absolute Temperature Termination */

                mod=abs_time%4;

                while(abs_time%4==mod)

                {

                        temp = get_avg_temperature();

                }

                if(temp<250)

                {

                        //SEND ERROR

                        status=0;

                }

#if DEBUG

                tempData[0] = 'T';

                tempData[1] = temp>>8;

                tempData[2] = temp&0xFF;

        delay_ms(50);

                i2c_putpacket(0x01, tempData, 3);

        delay_ms(50);

#endif

                temp=6666;

        }

#if USE_I2C

        data[1]=I2C_MSG_BATTERY_FULL;

        i2c_putpacket(0x01, data, 2);

#endif

}

int main(void)

{

        new_second=0;

        char tempData[5];        //For i2c communication

        setup();

i2c_init();

PORTB|=_BV(LED2);

PORTB|=_BV(LED1);

while(1)

{

        delay_ms(500);

        i2c_putpacket(0x01,'I', 1);

        delay_ms(500);

}

#if USE_I2C

        delay_ms(500);

        i2c_init();

        i2c_putpacket(0x01,"I2C init'd on ARCHS\r\n", 21);

        delay_ms(500);

#else

    #if DEBUG

        i2c_init();

    #endif

#endif

        /*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();

  //test delay_ms

  PORTB|=_BV(LED2);

  PORTB|=_BV(LED1);

  delay_ms(1000);

  PORTB&=~_BV(LED2);

  PORTB&=~_BV(LED1);

        //*******************************

        while(1)

                trickle_charge();

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

        sleep_cpu();*/

        PORTB=0;//clear outputs

        GIMSK = 0;

        error=0;

        i2c_init();

        int volt=0, last_volt=0, same_volt=0;

        int temp=0, dt;

        int curr=0;

        int meas_count;

        int mod=0;

        status=FAST_CHARGE;

        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)

                {

      /* CONTACT */

                        if(supply_voltage())

                        {

                                //curr = regulate_current(500);

                                curr = get_avg_current();

                                if(status==FAST_CHARGE)

                                        OCR1B=50;

                        }

      /* NO CONTACT */

                        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();

                }

    //Same volt - Last volt upkeep

                if(volt==last_volt && supply_voltage())

                                same_volt++;

    else

    {

      last_volt = volt;

      same_volt=0;

    }

                tempData[0] = 'v';

                tempData[1] = same_volt>>8;

                tempData[2] = same_volt&0xFF;

                i2c_putpacket(0x01, tempData, 3);

    /* Voltage Dip Termination */

                if(volt<last_volt && same_volt>=VOLT_PLATEAU)

                {

                        OCR1B=0;

                        status=0;

                }

                tempData[0] = 'V';

                tempData[1] = volt>>8;

                tempData[2] = volt&0xFF;

                i2c_putpacket(0x01, tempData, 3);

                volt=6666;

    //Temp ring buffer upkeep

                mod=abs_time%4;

                while(abs_time%4==mod)

                {

                        temp = get_avg_temperature();

                }

                dt=ring_buffer_d10(temp);

                tempData[0] = 't';

                tempData[1] = dt>>8;

                tempData[2] = dt&0xFF;

                i2c_putpacket(0x01, tempData, 3);

    /* Temperature Rise Termination */

                if(dt < MAX_DT && temp < MAX_DT_ABS)

                {

                        status=0;

                        OCR1B=0;

                }

                tempData[0] = 'T';

                tempData[1] = temp>>8;

                tempData[2] = temp&0xFF;

                i2c_putpacket(0x01, tempData, 3);

                temp=6666;

        }

        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(TIMER1_OVF_vect)

{

        wait(2); //wait a bit so we know the ouput gets set (which happens at timer = 0)

        TCNT1 = 0;//156; // start out at 156. Now OCR1B - 156 = duty cycle

}

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