Subversion Repositories group.electronics

#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "config.h"
#include "avrutil.h"
#include "usbdrv.h"
#include "i2cbb.h"


#ifndef NULL
#define NULL    ((void *)0)
#endif

void usbEventResetReady(void);
static void calibrateOscillator(void);
static void updateDisplay(uint8_t dis);
static void updateInput();

//static void requestData(uint8_t addr, uint8_t code, uint8_t* data, uint8_t len);

void print16(uint8_t dis, uint8_t dig, uint16_t val);

#define DISPLAYS_ATTACHED 2
#define INPUT_REFRESH 5

struct display_type {
        uint8_t address;
        uint8_t value[10];
        uint16_t decpts;

        int8_t rotary;          // State of the rotary encoder
        uint8_t buttons;        // State of the buttons
} display[DISPLAYS_ATTACHED];



static uint8_t usbReplyBuf[8];
static uint8_t update = 255;


volatile uint8_t tmr0_ovf = 0;


int main(void) {
        // calibration value from last time
        uchar   calibrationValue;
        calibrationValue = eeprom_read_byte(0);
        if(calibrationValue != 0xff){
                OSCCAL = calibrationValue;
        }

        /*
                DDR : 1 = Output, 0 = Input
                PORT: 1 = Pullup for Input, otherwise set output
                PIN : Read input pin

                PB0     -
                PB1     -               - USB D- Low Speed
                PB2     -               - USB D+
                PB3     -               - SCL i2c bb
                PB4     -               - SDA i2c bb
                PB5     -
        */
        DDRB          = 0B00000001;
        PORTB         = 0B00000001;


    usbDeviceDisconnect();
    _delay_ms(500);
    usbDeviceConnect();

    systime = 0;
    uint32_t refresh = 0;
    sysclockInit();

    wdt_enable(WDTO_1S);
    usbInit();
    sei();


    // Set the displays to blank


    uint8_t i;
    for (i=0; i<DISPLAYS_ATTACHED; i++) {
        display[i].address = 0x26 + i;
        display[i].decpts = 0x00;

        uint8_t j;
        for (j=0; j<10; j++)
                display[i].value[j] = 0x0a;
        updateDisplay(i);
    }

    for(;;){
         wdt_reset();
         usbPoll();

        // Only update the display when a change
        //  comes in fron the usb port
        if (update != 255) {
                updateDisplay(update);
                update = 255;
        }

                if (systime > refresh) {
                        refresh = systime + INPUT_REFRESH;
                        updateInput();
                }
    }
    return 0;
}

static void updateInput() {
        uint8_t i;
        for (i = 0; i < DISPLAYS_ATTACHED; i++) {
                i2cbb_Init();
                i2cbb_Start();
                i2cbb_Write( display[i].address << 1 );
                i2cbb_Write( 0x0a );
                i2cbb_Stop();

                i2cbb_Start();
                i2cbb_Write( (display[i].address << 1) + 1 );
                display[i].rotary += (int8_t)i2cbb_Read(1);
                i2cbb_Stop();

                i2cbb_Init();
                i2cbb_Start();
                i2cbb_Write( display[i].address << 1 );
                i2cbb_Write( 0x09 );
                i2cbb_Stop();


                i2cbb_Init();
                i2cbb_Start();
                i2cbb_Write( display[i].address << 1 );
                i2cbb_Write( 0x0c );
                i2cbb_Stop();

                i2cbb_Start();
                i2cbb_Write( (display[i].address << 1) + 1 );
                display[i].buttons = i2cbb_Read(1);
                i2cbb_Stop();
        }

}

static void updateDisplay(uint8_t dis) {
    cbi(PORTB, PB0);

    // Send the display buffer to display board
    i2cbb_Init();
    i2cbb_Start();
    i2cbb_Write( display[dis].address << 1);
    i2cbb_Write( 0x05 );
    uint8_t n;
    for (n=0; n<10; n++) {
        uint8_t send = (n << 4) | display[dis].value[n];
        i2cbb_Write( send );
    }
    i2cbb_Stop();

    /*
    // Send the decimal point
        i2cbb_Init();
        i2cbb_Start();
        i2cbb_Write( 0x4c );
        i2cbb_Write(0x08);
        i2cbb_Write((uint8_t)(display[dis].decpts>>8));
        i2cbb_Write((uint8_t)display[dis].decpts);
        i2cbb_Stop();
        */

    sbi(PORTB, PB0);
}

#define USB_SET_LATCH                   20
#define USB_SET_DISPLAY1                21
#define USB_SET_DISPLAY2                22

#define USB_GET_INPUT                   30

#define USB_SET_INT16                   50

usbMsgLen_t usbFunctionSetup(uchar data[8])
{
    usbRequest_t    *rq = (void *)data;

        switch (rq->bRequest ) {
                case USB_SET_LATCH: {
                        update = rq->wValue.bytes[0];;
                        break;
                }
                case USB_SET_DISPLAY1: {
                        uint8_t dis = rq->wValue.bytes[1];
                        uint8_t dig = rq->wValue.bytes[0];
                        //uint8_t dp = rq->wIndex.bytes[1];
                        uint8_t val = rq->wIndex.bytes[0];
                        display[dis].value[dig] = val;
                        /*
                        if (dp)
                                sbi(display[dis].decpts, 1 << dig);
                        else
                                cbi(display[dis].decpts, 1 << dig);
                        //display[dis].decpts |= dp << dig;*/
                        break;
                }
                case USB_GET_INPUT: {
                        uint8_t i;
                        for (i=0; i<DISPLAYS_ATTACHED; i++) {
                                usbReplyBuf[(i*2)] = display[i].buttons;
                                usbReplyBuf[(i*2+1)] = display[i].rotary;
                                display[i].rotary = 0;
                        }

                        usbMsgPtr = usbReplyBuf;
                        return sizeof(usbReplyBuf);
                }

        }
        return 0;
}

static void calibrateOscillator(void) {
    uchar step = 128;
    uchar trialValue = 0, optimumValue;
    int x, optimumDev;
    int targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e6 + 0.5);

    /* do a binary search: */
    do {
        OSCCAL = trialValue + step;
        x = usbMeasureFrameLength();    /* proportional to current real frequency */
        if(x < targetValue)             /* frequency still too low */
            trialValue += step;
        step >>= 1;
    } while(step > 0);
    /* We have a precision of +/- 1 for optimum OSCCAL here */
    /* now do a neighborhood search for optimum value */
    optimumValue = trialValue;
    optimumDev = x; /* this is certainly far away from optimum */
    for(OSCCAL = trialValue - 1; OSCCAL <= trialValue + 1; OSCCAL++){
        x = usbMeasureFrameLength() - targetValue;
        if(x < 0)
            x = -x;
        if(x < optimumDev){
            optimumDev = x;
            optimumValue = OSCCAL;
        }
    }
    OSCCAL = optimumValue;
}


void usbEventResetReady(void) {
    cli();
    calibrateOscillator();
    sei();
    eeprom_write_byte(0, OSCCAL);   /* store the calibrated value in EEPROM */
}

ISR(TIM0_OVF_vect) {

        tmr0_ovf++;

        // Clk/1 TCCR0B = (1<< CS00);
        //20.0Mhz, 1ms = 78ovf
        //16.5Mhz, 1ms = 64ovf
        //16.0Mhz, 1ms = 62ovf
        //12.0Mhz, 1ms = 46ovf
        // 8.0Mhz, 1ms = 31ovf
        // 8.0Mhz, .5ms = 15ovf, 160r

        if (tmr0_ovf>=64) {
                        systime++;
                        tmr0_ovf = 0;
        }

}