]> git.donarmstrong.com Git - tmk_firmware.git/blob - common/command.c
Clean code.
[tmk_firmware.git] / common / command.c
1 /*
2 Copyright 2011 Jun Wako <wakojun@gmail.com>
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 */
17 #include <stdint.h>
18 #include <stdbool.h>
19 #include <util/delay.h>
20 #include "keycode.h"
21 #include "host.h"
22 #include "keymap.h"
23 #include "print.h"
24 #include "debug.h"
25 #include "util.h"
26 #include "timer.h"
27 #include "keyboard.h"
28 #include "bootloader.h"
29 #include "command.h"
30 #ifdef MOUSEKEY_ENABLE
31 #include "mousekey.h"
32 #endif
33
34 #ifdef HOST_PJRC
35 #   include "usb_keyboard.h"
36 #   ifdef EXTRAKEY_ENABLE
37 #       include "usb_extra.h"
38 #   endif
39 #endif
40
41 #ifdef HOST_VUSB
42 #   include "usbdrv.h"
43 #endif
44
45
46 static bool command_common(uint8_t code);
47 static void command_common_help(void);
48 static bool command_console(uint8_t code);
49 static void command_console_help(void);
50 #ifdef MOUSEKEY_ENABLE
51 static bool mousekey_console(uint8_t code);
52 static void mousekey_console_help(void);
53 #endif
54
55 static uint8_t numkey2num(uint8_t code);
56 static void switch_layer(uint8_t layer);
57
58
59 typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t;
60 static cmdstate_t state = ONESHOT;
61
62
63 bool command_proc(uint8_t code)
64 {
65     switch (state) {
66         case ONESHOT:
67             if (!IS_COMMAND())
68                 return false;
69             return (command_extra(code) || command_common(code));
70         case CONSOLE:
71             command_console(code);
72             break;
73 #ifdef MOUSEKEY_ENABLE
74         case MOUSEKEY:
75             mousekey_console(code);
76             break;
77 #endif
78         default:
79             state = ONESHOT;
80             return false;
81     }
82     return true;
83 }
84
85 /* This allows to define extra commands. return false when not processed. */
86 bool command_extra(uint8_t code) __attribute__ ((weak));
87 bool command_extra(uint8_t code)
88 {
89     return false;
90 }
91
92
93 /***********************************************************
94  * Command common
95  ***********************************************************/
96 static void command_common_help(void)
97 {
98     print_enable = true;
99     print("\n\n----- Command Help -----\n");
100     print("c:   enter console mode\n");
101     print("d:   toggle debug enable\n");
102     print("x:   toggle matrix debug\n");
103     print("k:   toggle keyboard debug\n");
104     print("m:   toggle mouse debug\n");
105     print("p:   toggle print enable\n");
106     print("v:   print device version & info\n");
107     print("t:   print timer count\n");
108     print("s:   print status\n");
109 #ifdef NKRO_ENABLE
110     print("n:   toggle NKRO\n");
111 #endif
112     print("0/F10:       switch to Layer0 \n");
113     print("1/F1:        switch to Layer1 \n");
114     print("2/F2:        switch to Layer2 \n");
115     print("3/F3:        switch to Layer3 \n");
116     print("4/F4:        switch to Layer4 \n");
117     print("PScr:        power down/remote wake-up\n");
118     print("Caps:        Lock Keyboard(Child Proof)\n");
119     print("Paus:        jump to bootloader\n");
120 }
121
122 static bool command_common(uint8_t code)
123 {
124     static host_driver_t *host_driver = 0;
125     switch (code) {
126         case KC_CAPSLOCK:
127             if (host_get_driver()) {
128                 host_driver = host_get_driver();
129                 host_set_driver(0);
130                 print("Locked.\n");
131             } else {
132                 host_set_driver(host_driver);
133                 print("Unlocked.\n");
134             }
135             break;
136         case KC_H:
137         case KC_SLASH: /* ? */
138             command_common_help();
139             break;
140         case KC_C:
141             print_enable = true;
142             debug_matrix   = false;
143             debug_keyboard = false;
144             debug_mouse    = false;
145             debug_enable   = false;
146             command_console_help();
147             print("\nEnter Console Mode\n");
148             print("C> ");
149             state = CONSOLE;
150             break;
151         case KC_PAUSE:
152             clear_keyboard();
153             print("\n\nJump to bootloader... ");
154             _delay_ms(1000);
155             bootloader_jump(); // not return
156             print("not supported.\n");
157             break;
158         case KC_D:
159             if (debug_enable) {
160                 print("\nDEBUG: disabled.\n");
161                 debug_matrix   = false;
162                 debug_keyboard = false;
163                 debug_mouse    = false;
164                 debug_enable   = false;
165             } else {
166                 print("\nDEBUG: enabled.\n");
167                 debug_enable   = true;
168             }
169             break;
170         case KC_X: // debug matrix toggle
171             debug_matrix = !debug_matrix;
172             if (debug_matrix) {
173                 print("\nDEBUG: matrix enabled.\n");
174                 debug_enable = true;
175             } else {
176                 print("\nDEBUG: matrix disabled.\n");
177             }
178             break;
179         case KC_K: // debug keyboard toggle
180             debug_keyboard = !debug_keyboard;
181             if (debug_keyboard) {
182                 print("\nDEBUG: keyboard enabled.\n");
183                 debug_enable = true;
184             } else {
185                 print("\nDEBUG: keyboard disabled.\n");
186             }
187             break;
188         case KC_M: // debug mouse toggle
189             debug_mouse = !debug_mouse;
190             if (debug_mouse) {
191                 print("\nDEBUG: mouse enabled.\n");
192                 debug_enable = true;
193             } else {
194                 print("\nDEBUG: mouse disabled.\n");
195             }
196             break;
197         case KC_V: // print version & information
198             print("\n\n----- Version -----\n");
199             print(STR(DESCRIPTION) "\n");
200             print(STR(MANUFACTURER) "(" STR(VENDOR_ID) ")/");
201             print(STR(PRODUCT) "(" STR(PRODUCT_ID) ") ");
202             print("VERSION: " STR(DEVICE_VER) "\n");
203             break;
204         case KC_T: // print timer
205             print_val_hex32(timer_count);
206             break;
207         case KC_P: // print toggle
208             if (print_enable) {
209                 print("print disabled.\n");
210                 print_enable = false;
211             } else {
212                 print_enable = true;
213                 print("print enabled.\n");
214             }
215             break;
216         case KC_S:
217             print("\n\n----- Status -----\n");
218             print_val_hex8(host_keyboard_leds());
219 #ifdef HOST_PJRC
220             print_val_hex8(UDCON);
221             print_val_hex8(UDIEN);
222             print_val_hex8(UDINT);
223             print_val_hex8(usb_keyboard_leds);
224             print_val_hex8(usb_keyboard_protocol);
225             print_val_hex8(usb_keyboard_idle_config);
226             print_val_hex8(usb_keyboard_idle_count);
227 #endif
228
229 #ifdef HOST_VUSB
230 #   if USB_COUNT_SOF
231             print_val_hex8(usbSofCount);
232 #   endif
233 #endif
234             break;
235 #ifdef NKRO_ENABLE
236         case KC_N:
237             keyboard_nkro = !keyboard_nkro;
238             if (keyboard_nkro)
239                 print("NKRO: enabled\n");
240             else
241                 print("NKRO: disabled\n");
242             break;
243 #endif
244 #ifdef EXTRAKEY_ENABLE
245         case KC_PSCREEN:
246             // TODO: Power key should take this feature? otherwise any key during suspend.
247 #ifdef HOST_PJRC
248             if (suspend && remote_wakeup) {
249                 usb_remote_wakeup();
250             } else {
251                 host_system_send(SYSTEM_POWER_DOWN);
252                 host_system_send(0);
253                 _delay_ms(500);
254             }
255 #else
256             host_system_send(SYSTEM_POWER_DOWN);
257             _delay_ms(100);
258             host_system_send(0);
259             _delay_ms(500);
260 #endif
261             break;
262 #endif
263         case KC_0:
264         case KC_F10:
265             switch_layer(0);
266             break;
267         case KC_1:
268         case KC_F1:
269             switch_layer(1);
270             break;
271         case KC_2:
272         case KC_F2:
273             switch_layer(2);
274             break;
275         case KC_3:
276         case KC_F3:
277             switch_layer(3);
278             break;
279         case KC_4:
280         case KC_F4:
281             switch_layer(4);
282             break;
283         default:
284             print("?");
285             return false;
286     }
287     return true;
288 }
289
290
291 /***********************************************************
292  * Command console
293  ***********************************************************/
294 static void command_console_help(void)
295 {
296     print_enable = true;
297     print("\n\n----- Console Help -----\n");
298     print("ESC/q:       quit\n");
299 #ifdef MOUSEKEY_ENABLE
300     print("m:   mousekey\n");
301 #endif
302 }
303
304 static bool command_console(uint8_t code)
305 {
306     switch (code) {
307         case KC_H:
308         case KC_SLASH: /* ? */
309             command_console_help();
310             break;
311         case KC_Q:
312         case KC_ESC:
313             print("\nQuit Console Mode\n");
314             state = ONESHOT;
315             return false;
316 #ifdef MOUSEKEY_ENABLE
317         case KC_M:
318             mousekey_console_help();
319             print("\nEnter Mousekey Console\n");
320             print("M0>");
321             state = MOUSEKEY;
322             return true;
323 #endif
324         default:
325             print("?");
326             return false;
327     }
328     print("C> ");
329     return true;
330 }
331
332
333 #ifdef MOUSEKEY_ENABLE
334 /***********************************************************
335  * Mousekey console
336  ***********************************************************/
337 static uint8_t mousekey_param = 0;
338
339 static void mousekey_param_print(void)
340 {
341     print("\n\n----- Mousekey Parameters -----\n");
342     print("1: mk_delay(*10ms): "); pdec(mk_delay); print("\n");
343     print("2: mk_interval(ms): "); pdec(mk_interval); print("\n");
344     print("3: mk_max_speed: "); pdec(mk_max_speed); print("\n");
345     print("4: mk_time_to_max: "); pdec(mk_time_to_max); print("\n");
346     print("5: mk_wheel_max_speed: "); pdec(mk_wheel_max_speed); print("\n");
347     print("6: mk_wheel_time_to_max: "); pdec(mk_wheel_time_to_max); print("\n");
348 }
349
350 #define PRINT_SET_VAL(v)  print(#v " = "); print_dec(v); print("\n");
351 static void mousekey_param_inc(uint8_t param, uint8_t inc)
352 {
353     switch (param) {
354         case 1:
355             if (mk_delay + inc < UINT8_MAX)
356                 mk_delay += inc;
357             else
358                 mk_delay = UINT8_MAX;
359             PRINT_SET_VAL(mk_delay);
360             break;
361         case 2:
362             if (mk_interval + inc < UINT8_MAX)
363                 mk_interval += inc;
364             else
365                 mk_interval = UINT8_MAX;
366             PRINT_SET_VAL(mk_interval);
367             break;
368         case 3:
369             if (mk_max_speed + inc < UINT8_MAX)
370                 mk_max_speed += inc;
371             else
372                 mk_max_speed = UINT8_MAX;
373             PRINT_SET_VAL(mk_max_speed);
374             break;
375         case 4:
376             if (mk_time_to_max + inc < UINT8_MAX)
377                 mk_time_to_max += inc;
378             else
379                 mk_time_to_max = UINT8_MAX;
380             PRINT_SET_VAL(mk_time_to_max);
381             break;
382         case 5:
383             if (mk_wheel_max_speed + inc < UINT8_MAX)
384                 mk_wheel_max_speed += inc;
385             else
386                 mk_wheel_max_speed = UINT8_MAX;
387             PRINT_SET_VAL(mk_wheel_max_speed);
388             break;
389         case 6:
390             if (mk_wheel_time_to_max + inc < UINT8_MAX)
391                 mk_wheel_time_to_max += inc;
392             else
393                 mk_wheel_time_to_max = UINT8_MAX;
394             PRINT_SET_VAL(mk_wheel_time_to_max);
395             break;
396     }
397 }
398
399 static void mousekey_param_dec(uint8_t param, uint8_t dec)
400 {
401     switch (param) {
402         case 1:
403             if (mk_delay > dec)
404                 mk_delay -= dec;
405             else
406                 mk_delay = 0;
407             PRINT_SET_VAL(mk_delay);
408             break;
409         case 2:
410             if (mk_interval > dec)
411                 mk_interval -= dec;
412             else
413                 mk_interval = 0;
414             PRINT_SET_VAL(mk_interval);
415             break;
416         case 3:
417             if (mk_max_speed > dec)
418                 mk_max_speed -= dec;
419             else
420                 mk_max_speed = 0;
421             PRINT_SET_VAL(mk_max_speed);
422             break;
423         case 4:
424             if (mk_time_to_max > dec)
425                 mk_time_to_max -= dec;
426             else
427                 mk_time_to_max = 0;
428             PRINT_SET_VAL(mk_time_to_max);
429             break;
430         case 5:
431             if (mk_wheel_max_speed > dec)
432                 mk_wheel_max_speed -= dec;
433             else
434                 mk_wheel_max_speed = 0;
435             PRINT_SET_VAL(mk_wheel_max_speed);
436             break;
437         case 6:
438             if (mk_wheel_time_to_max > dec)
439                 mk_wheel_time_to_max -= dec;
440             else
441                 mk_wheel_time_to_max = 0;
442             PRINT_SET_VAL(mk_wheel_time_to_max);
443             break;
444     }
445 }
446
447 static void mousekey_console_help(void)
448 {
449     print("\n\n----- Mousekey Parameters Help -----\n");
450     print("ESC/q:       quit\n");
451     print("1:   select mk_delay(*10ms)\n");
452     print("2:   select mk_interval(ms)\n");
453     print("3:   select mk_max_speed\n");
454     print("4:   select mk_time_to_max\n");
455     print("5:   select mk_wheel_max_speed\n");
456     print("6:   select mk_wheel_time_to_max\n");
457     print("p:   print prameters\n");
458     print("d:   set default values\n");
459     print("up:  increase prameters(+1)\n");
460     print("down:        decrease prameters(-1)\n");
461     print("pgup:        increase prameters(+10)\n");
462     print("pgdown:      decrease prameters(-10)\n");
463     print("\nspeed = delta * max_speed * (repeat / time_to_max)\n");
464     print("where delta: cursor="); pdec(MOUSEKEY_MOVE_DELTA);
465     print(", wheel="); pdec(MOUSEKEY_WHEEL_DELTA); print("\n");
466     print("See http://en.wikipedia.org/wiki/Mouse_keys\n");
467 }
468
469 static bool mousekey_console(uint8_t code)
470 {
471     switch (code) {
472         case KC_H:
473         case KC_SLASH: /* ? */
474             mousekey_console_help();
475             break;
476         case KC_Q:
477         case KC_ESC:
478             mousekey_param = 0;
479             print("\nQuit Mousekey Console\n");
480             print("C> ");
481             state = CONSOLE;
482             return false;
483         case KC_P:
484             mousekey_param_print();
485             break;
486         case KC_1:
487         case KC_2:
488         case KC_3:
489         case KC_4:
490         case KC_5:
491         case KC_6:
492         case KC_7:
493         case KC_8:
494         case KC_9:
495         case KC_0:
496             mousekey_param = numkey2num(code);
497             print("selected parameter: "); pdec(mousekey_param); print("\n");
498             break;
499         case KC_UP:
500             mousekey_param_inc(mousekey_param, 1);
501             break;
502         case KC_DOWN:
503             mousekey_param_dec(mousekey_param, 1);
504             break;
505         case KC_PGUP:
506             mousekey_param_inc(mousekey_param, 10);
507             break;
508         case KC_PGDN:
509             mousekey_param_dec(mousekey_param, 10);
510             break;
511         case KC_D:
512             mk_delay = MOUSEKEY_DELAY/10;
513             mk_interval = MOUSEKEY_INTERVAL;
514             mk_max_speed = MOUSEKEY_MAX_SPEED;
515             mk_time_to_max = MOUSEKEY_TIME_TO_MAX;
516             mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED;
517             mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX;
518             print("set default values.\n");
519             break;
520         default:
521             print("?");
522             return false;
523     }
524     print("M"); pdec(mousekey_param); print("> ");
525     return true;
526 }
527 #endif
528
529
530 /***********************************************************
531  * Utilities
532  ***********************************************************/
533 static uint8_t numkey2num(uint8_t code)
534 {
535     switch (code) {
536         case KC_1: return 1;
537         case KC_2: return 2;
538         case KC_3: return 3;
539         case KC_4: return 4;
540         case KC_5: return 5;
541         case KC_6: return 6;
542         case KC_7: return 7;
543         case KC_8: return 8;
544         case KC_9: return 9;
545         case KC_0: return 0;
546     }
547     return 0;
548 }
549
550 static void switch_layer(uint8_t layer)
551 {
552     print_val_hex8(current_layer);
553     print_val_hex8(default_layer);
554     current_layer = layer;
555     default_layer = layer;
556     print("switch to "); print_val_hex8(layer);
557 }