Subversion Repositories group.electronics

/* Name: main.c
 * Project: EasyLogger
 * Author: Christian Starkjohann
 * Creation Date: 2006-04-23
 * Tabsize: 4
 * Copyright: (c) 2006 by OBJECTIVE DEVELOPMENT Software GmbH
 * License: Proprietary, free under certain conditions. See Documentation.
 * This Revision: $Id$
 */

#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 "usbdrv.h"
#include "oddebug.h"
#include "config.h"

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

/* ------------------------------------------------------------------------- */

struct {
        union {
                int16_t axis[3];
                struct {
                        int16_t axis0:16;
                        int16_t axis1:16;
                        int16_t axis2:16;
                };
                uint8_t buttons;
                struct {
                        int8_t b1:1;
                        int8_t b2:2;
                        int8_t reserved:6;
                };
        };
} reportBuffer;


volatile struct {
        uint8_t current;
        uint8_t last;
        uint8_t mask;
} pcInt[1];

volatile struct {
        uint8_t button;
        uint8_t timer;
} buttons;


static uchar    idleRate;           /* in 4 ms units */
volatile uint8_t tmr0_ovf = 0;
volatile uint32_t systime = 0;

/* ------------------------------------------------------------------------- */

const PROGMEM char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = { /* USB report descriptor */
    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    0x09, 0x05,                    // USAGE (Game Pad)
    0xa1, 0x01,                    // COLLECTION (Application)
    0x09, 0x01,                    //   USAGE (Pointer)
    0xa1, 0x00,                    //   COLLECTION (Physical)
    0x09, 0x30,                    //     USAGE (X)
    0x09, 0x31,                    //     USAGE (Y)
    0x09, 0x38,                    //     USAGE (Y)
    0x16, 0x00, 0x80,              //     Log Min -32768
    0x26, 0xff, 0x7f,              //     Log max 32768
    0x75, 0x10,                    //     REPORT_SIZE (16)
    0x95, 0x03,                    //     REPORT_COUNT (2)
    0x81, 0x02,                    //     INPUT (Data,Var,Abs)

    0x05, 0x09,                    //     USAGE_PAGE (Button)
    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
    0x29, 0x02,                    //     USAGE_MAXIMUM (Button 2)
    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
    0x75, 0x01,                    //     REPORT_SIZE (1)
    0x95, 0x08,                    //     REPORT_COUNT (2)
    0x81, 0x02,                    //     INPUT (Data,Var,Abs)

    0xc0,                          //   END_COLLECTION
    0xc0                           // END_COLLECTION
};


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

    //usbMsgPtr = reportBuffer;
    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){ 
        if(rq->bRequest == USBRQ_HID_GET_REPORT){ 
            return sizeof(reportBuffer);
        }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
            usbMsgPtr = &idleRate;
            return 1;
        }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
            idleRate = rq->wValue.bytes[1];
        }
    }else{

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


void usbSendHidReport(uchar * data, uchar len) {
        usbSetInterrupt(data, len);
}


int main(void) {
uchar   i;
uchar   calibrationValue;

    calibrationValue = eeprom_read_byte(0); /* calibration value from last time */
    if(calibrationValue != 0xff){
        OSCCAL = calibrationValue;
    }

    odDebugInit();
    usbDeviceDisconnect();
    for(i=0;i<20;i++){  /* 300 ms disconnect */
        _delay_ms(15);
    }

    usbDeviceConnect();
    wdt_enable(WDTO_1S);

  PCMSK |= (( 1 << PCINT3 ) | ( 1 << PCINT4 )); //enable encoder pins interrupt sources
  GIMSK |= ( 1 << PCIE ); //enable pin change interupts

        TIMSK = (1<<TOIE0);                    // Enable timer overflow
        TCNT0 = 0x00;                           // Set Timer0 initial value to 0
        TCCR0B = (1<< CS01) ;                   // /1 prescaler

  DDRB          = 0B00000001;
  PORTB         = 0B00000000;

    usbInit();
    sei();

    reportBuffer.axis0 = 0;
    reportBuffer.axis1 = 0;
    reportBuffer.axis2 = 0;
    reportBuffer.buttons = 0;

    for(;;){    /* main event loop */
        wdt_reset();
        usbPoll();

        

        if(usbInterruptIsReady()){ 

                // Check if our buttons need pressing
                reportBuffer.buttons = 0;
                if (buttons.timer != 0) {
                        if (buttons.button == 1)
                                reportBuffer.b1 = 1;
                        else
                                reportBuffer.b2 = 1;
                }

                usbSendHidReport(&reportBuffer, sizeof(reportBuffer));
        }
    }
    return 0;
}

void pcInterrupt(uint8_t pcint) {

        switch (pcint) {
                case 0: pcInt[pcint].current = PINB; break;
        }
        pcInt[pcint].mask = pcInt[pcint].current ^ pcInt[pcint].last;
        pcInt[pcint].last = pcInt[pcint].current;

        if (pcInt[pcint].mask == 0)
                return;

        // Check which pin caused the interrupt. If they both
        //  equal 0, the pin that interrupted is the direction
        if (rbi(pcInt[pcint].current, PCINT3) == 0
                && rbi(pcInt[pcint].current, PCINT4) == 0
                && rbi(pcInt[pcint].mask, PCINT4) ) {

                        if (reportBuffer.axis2 < 32500)
                                reportBuffer.axis2 += 200;

                        buttons.button = 1;
                        buttons.timer = 5;

        } else if (rbi(pcInt[pcint].current, PCINT3) == 0
                && rbi(pcInt[pcint].current, PCINT4) == 0
                && rbi(pcInt[pcint].mask, PCINT3) ) {

                        if (reportBuffer.axis2 > -32500)
                                reportBuffer.axis2 -= 200;

                        buttons.button = 2;
                        buttons.timer = 5;
        }

        // Clear the mask so we know we've delth with it
        pcInt[pcint].mask = 0;
}

ISR(PCINT0_vect) {
        pcInterrupt(0);
}

ISR(TIMER0_OVF_vect) {
        tmr0_ovf++;
        if (tmr0_ovf>=50) {
                systime++;
                tmr0_ovf = 0;

                if (buttons.timer != 0) 
                        buttons.timer--;
        }
}