/**
 * @defgroup RGB leds DMX512 controller
 * @type firmware
 * @file main.c
 * @author Etienne Meleard <etienne@yent.eu>
 * @creation 2014-06-20
 * @tabsize 4
 * @mcu ATMEGA8L
 * @fcpu 8MHz
*/


//============================ WARNING ===============================//
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
//                                                                    //
// Fuses must be like SUT1 = 1, SUT0 = 1, CKSEL3 = 1, CKSEL2 = 1,     //
// CKSEL1 = 1 and CKSEL0 = 0 to ensure using the crystal as clock     //
// (otherwise it uses the 8MHz internal clock), full swing mode is    //
// mandatory to acheive 8MHz operation.                               //
//                                                                    //
// CKDIV8 fuse must not be set to avoid clock frequency divided by 8  //
//                                                                    //
// Fuse set or = 1 means checked in ponyprog                          //
//                                                                    //
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
//====================================================================//


// ================= Fuses ================= //
 
/*FUSES = { // No success writing fuse this way, command line below ...
    .low = (FUSE_SUT1 & FUSE_SUT0 & FUSE_CKSEL3),
    .high = HFUSE_DEFAULT,
    .extended = EFUSE_DEFAULT,
};*/

// Run
// avrdude -c usbasp -p m8 -U lfuse:w:0xfe:m -U hfuse:w:0xd1:m -B250
// at first (-F may be needed)


// ================ Includes =============== //

#include <avr/io.h>
#include <sup_avr/io2.h>
#include <avr/interrupt.h>
#include <util/delay.h>


// ================ Pinouts ================ //

#define LED         Bit(PORTD).bit5

#define RX          Bit(PIND).bit0
#define RX_COMPLETE SIG_UART_RECV
#define RX_INT      Bit(PORTD).bit2
#define RX_SIG      SIG_INTERRUPT0
#define RX_TIMER    TCNT0
#define BREAK_LEN   11
#define MAB_LEN     1

#define DIP_0       Bit(PINC).bit0
#define DIP_1       Bit(PINC).bit1
#define DIP_2       Bit(PINC).bit2
#define DIP_3       Bit(PINC).bit3

#define DIP_A       Bit(PORTC).bit4
#define DIP_B       Bit(PORTB).bit4
#define DIP_C       Bit(PORTB).bit5

#define EXT_ADC     6
#define EXT_INPUT   Bit(PIND).bit3
#define EXT_OUTPUT  Bit(PORTD).bit3
#define EXT_SIG     SIG_INTERRUPT1

#define OUT_RED     Bit(PORTB).bit1
#define RED_CH      OCR1A
#define OUT_GREEN   Bit(PORTB).bit2
#define GREEN_CH    OCR1B
#define OUT_BLUE    Bit(PORTB).bit3
#define BLUE_CH     OCR2


// ================ Macros ================= //

#define BLINK       LED=1; _delay_ms(150); LED=0; _delay_ms(150)
#define PULSE10     LED=1; _delay_us(10); LED=0; _delay_us(10)
#define PULSE5      LED=1; _delay_us(5); LED=0; _delay_us(5)
#define PULSE3      LED=1; _delay_us(3); LED=0; _delay_us(3)
#define PULSE1      LED=1; _delay_us(1); LED=0; _delay_us(1)

#define RX_START    UCSRB |= 0x10; receiving = 1
#define RX_STOP     UCSRB &= 0xef; receiving = 0

#define ADDR_4      ((uint8_t)((PINC ^ 0x0f) & 0x0f))

#define DIP_SETTIME 10    // us, allows diodes to set (due to diode capacitance)

#define RX_ERROR    ((UCSRA & 0x10) || (UCSRA & 0x08))

#define MAX_TIME_WITHOUT_START 10000
#define ADDRESS_REFRESH_PERIOD 3000

#define PATTERN_FIXED   0
#define PATTERN_RAINBOW 1
#define PATTERN_BREATH  2


// ================ Globals ================ //

volatile uint16_t address = 0x0000;

volatile uint8_t receiving = 0;
volatile uint16_t received = 0;

volatile const uint8_t colors[12][3] = {
    {0xff, 0x00, 0x00}, // Linear colors
    {0x7f, 0x3f, 0x00},
    {0x7f, 0x7f, 0x00},
    {0x3f, 0x7f, 0x00},
    {0x00, 0xff, 0x00},
    {0x00, 0x7f, 0x3f},
    {0x00, 0x7f, 0x7f},
    {0x00, 0x3f, 0x7f},
    {0x00, 0x00, 0xff},
    {0x3f, 0x00, 0x7f},
    {0x7f, 0x00, 0x7f},
    {0x7f, 0x00, 0x3f}
    /*{0xff, 0x00, 0x00}, // Not linear
    {0xff, 0x7f, 0x00},
    {0xff, 0xff, 0x00},
    {0x7f, 0xff, 0x00},
    {0x00, 0xff, 0x00},
    {0x00, 0xff, 0x7f},
    {0x00, 0xff, 0xff},
    {0x00, 0x7f, 0xff},
    {0x00, 0x00, 0xff},
    {0x7f, 0x00, 0xff},
    {0xff, 0x00, 0xff},
    {0xff, 0x00, 0x7f}*/
};

volatile const uint16_t speeds[2][8] = {
    { // Rainbow : 1536 steps for each cycle, measured speed : c = 6.26 T + 17.49
        31 /*5s*/, 63 /*10s*/, 186 /*30s*/, 373 /*60s*/,
        562 /*90s*/, 752 /*120s*/, 1864 /*300s*/, 3740 /*600s*/
    },
    { // Breath : 256 steps for each cycle, so speed = 10000 T / 256, min is ???
        19 /*1s*/, 37 /*2s*/, 94 /*5s*/, 187 /*10s*/,
        375 /*20s*/, 562 /*30s*/, 1125 /*60s*/, 2250 /*120s*/
    }
};


// ================ Functions ============== //

void init(void) {
    // Led as output
    DDRD |= 1 << 5;
    
    // USART
    UCSRA = 0x00;   // No doubling of frequency
    UCSRB = 0x80;   // Rx disabled, Rx irq enabled, 8bit mode
    UCSRC = 0x8e;   // Async, no parity, 2 stops, 8 bits
    UBRRL = 1;      // 250kbds
    
    // Detection timer (timer 0)
    TCCR0 = 0x03;   // 64 prescaler, increment every 8us
    
    // Dip inputs
    DDRC &= 0xf0;
    PORTC |= 0x0f;  // Pull-up
    
    // Dip outputs
    DDRC |= 0x10;
    DDRB |= 0x30;
    DIP_A = 1;
    DIP_B = 1;
    DIP_C = 1;
    
    // RGB outputs as outputs
    DDRB |= 0x0e;
    
    // R/G timer (timer 1)
    TCCR1A = 0xa1;      // 8 bits, fast, non-inverting PWM on OC1A and OC1B
    TCCR1B = 0x04;      // with 256 prescaler ~ 122Hz
    RED_CH = 0x00;      // Red channel to 0
    GREEN_CH = 0x00;    // Green channel to 0
    
    // B timer (timer 2)
    TCCR2 = 0x66;   // 8 bits, fast, non-inverting PWM on OC2
    BLUE_CH = 0x00; // Blue channel to 0
}

void getAddress(void) {
    uint16_t buffer = 0x0000;
    
    DIP_A = 1;
    DIP_B = 1;
    DIP_C = 1;
    
    DIP_C = 0;
    _delay_us(DIP_SETTIME);
    buffer += ADDR_4;
    DIP_C = 1;
    buffer <<= 4;
    
    DIP_B = 0;
    _delay_us(DIP_SETTIME);
    buffer += ADDR_4;
    DIP_B = 1;
    buffer <<= 4;
    
    DIP_A = 0;
    _delay_us(DIP_SETTIME);
    buffer += ADDR_4;
    DIP_A = 1;
    
    address = buffer;
}

uint8_t getFrameStart(void) {
    uint32_t t = 1500000; // 1.5s
    while(t && RX) {
        _delay_us(1);
        t--;
    }
    if(!t) return 0;
    
    RX_TIMER = 0;
    while(!RX && RX_TIMER < BREAK_LEN) _delay_us(1);
    if(RX_TIMER < BREAK_LEN) return 0; // Error, break too short
    
    while(!RX) _delay_us(1); // Wait for MAB
    
    RX_TIMER = 0;
    while(RX && RX_TIMER < MAB_LEN) _delay_us(1);
    if(RX_TIMER < MAB_LEN) return 0; // Error, break too short
    
    received = 0;
    RX_START;
    
    return 1;
}


// =============== Interrupts ============== //

SIGNAL(RX_COMPLETE) {
    uint8_t data;
    data = UDR;
    
    if(!receiving) return;
    
    if(UCSRA & 0x10) return;
    if(UCSRA & 0x08)return;
    
    received++;
    
    if(received == 1) {
        //if(data != 0x00) RX_STOP; // Should be 0x00, not a setting packet otherwise
        return; // Ignore first slot
    }
    
    if(received < address + 2) {
        return; // Address not reached
    }
    
    if(received > address + 4) { // Received enough packets, stop receiving and wait for next frame
        RX_STOP;
        return;
    }
    
    // Got channel, set it
    switch(received - address - 2) {
        case 0: RED_CH      = data; break;
        case 1: GREEN_CH    = data; break;
        case 2: BLUE_CH     = data; break;
    }
}


// ================== Main ================= //

int main(void) {
    uint16_t time_without_start = 0;
    uint16_t address_is_valid = 0;
    
    uint8_t auto_mode = 0;
    uint8_t pattern = 0;
    uint8_t speed = 0;
    uint8_t stepped = 0;
    uint8_t color = 0;
    
    uint8_t color_index = 0;
    uint16_t wait_step = 0;
    uint16_t step = 0;
    
    uint16_t level = 0;
    
    cli();        // WatchDog disabled AT ALL TIMES !
    init();
    sei();
    
    BLINK;
    BLINK;
    
    while(1) {
        if(!address_is_valid) {
            getAddress();
            
            auto_mode = address >> 9;
            pattern = (address >> 7) & 0x03;
            
            if(auto_mode) switch(pattern) {
                case PATTERN_FIXED :
                    color = address & 0x3f;
                    break;
                
                case PATTERN_RAINBOW :
                    speed = (address >> 4) & 0x07;
                    stepped = (address >> 3) & 0x01;
                    break;
                
                case PATTERN_BREATH :
                    speed = (address >> 4) & 0x07;
                    color = address & 0x0f;
                    //color_index = color;
                    break;
            }
            
            address_is_valid = ADDRESS_REFRESH_PERIOD;
        }
        
        if(auto_mode) {
            if(!wait_step) { // Update output
                switch(pattern) {
                    case PATTERN_FIXED :
                        RED_CH = (color << 6) & 0xc0;
                        GREEN_CH = (color << 4) & 0xc0;
                        BLUE_CH = (color << 2) & 0xc0;
                        wait_step = (uint16_t)3500; // 0.35s
                        break;
                    
                    case PATTERN_RAINBOW :
                        if(color) {
                            color_index = color - 1;
                        }else color_index = 11;
                        
                        if(stepped) { // 25% (x2) holding
                            if(step < 32) level = 0;
                            else if(step >= 96) level = 127;
                            else level = 2 * step - 64;
                            
                        }else level = step;
                        
                        RED_CH = ((127 - level) * colors[color_index][0] + level * colors[color][0]) >> 7;
                        GREEN_CH = ((127 - level) * colors[color_index][1] + level * colors[color][1]) >> 7;
                        BLUE_CH = ((127 - level) * colors[color_index][2] + level * colors[color][2]) >> 7;
                        
                        step++;
                        if(step >= 128) {
                            step = 0;
                            color++;
                            if(color >= 12) {
                                color = 0;
                            }
                        }
                        wait_step = speeds[0][speed];// - (stepped ? 25 : 19); // stepped cycle code takes approx. 25 (TODO), fade cycle code takes approx. 19
                        break;
                    
                    case PATTERN_BREATH :
                        if(step < 256) {
                            level = step;
                        }else{
                            level = 511 - step;
                        }
                        
                        RED_CH = (level * colors[color_index][0]) >> 8;
                        GREEN_CH = (level * colors[color_index][1]) >> 8;
                        BLUE_CH = (level * colors[color_index][2]) >> 8;
                        
                        step++;
                        if(step >= 512) {
                            step = 0;
                            if(color == 0) {
                                color_index += 2;
                                if(color_index >= 12) color_index = 0;
                            }else color_index = color - 1;
                        }
                        wait_step = speeds[1][speed]; // TODO modulate dep on cycle approx time
                        break;
                }
            }
            
            if(wait_step) wait_step--;
        }else{ // DMX
            if(getFrameStart()) {
                LED = 0;
                time_without_start = 0;
            }
            if(time_without_start > MAX_TIME_WITHOUT_START) {
                if(receiving) RX_STOP;
                BLINK;
            }
            time_without_start++;
        }
        
        if(address_is_valid) address_is_valid--;
        _delay_us(100);
    }
    return 0;
}