keyboard/hhkb_rn42/main.c

   1 #include <avr/io.h>
   2 #include <avr/power.h>
   3 #include <avr/wdt.h>
   4 #include "lufa.h"
   5 #include "print.h"
   6 #include "sendchar.h"
   7 #include "rn42.h"
   8 #include "serial.h"
   9 #include "keyboard.h"
  10 #include "command.h"
  11 #include "keycode.h"
  12 #include "action.h"
  13 #include "action_util.h"
  14 #include "wait.h"
  15 #include "suart.h"
  16
  17 bool config_mode = false;
  18
  19 static int8_t sendchar_func(uint8_t c)
  20 {
  21     sendchar(c);    // LUFA
  22     xmit(c);        // SUART
  23 }
  24
  25 static void SetupHardware(void)
  26 {
  27     /* Disable watchdog if enabled by bootloader/fuses */
  28     MCUSR &= ~(1 << WDRF);
  29     wdt_disable();
  30
  31     /* Disable clock division */
  32     clock_prescale_set(clock_div_1);
  33
  34     // Leonardo needs. Without this USB device is not recognized.
  35     USB_Disable();
  36
  37     USB_Init();
  38
  39     // for Console_Task
  40     USB_Device_EnableSOFEvents();
  41     print_set_sendchar(sendchar_func);
  42
  43     // SUART PD0:output, PD1:input
  44     DDRD |= (1<<0);
  45     PORTD |= (1<<0);
  46     DDRD &= ~(1<<1);
  47     PORTD |= (1<<1);
  48 }
  49
  50 static bool force_usb = false;
  51 int main(void)  __attribute__ ((weak));
  52 int main(void)
  53 {
  54     SetupHardware();
  55     sei();
  56
  57     /* wait for USB startup to get ready for debug output */
  58     uint8_t timeout = 255;  // timeout when USB is not available(Bluetooth)
  59     while (timeout-- && USB_DeviceState != DEVICE_STATE_Configured) {
  60         wait_ms(4);
  61 #if defined(INTERRUPT_CONTROL_ENDPOINT)
  62         ;
  63 #else
  64         USB_USBTask();
  65 #endif
  66     }
  67     print("USB configured.\n");
  68
  69     rn42_init();
  70     print("RN-42 init\n");
  71
  72     /* init modules */
  73     keyboard_init();
  74
  75     if (!rn42_rts()) {
  76         host_set_driver(&rn42_driver);
  77     } else {
  78         host_set_driver(&lufa_driver);
  79     }
  80
  81 #ifdef SLEEP_LED_ENABLE
  82     sleep_led_init();
  83 #endif
  84
  85     // ADC for battery
  86     //ADMUX = (1<<REFS0); // Ref:AVCC, Input:ADC0(PF0)
  87     ADMUX = (1<<REFS1) | (1<<REFS0); // Ref:AVCC, Input:ADC0(PF0)
  88     ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // Prescale:128
  89     ADCSRA |= (1<<ADEN); // enable ADC
  90
  91     print("Keyboard start.\n");
  92     while (1) {
  93 /*
  94         while (USB_DeviceState == DEVICE_STATE_Suspended) {
  95             suspend_power_down();
  96             if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
  97                     USB_Device_SendRemoteWakeup();
  98             }
  99         }
 100 */
 101
 102         keyboard_task();
 103
 104 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
 105         USB_USBTask();
 106 #endif
 107
 108         int16_t c;
 109         if (config_mode) {
 110             while ((c = serial_recv2()) != -1) {
 111                 // without flow control it'll fail to receive data when flooded
 112                 rn42_cts_hi();
 113                 xprintf("%c", c);
 114                 rn42_cts_lo();
 115             }
 116         } else {
 117             while ((c = serial_recv2()) != -1) {
 118                 // LED Out report: 0xFE, 0x02, 0x01, <leds>
 119                 // To get the report over UART set bit3 with SH, command.
 120                 static enum {LED_INIT, LED_FE, LED_02, LED_01} state = LED_INIT;
 121                 xprintf("%X\n", c);
 122                 switch (state) {
 123                     case LED_INIT:
 124                         if (c == 0xFE) state = LED_FE;
 125                         else           state = LED_INIT;
 126                         break;
 127                     case LED_FE:
 128                         if (c == 0x02) state = LED_02;
 129                         else           state = LED_INIT;
 130                         break;
 131                     case LED_02:
 132                         if (c == 0x01) state = LED_01;
 133                         else           state = LED_INIT;
 134                         break;
 135                     case LED_01:
 136                         // TODO: move to rn42.c and make accessible with keyboard_leds()
 137                         xprintf("LED status: %X\n", c);
 138                         state = LED_INIT;
 139                         break;
 140                     default:
 141                         state = LED_INIT;
 142                 }
 143             }
 144         }
 145
 146         /* Bluetooth mode when ready */
 147         if (!config_mode && !force_usb) {
 148             if (!rn42_rts() && host_get_driver() != &rn42_driver) {
 149                 clear_keyboard();
 150                 host_set_driver(&rn42_driver);
 151             } else if (rn42_rts() && host_get_driver() != &lufa_driver) {
 152                 clear_keyboard();
 153                 host_set_driver(&lufa_driver);
 154             }
 155         }
 156     }
 157 }
 158
 159
 160 /******************************************************************************
 161  * Command
 162  ******************************************************************************/
 163 bool command_extra(uint8_t code)
 164 {
 165     static host_driver_t *prev_driver = &rn42_driver;
 166     switch (code) {
 167         case KC_H:
 168         case KC_SLASH: /* ? */
 169             print("\n\n----- Bluetooth RN-42 Help -----\n");
 170             print("Del: auto_connect/disconnect(enter/exit config mode)\n");
 171             print("i:   RN-42 info\n");
 172             print("b:   battery voltage\n");
 173
 174             if (config_mode) {
 175                 return true;
 176             } else {
 177                 print("u:   Force USB mode\n");
 178                 return false;   // to display default command help
 179             }
 180         case KC_DELETE:
 181             if (rn42_autoconnecting()) {
 182                 rn42_disconnect();
 183                 print("\nRN-42: disconnect\n");
 184                 print("Enter config mode\n");
 185                 print("type $$$ to start and + for local echo\n");
 186                 command_state = CONSOLE;
 187                 config_mode = true;
 188                 prev_driver = host_get_driver();
 189                 clear_keyboard();
 190                 host_set_driver(&rn42_config_driver);   // null driver; not to send a key to host
 191             } else {
 192                 rn42_autoconnect();
 193                 print("\nRN-42: auto_connect\n");
 194                 print("Exit config mode\n");
 195                 command_state = ONESHOT;
 196                 config_mode = false;
 197                 clear_keyboard();
 198                 host_set_driver(prev_driver);
 199             }
 200             return true;
 201         case KC_U:
 202             if (config_mode) return false;
 203             if (force_usb) {
 204                 print("Auto mode\n");
 205                 force_usb = false;
 206             } else {
 207                 print("USB mode\n");
 208                 force_usb = true;
 209                 clear_keyboard();
 210                 host_set_driver(&lufa_driver);
 211             }
 212             return true;
 213         case KC_I:
 214             print("\n----- RN-42 info -----\n");
 215             xprintf("protocol: %s\n", (host_get_driver() == &rn42_driver) ? "RN-42" : "LUFA");
 216             xprintf("force_usb: %X\n", force_usb);
 217             xprintf("rn42_autoconnecting(): %X\n", rn42_autoconnecting());
 218             xprintf("rn42_rts(): %X\n", rn42_rts());
 219             xprintf("config_mode: %X\n", config_mode);
 220             return true;
 221         case KC_B:
 222             // battery monitor
 223             ADCSRA |= (1<<ADEN) | (1<<ADSC);
 224             while (ADCSRA & (1<<ADSC)) ;
 225             uint16_t bat = ADCL;
 226             bat = ADCH<<8 | bat;
 227             xprintf("BAT: %04X\n", bat);
 228
 229             ADCSRA |= (1<<ADEN) | (1<<ADSC);
 230             while (ADCSRA & (1<<ADSC)) ;
 231             bat = ADCL;
 232             bat = ADCH<<8 | bat;
 233             xprintf("BAT: %04X\n", bat);
 234
 235             ADCSRA &= ~(1<<ADEN);
 236             return true;
 237         default:
 238             if (config_mode)
 239                 return true;
 240             else
 241                 return false;   // exec default command
 242     }
 243     return true;
 244 }
 245
 246 static uint8_t code2asc(uint8_t code);
 247 bool command_console_extra(uint8_t code)
 248 {
 249     switch (code) {
 250         default:
 251             rn42_putc(code2asc(code));
 252             return true;
 253     }
 254     return false;
 255 }
 256
 257 // convert keycode into ascii charactor
 258 static uint8_t code2asc(uint8_t code)
 259 {
 260     bool shifted = (get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))) ? true : false;
 261     switch (code) {
 262         case KC_A: return (shifted ? 'A' : 'a');
 263         case KC_B: return (shifted ? 'B' : 'b');
 264         case KC_C: return (shifted ? 'C' : 'c');
 265         case KC_D: return (shifted ? 'D' : 'd');
 266         case KC_E: return (shifted ? 'E' : 'e');
 267         case KC_F: return (shifted ? 'F' : 'f');
 268         case KC_G: return (shifted ? 'G' : 'g');
 269         case KC_H: return (shifted ? 'H' : 'h');
 270         case KC_I: return (shifted ? 'I' : 'i');
 271         case KC_J: return (shifted ? 'J' : 'j');
 272         case KC_K: return (shifted ? 'K' : 'k');
 273         case KC_L: return (shifted ? 'L' : 'l');
 274         case KC_M: return (shifted ? 'M' : 'm');
 275         case KC_N: return (shifted ? 'N' : 'n');
 276         case KC_O: return (shifted ? 'O' : 'o');
 277         case KC_P: return (shifted ? 'P' : 'p');
 278         case KC_Q: return (shifted ? 'Q' : 'q');
 279         case KC_R: return (shifted ? 'R' : 'r');
 280         case KC_S: return (shifted ? 'S' : 's');
 281         case KC_T: return (shifted ? 'T' : 't');
 282         case KC_U: return (shifted ? 'U' : 'u');
 283         case KC_V: return (shifted ? 'V' : 'v');
 284         case KC_W: return (shifted ? 'W' : 'w');
 285         case KC_X: return (shifted ? 'X' : 'x');
 286         case KC_Y: return (shifted ? 'Y' : 'y');
 287         case KC_Z: return (shifted ? 'Z' : 'z');
 288         case KC_1: return (shifted ? '!' : '1');
 289         case KC_2: return (shifted ? '@' : '2');
 290         case KC_3: return (shifted ? '#' : '3');
 291         case KC_4: return (shifted ? '$' : '4');
 292         case KC_5: return (shifted ? '%' : '5');
 293         case KC_6: return (shifted ? '^' : '6');
 294         case KC_7: return (shifted ? '&' : '7');
 295         case KC_8: return (shifted ? '*' : '8');
 296         case KC_9: return (shifted ? '(' : '9');
 297         case KC_0: return (shifted ? ')' : '0');
 298         case KC_ENTER: return '\n';
 299         case KC_ESCAPE: return 0x1B;
 300         case KC_BSPACE: return '\b';
 301         case KC_TAB: return '\t';
 302         case KC_SPACE: return ' ';
 303         case KC_MINUS: return (shifted ? '_' : '-');
 304         case KC_EQUAL: return (shifted ? '+' : '=');
 305         case KC_LBRACKET: return (shifted ? '{' : '[');
 306         case KC_RBRACKET: return (shifted ? '}' : ']');
 307         case KC_BSLASH: return (shifted ? '|' : '\\');
 308         case KC_NONUS_HASH: return (shifted ? '|' : '\\');
 309         case KC_SCOLON: return (shifted ? ':' : ';');
 310         case KC_QUOTE: return (shifted ? '"' : '\'');
 311         case KC_GRAVE: return (shifted ? '~' : '`');
 312         case KC_COMMA: return (shifted ? '<' : ',');
 313         case KC_DOT: return (shifted ? '>' : '.');
 314         case KC_SLASH: return (shifted ? '?' : '/');
 315         case KC_DELETE: return '\0';    // Delete to disconnect
 316         default: return ' ';
 317     }
 318 }