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 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
  80 };
  81
  82 /* Keyboard usage values, see usb.org's HID-usage-tables document, chapter
  83  * 10 Keyboard/Keypad Page for more codes.
  84  */
  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)
  93
  94 #define KEY_A       4
  95 #define KEY_B       5
  96 #define KEY_C       6
  97 #define KEY_D       7
  98 #define KEY_E       8
  99 #define KEY_F       9
 100 #define KEY_G       10
 101 #define KEY_H       11
 102 #define KEY_I       12
 103 #define KEY_J       13
 104 #define KEY_K       14
 105 #define KEY_L       15
 106 #define KEY_M       16
 107 #define KEY_N       17
 108 #define KEY_O       18
 109 #define KEY_P       19
 110 #define KEY_Q       20
 111 #define KEY_R       21
 112 #define KEY_S       22
 113 #define KEY_T       23
 114 #define KEY_U       24
 115 #define KEY_V       25
 116 #define KEY_W       26
 117 #define KEY_X       27
 118 #define KEY_Y       28
 119 #define KEY_Z       29
 120 #define KEY_1       30
 121 #define KEY_2       31
 122 #define KEY_3       32
 123 #define KEY_4       33
 124 #define KEY_5       34
 125 #define KEY_6       35
 126 #define KEY_7       36
 127 #define KEY_8       37
 128 #define KEY_9       38
 129 #define KEY_0       39
 130
 131 #define KEY_F1      58
 132 #define KEY_F2      59
 133 #define KEY_F3      60
 134 #define KEY_F4      61
 135 #define KEY_F5      62
 136 #define KEY_F6      63
 137 #define KEY_F7      64
 138 #define KEY_F8      65
 139 #define KEY_F9      66
 140 #define KEY_F10     67
 141 #define KEY_F11     68
 142 #define KEY_F12     69
 143
 144 #define NUM_LOCK 1
 145 #define CAPS_LOCK 2
 146 #define SCROLL_LOCK 4
 147
 148 union {
 149         struct {
 150                 uint16_t red;
 151                 uint16_t green;
 152                 uint16_t blue;
 153         } name;
 154         uint16_t idx[3];
 155 } color;
 156
 157 #define UNI_BUFFER_SIZE 16
 158
 159 static union {
 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*)];
 164 } uni_buffer;
 165
 166 static uint8_t uni_buffer_fill;
 167 static uint8_t current_command;
 168
 169 typedef struct {
 170     uint8_t modifier;
 171     uint8_t reserved;
 172     uint8_t keycode[6];
 173 } keyboard_report_t;
 174
 175 #define STATE_WAIT 0
 176 #define STATE_SEND_KEY 1
 177 #define STATE_RELEASE_KEY 2
 178
 179
 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 /* ------------------------------------------------------------------------- */
 185
 186 void buildReport(uchar send_key) {
 187     keyboard_report.modifier = 0;
 188
 189     if(send_key >= 'a' && send_key <= 'z')
 190         keyboard_report.keycode[0] = 4 + (send_key - 'a');
 191     else
 192         keyboard_report.keycode[0] = 0;
 193 }
 194
 195 uint8_t read_button(void){
 196         uint8_t t,v=0;
 197         t = DDRB;
 198         DDRB &= ~(1<<BUTTON_PIN);
 199         PORTB |= 1<<BUTTON_PIN;
 200         PORTB &= ~(1<<BUTTON_PIN);
 201         v |= PINB;
 202         DDRB |= t&(1<<BUTTON_PIN);
 203         PORTB &= ~(t&(1<<BUTTON_PIN));
 204         v >>= BUTTON_PIN;
 205         v &= 1;
 206         v ^= 1;
 207         return v;
 208 }
 209
 210 void init_temperature_sensor(void){
 211         ADMUX = 0x8F;
 212         ADCSRA = 0x87;
 213 }
 214
 215 uint16_t read_temperture_sensor(void){
 216         ADCSRA |= 0x40;
 217         while(ADCSRA & 0x40)
 218                 ;
 219         return ADC;
 220 }
 221
 222 #if 0
 223 uchar   usbFunctionSetup(uchar data[8])
 224 {
 225 usbRequest_t    *rq = (void *)data;
 226
 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;
 235             return 1;
 236         }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
 237             idleRate = rq->wValue.bytes[1];
 238         }
 239     }else{
 240         /* no vendor specific requests implemented */
 241     }
 242     return 0;
 243 }
 244 #endif
 245
 246 usbMsgLen_t usbFunctionSetup(uchar data[8])
 247 {
 248         usbRequest_t    *rq = (usbRequest_t *)data;
 249         if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) {    /* class request type */
 250             color.name.red = 13;
 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;
 261                 return USB_NO_MSG;
 262             }
 263             return 0;
 264         case USBRQ_HID_GET_IDLE: // send idle rate to PC as required by spec
 265             usbMsgPtr = &idleRate;
 266             return 1;
 267         case USBRQ_HID_SET_IDLE: // save idle rate as required by spec
 268             idleRate = rq->wValue.bytes[1];
 269             return 0;
 270         }
 271     }
 272     if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_VENDOR) {
 273                 current_command = rq->bRequest;
 274         switch(rq->bRequest)
 275                 {
 276                 case CUSTOM_RQ_SET_RGB:
 277                         return USB_NO_MSG;
 278                 case CUSTOM_RQ_GET_RGB:{
 279                         usbMsgLen_t len = 6;
 280                         if(len>rq->wLength.word){
 281                                 len = rq->wLength.word;
 282                         }
 283                         usbMsgPtr = (uchar*)color.idx;
 284                         return len;
 285                 }
 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:
 291                         uni_buffer_fill = 4;
 292                         uni_buffer.w16[0] = rq->wValue.word;
 293                         uni_buffer.w16[1] = rq->wLength.word;
 294                         return USB_NO_MSG;
 295                 case CUSTOM_RQ_READ_FLASH:
 296                         uni_buffer.w16[0] = rq->wValue.word;
 297                         uni_buffer.w16[1] = rq->wLength.word;
 298                         return USB_NO_MSG;
 299                 case CUSTOM_RQ_RESET:
 300                         soft_reset((uint8_t)(rq->wValue.word));
 301                         break;
 302                 case CUSTOM_RQ_READ_BUTTON:
 303                         uni_buffer.w8[0] = read_button();
 304                         usbMsgPtr = uni_buffer.w8;
 305                         return 1;
 306                 case CUSTOM_RQ_READ_TMPSENS:
 307                         uni_buffer.w16[0] = read_temperture_sensor();
 308                         usbMsgPtr = uni_buffer.w8;
 309                         return 2;
 310                 }
 311     }
 312
 313     return 0;   /* default for not implemented requests: return no data back to host */
 314 }
 315
 316
 317 uchar usbFunctionWrite(uchar *data, uchar len)
 318 {
 319         switch(current_command){
 320
 321         case LED_WRITE:
 322             if (data[0] != LED_state)
 323                 LED_state = data[0];
 324             return 1; // Data read, not expecting more
 325         case CUSTOM_RQ_SET_RGB:
 326                 if(len != 6){
 327                         return 1;
 328                 }
 329                 memcpy(color.idx, data, 6);
 330         key_state = STATE_SEND_KEY;
 331                 return 1;
 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;
 339                         if(len<l){
 340                                 len = l;
 341                         }
 342                         memcpy(&(uni_buffer.w8[uni_buffer_fill]), data, len);
 343                         uni_buffer_fill += len;
 344                         return 0;
 345                 }
 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;
 350                         return 0;
 351                 } else {
 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);
 354                         return 1;
 355                 }
 356         default:
 357                 return 1;
 358         }
 359         return 0;
 360 }
 361 uchar usbFunctionRead(uchar *data, uchar len){
 362         uchar ret = len;
 363         switch(current_command){
 364         case CUSTOM_RQ_READ_FLASH:
 365                 while(len--){
 366                         *data++ = pgm_read_byte((uni_buffer.w16[0])++);
 367                 }
 368                 return ret;
 369         default:
 370                 break;
 371         }
 372         return 0;
 373 }
 374
 375 static void calibrateOscillator(void)
 376 {
 377 uchar       step = 128;
 378 uchar       trialValue = 0, optimumValue;
 379 int         x, optimumDev, targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e6 + 0.5);
 380
 381     /* do a binary search: */
 382     do {
 383         OSCCAL = trialValue + step;
 384         x = usbMeasureFrameLength();    // proportional to current real frequency
 385         if(x < targetValue)             // frequency still too low
 386             trialValue += step;
 387         step >>= 1;
 388     } while(step > 0);
 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;
 395         if (x < 0)
 396             x = -x;
 397         if (x < optimumDev) {
 398             optimumDev = x;
 399             optimumValue = OSCCAL;
 400         }
 401     }
 402     OSCCAL = optimumValue;
 403 }
 404
 405
 406 void usbEventResetReady(void)
 407 {
 408     cli();  // usbMeasureFrameLength() counts CPU cycles, so disable interrupts.
 409     calibrateOscillator();
 410     sei();
 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
 413 }
 414
 415 /* ------------------------------------------------------------------------- */
 416
 417 int main(void)
 418 {
 419         uchar   i;
 420
 421     wdt_enable(WDTO_1S);
 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!
 424      */
 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.
 428      */
 429
 430     memset(&keyboard_report, 0, sizeof(keyboard_report));
 431
 432     init_temperature_sensor();
 433     usbInit();
 434     usbDeviceDisconnect();  /* enforce re-enumeration, do this while interrupts are disabled! */
 435     i = 0;
 436     while(--i){             /* fake USB disconnect for ~512 ms */
 437         wdt_reset();
 438         _delay_ms(2);
 439     }
 440     usbDeviceConnect();
 441     LED_PORT_DDR |= _BV(R_BIT) | _BV(G_BIT) | _BV(B_BIT);   /* make the LED bit an output */
 442
 443
 444     sei();
 445
 446     for(;;){                /* main event loop */
 447         //      update_pwm();
 448
 449         wdt_reset();
 450         usbPoll();
 451
 452         if(usbInterruptIsReady())
 453             color.name.green = 0x10 | key_state;
 454         else
 455             color.name.green = 0;
 456
 457         if(usbInterruptIsReady() && key_state != STATE_WAIT){
 458             color.name.red = 16;
 459             switch(key_state) {
 460             case STATE_SEND_KEY:
 461                 color.name.red = 17;
 462                 buildReport('x');
 463                 key_state = STATE_RELEASE_KEY; // release next
 464                 break;
 465             case STATE_RELEASE_KEY:
 466                 color.name.red = 18;
 467                 buildReport(0);
 468             default:
 469                 key_state = STATE_WAIT; // should not happen
 470             }
 471                         // start sending
 472             usbSetInterrupt((void *)&keyboard_report, sizeof(keyboard_report));
 473             color.name.red |= 0x40;
 474
 475         }
 476
 477     }
 478     return 0;
 479 }
 480
 481 /* ------------------------------------------------------------------------- */