Subversion Repositories group.electronics

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>

#define F_CPU 12000000
#include <util/delay.h>
#include <avr/wdt.h>
#include <usbdrv.h>

#include <stdlib.h>
#include <string.h>

#include "config.h"
#include "hiddesc.h"

#define ROTS_ATTACHED   2
#define STAT            0
#define SENT            1


void doInt(uint8_t pcint);
uint8_t getKey(void);
uint8_t analogRead(uint8_t pin);

volatile uint8_t pcIntCurr[3] = {0,0,0};
volatile uint8_t pcIntLast[3] = {0,0,0};
volatile uint8_t pcIntMask[3] = {0,0,0};

//volatile uint8_t rot_stat[2] = {0,0};
//volatile uint8_t rot_sent[2] = {0,0};
// rotdata = [rot#][(stat|sent)]
volatile uint8_t rotdata[2][2] = { {0,0}, {0,0} };

struct{
  union {
    uint8_t data1[2];   // Rotaries
    struct {
        uint8_t rx:8;
        uint8_t ry:8;
    };
  };


  union {
    uint16_t data2;
    struct {
        uint8_t b00:1;
        uint8_t b01:1;
        uint8_t b02:1;
        uint8_t b03:1;
        uint8_t b04:1;
        uint8_t b05:1;
        uint8_t b06:1;
        uint8_t b07:1;
        uint8_t b08:1;
        uint8_t b09:1;
        uint8_t b10:1;
        uint8_t b11:1;
        uint8_t rot2a:1;
        uint8_t rot2b:1;
        uint8_t rot1a:1;
        uint8_t rot1b:1;
    };
  };
} report;

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

    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) {
        if(rq->bRequest == USBRQ_HID_GET_REPORT) {  
            return sizeof(report);
        } else if(rq->bRequest == USBRQ_HID_GET_IDLE) {
            return 1;
        } 
    }

  return 0;
}

void hadUsbReset(void) {
}

int main(void) {

  ACSR |= (1<<ACD); // Disable analog comparator

  ADMUX = (1<<ADLAR) | (0<<REFS0) | (1<<REFS1);
  ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0) ;

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

  /*
        PB0     - Output                - Keypad 1
        PB1     - Output                - Keypad 2
        PB2     - Output                - Keypad 3
        PB3     - Output                - Keypad 4
        PB4     - Input, Pullup         - Function select
  */
  DDRB          = 0B00001111;
  PORTB         = 0B00011111;

  /*
        PD0     - Input, Pullup, PCINT16        - Rotary 1a
        PD1     - Input, Pullup, PCINT17        - Rotary 1b


        PD4     - Input, Pullup         - Keypad 5
        PD5     - Input, Pullup         - Keypad 6
        PD6     - Input, Pullup         - Keypad 7
        PD7     - Input, Pullup         - Keypad 8
  */
  DDRD          = 0B00000000;
  PORTD         = 0B11110011;

  PCMSK2 |= (( 1 << PCINT16 ) | ( 1 << PCINT17 )); //enable encoder pins interrupt sources
  PCICR |= ( 1 << PCIE2 ); //enable pin change interupts

  // Timers not used for the moment
  // Setup timer0 - Enable overflow, 8 times prescaler
  //TIMSK0 = (1<<TOIE0);                        // Eable timer overflow for Timer0
  //TCNT0 = 0x00;                               // Set Timer0 to 0
  //TCCR0B = (1<< CS01) ;                       // /8 prescaler

  usbDeviceDisconnect();  /* enforce re-enumeration, do this while interrupts are disabled! */
  _delay_ms(500);
  usbDeviceConnect();

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

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

    if(usbInterruptIsReady()){
        report.data1[0] = (-128 + analogRead(0));
        report.data1[1] = (-128 + analogRead(1));
        report.data2 = 0x0000;


        uint8_t key = getKey();
        if (key > 0)
                report.data2 |= (1 << (key -1));

        // Now work out what rotary to send, if any
        // Also record if we sent a positive response, 
        //  so we can send a '0' next time (if selected on PD4)
        // rotdata = [rot#][(stat|sent)]
        uint8_t rot = 0;
        for (rot=0; rot<=(ROTS_ATTACHED - 1); rot++) {
                if (rotdata[rot][STAT] == 0x01 && rotdata[rot][SENT] == 0) {
                        rotdata[rot][SENT] = 1;
                        switch (rot) {
                                case(0):        report.rot1a = 1; break;
                                case(1):        report.rot2a = 1; break;
                        }
                } else if (rotdata[rot][STAT] == 0x02 && rotdata[rot][SENT] == 0) {
                        rotdata[rot][SENT] = 1;
                        switch (rot) {
                                case(0):      report.rot1b = 1; break;
                                case(1):      report.rot2b = 1; break;
                        }
                } else {
                        rotdata[rot][SENT] = 0;
                }
                rotdata[rot][STAT] = 0;

                if (rbi(PINB, PB4))
                        rotdata[rot][SENT] = 0;
        }

/*      
        if (rot_stat[0] == 0x01 && rot_sent[0] == 0) {
                report.rot1a = 1;
                rot_sent[0] = 1;
        } else if (rot_stat[0] == 0x02 && rot_sent[0] == 0) {
                report.rot1b = 1;
                rot_sent[0] = 1;
        } else {
                rot_sent[0] = 0;
        }

        // Reset our stat so ready for next turn
        rot_stat[0] = 0;

        // If our function select is set, dont bother
        //  sending a 'o' between consequtive 1's.
        if (rbi(PINB, PB4))
                rot_sent[0] = 0;
*/

      /* called after every poll of the interrupt endpoint */
      usbSetInterrupt(&report, sizeof(report));
    }
  }
}

uint8_t analogRead(uint8_t pin) {
        ADMUX = (1<<ADLAR) | (1<<REFS0) | (0<<REFS1) | (pin & 0x0f);
        ADCSRA |= (1<<ADSC);            // Start converting

        while (((ADCSRA >> ADSC) & 1)) {}       //Wait until conversion finished
        uint8_t result = ADCH;
        //ADCSRA |= (0<<ADSC);          // Stop converting

        return result;
}

uint8_t getKey() {
        uint8_t col, row = 0;
        uint8_t key = 0;
        uint8_t n = 1;

        for (row=0; row<=3; row++) {
                cbi(PORTB, row);
                _delay_us(10);                          // Wait for the port to change

                for (col=5; col<=7; col++) {
                        if (rbi(PIND, col) == 0)
                                key = n;
                        n++;
                }       

                sbi(PORTB, row);
        }
        return key;
}

/*
 *
 * Process the Pin Change Interrupt.
 * pcint provides what bank caused the interrupt
 *
 */
void doInt(uint8_t pcint) {

        // Select what rotary we are dealing with
        //   based on the pc interrupt that fired.
        uint8_t rot = 0;
        if (pcint == 1) 
                rot = 1;

        // If rot stat is not 0, we havn't sent
        //  our last results yet. Skip this click.
        if (rotdata[rot][STAT] != 0) {
                pcIntMask[pcint] = 0;
                return;
        }
        // Check which pin caused the interrupt. If they both
        //  equal 0, the pin that interrupted is the direction
        if (rbi(pcIntCurr[pcint], PCINT17) == 0 
                && rbi(pcIntCurr[pcint], PCINT17) == 0 
                && rbi(pcIntMask[pcint], PCINT16) ) {
                        rotdata[rot][STAT] = 1;
        } else if (rbi(pcIntCurr[pcint], PCINT16) == 0 
                && rbi(pcIntCurr[pcint], PCINT17) == 0 
                && rbi(pcIntMask[pcint], PCINT17) ) {
                        rotdata[rot][STAT] = 2;
        }

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

/* Not used for the moment
ISR(TIMER0_OVF_vect) {
        timer0_ovf++;
}
*/

ISR(PCINT1_vect)
{
        // Save the state and work out which pin caused
        //  the interrupt to occur
        pcIntCurr[1] = PIND;
        pcIntMask[1] = pcIntCurr[1] ^ pcIntLast[1];
        pcIntLast[1] = pcIntCurr[1];
        doInt(1);
}

ISR(PCINT2_vect)
{
        // Save the state and work out which pin caused
        //  the interrupt to occur
        pcIntCurr[2] = PIND;
        pcIntMask[2] = pcIntCurr[2] ^ pcIntLast[2];
        pcIntLast[2] = pcIntCurr[2];
        doInt(2);
}