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     // CTS control
  50     CTS_INIT();
  51 }
  52
  53 static bool force_usb = false;
  54 int main(void)  __attribute__ ((weak));
  55 int main(void)
  56 {
  57     SetupHardware();
  58     sei();
  59
  60     /* wait for USB startup to get ready for debug output */
  61     uint8_t timeout = 255;  // timeout when USB is not available(Bluetooth)
  62     while (timeout-- && USB_DeviceState != DEVICE_STATE_Configured) {
  63         wait_ms(4);
  64 #if defined(INTERRUPT_CONTROL_ENDPOINT)
  65         ;
  66 #else
  67         USB_USBTask();
  68 #endif
  69     }
  70     print("USB configured.\n");
  71
  72     rn42_init();
  73     print("RN-42 init\n");
  74
  75     /* init modules */
  76     keyboard_init();
  77
  78     if (rn42_ready()) {
  79         host_set_driver(&rn42_driver);
  80     } else {
  81         host_set_driver(&lufa_driver);
  82     }
  83
  84 #ifdef SLEEP_LED_ENABLE
  85     sleep_led_init();
  86 #endif
  87
  88     // ADC for battery
  89     //ADMUX = (1<<REFS0); // Ref:AVCC, Input:ADC0(PF0)
  90     ADMUX = (1<<REFS1) | (1<<REFS0); // Ref:AVCC, Input:ADC0(PF0)
  91     ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // Prescale:128
  92     ADCSRA |= (1<<ADEN); // enable ADC
  93
  94     print("Keyboard start.\n");
  95     while (1) {
  96 /*
  97         while (USB_DeviceState == DEVICE_STATE_Suspended) {
  98             suspend_power_down();
  99             if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
 100                     USB_Device_SendRemoteWakeup();
 101             }
 102         }
 103 */
 104
 105         keyboard_task();
 106
 107 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
 108         USB_USBTask();
 109 #endif
 110
 111         int16_t c;
 112         if (config_mode) {
 113             while ((c = serial_recv2()) != -1) {
 114                 // without flow control it'll fail to receive data when flooded
 115                 CTS_HI();
 116                 xprintf("%c", c);
 117                 CTS_LO();
 118             }
 119         } else {
 120             while ((c = serial_recv2()) != -1) {
 121                 // LED Out report: 0xFE, 0x02, 0x01, <leds>
 122                 // To get the report over UART set bit3 with SH, command.
 123                 static enum {LED_INIT, LED_FE, LED_02, LED_01} state = LED_INIT;
 124                 xprintf("%X\n", c);
 125                 switch (state) {
 126                     case LED_INIT:
 127                         if (c == 0xFE) state = LED_FE;
 128                         else           state = LED_INIT;
 129                         break;
 130                     case LED_FE:
 131                         if (c == 0x02) state = LED_02;
 132                         else           state = LED_INIT;
 133                         break;
 134                     case LED_02:
 135                         if (c == 0x01) state = LED_01;
 136                         else           state = LED_INIT;
 137                         break;
 138                     case LED_01:
 139                         // TODO: move to rn42.c and make accessible with keyboard_leds()
 140                         xprintf("LED status: %X\n", c);
 141                         state = LED_INIT;
 142                         break;
 143                     default:
 144                         state = LED_INIT;
 145                 }
 146             }
 147         }
 148
 149         /* Bluetooth mode when ready */
 150         if (!config_mode && !force_usb) {
 151             if (rn42_ready() && host_get_driver() != &rn42_driver) {
 152                 clear_keyboard();
 153                 host_set_driver(&rn42_driver);
 154             } else if (!rn42_ready() && host_get_driver() != &lufa_driver) {
 155                 clear_keyboard();
 156                 host_set_driver(&lufa_driver);
 157             }
 158         }
 159     }
 160 }
 161
 162 static bool local_echo = false;
 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("w:   toggle RN-42 config mode(enter/exit)\n");
 171             print("l:   toggle print module output(local echo)\n");
 172             print("a:   Bluetooth auto connect\n");
 173             print("del: Bluetooth disconnect\n");
 174             print("i:   info\n");
 175             print("b:   battery voltage\n");
 176
 177             if (config_mode) {
 178                 return true;
 179             } else {
 180                 print("u:   force USB mode\n");
 181                 return false;   // to display default command help
 182             }
 183         case KC_W:
 184             if (!config_mode) {
 185                 print("\nEnter RN-42 config mode\n");
 186                 print("type $$$ to enter RN-42 command mode\n");
 187                 print("type Delete to disconnect Bluetooth connection\n");
 188                 command_state = CONSOLE;
 189                 config_mode = true;
 190                 prev_driver = host_get_driver();
 191                 clear_keyboard();
 192                 host_set_driver(&rn42_config_driver);
 193             } else {
 194                 print("\nExit RN-42 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_L:
 202             if (local_echo) {
 203                 print("local echo off\n");
 204                 local_echo = false;
 205             } else {
 206                 print("local echo on\n");
 207                 local_echo = true;
 208             }
 209             return true;
 210         case KC_U:
 211             if (config_mode) return false;
 212             if (force_usb) {
 213                 print("Auto mode\n");
 214                 force_usb = false;
 215             } else {
 216                 print("USB mode\n");
 217                 force_usb = true;
 218                 clear_keyboard();
 219                 host_set_driver(&lufa_driver);
 220             }
 221             return true;
 222         case KC_A:
 223             print("auto connect\n");
 224             rn42_autoconnect();
 225             return true;
 226         case KC_DELETE:
 227             print("disconnect\n");
 228             rn42_disconnect();
 229             //rn42_putc('\0');    // see 5.3.4.4 DISCONNECT KEY of User's Guide
 230             return true;
 231         case KC_I:
 232             print("\nRN-42 info\n");
 233             xprintf("protocol: %s\n", (host_get_driver() == &rn42_driver) ? "RN-42" : "LUFA");
 234             xprintf("force_usb: %X\n", force_usb);
 235             xprintf("rn42_ready(): %X\n", rn42_ready());
 236             xprintf("config_mode: %X\n", config_mode);
 237             return true;
 238         case KC_B:
 239             // battery monitor
 240             ADCSRA |= (1<<ADEN) | (1<<ADSC);
 241             while (ADCSRA & (1<<ADSC)) ;
 242             uint16_t bat = ADCL;
 243             bat = ADCH<<8 | bat;
 244             xprintf("BAT: %04X\n", bat);
 245
 246             ADCSRA |= (1<<ADEN) | (1<<ADSC);
 247             while (ADCSRA & (1<<ADSC)) ;
 248             bat = ADCL;
 249             bat = ADCH<<8 | bat;
 250             xprintf("BAT: %04X\n", bat);
 251
 252             ADCSRA &= ~(1<<ADEN);
 253             return true;
 254         default:
 255             if (config_mode)
 256                 return true;
 257             else
 258                 return false;   // exec default command
 259     }
 260     return true;
 261 }
 262
 263 static uint8_t code2asc(uint8_t code);
 264 bool command_console_extra(uint8_t code)
 265 {
 266     switch (code) {
 267         default:
 268             rn42_putc(code2asc(code));
 269             if (local_echo) xprintf("%c", code2asc(code));
 270             return true;
 271     }
 272     return false;
 273 }
 274
 275 // convert keycode into ascii charactor
 276 static uint8_t code2asc(uint8_t code)
 277 {
 278     bool shifted = (get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))) ? true : false;
 279     switch (code) {
 280         case KC_A: return (shifted ? 'A' : 'a');
 281         case KC_B: return (shifted ? 'B' : 'b');
 282         case KC_C: return (shifted ? 'C' : 'c');
 283         case KC_D: return (shifted ? 'D' : 'd');
 284         case KC_E: return (shifted ? 'E' : 'e');
 285         case KC_F: return (shifted ? 'F' : 'f');
 286         case KC_G: return (shifted ? 'G' : 'g');
 287         case KC_H: return (shifted ? 'H' : 'h');
 288         case KC_I: return (shifted ? 'I' : 'i');
 289         case KC_J: return (shifted ? 'J' : 'j');
 290         case KC_K: return (shifted ? 'K' : 'k');
 291         case KC_L: return (shifted ? 'L' : 'l');
 292         case KC_M: return (shifted ? 'M' : 'm');
 293         case KC_N: return (shifted ? 'N' : 'n');
 294         case KC_O: return (shifted ? 'O' : 'o');
 295         case KC_P: return (shifted ? 'P' : 'p');
 296         case KC_Q: return (shifted ? 'Q' : 'q');
 297         case KC_R: return (shifted ? 'R' : 'r');
 298         case KC_S: return (shifted ? 'S' : 's');
 299         case KC_T: return (shifted ? 'T' : 't');
 300         case KC_U: return (shifted ? 'U' : 'u');
 301         case KC_V: return (shifted ? 'V' : 'v');
 302         case KC_W: return (shifted ? 'W' : 'w');
 303         case KC_X: return (shifted ? 'X' : 'x');
 304         case KC_Y: return (shifted ? 'Y' : 'y');
 305         case KC_Z: return (shifted ? 'Z' : 'z');
 306         case KC_1: return (shifted ? '!' : '1');
 307         case KC_2: return (shifted ? '@' : '2');
 308         case KC_3: return (shifted ? '#' : '3');
 309         case KC_4: return (shifted ? '$' : '4');
 310         case KC_5: return (shifted ? '%' : '5');
 311         case KC_6: return (shifted ? '^' : '6');
 312         case KC_7: return (shifted ? '&' : '7');
 313         case KC_8: return (shifted ? '*' : '8');
 314         case KC_9: return (shifted ? '(' : '9');
 315         case KC_0: return (shifted ? ')' : '0');
 316         case KC_ENTER: return '\n';
 317         case KC_ESCAPE: return 0x1B;
 318         case KC_BSPACE: return '\b';
 319         case KC_TAB: return '\t';
 320         case KC_SPACE: return ' ';
 321         case KC_MINUS: return (shifted ? '_' : '-');
 322         case KC_EQUAL: return (shifted ? '+' : '=');
 323         case KC_LBRACKET: return (shifted ? '{' : '[');
 324         case KC_RBRACKET: return (shifted ? '}' : ']');
 325         case KC_BSLASH: return (shifted ? '|' : '\\');
 326         case KC_NONUS_HASH: return (shifted ? '|' : '\\');
 327         case KC_SCOLON: return (shifted ? ':' : ';');
 328         case KC_QUOTE: return (shifted ? '"' : '\'');
 329         case KC_GRAVE: return (shifted ? '~' : '`');
 330         case KC_COMMA: return (shifted ? '<' : ',');
 331         case KC_DOT: return (shifted ? '>' : '.');
 332         case KC_SLASH: return (shifted ? '?' : '/');
 333         case KC_DELETE: return '\0';    // Delete to disconnect
 334         default: return ' ';
 335     }
 336 }