2 * Project: hid-custom-rq example
3 * Author: Christian Starkjohann
4 * Creation Date: 2008-04-07
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 $
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:
19 #define LED_PORT_DDR DDRB
20 #define LED_PORT_OUTPUT PORTB
32 #include <avr/eeprom.h>
33 #include <avr/interrupt.h> /* for sei() */
34 #include <util/delay.h> /* for _delay_ms() */
36 #include <avr/pgmspace.h> /* required by 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"
42 void update_pwm(void);
44 /* ------------------------------------------------------------------------- */
45 /* ----------------------------- USB interface ----------------------------- */
46 /* ------------------------------------------------------------------------- */
47 PROGMEM const char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = {
48 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
49 0x09, 0x06, // USAGE (Keyboard)
50 0xa1, 0x01, // COLLECTION (Application)
51 0x75, 0x01, // REPORT_SIZE (1)
52 0x95, 0x08, // REPORT_COUNT (8)
53 0x05, 0x07, // USAGE_PAGE (Keyboard)(Key Codes)
54 0x19, 0xe0, // USAGE_MINIMUM (Keyboard LeftControl)(224)
55 0x29, 0xe7, // USAGE_MAXIMUM (Keyboard Right GUI)(231)
56 0x15, 0x00, // LOGICAL_MINIMUM (0)
57 0x25, 0x01, // LOGICAL_MAXIMUM (1)
58 0x81, 0x02, // INPUT (Data,Var,Abs) ; Modifier byte
59 0x95, 0x01, // REPORT_COUNT (1)
60 0x75, 0x08, // REPORT_SIZE (8)
61 0x81, 0x03, // INPUT (Cnst,Var,Abs) ; Reserved byte
62 0x95, 0x05, // REPORT_COUNT (5)
63 0x75, 0x01, // REPORT_SIZE (1)
64 0x05, 0x08, // USAGE_PAGE (LEDs)
65 0x19, 0x01, // USAGE_MINIMUM (Num Lock)
66 0x29, 0x05, // USAGE_MAXIMUM (Kana)
67 0x91, 0x02, // OUTPUT (Data,Var,Abs) ; LED report
68 0x95, 0x01, // REPORT_COUNT (1)
69 0x75, 0x03, // REPORT_SIZE (3)
70 0x91, 0x03, // OUTPUT (Cnst,Var,Abs) ; LED report padding
71 0x95, 0x06, // REPORT_COUNT (6)
72 0x75, 0x08, // REPORT_SIZE (8)
73 0x15, 0x00, // LOGICAL_MINIMUM (0)
74 0x25, 0x65, // LOGICAL_MAXIMUM (101)
75 0x05, 0x07, // USAGE_PAGE (Keyboard)(Key Codes)
76 0x19, 0x00, // USAGE_MINIMUM (Reserved (no event indicated))(0)
77 0x29, 0x65, // USAGE_MAXIMUM (Keyboard Application)(101)
78 0x81, 0x00, // INPUT (Data,Ary,Abs)
79 0xc0 // END_COLLECTION
82 /* Keyboard usage values, see usb.org's HID-usage-tables document, chapter
83 * 10 Keyboard/Keypad Page for more codes.
85 #define MOD_CONTROL_LEFT (1<<0)
86 #define MOD_SHIFT_LEFT (1<<1)
87 #define MOD_ALT_LEFT (1<<2)
88 #define MOD_GUI_LEFT (1<<3)
89 #define MOD_CONTROL_RIGHT (1<<4)
90 #define MOD_SHIFT_RIGHT (1<<5)
91 #define MOD_ALT_RIGHT (1<<6)
92 #define MOD_GUI_RIGHT (1<<7)
146 #define SCROLL_LOCK 4
157 #define UNI_BUFFER_SIZE 16
160 uint8_t w8[UNI_BUFFER_SIZE];
161 uint16_t w16[UNI_BUFFER_SIZE/2];
162 uint32_t w32[UNI_BUFFER_SIZE/4];
163 void* ptr[UNI_BUFFER_SIZE/sizeof(void*)];
166 static uint8_t uni_buffer_fill;
167 static uint8_t current_command;
176 #define STATE_SEND_KEY 1
177 #define STATE_RELEASE_KEY 2
180 static keyboard_report_t keyboard_report; // sent to PC
181 static uchar idleRate; /* in 4 ms units */
182 static uchar key_state = STATE_WAIT;
183 volatile static uchar LED_state = 0xff; // received from PC
184 /* ------------------------------------------------------------------------- */
186 void buildReport(uchar send_key) {
187 keyboard_report.modifier = 0;
189 if(send_key >= 'a' && send_key <= 'z')
190 keyboard_report.keycode[0] = 4 + (send_key - 'a');
192 keyboard_report.keycode[0] = 0;
195 uint8_t read_button(void){
198 DDRB &= ~(1<<BUTTON_PIN);
199 PORTB |= 1<<BUTTON_PIN;
200 PORTB &= ~(1<<BUTTON_PIN);
202 DDRB |= t&(1<<BUTTON_PIN);
203 PORTB &= ~(t&(1<<BUTTON_PIN));
210 void init_temperature_sensor(void){
215 uint16_t read_temperture_sensor(void){
223 uchar usbFunctionSetup(uchar data[8])
225 usbRequest_t *rq = (void *)data;
227 usbMsgPtr = reportBuffer;
228 if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){ /* class request type */
229 if(rq->bRequest == USBRQ_HID_GET_REPORT){ /* wValue: ReportType (highbyte), ReportID (lowbyte) */
230 /* we only have one report type, so don't look at wValue */
231 buildReport(keyPressed());
232 return sizeof(reportBuffer);
233 }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
234 usbMsgPtr = &idleRate;
236 }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
237 idleRate = rq->wValue.bytes[1];
240 /* no vendor specific requests implemented */
246 usbMsgLen_t usbFunctionSetup(uchar data[8])
248 usbRequest_t *rq = (usbRequest_t *)data;
249 if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) { /* class request type */
251 switch(rq->bRequest) {
252 case USBRQ_HID_GET_REPORT: // send "no keys pressed" if asked here
253 // wValue: ReportType (highbyte), ReportID (lowbyte)
254 usbMsgPtr = (void *)&keyboard_report; // we only have this one
255 keyboard_report.modifier = 0;
256 keyboard_report.keycode[0] = 0;
257 return sizeof(keyboard_report);
258 case USBRQ_HID_SET_REPORT: // if wLength == 1, should be LED state
259 if (rq->wLength.word == 1) {
260 current_command = LED_WRITE;
264 case USBRQ_HID_GET_IDLE: // send idle rate to PC as required by spec
265 usbMsgPtr = &idleRate;
267 case USBRQ_HID_SET_IDLE: // save idle rate as required by spec
268 idleRate = rq->wValue.bytes[1];
272 if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_VENDOR) {
273 current_command = rq->bRequest;
276 case CUSTOM_RQ_SET_RGB:
278 case CUSTOM_RQ_GET_RGB:{
280 if(len>rq->wLength.word){
281 len = rq->wLength.word;
283 usbMsgPtr = (uchar*)color.idx;
286 case CUSTOM_RQ_READ_MEM:
287 usbMsgPtr = (uchar*)rq->wValue.word;
288 return rq->wLength.word;
289 case CUSTOM_RQ_WRITE_MEM:
290 case CUSTOM_RQ_EXEC_SPM:
292 uni_buffer.w16[0] = rq->wValue.word;
293 uni_buffer.w16[1] = rq->wLength.word;
295 case CUSTOM_RQ_READ_FLASH:
296 uni_buffer.w16[0] = rq->wValue.word;
297 uni_buffer.w16[1] = rq->wLength.word;
299 case CUSTOM_RQ_RESET:
300 soft_reset((uint8_t)(rq->wValue.word));
302 case CUSTOM_RQ_READ_BUTTON:
303 uni_buffer.w8[0] = read_button();
304 usbMsgPtr = uni_buffer.w8;
306 case CUSTOM_RQ_READ_TMPSENS:
307 uni_buffer.w16[0] = read_temperture_sensor();
308 usbMsgPtr = uni_buffer.w8;
313 return 0; /* default for not implemented requests: return no data back to host */
317 uchar usbFunctionWrite(uchar *data, uchar len)
319 switch(current_command){
322 if (data[0] != LED_state)
324 return 1; // Data read, not expecting more
325 case CUSTOM_RQ_SET_RGB:
329 memcpy(color.idx, data, 6);
330 key_state = STATE_SEND_KEY;
332 case CUSTOM_RQ_WRITE_MEM:
333 memcpy(uni_buffer.ptr[0], data, len);
334 uni_buffer.w16[0] += len;
335 return !(uni_buffer.w16[1] -= len);
336 case CUSTOM_RQ_EXEC_SPM:
337 if(uni_buffer_fill < 8){
338 uint8_t l = 8 - uni_buffer_fill;
342 memcpy(&(uni_buffer.w8[uni_buffer_fill]), data, len);
343 uni_buffer_fill += len;
346 uni_buffer.w16[1] -= len;
347 if (uni_buffer.w16[1] > 8) {
348 memcpy(uni_buffer.ptr[0], data, len);
349 uni_buffer.w16[0] += len;
352 memcpy(&(uni_buffer.w8[uni_buffer_fill]), data, len);
353 exec_spm(uni_buffer.w16[2], uni_buffer.w16[3], uni_buffer.ptr[0], data, len);
361 uchar usbFunctionRead(uchar *data, uchar len){
363 switch(current_command){
364 case CUSTOM_RQ_READ_FLASH:
366 *data++ = pgm_read_byte((uni_buffer.w16[0])++);
375 static void calibrateOscillator(void)
378 uchar trialValue = 0, optimumValue;
379 int x, optimumDev, targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e6 + 0.5);
381 /* do a binary search: */
383 OSCCAL = trialValue + step;
384 x = usbMeasureFrameLength(); // proportional to current real frequency
385 if(x < targetValue) // frequency still too low
389 /* We have a precision of +/- 1 for optimum OSCCAL here */
390 /* now do a neighborhood search for optimum value */
391 optimumValue = trialValue;
392 optimumDev = x; // this is certainly far away from optimum
393 for (OSCCAL = trialValue - 1; OSCCAL <= trialValue + 1; OSCCAL++){
394 x = usbMeasureFrameLength() - targetValue;
397 if (x < optimumDev) {
399 optimumValue = OSCCAL;
402 OSCCAL = optimumValue;
406 void usbEventResetReady(void)
408 cli(); // usbMeasureFrameLength() counts CPU cycles, so disable interrupts.
409 calibrateOscillator();
411 // we never read the value from eeprom so this causes only degradation of eeprom
412 // eeprom_write_byte(0, OSCCAL); // store the calibrated value in EEPROM
415 /* ------------------------------------------------------------------------- */
422 /* Even if you don't use the watchdog, turn it off here. On newer devices,
423 * the status of the watchdog (on/off, period) is PRESERVED OVER RESET!
425 /* RESET status: all port bits are inputs without pull-up.
426 * That's the way we need D+ and D-. Therefore we don't need any
427 * additional hardware initialization.
430 memset(&keyboard_report, 0, sizeof(keyboard_report));
432 init_temperature_sensor();
434 usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */
436 while(--i){ /* fake USB disconnect for ~512 ms */
441 LED_PORT_DDR |= _BV(R_BIT) | _BV(G_BIT) | _BV(B_BIT); /* make the LED bit an output */
446 for(;;){ /* main event loop */
452 if(usbInterruptIsReady())
453 color.name.green = 0x10 | key_state;
455 color.name.green = 0;
457 if(usbInterruptIsReady() && key_state != STATE_WAIT){
463 key_state = STATE_RELEASE_KEY; // release next
465 case STATE_RELEASE_KEY:
469 key_state = STATE_WAIT; // should not happen
472 usbSetInterrupt((void *)&keyboard_report, sizeof(keyboard_report));
473 color.name.red |= 0x40;
481 /* ------------------------------------------------------------------------- */