keyboard functionality still not working
[labortage2013badge.git] / firmware / main.c
1 /* Name: main.c
2  * Project: hid-custom-rq example
3  * Author: Christian Starkjohann
4  * Creation Date: 2008-04-07
5  * Tabsize: 4
6  * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH
7  * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
8  * This Revision: $Id: main.c 692 2008-11-07 15:07:40Z cs $
9  */
10
11 /*
12 This example should run on most AVRs with only little changes. No special
13 hardware resources except INT0 are used. You may have to change usbconfig.h for
14 different I/O pins for USB. Please note that USB D+ must be the INT0 pin, or
15 at least be connected to INT0 as well.
16 We assume that an LED is connected to port B bit 0. If you connect it to a
17 different port or bit, change the macros below:
18 */
19 #define LED_PORT_DDR        DDRB
20 #define LED_PORT_OUTPUT     PORTB
21 #define R_BIT            4
22 #define G_BIT            3
23 #define B_BIT            1
24 #define BUTTON_PIN 4
25
26 #include <stdint.h>
27 #include <string.h>
28 #include <stdbool.h>
29
30 #include <avr/io.h>
31 #include <avr/wdt.h>
32 #include <avr/eeprom.h>
33 #include <avr/interrupt.h>  /* for sei() */
34 #include <util/delay.h>     /* for _delay_ms() */
35
36 #include <avr/pgmspace.h>   /* required by usbdrv.h */
37 #include "usbdrv.h"
38 #include "oddebug.h"        /* This is also an example for using debug macros */
39 #include "requests.h"       /* The custom request numbers we use */
40 #include "special_functions.h"
41
42 void update_pwm(void);
43
44 /* ------------------------------------------------------------------------- */
45 /* ----------------------------- USB interface ----------------------------- */
46 /* ------------------------------------------------------------------------- */
47 const PROGMEM char usbHidReportDescriptor[35] = {   /* USB report descriptor */
48     0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
49     0x09, 0x06,                    // USAGE (Keyboard)
50     0xa1, 0x01,                    // COLLECTION (Application)
51     0x05, 0x07,                    //   USAGE_PAGE (Keyboard)
52     0x19, 0xe0,                    //   USAGE_MINIMUM (Keyboard LeftControl)
53     0x29, 0xe7,                    //   USAGE_MAXIMUM (Keyboard Right GUI)
54     0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
55     0x25, 0x01,                    //   LOGICAL_MAXIMUM (1)
56     0x75, 0x01,                    //   REPORT_SIZE (1)
57     0x95, 0x08,                    //   REPORT_COUNT (8)
58     0x81, 0x02,                    //   INPUT (Data,Var,Abs)
59     0x95, 0x01,                    //   REPORT_COUNT (1)
60     0x75, 0x08,                    //   REPORT_SIZE (8)
61     0x25, 0x65,                    //   LOGICAL_MAXIMUM (101)
62     0x19, 0x00,                    //   USAGE_MINIMUM (Reserved (no event indicated))
63     0x29, 0x65,                    //   USAGE_MAXIMUM (Keyboard Application)
64     0x81, 0x00,                    //   INPUT (Data,Ary,Abs)
65     0xc0                           // END_COLLECTION
66 };
67 /* We use a simplifed keyboard report descriptor which does not support the
68  * boot protocol. We don't allow setting status LEDs and we only allow one
69  * simultaneous key press (except modifiers). We can therefore use short
70  * 2 byte input reports.
71  * The report descriptor has been created with usb.org's "HID Descriptor Tool"
72  * which can be downloaded from http://www.usb.org/developers/hidpage/.
73  * Redundant entries (such as LOGICAL_MINIMUM and USAGE_PAGE) have been omitted
74  * for the second INPUT item.
75  */
76
77 /* Keyboard usage values, see usb.org's HID-usage-tables document, chapter
78  * 10 Keyboard/Keypad Page for more codes.
79  */
80 #define MOD_CONTROL_LEFT    (1<<0)
81 #define MOD_SHIFT_LEFT      (1<<1)
82 #define MOD_ALT_LEFT        (1<<2)
83 #define MOD_GUI_LEFT        (1<<3)
84 #define MOD_CONTROL_RIGHT   (1<<4)
85 #define MOD_SHIFT_RIGHT     (1<<5)
86 #define MOD_ALT_RIGHT       (1<<6)
87 #define MOD_GUI_RIGHT       (1<<7)
88
89 #define KEY_A       4
90 #define KEY_B       5
91 #define KEY_C       6
92 #define KEY_D       7
93 #define KEY_E       8
94 #define KEY_F       9
95 #define KEY_G       10
96 #define KEY_H       11
97 #define KEY_I       12
98 #define KEY_J       13
99 #define KEY_K       14
100 #define KEY_L       15
101 #define KEY_M       16
102 #define KEY_N       17
103 #define KEY_O       18
104 #define KEY_P       19
105 #define KEY_Q       20
106 #define KEY_R       21
107 #define KEY_S       22
108 #define KEY_T       23
109 #define KEY_U       24
110 #define KEY_V       25
111 #define KEY_W       26
112 #define KEY_X       27
113 #define KEY_Y       28
114 #define KEY_Z       29
115 #define KEY_1       30
116 #define KEY_2       31
117 #define KEY_3       32
118 #define KEY_4       33
119 #define KEY_5       34
120 #define KEY_6       35
121 #define KEY_7       36
122 #define KEY_8       37
123 #define KEY_9       38
124 #define KEY_0       39
125
126 #define KEY_F1      58
127 #define KEY_F2      59
128 #define KEY_F3      60
129 #define KEY_F4      61
130 #define KEY_F5      62
131 #define KEY_F6      63
132 #define KEY_F7      64
133 #define KEY_F8      65
134 #define KEY_F9      66
135 #define KEY_F10     67
136 #define KEY_F11     68
137 #define KEY_F12     69
138
139 union {
140         struct {
141                 uint16_t red;
142                 uint16_t green;
143                 uint16_t blue;
144         } name;
145         uint16_t idx[3];
146 } color;
147
148 #define UNI_BUFFER_SIZE 16
149
150 static union {
151         uint8_t  w8[UNI_BUFFER_SIZE];
152         uint16_t w16[UNI_BUFFER_SIZE/2];
153         uint32_t w32[UNI_BUFFER_SIZE/4];
154         void*    ptr[UNI_BUFFER_SIZE/sizeof(void*)];
155 } uni_buffer;
156
157 static uint8_t uni_buffer_fill;
158 static uint8_t current_command;
159
160 static uchar    reportBuffer[2];    /* buffer for HID reports */
161 static uchar    idleRate;           /* in 4 ms units */
162
163 static bool  keyDidChange = false;
164 /* ------------------------------------------------------------------------- */
165
166
167 uint8_t read_button(void){
168         uint8_t t,v=0;
169         t = DDRB;
170         DDRB &= ~(1<<BUTTON_PIN);
171         PORTB |= 1<<BUTTON_PIN;
172         PORTB &= ~(1<<BUTTON_PIN);
173         v |= PINB;
174         DDRB |= t&(1<<BUTTON_PIN);
175         PORTB &= ~(t&(1<<BUTTON_PIN));
176         v >>= BUTTON_PIN;
177         v &= 1;
178         v ^= 1;
179         return v;
180 }
181
182 void init_temperature_sensor(void){
183         ADMUX = 0x8F;
184         ADCSRA = 0x87;
185 }
186
187 uint16_t read_temperture_sensor(void){
188         ADCSRA |= 0x40;
189         while(ADCSRA & 0x40)
190                 ;
191         return ADC;
192 }
193
194 #if 0
195 uchar   usbFunctionSetup(uchar data[8])
196 {
197 usbRequest_t    *rq = (void *)data;
198
199     usbMsgPtr = reportBuffer;
200     if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){    /* class request type */
201         if(rq->bRequest == USBRQ_HID_GET_REPORT){  /* wValue: ReportType (highbyte), ReportID (lowbyte) */
202             /* we only have one report type, so don't look at wValue */
203             buildReport(keyPressed());
204             return sizeof(reportBuffer);
205         }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
206             usbMsgPtr = &idleRate;
207             return 1;
208         }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
209             idleRate = rq->wValue.bytes[1];
210         }
211     }else{
212         /* no vendor specific requests implemented */
213     }
214     return 0;
215 }
216 #endif
217
218 usbMsgLen_t usbFunctionSetup(uchar data[8])
219 {
220         usbRequest_t    *rq = (usbRequest_t *)data;
221         if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) {    /* class request type */
222             color.name.red = 13;
223             if (rq->bRequest == USBRQ_HID_GET_REPORT){  /* wValue: ReportType (highbyte), ReportID (lowbyte) */
224             /* we only have one report type, so don't look at wValue */
225             if (color.name.red == 133) {
226                 color.name.red = 23;
227                 usbMsgPtr = reportBuffer;
228                 reportBuffer[0] = 0;
229                 reportBuffer[1] = KEY_X;
230             }
231             return sizeof(reportBuffer);
232         } else if (rq->bRequest == USBRQ_HID_GET_IDLE) {
233             usbMsgPtr = &idleRate;
234             return 1;
235         }else if (rq->bRequest == USBRQ_HID_SET_IDLE) {
236             usbMsgPtr = reportBuffer;
237             idleRate = rq->wValue.bytes[1];
238         }
239     }
240     if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_VENDOR) {
241                 current_command = rq->bRequest;
242         switch(rq->bRequest)
243                 {
244                 case CUSTOM_RQ_SET_RGB:
245                         return USB_NO_MSG;
246                 case CUSTOM_RQ_GET_RGB:{
247                         usbMsgLen_t len=6;
248                         if(len>rq->wLength.word){
249                                 len = rq->wLength.word;
250                         }
251                         usbMsgPtr = (uchar*)color.idx;
252                         return len;
253                 }
254                 case CUSTOM_RQ_READ_MEM:
255                         usbMsgPtr = (uchar*)rq->wValue.word;
256                         return rq->wLength.word;
257                 case CUSTOM_RQ_WRITE_MEM:
258                 case CUSTOM_RQ_EXEC_SPM:
259                         uni_buffer_fill = 4;
260                         uni_buffer.w16[0] = rq->wValue.word;
261                         uni_buffer.w16[1] = rq->wLength.word;
262                         return USB_NO_MSG;
263                 case CUSTOM_RQ_READ_FLASH:
264                         uni_buffer.w16[0] = rq->wValue.word;
265                         uni_buffer.w16[1] = rq->wLength.word;
266                         return USB_NO_MSG;
267                 case CUSTOM_RQ_RESET:
268                         soft_reset((uint8_t)(rq->wValue.word));
269                         break;
270                 case CUSTOM_RQ_READ_BUTTON:
271                         uni_buffer.w8[0] = read_button();
272                         usbMsgPtr = uni_buffer.w8;
273                         return 1;
274                 case CUSTOM_RQ_READ_TMPSENS:
275                         uni_buffer.w16[0] = read_temperture_sensor();
276                         usbMsgPtr = uni_buffer.w8;
277                         return 2;
278                 }
279     }
280
281     return 0;   /* default for not implemented requests: return no data back to host */
282 }
283
284 uchar usbFunctionWrite(uchar *data, uchar len)
285 {
286         switch(current_command){
287         case CUSTOM_RQ_SET_RGB:
288                 if(len!=6){
289                         return 1;
290                 }
291                 memcpy(color.idx, data, 6);
292         keyDidChange = true;
293                 return 1;
294         case CUSTOM_RQ_WRITE_MEM:
295                 memcpy(uni_buffer.ptr[0], data, len);
296                 uni_buffer.w16[0] += len;
297                 return !(uni_buffer.w16[1] -= len);
298         case CUSTOM_RQ_EXEC_SPM:
299                 if(uni_buffer_fill<8){
300                         uint8_t l = 8-uni_buffer_fill;
301                         if(len<l){
302                                 len = l;
303                         }
304                         memcpy(&(uni_buffer.w8[uni_buffer_fill]), data, len);
305                         uni_buffer_fill += len;
306                         return 0;
307                 }
308                 uni_buffer.w16[1] -= len;
309                 if(uni_buffer.w16[1]>8){
310                         memcpy(uni_buffer.ptr[0], data, len);
311                         uni_buffer.w16[0] += len;
312                         return 0;
313                 }else{
314                         memcpy(&(uni_buffer.w8[uni_buffer_fill]), data, len);
315                         exec_spm(uni_buffer.w16[2], uni_buffer.w16[3], uni_buffer.ptr[0], data, len);
316                         return 1;
317                 }
318         default:
319                 return 1;
320         }
321         return 0;
322 }
323 uchar usbFunctionRead(uchar *data, uchar len){
324         uchar ret=len;
325         switch(current_command){
326         case CUSTOM_RQ_READ_FLASH:
327                 while(len--){
328                         *data++ = pgm_read_byte((uni_buffer.w16[0])++);
329                 }
330                 return ret;
331         default:
332                 break;
333         }
334         return 0;
335 }
336
337 static void calibrateOscillator(void)
338 {
339 uchar       step = 128;
340 uchar       trialValue = 0, optimumValue;
341 int         x, optimumDev, targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e6 + 0.5);
342  
343     /* do a binary search: */
344     do{
345         OSCCAL = trialValue + step;
346         x = usbMeasureFrameLength();    // proportional to current real frequency
347         if(x < targetValue)             // frequency still too low
348             trialValue += step;
349         step >>= 1;
350     }while(step > 0);
351     /* We have a precision of +/- 1 for optimum OSCCAL here */
352     /* now do a neighborhood search for optimum value */
353     optimumValue = trialValue;
354     optimumDev = x; // this is certainly far away from optimum
355     for(OSCCAL = trialValue - 1; OSCCAL <= trialValue + 1; OSCCAL++){
356         x = usbMeasureFrameLength() - targetValue;
357         if(x < 0)
358             x = -x;
359         if(x < optimumDev){
360             optimumDev = x;
361             optimumValue = OSCCAL;
362         }
363     }
364     OSCCAL = optimumValue;
365 }
366  
367
368 void usbEventResetReady(void)
369 {
370     cli();  // usbMeasureFrameLength() counts CPU cycles, so disable interrupts.
371     calibrateOscillator();
372     sei();
373 // we never read the value from eeprom so this causes only degradation of eeprom
374 //    eeprom_write_byte(0, OSCCAL);   // store the calibrated value in EEPROM
375 }
376
377 /* ------------------------------------------------------------------------- */
378
379 int main(void)
380 {
381         uchar   i;
382
383     wdt_enable(WDTO_1S);
384     /* Even if you don't use the watchdog, turn it off here. On newer devices,
385      * the status of the watchdog (on/off, period) is PRESERVED OVER RESET!
386      */
387     /* RESET status: all port bits are inputs without pull-up.
388      * That's the way we need D+ and D-. Therefore we don't need any
389      * additional hardware initialization.
390      */
391
392     init_temperature_sensor();
393     usbInit();
394     usbDeviceDisconnect();  /* enforce re-enumeration, do this while interrupts are disabled! */
395     i = 0;
396     while(--i){             /* fake USB disconnect for > 250 ms */
397         wdt_reset();
398         _delay_ms(1);
399     }
400     usbDeviceConnect();
401     LED_PORT_DDR |= _BV(R_BIT) | _BV(G_BIT) | _BV(B_BIT);   /* make the LED bit an output */
402         
403     sei();
404
405     for(;;){                /* main event loop */
406         //      update_pwm();
407                 
408         wdt_reset();
409         usbPoll();
410         if(keyDidChange && usbInterruptIsReady()){
411             keyDidChange = 0;
412             color.name.red = 42;
413             /* use last key and not current key status in order to avoid lost
414                changes in key status. */
415            reportBuffer[0] = 0;
416            reportBuffer[1] = KEY_Y;
417            usbSetInterrupt(reportBuffer, sizeof(reportBuffer));
418         }
419     }
420     return 0;
421 }
422
423 /* ------------------------------------------------------------------------- */