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);

}