some minor editings
[labortage2013badge.git] / firmware / main.c
index 20bf8c0..5bcb934 100644 (file)
@@ -1,10 +1,10 @@
 /* Name: main.c
- * Project: hid-custom-rq example
- * Author: Christian Starkjohann
- * Creation Date: 2008-04-07
+ * Project: labortage-2013-badge
+ * Author: bg (bg@das-labor.org)
+ * Creation Date: 2013-10-16
  * Tabsize: 4
- * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH, (c) Daniel Otte
+ * License: GNU GPL v3
  * This Revision: $Id: main.c 692 2008-11-07 15:07:40Z cs $
  */
 
@@ -13,16 +13,13 @@ This example should run on most AVRs with only little changes. No special
 hardware resources except INT0 are used. You may have to change usbconfig.h for
 different I/O pins for USB. Please note that USB D+ must be the INT0 pin, or
 at least be connected to INT0 as well.
-We assume that an LED is connected to port B bit 0. If you connect it to a
-different port or bit, change the macros below:
 */
-#define LED_PORT_DDR        DDRB
-#define LED_PORT_OUTPUT     PORTB
-#define R_BIT            4
-#define G_BIT            3
-#define B_BIT            1
+
 #define BUTTON_PIN 4
 
+#define SIMPLE_COUNTER 1
+#define NO_CHECK 1
+
 #include <stdint.h>
 #include <string.h>
 #include <stdbool.h>
@@ -35,302 +32,357 @@ different port or bit, change the macros below:
 
 #include <avr/pgmspace.h>   /* required by usbdrv.h */
 #include "usbdrv.h"
-#include "oddebug.h"        /* This is also an example for using debug macros */
 #include "requests.h"       /* The custom request numbers we use */
-#include "special_functions.h"
-
-void update_pwm(void);
+#include "hotp.h"
+#if !SIMPLE_COUNTER
+#include "percnt2.h"
+#endif
+#include "usb_keyboard_codes.h"
 
 /* ------------------------------------------------------------------------- */
 /* ----------------------------- USB interface ----------------------------- */
 /* ------------------------------------------------------------------------- */
-const PROGMEM char usbHidReportDescriptor[35] = {   /* USB report descriptor */
-    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
-    0x09, 0x06,                    // USAGE (Keyboard)
-    0xa1, 0x01,                    // COLLECTION (Application)
-    0x05, 0x07,                    //   USAGE_PAGE (Keyboard)
-    0x19, 0xe0,                    //   USAGE_MINIMUM (Keyboard LeftControl)
-    0x29, 0xe7,                    //   USAGE_MAXIMUM (Keyboard Right GUI)
-    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-    0x25, 0x01,                    //   LOGICAL_MAXIMUM (1)
-    0x75, 0x01,                    //   REPORT_SIZE (1)
-    0x95, 0x08,                    //   REPORT_COUNT (8)
-    0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-    0x95, 0x01,                    //   REPORT_COUNT (1)
-    0x75, 0x08,                    //   REPORT_SIZE (8)
-    0x25, 0x65,                    //   LOGICAL_MAXIMUM (101)
-    0x19, 0x00,                    //   USAGE_MINIMUM (Reserved (no event indicated))
-    0x29, 0x65,                    //   USAGE_MAXIMUM (Keyboard Application)
-    0x81, 0x00,                    //   INPUT (Data,Ary,Abs)
-    0xc0                           // END_COLLECTION
+
+#define STATE_WAIT 0
+#define STATE_SEND_KEY 1
+#define STATE_RELEASE_KEY 2
+#define STATE_NEXT 3
+
+PROGMEM const char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = {
+    0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop) */
+    0x09, 0x06,                    /* USAGE (Keyboard) */
+    0xa1, 0x01,                    /* COLLECTION (Application) */
+    0x75, 0x01,                    /*   REPORT_SIZE (1) */
+    0x95, 0x08,                    /*   REPORT_COUNT (8) */
+    0x05, 0x07,                    /*   USAGE_PAGE (Keyboard)(Key Codes) */
+    0x19, 0xe0,                    /*   USAGE_MINIMUM (Keyboard LeftControl)(224) */
+    0x29, 0xe7,                    /*   USAGE_MAXIMUM (Keyboard Right GUI)(231) */
+    0x15, 0x00,                    /*   LOGICAL_MINIMUM (0) */
+    0x25, 0x01,                    /*   LOGICAL_MAXIMUM (1) */
+    0x81, 0x02,                    /*   INPUT (Data,Var,Abs) ; Modifier byte */
+    0x95, 0x01,                    /*   REPORT_COUNT (1) */
+    0x75, 0x08,                    /*   REPORT_SIZE (8) */
+    0x81, 0x03,                    /*   INPUT (Cnst,Var,Abs) ; Reserved byte */
+    0x95, 0x05,                    /*   REPORT_COUNT (5) */
+    0x75, 0x01,                    /*   REPORT_SIZE (1) */
+    0x05, 0x08,                    /*   USAGE_PAGE (LEDs) */
+    0x19, 0x01,                    /*   USAGE_MINIMUM (Num Lock) */
+    0x29, 0x05,                    /*   USAGE_MAXIMUM (Kana) */
+    0x91, 0x02,                    /*   OUTPUT (Data,Var,Abs) ; LED report */
+    0x95, 0x01,                    /*   REPORT_COUNT (1) */
+    0x75, 0x03,                    /*   REPORT_SIZE (3) */
+    0x91, 0x03,                    /*   OUTPUT (Cnst,Var,Abs) ; LED report padding */
+    0x95, 0x06,                    /*   REPORT_COUNT (6) */
+    0x75, 0x08,                    /*   REPORT_SIZE (8) */
+    0x15, 0x00,                    /*   LOGICAL_MINIMUM (0) */
+    0x25, 0x65,                    /*   LOGICAL_MAXIMUM (101) */
+    0x05, 0x07,                    /*   USAGE_PAGE (Keyboard)(Key Codes) */
+    0x19, 0x00,                    /*   USAGE_MINIMUM (Reserved (no event indicated))(0) */
+    0x29, 0x65,                    /*   USAGE_MAXIMUM (Keyboard Application)(101) */
+    0x81, 0x00,                    /*   INPUT (Data,Ary,Abs) */
+    0xc0                           /* END_COLLECTION */
 };
-/* We use a simplifed keyboard report descriptor which does not support the
- * boot protocol. We don't allow setting status LEDs and we only allow one
- * simultaneous key press (except modifiers). We can therefore use short
- * 2 byte input reports.
- * The report descriptor has been created with usb.org's "HID Descriptor Tool"
- * which can be downloaded from http://www.usb.org/developers/hidpage/.
- * Redundant entries (such as LOGICAL_MINIMUM and USAGE_PAGE) have been omitted
- * for the second INPUT item.
- */
 
-/* Keyboard usage values, see usb.org's HID-usage-tables document, chapter
- * 10 Keyboard/Keypad Page for more 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)
-
-#define KEY_A       4
-#define KEY_B       5
-#define KEY_C       6
-#define KEY_D       7
-#define KEY_E       8
-#define KEY_F       9
-#define KEY_G       10
-#define KEY_H       11
-#define KEY_I       12
-#define KEY_J       13
-#define KEY_K       14
-#define KEY_L       15
-#define KEY_M       16
-#define KEY_N       17
-#define KEY_O       18
-#define KEY_P       19
-#define KEY_Q       20
-#define KEY_R       21
-#define KEY_S       22
-#define KEY_T       23
-#define KEY_U       24
-#define KEY_V       25
-#define KEY_W       26
-#define KEY_X       27
-#define KEY_Y       28
-#define KEY_Z       29
-#define KEY_1       30
-#define KEY_2       31
-#define KEY_3       32
-#define KEY_4       33
-#define KEY_5       34
-#define KEY_6       35
-#define KEY_7       36
-#define KEY_8       37
-#define KEY_9       38
-#define KEY_0       39
-
-#define KEY_F1      58
-#define KEY_F2      59
-#define KEY_F3      60
-#define KEY_F4      61
-#define KEY_F5      62
-#define KEY_F6      63
-#define KEY_F7      64
-#define KEY_F8      65
-#define KEY_F9      66
-#define KEY_F10     67
-#define KEY_F11     68
-#define KEY_F12     69
-
-union {
-       struct {
-               uint16_t red;
-               uint16_t green;
-               uint16_t blue;
-       } name;
-       uint16_t idx[3];
-} color;
+static uint16_t secret_length_ee EEMEM = 0;
+static uint8_t  secret_ee[32] EEMEM;
+static uint8_t  reset_counter_ee EEMEM = 0;
+static uint8_t  digits_ee EEMEM = 8;
+
+#if SIMPLE_COUNTER
+static uint32_t counter_ee EEMEM = 0;
+#endif
+
+static uint8_t dbg_buffer[8];
+static uint8_t secret[32];
+static uint16_t secret_length_b;
+static char token[10];
 
 #define UNI_BUFFER_SIZE 16
 
-static union {
+static union __attribute__((packed)) {
        uint8_t  w8[UNI_BUFFER_SIZE];
        uint16_t w16[UNI_BUFFER_SIZE/2];
        uint32_t w32[UNI_BUFFER_SIZE/4];
        void*    ptr[UNI_BUFFER_SIZE/sizeof(void*)];
 } uni_buffer;
 
-static uint8_t uni_buffer_fill;
 static uint8_t current_command;
 
-static uchar    reportBuffer[2];    /* buffer for HID reports */
-static uchar    idleRate;           /* in 4 ms units */
+typedef struct __attribute__((packed)) {
+    uint8_t modifier;
+    uint8_t reserved;
+    uint8_t keycode[6];
+} keyboard_report_t;
 
-static bool  keyDidChange = false;
+static keyboard_report_t keyboard_report; /* report sent to the host */
+static uchar idleRate;  /* in 4 ms units */
+static uchar key_state = STATE_WAIT;
+volatile static uchar LED_state = 0xff;
 /* ------------------------------------------------------------------------- */
 
+static
+void memory_clean(void) {
+    memset(secret, 0, 32);
+    secret_length_b = 0;
+}
+
+static
+uint8_t secret_set(void){
+#if !NO_CHECK
+    uint8_t r;
+    union {
+        uint8_t w8[32];
+        uint16_t w16[16];
+    } read_back;
+#endif
+    const uint8_t length_B = (secret_length_b + 7) / 8;
+
+    eeprom_busy_wait();
+    eeprom_write_block(secret, secret_ee, length_B);
+#if !NO_CHECK
+    eeprom_busy_wait();
+    eeprom_read_block(read_back.w8, secret_ee, length_B);
+    r = memcmp(secret, read_back.w8, length_B);
+    memory_clean();
+    memset(read_back.w8, 0, 32);
+    if (r) {
+        return 1;
+    }
+#endif
+    eeprom_busy_wait();
+    eeprom_write_word(&secret_length_ee, secret_length_b);
+#if !NO_CHECK
+    eeprom_busy_wait();
+    r = eeprom_read_word(&secret_length_ee) == secret_length_b;
+    memory_clean();
+    *read_back.w16 = 0;
+    if (!r) {
+        return 1;
+    }
+#else
+    memory_clean();
+#endif
 
-uint8_t read_button(void){
-       uint8_t t,v=0;
-       t = DDRB;
-       DDRB &= ~(1<<BUTTON_PIN);
-       PORTB |= 1<<BUTTON_PIN;
-       PORTB &= ~(1<<BUTTON_PIN);
-       v |= PINB;
-       DDRB |= t&(1<<BUTTON_PIN);
-       PORTB &= ~(t&(1<<BUTTON_PIN));
-       v >>= BUTTON_PIN;
-       v &= 1;
-       v ^= 1;
-       return v;
+    return 0;
 }
 
-void init_temperature_sensor(void){
-       ADMUX = 0x8F;
-       ADCSRA = 0x87;
+static
+void counter_inc(void){
+#if SIMPLE_COUNTER
+    uint32_t t;
+    eeprom_busy_wait();
+    t = eeprom_read_dword(&counter_ee);
+    eeprom_busy_wait();
+    eeprom_write_dword(&counter_ee, t + 1);
+#else
+    percnt_inc(0);
+#endif
 }
 
-uint16_t read_temperture_sensor(void){
-       ADCSRA |= 0x40;
-       while(ADCSRA & 0x40)
-               ;
-       return ADC;
+static
+void counter_reset(void) {
+    uint8_t reset_counter;
+    eeprom_busy_wait();
+    reset_counter = eeprom_read_byte(&reset_counter_ee);
+#if SIMPLE_COUNTER
+    eeprom_busy_wait();
+    eeprom_write_dword(&counter_ee, 0);
+#else
+    percnt_reset(0);
+#endif
+    eeprom_busy_wait();
+    eeprom_write_byte(&reset_counter_ee, reset_counter + 1);
 }
 
-#if 0
-uchar   usbFunctionSetup(uchar data[8])
-{
-usbRequest_t    *rq = (void *)data;
-
-    usbMsgPtr = reportBuffer;
-    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){    /* class request type */
-        if(rq->bRequest == USBRQ_HID_GET_REPORT){  /* wValue: ReportType (highbyte), ReportID (lowbyte) */
-            /* we only have one report type, so don't look at wValue */
-            buildReport(keyPressed());
-            return sizeof(reportBuffer);
-        }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
-            usbMsgPtr = &idleRate;
-            return 1;
-        }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
-            idleRate = rq->wValue.bytes[1];
-        }
-    }else{
-        /* no vendor specific requests implemented */
+static
+void counter_init(void) {
+#if !SIMPLE_COUNTER
+    eeprom_busy_wait();
+    if (eeprom_read_byte(&reset_counter_ee) == 0) {
+        counter_reset();
     }
-    return 0;
+    percnt_init(0);
+#endif
 }
+
+static
+void token_generate(void) {
+    counter_inc();
+    eeprom_busy_wait();
+    eeprom_read_block(secret, secret_ee, 32);
+    eeprom_busy_wait();
+#if SIMPLE_COUNTER
+    hotp(token, secret, eeprom_read_word(&secret_length_ee), eeprom_read_dword(&counter_ee), eeprom_read_byte(&digits_ee));
+#else
+    hotp(token, secret, eeprom_read_word(&secret_length_ee), percnt_get(0), eeprom_read_byte(&digits_ee));
 #endif
+    memory_clean();
+}
+
+
+static
+void buildReport(uchar send_key) {
+    keyboard_report.modifier = 0;
+
+    switch (send_key) {
+    case '1' ... '9':
+        keyboard_report.keycode[0] = KEY_1 + (send_key-'1');
+        break;
+    case '0':
+        keyboard_report.keycode[0] = KEY_0;
+        break;
+    default:
+        keyboard_report.keycode[0] = 0;
+    }
+}
+
+static
+int8_t button_get_debounced(volatile uint8_t debounce_count) {
+    uint8_t v;
+    v = PINB & _BV(BUTTON_PIN);
+    while (debounce_count-- && v == (PINB & _BV(BUTTON_PIN))) {
+        ;
+    }
+    if (debounce_count) {
+        return -1;
+    }
+    return v ? 0 : 1;
+}
 
 usbMsgLen_t usbFunctionSetup(uchar data[8])
 {
        usbRequest_t    *rq = (usbRequest_t *)data;
        if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) {    /* class request type */
-           color.name.red = 13;
-           if (rq->bRequest == USBRQ_HID_GET_REPORT){  /* wValue: ReportType (highbyte), ReportID (lowbyte) */
-            /* we only have one report type, so don't look at wValue */
-            if (color.name.red == 133) {
-                color.name.red = 23;
-                usbMsgPtr = reportBuffer;
-                reportBuffer[0] = 0;
-                reportBuffer[1] = KEY_X;
+           switch(rq->bRequest) {
+        case USBRQ_HID_GET_REPORT: /* send "no keys pressed" if asked here */
+            /* wValue: ReportType (highbyte), ReportID (lowbyte) */
+            usbMsgPtr = (void *)&keyboard_report; /* we only have this one */
+            keyboard_report.modifier = 0;
+            keyboard_report.keycode[0] = 0;
+            return sizeof(keyboard_report);
+        case USBRQ_HID_SET_REPORT: /* if wLength == 1, should be LED state */
+            if (rq->wLength.word == 1) {
+                current_command = LED_WRITE;
+                return USB_NO_MSG;
             }
-            return sizeof(reportBuffer);
-        } else if (rq->bRequest == USBRQ_HID_GET_IDLE) {
+            return 0;
+        case USBRQ_HID_GET_IDLE: /* send idle rate to PC as required by spec */
             usbMsgPtr = &idleRate;
             return 1;
-        }else if (rq->bRequest == USBRQ_HID_SET_IDLE) {
-            usbMsgPtr = reportBuffer;
+        case USBRQ_HID_SET_IDLE: /* save idle rate as required by spec */
             idleRate = rq->wValue.bytes[1];
+            return 0;
         }
     }
     if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_VENDOR) {
                current_command = rq->bRequest;
+        usbMsgPtr = uni_buffer.w8;
        switch(rq->bRequest)
                {
-               case CUSTOM_RQ_SET_RGB:
+       case CUSTOM_RQ_SET_SECRET:
+           secret_length_b = rq->wValue.word;
+           if (secret_length_b > 256) {
+               secret_length_b = 256;
+           }
+           uni_buffer.w8[0] = 0;
+           return USB_NO_MSG;
+       case CUSTOM_RQ_INC_COUNTER:
+           counter_inc();
+           return 0;
+       case CUSTOM_RQ_GET_COUNTER:
+#if SIMPLE_COUNTER
+           eeprom_busy_wait();
+           uni_buffer.w32[0] = eeprom_read_dword(&counter_ee);
+#else
+           uni_buffer.w32[0] = percnt_get(0);
+#endif
+           return 4;
+       case CUSTOM_RQ_RESET_COUNTER:
+           counter_reset();
+           return 0;
+        case CUSTOM_RQ_GET_RESET_COUNTER:
+           eeprom_busy_wait();
+            uni_buffer.w8[0] = eeprom_read_byte(&reset_counter_ee);
+            return 1;
+       case CUSTOM_RQ_SET_DIGITS:
+            if (rq->wValue.bytes[0] < 6) {
+                rq->wValue.bytes[0] = 6;
+            }
+           if (rq->wValue.bytes[0] > 9) {
+               rq->wValue.bytes[0] = 9;
+           }
+           eeprom_busy_wait();
+           eeprom_write_byte(&digits_ee, rq->wValue.bytes[0]);
+           return 0;
+       case CUSTOM_RQ_GET_DIGITS:
+           eeprom_busy_wait();
+            uni_buffer.w8[0] = eeprom_read_byte(&digits_ee);
+            return 1;
+       case CUSTOM_RQ_GET_TOKEN:
+           token_generate();
+           usbMsgPtr = (usbMsgPtr_t)token;
+           return strlen(token);
+       case CUSTOM_RQ_PRESS_BUTTON:
+           key_state = STATE_SEND_KEY;
+           return 0;
+       case CUSTOM_RQ_CLR_DBG:
+            memset(dbg_buffer, 0, sizeof(dbg_buffer));
+            return 0;
+               case CUSTOM_RQ_SET_DBG:
                        return USB_NO_MSG;
-               case CUSTOM_RQ_GET_RGB:{
-                       usbMsgLen_t len=6;
-                       if(len>rq->wLength.word){
+               case CUSTOM_RQ_GET_DBG:{
+                       usbMsgLen_t len = 8;
+                       if(len > rq->wLength.word){
                                len = rq->wLength.word;
                        }
-                       usbMsgPtr = (uchar*)color.idx;
+                       usbMsgPtr = dbg_buffer;
                        return len;
                }
-               case CUSTOM_RQ_READ_MEM:
-                       usbMsgPtr = (uchar*)rq->wValue.word;
-                       return rq->wLength.word;
-               case CUSTOM_RQ_WRITE_MEM:
-               case CUSTOM_RQ_EXEC_SPM:
-                       uni_buffer_fill = 4;
-                       uni_buffer.w16[0] = rq->wValue.word;
-                       uni_buffer.w16[1] = rq->wLength.word;
-                       return USB_NO_MSG;
-               case CUSTOM_RQ_READ_FLASH:
-                       uni_buffer.w16[0] = rq->wValue.word;
-                       uni_buffer.w16[1] = rq->wLength.word;
-                       return USB_NO_MSG;
                case CUSTOM_RQ_RESET:
                        soft_reset((uint8_t)(rq->wValue.word));
                        break;
                case CUSTOM_RQ_READ_BUTTON:
-                       uni_buffer.w8[0] = read_button();
-                       usbMsgPtr = uni_buffer.w8;
+                       uni_buffer.w8[0] = button_get_debounced(25);
                        return 1;
-               case CUSTOM_RQ_READ_TMPSENS:
-                       uni_buffer.w16[0] = read_temperture_sensor();
-                       usbMsgPtr = uni_buffer.w8;
-                       return 2;
                }
     }
 
     return 0;   /* default for not implemented requests: return no data back to host */
 }
 
+
 uchar usbFunctionWrite(uchar *data, uchar len)
 {
        switch(current_command){
-       case CUSTOM_RQ_SET_RGB:
-               if(len!=6){
-                       return 1;
+
+       case LED_WRITE:
+           if (data[0] != LED_state)
+               LED_state = data[0];
+           return 1; /* Data read, not expecting more */
+       case CUSTOM_RQ_SET_SECRET:
+        {
+            if (uni_buffer.w8[0] < (secret_length_b + 7) / 8) {
+                memcpy(&secret[uni_buffer.w8[0]], data, len);
+                uni_buffer.w8[0] += len;
+            }
+            if (uni_buffer.w8[0] >= (secret_length_b + 7) / 8) {
+                secret_set();
+                return 1;
+            }
+            return 0;
+        }
+       case CUSTOM_RQ_SET_DBG:
+               if(len > sizeof(dbg_buffer)){
+                       len = sizeof(dbg_buffer);
                }
-               memcpy(color.idx, data, 6);
-        keyDidChange = true;
+               memcpy(dbg_buffer, data, len);
                return 1;
-       case CUSTOM_RQ_WRITE_MEM:
-               memcpy(uni_buffer.ptr[0], data, len);
-               uni_buffer.w16[0] += len;
-               return !(uni_buffer.w16[1] -= len);
-       case CUSTOM_RQ_EXEC_SPM:
-               if(uni_buffer_fill<8){
-                       uint8_t l = 8-uni_buffer_fill;
-                       if(len<l){
-                               len = l;
-                       }
-                       memcpy(&(uni_buffer.w8[uni_buffer_fill]), data, len);
-                       uni_buffer_fill += len;
-                       return 0;
-               }
-               uni_buffer.w16[1] -= len;
-               if(uni_buffer.w16[1]>8){
-                       memcpy(uni_buffer.ptr[0], data, len);
-                       uni_buffer.w16[0] += len;
-                       return 0;
-               }else{
-                       memcpy(&(uni_buffer.w8[uni_buffer_fill]), data, len);
-                       exec_spm(uni_buffer.w16[2], uni_buffer.w16[3], uni_buffer.ptr[0], data, len);
-                       return 1;
-               }
        default:
                return 1;
        }
        return 0;
 }
 uchar usbFunctionRead(uchar *data, uchar len){
-       uchar ret=len;
-       switch(current_command){
-       case CUSTOM_RQ_READ_FLASH:
-               while(len--){
-                       *data++ = pgm_read_byte((uni_buffer.w16[0])++);
-               }
-               return ret;
-       default:
-               break;
-       }
        return 0;
 }
 
@@ -341,22 +393,22 @@ uchar       trialValue = 0, optimumValue;
 int         x, optimumDev, targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e6 + 0.5);
  
     /* do a binary search: */
-    do{
+    do {
         OSCCAL = trialValue + step;
-        x = usbMeasureFrameLength();    // proportional to current real frequency
-        if(x < targetValue)             // frequency still too low
+        x = usbMeasureFrameLength();    /* proportional to current real frequency */
+        if(x < targetValue)             /* frequency still too low */
             trialValue += step;
         step >>= 1;
-    }while(step > 0);
+    } while(step > 0);
     /* We have a precision of +/- 1 for optimum OSCCAL here */
     /* now do a neighborhood search for optimum value */
     optimumValue = trialValue;
-    optimumDev = x; // this is certainly far away from optimum
-    for(OSCCAL = trialValue - 1; OSCCAL <= trialValue + 1; OSCCAL++){
+    optimumDev = x; /* this is certainly far away from optimum */
+    for (OSCCAL = trialValue - 1; OSCCAL <= trialValue + 1; OSCCAL++){
         x = usbMeasureFrameLength() - targetValue;
-        if(x < 0)
+        if (x < 0)
             x = -x;
-        if(x < optimumDev){
+        if (x < optimumDev) {
             optimumDev = x;
             optimumValue = OSCCAL;
         }
@@ -367,18 +419,17 @@ int         x, optimumDev, targetValue = (unsigned)(1499 * (double)F_CPU / 10.5e
 
 void usbEventResetReady(void)
 {
-    cli();  // usbMeasureFrameLength() counts CPU cycles, so disable interrupts.
+    cli();  /* usbMeasureFrameLength() counts CPU cycles, so disable interrupts. */
     calibrateOscillator();
     sei();
-// we never read the value from eeprom so this causes only degradation of eeprom
-//    eeprom_write_byte(0, OSCCAL);   // store the calibrated value in EEPROM
 }
 
 /* ------------------------------------------------------------------------- */
 
 int main(void)
 {
-       uchar   i;
+       size_t idx = 0;
+       int8_t i = 0, last_stable_button_state = 0;
 
     wdt_enable(WDTO_1S);
     /* Even if you don't use the watchdog, turn it off here. On newer devices,
@@ -389,33 +440,55 @@ int main(void)
      * additional hardware initialization.
      */
 
-    init_temperature_sensor();
+    DDRB &= ~_BV(BUTTON_PIN); /* make button pin input */
+    PORTB |= _BV(BUTTON_PIN); /* turn on pull-up resistor */
+    counter_init();
     usbInit();
     usbDeviceDisconnect();  /* enforce re-enumeration, do this while interrupts are disabled! */
-    i = 0;
-    while(--i){             /* fake USB disconnect for > 250 ms */
+    while(--i){             /* fake USB disconnect for ~512 ms */
         wdt_reset();
-        _delay_ms(1);
+        _delay_ms(2);
     }
     usbDeviceConnect();
-    LED_PORT_DDR |= _BV(R_BIT) | _BV(G_BIT) | _BV(B_BIT);   /* make the LED bit an output */
        
     sei();
 
     for(;;){                /* main event loop */
-       //      update_pwm();
-               
         wdt_reset();
         usbPoll();
-        if(keyDidChange && usbInterruptIsReady()){
-            keyDidChange = 0;
-            color.name.red = 42;
-            /* use last key and not current key status in order to avoid lost
-               changes in key status. */
-           reportBuffer[0] = 0;
-           reportBuffer[1] = KEY_Y;
-           usbSetInterrupt(reportBuffer, sizeof(reportBuffer));
+
+        i = button_get_debounced(25);
+        if (i != -1) {
+            if (last_stable_button_state == 0 && i == 1) {
+                key_state = STATE_SEND_KEY;
+            }
+            last_stable_button_state = i;
+        }
+
+        if(usbInterruptIsReady() && key_state != STATE_WAIT){
+            switch(key_state) {
+            case STATE_SEND_KEY:
+                buildReport(token[idx]);
+                key_state = STATE_RELEASE_KEY; /* release next */
+                break;
+            case STATE_RELEASE_KEY:
+                buildReport(0);
+                ++idx;
+                if (token[idx] == '\0') {
+                    idx = 0;
+                    key_state = STATE_WAIT;
+                } else {
+                    key_state = STATE_SEND_KEY;
+                }
+                break;
+            default:
+                key_state = STATE_WAIT; /* should not happen */
+            }
+                        /* start sending */
+            usbSetInterrupt((void *)&keyboard_report, sizeof(keyboard_report));
+
         }
+
     }
     return 0;
 }