Mercurial > hg-public > freeslot / file revision

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

#include "main.h"
#include "util/delay.h"


ISR ( USART_RXC_vect ) {
}

#define PULSE_PORT      PORTD
#define PULSE_BIT       PD2

typedef struct  {
    uint8_t slot;
    uint8_t light;
    uint8_t program; // 0xff = inactive ; programming mode active on slot X
    uint8_t initialized;
} config_t;
config_t EEMEM eeconfig = {0,0,0xff,0};
config_t config;

volatile uint16_t data = 0;
volatile uint8_t data_len = 0;
volatile uint8_t bitbuf_len = 0;
volatile uint16_t bitbuf = 0;
volatile uint8_t car_speed[8];
volatile uint8_t car_switch[8];

volatile uint8_t timeout = 0;
volatile uint8_t brake_timeout = 0;


uint8_t my_switch;
uint8_t my_speed;

ISR ( INT0_vect ) {
    GICR &= ~_BV(INT0) ; // Disable INT0
    // Startsignal erkannt, ab hier den Timer2 starten,
    // der liest dann alle 50µs den Zustand ein und schreibt das
    // empfangene Bit in den Puffer
    bitbuf = 0; // init
    bitbuf_len = 0b10000000; // init 1 pulse received
    TCNT2 = 0;
    TIMSK |= _BV(OCIE2); //enable timer2 interrupt
}

ISR ( TIMER2_COMP_vect ) {
    uint8_t clock;
    uint8_t state;
    uint8_t state2;
    if ((bitbuf_len & 0b10000000) == 0) clock = 0; else clock = 0xff;
    if ((bitbuf_len & 0b01000000) == 0) state = 0; else state = 0xff;
    if ((PIN(PULSE_PORT) & _BV(PULSE_BIT)) == 0) state2 = 0xff; else state2 = 0;

    if (clock) {
        bitbuf_len &= ~_BV(7); // switch clock to low
        // second pulse of bit
        if ((state==state2) & state2) {
            // two cycles high: packet end received
            data_len = (bitbuf_len & 0b00111111);
            TIMSK &= ~_BV(OCIE2); //disable timer2 interrupt
            GICR |= _BV(INT0) ; // Enable INT0

            //data = bitbuf; // output data
            // write data of controllers to array
            if (data_len == 10) { // controller data packet
                clock = (bitbuf >> 6) & 0b00000111;
                car_speed[clock] = (bitbuf >> 1) & 0x0F;
                car_switch[clock] = (bitbuf >> 5) & 1;
                // current response for this car?
                /*
                if (response != 0) {
                    if ( ((response & 0b00001110) >> 1) == clock) {
                        // add our ID to response:
                        send_response(response | self_id << 6);
                        response = 0;
                    }
                }
                */
            }


        } else {
            bitbuf_len++; // increment bit counter
            bitbuf = bitbuf << 1; // shift bits
            if (state2 == 0) bitbuf |= 1; // receive logic one
        }
    } else {
        bitbuf_len |= _BV(7); // switch clock to high
        // first pulse of bit
        if (state2) {
            bitbuf_len |= _BV(6); // store new state
        } else {
            bitbuf_len &= ~_BV(6); // store new state
        }
    }
}

ISR (INT1_vect) {
}

ISR (TIMER0_OVF_vect) {
    TCNT0  = 100;            // TIMER0 vorladen mit 100
    if (brake_timeout > 1) brake_timeout--;
    if (timeout > 1) timeout--;
}

#define LIGHT_PORT      PORTC
#define LIGHT_FRONT     2
#define LIGHT_BRAKE     4

#define IR_PORT         PORTB
#define IR_LED          3

#define BRAKE_PORT      PORTB
#define BRAKE           0

#define LIGHT_MODES             1       // anzahl der lichtmodi (ohne den modus "aus")
#define BRAKE_OFF_TIMEOUT       60      // value * 10ms

#define CAR_DEBUG       1
#define EE_CONFIG_ADDR  64

void config_save(void) {
    eeprom_write_block( &config, &eeconfig, sizeof(config_t) );
}


void brake_on(void) {
    LIGHT_PORT |= _BV(LIGHT_BRAKE); // brake light on
    BRAKE_PORT |= _BV(BRAKE); // brake on
    brake_timeout = BRAKE_OFF_TIMEOUT;
}

void brake_off(void) {
    LIGHT_PORT &= ~_BV(LIGHT_BRAKE); // brake light off
    BRAKE_PORT &= ~_BV(BRAKE); // brake off
    brake_timeout = 0;
}

uint8_t scan_id(void) {
    uint8_t temp;
    timeout = 1;
        // scan for any key press and assign to that controller
        while (car_speed[config.slot] == 0) {
            for (uint8_t i=0; i<6; i++) {
                if (car_switch[i] == 1) {
                    // wait for second key press within timeout period to assign successfully
                    brake_timeout = 0xff;
                    temp = car_switch[i];
                    while (brake_timeout > 1) {
                        if (temp != car_switch[i]) {
                            temp = car_switch[i];
                            if (temp == 1) {
                                config.slot = i;
                                return 1;
                            }
                        }
                        // toggle lights if timeout
                        if (timeout == 1) {
                            LIGHT_PORT ^= _BV(LIGHT_FRONT);
                            timeout = 5;
                        }
                    }
                    return 0;
                }
            }
            // toggle lights if timeout
            if (timeout == 1) {
                LIGHT_PORT ^= _BV(LIGHT_FRONT);
                timeout = 10;
            }
        }
    return 0;
}

int main(void)
{
    uint8_t temp;

    // setup data bit timer2
    TCCR2 = (1<<CS21) | (1<<WGM21); //divide by 8, set compare match
    OCR2 = TIMER2_50US;


    // enable both external interrupts
    // int 0 = data RX
    MCUCR = _BV(ISC00) | _BV(ISC01) | _BV(ISC10) | _BV(ISC11); // INT0/1 rising edge
    GICR = _BV(INT0) | _BV(INT1) ; // Enable INT0 + INT1


    DDR(LIGHT_PORT) |= _BV(LIGHT_FRONT) | _BV(LIGHT_BRAKE);
    DDR(BRAKE_PORT) |= _BV(BRAKE);

    TCCR1A = (1<<WGM10)|(1<<COM1A1)   // Set up the two Control registers of Timer1.
            |(1<<COM1B1);             // Wave Form Generation is Fast PWM 8 Bit,

    TCCR1B = (1<<WGM12)|(1<<CS10);     // OC1A and OC1B are cleared on compare match
                                       // and set at BOTTOM. Clock Prescaler is 1.


    //OCR1A = 63;                       // Dutycycle of OC1A = 25%
    //OCR1B = 127;                      // Dutycycle of OC1B = 50%
    OCR1A = 0;
    OCR1B = 0;
    DDRB &= ~_BV(2);                  // PB2 PWM Output disable

    // configure TIMER0 to overflow every 10ms at 4 MHz
    TIMSK = _BV(TOIE0);         // Timer0 Overflow INT erlauben
    TCNT0  = 100;            // TIMER0 vorladen mit 100
    TCCR0 = _BV(CS02) ;         // Vorteiler auf 256, ab hier läuft der TIMER0

    sei();

    // config (from eeprom!)
    eeprom_read_block( &config, &eeconfig, sizeof(config_t) );


#ifdef CAR_DEBUG
    if (config.initialized == 0) {
    LIGHT_PORT &= ~_BV(LIGHT_FRONT);
    for (temp = 0; temp <= config.slot; temp++) {
        LIGHT_PORT ^= _BV(LIGHT_FRONT);
        _delay_ms(250);
        LIGHT_PORT ^= _BV(LIGHT_FRONT);
        _delay_ms(250);
    }
    }
#endif



    if (config.initialized != 0) {
        config.slot = 0;
        config.light = 0;
        config.program = 0;
        config.initialized = 0;
        config_save();
    }

    if ((config.program != 0xff) || (config.slot > 5 )) {
        temp = scan_id();
        config.program = 0xff;
        config_save();
        if (temp == 1) {
            // acknowledge with the engine
            OCR1B = 25;
            DDRB &= ~_BV(2);                  // PB2 PWM Output disable
            for (temp = 0xff; temp > 0; temp--) {
                DDRB ^= _BV(2);                   // PB2 PWM Output toggle
                _delay_ms(5); // 50 hz
                DDRB ^= _BV(2);                   // PB2 PWM Output toggle
                _delay_ms(15); // 50 hz
            }

        }
        timeout = 0;
    }


    while (1) {
        // main loop

        if (brake_timeout == 1) brake_off();

        if (my_speed != car_speed[config.slot]) {
            my_speed = car_speed[config.slot];
            OCR1B = (int) ((float)0xff * (float)((float)my_speed / (float)15));
            if (my_speed == 0) {
                DDRB &= ~_BV(2);                  // PB2 PWM Output disable
                brake_on();
            } else {
                brake_off();
                DDRB |= _BV(2);                   // PB2 PWM Output enable
            }
        }

        // Light cycle if switch pressed without speed
        if (car_speed[config.slot] == 0) {
            if (my_switch != car_switch[config.slot]) {
                my_switch = car_switch[config.slot];
                if (my_switch != 0) {
                    // cycle light
                    if (config.light == LIGHT_MODES) config.light = 0; else config.light++;
                    if (timeout > 1) {
                        // zweiter Tastendruck, Program Mode im EEPROM setzen
                        config.program = 1; // TODO: hier muss der slot rein welcher doppelclicked wurde (natuerlich dann auch nicht in der Lichtschaltelogik abfragen!)
                    } else {
                        // erster Tastendruck, timeout setzen
                        timeout = 80;
                    }
                    config_save();
                }
            }
        }

        switch (config.light) {
            case 0:
                LIGHT_PORT &= ~_BV(LIGHT_FRONT); // switch lights off
                break;
            case 1:
                LIGHT_PORT |= _BV(LIGHT_FRONT); // switch lights on
                break;
        }


        // timeout reset
        timeout = 0;
    } // main loop end
};