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 "util.h"

#include "wire.h"

#include "config.h"

#include "hiddesc.h"

#define ROTS_ATTACHED	1

#define STAT		0

#define SENT		1

#define SWITCHES	1

#define ON		1

#define OFF		0

#define DETECTED	0

#define TIMER		1

#define	DEBOUNCED	2

/*

 * Keyboard modifier codes

 */

#define MOD_CONTROL_LEFT    (1<<0)

#define MOD_SHIFT_LEFT      (1<<1)

#define MOD_ALT_LEFT        (1<<2)

#define MOD_GUI_LEFT        (1<<3)

#define MOD_CONTROL_RIGHT   (1<<4)

#define MOD_SHIFT_RIGHT     (1<<5)

#define MOD_ALT_RIGHT       (1<<6)

#define MOD_GUI_RIGHT       (1<<7)

void doInt(uint8_t pcint);

uint8_t getKey(void);

volatile struct {

	uint8_t current;

	uint8_t last;

	uint8_t mask;

} pcInt[3];

// switches = [detected][timer][debounced]

volatile uint8_t switches[1][3] = { {0,0,0} };

// rotData = [rot#][(stat|sent)]

//volatile uint8_t rotData[2][2] = { {0,0}, {0,0} };

volatile struct {

	union {

		uint8_t data;

		struct {

			uint8_t stat:4;

			uint8_t sent:4;

		};

	};

} rotData[2];

uint8_t keyMap[] = { 	0x1E, 0x1F, 0x20,

			0x21, 0x22, 0x23,

			0x24, 0x25, 0x26,

			0x25, 0x27, 0x20 };

uint8_t keySelect = 1;

struct {

	uint8_t report_id;

	uint8_t modifier;

	uint8_t keycode;

} reportKeyboard;

struct{

	uint8_t report_id;

  union {

    uint8_t data1[2];

    struct {

	uint8_t rx:8;

	uint8_t ry:8;

    };

  };

  union {

    uint16_t data2;

    struct {

	uint16_t buttons:12;

	uint16_t rot2a:1;

	uint16_t rot2b:1;

	uint16_t rot1a:1;

	uint16_t rot1b:1;

    };

  };

} reportJoystick;

void usbSendHidReport(uchar * data, uchar len) {

	while(1)

	{

		usbPoll();

		if (usbInterruptIsReady())

		{

			usbSetInterrupt(data, len);

			break;

		}

	}

}

usbMsgLen_t usbFunctionSetup(uchar data[8]) {

	usbRequest_t *rq = (void *)data;

	if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) {

		switch (rq->bRequest) {

			case USBRQ_HID_GET_REPORT:

				if (rq->wValue.bytes[0] == 1)

					return sizeof(reportKeyboard);

				else if (rq->wValue.bytes[0] == 2)

					return sizeof(reportJoystick);

				else

					return 0;

			case USBRQ_HID_GET_IDLE:

				return 1;

			default:

				return 0;

		}

	}

	return 0;

}

void hadUsbReset(void) {

}

int main(void) {

	analogInit();

  /*

  DDR : 1 = Output, 0 = Input

  PORT: 1 = Pullup for Input, otherwise set output

  PIN : Read input pin

  */

  /*

	PB0	- Output 		- Keypad 2

	PB1	- Output 		- Keypad 7

	PB2	- Output 		- Keypad 6

	PB3	- Output 		- Keypad 4

	PB4	- Input, Pullup		- Function select

	PB5	- Input, Pullup		- Function select

  */

  DDRB		= 0B00001111;

  PORTB 	= 0B00111111;

  /*

	PD0	- Input, Pullup, PCINT16	- Rotary 1a

	PD1	- Input, Pullup, PCINT17	- Rotary 1b

	PD4	- Output		- Keypad select status led

	PD5	- Input, Pullup		- Keypad 3

	PD6	- Input, Pullup		- Keypad 1

	PD7	- Input, Pullup		- Keypad 5

  */

  DDRD		= 0B00010000;

  PORTD		= 0B11100011;

  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

	i2c_master();

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

  _delay_ms(500);

  usbDeviceConnect();

  wdt_enable(WDTO_1S);

  usbInit();

  sei();

	reportKeyboard.report_id = 1;

	reportJoystick.report_id = 2;

  for(;;) {

    wdt_reset();

    usbPoll();

	/*

	 * This is some really bad deboucing code

	 */

	// Detect the button press, wait 100 timer cycles (1.7ms / cycle)

	if (rbi(PINB, PB5) == 0 && switches[0][DETECTED]==0) {

		switches[0][DETECTED] = 1;

		switches[0][TIMER] = 100;

	}

	// After timer is zero, check switch again.

	//  If switch still pressed, its debounced

	//  Otherwise, reset the debounce

	if (switches[0][DETECTED] == 1 && switches[0][TIMER] == 0 && switches[0][DEBOUNCED]==0) {

		if (rbi(PINB, PB5) == 0)	

			switches[0][DEBOUNCED] = 1;

		else {

			switches[0][DETECTED] = 0;

			switches[0][TIMER] = 0;

		}

	}

	// If the switch has come up, do another debounce

	if (rbi(PINB, PB5) && switches[0][DETECTED]==2) {

		switches[0][TIMER] = 100;

		switches[0][DETECTED] = 3;

	}

	// After the up switch timer is zero, do the debounce check

	// Otherwise, assume switch is still down

	if (switches[0][DETECTED] == 3 && switches[0][TIMER] == 0) {

		if (rbi(PINB, PB5))

			switches[0][DETECTED] = 0;

	}

	// Process the switch

	if (switches[0][DEBOUNCED] == 1) {

		xbi(keySelect, 0);

		if (keySelect == 0)

			sbi(PORTD, PD4);

		else

			cbi(PORTD, PD4);

		switches[0][DETECTED] = 2;

		switches[0][DEBOUNCED] = 0;

	}

    if(usbInterruptIsReady()){

	reportJoystick.data1[0] = (-128 + analogRead(0));

	reportJoystick.data1[1] = (-128 + analogRead(1));

	reportJoystick.data2 = 0x0000;				// Clear all the buttons

	reportKeyboard.modifier = 0x00;

	reportKeyboard.keycode = 0x00;

	uint8_t key = getKey();

	if (rbi(keySelect, 0)) {

		// Keypad is joystick

		if (key > 0)

			reportJoystick.data2 |= (1 << (--key));

	} else {

		// Keypad is keyboard

		if (key > 0) {

			if (key==10 || key==12)

				reportKeyboard.modifier |= (1<<1);	//Left shift

			reportKeyboard.keycode = keyMap[--key];

		}

	}

	// 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):	reportJoystick.rot1a = 1; break;

				case(1):	reportJoystick.rot2a = 1; break;

			}

	        } else if (rotData[rot].stat == 0x02 && rotData[rot].sent == 0) {

                	rotData[rot].sent = 1;

                        switch (rot) {

                                case(0):      reportJoystick.rot1b = 1; break;

                                case(1):      reportJoystick.rot2b = 1; break;

                        }

	        } else {

        	        rotData[rot].sent = 0;

	        }

		rotData[rot].stat = 0;

	        if (rbi(PINB, PB4))

        	        rotData[rot].sent = 0;

	}

      /* called after every poll of the interrupt endpoint */

      //usbSetInterrupt(&reportKeyboard, sizeof(reportKeyboard));

      //usbSetInterrupt(&reportJoystick, sizeof(reportJoystick));

	usbSendHidReport(&reportKeyboard, sizeof(reportKeyboard));

	usbSendHidReport(&reportJoystick, sizeof(reportJoystick));

    }

  }

}

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 pcInterrupt(uint8_t pcint) {

	switch (pcint) {

		case 0:	pcInt[pcint].current = PINB; break;

		case 1:	pcInt[pcint].current = PIND; break;

		case 2:	pcInt[pcint].current = PINC; break;

	}

	pcInt[pcint].current = PIND;

	pcInt[pcint].mask = pcInt[pcint].current ^ pcInt[pcint].last;

	pcInt[pcint].last = pcInt[pcint].current;

	// 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) {

		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, PCINT17) == 0 

		&& rbi(pcInt[pcint].current, PCINT17) == 0 

		&& rbi(pcInt[pcint].mask, PCINT16) ) {

			rotData[rot].stat = 1;

  	} else if (rbi(pcInt[pcint].current, PCINT16) == 0 

		&& rbi(pcInt[pcint].current, PCINT17) == 0 

		&& rbi(pcInt[pcint].mask, PCINT17) ) {

			rotData[rot].stat = 2;

  	}

	// Clear the mask so we know we've delth with it

	pcInt[pcint].mask = 0;

}

ISR(TIMER0_OVF_vect) {

	if (switches[0][DETECTED] && switches[0][TIMER])

		switches[0][TIMER]--;

}

ISR(PCINT0_vect) {

	pcInterrupt(0);

}

ISR(PCINT1_vect) {

	pcInterrupt(1);

}

ISR(PCINT2_vect) {

	pcInterrupt(2);

}