key_process.c

   1 #include <stdbool.h>
   2 #include <avr/io.h>
   3 #include <util/delay.h>
   4 #include "print.h"
   5 #include "debug.h"
   6 #include "timer.h"
   7 #include "util.h"
   8 #include "jump_bootloader.h"
   9 #include "usb_keyboard.h"
  10 #include "usb_mouse.h"
  11 #include "usb_extra.h"
  12 #include "usb_keycodes.h"
  13 #include "usb.h"
  14 #include "layer.h"
  15 #include "matrix_skel.h"
  16 #include "keymap_skel.h"
  17 #include "controller.h"
  18 #include "key_process.h"
  19
  20
  21 #define MOUSE_MOVE_UNIT 10
  22 #define MOUSE_MOVE_ACCEL (mouse_repeat < 50 ? mouse_repeat/5 : 10)
  23
  24 #ifndef MOUSE_DELAY_TIME
  25 #   define MOUSE_DELAY_TIME 255
  26 #endif
  27 #define MOUSE_DELAY_MS (MOUSE_DELAY_TIME >> (mouse_repeat < 5 ? mouse_repeat : 4))
  28
  29
  30 // TODO: refactoring
  31 void proc_matrix(void) {
  32     static int mouse_repeat = 0;
  33
  34     bool modified = false;
  35     uint8_t mouse_btn = 0;
  36     int8_t mouse_x = 0;
  37     int8_t mouse_y = 0;
  38     int8_t mouse_vwheel = 0;
  39     int8_t mouse_hwheel = 0;
  40     uint8_t fn_bits = 0;
  41
  42     matrix_scan();
  43     modified = matrix_is_modified();
  44
  45     if (modified) {
  46         if (debug_matrix) matrix_print();
  47 #ifdef DEBUG_LED
  48         // LED flash for debug
  49         DEBUG_LED_CONFIG;
  50         DEBUG_LED_ON;
  51 #endif
  52     }
  53
  54     if (matrix_has_ghost()) {
  55         // should send error?
  56         debug("matrix has ghost!!\n");
  57         return;
  58     }
  59
  60     usb_keyboard_swap_report();
  61     usb_keyboard_clear_report();
  62     for (int row = 0; row < matrix_rows(); row++) {
  63         for (int col = 0; col < matrix_cols(); col++) {
  64             if (!matrix_is_on(row, col)) continue;
  65
  66             // TODO: clean code
  67             uint8_t code = layer_get_keycode(row, col);
  68             if (code == KB_NO) {
  69                 // do nothing
  70             } else if (IS_MOD(code)) {
  71                 usb_keyboard_mods |= MOD_BIT(code);
  72             } else if (IS_FN(code)) {
  73                 fn_bits |= FN_BIT(code);
  74             } else if (IS_MOUSE(code)) {
  75                 if (code == MS_UP)   mouse_y -= MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  76                 if (code == MS_DOWN) mouse_y += MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  77                 if (code == MS_LEFT) mouse_x -= MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  78                 if (code == MS_RGHT) mouse_x += MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  79                 if (code == MS_BTN1) mouse_btn |= BIT_BTN1;
  80                 if (code == MS_BTN2) mouse_btn |= BIT_BTN2;
  81                 if (code == MS_BTN3) mouse_btn |= BIT_BTN3;
  82                 if (code == MS_BTN4) mouse_btn |= BIT_BTN4;
  83                 if (code == MS_BTN5) mouse_btn |= BIT_BTN5;
  84                 if (code == MS_WH_U) mouse_vwheel += 1;
  85                 if (code == MS_WH_D) mouse_vwheel -= 1;
  86                 if (code == MS_WH_L) mouse_hwheel -= 1;
  87                 if (code == MS_WH_R) mouse_hwheel += 1;
  88             }
  89
  90             // audio control & system control
  91             else if (code == KB_MUTE) {
  92                 usb_extra_audio_send(AUDIO_MUTE);
  93                 usb_extra_audio_send(0);
  94                 _delay_ms(500);
  95             } else if (code == KB_VOLU) {
  96                 usb_extra_audio_send(AUDIO_VOL_UP);
  97                 usb_extra_audio_send(0);
  98                 _delay_ms(100);
  99             } else if (code == KB_VOLD) {
 100                 usb_extra_audio_send(AUDIO_VOL_DOWN);
 101                 usb_extra_audio_send(0);
 102                 _delay_ms(100);
 103             } else if (code == KB_PWR) {
 104                 if (suspend && remote_wakeup) {
 105                     usb_remote_wakeup();
 106                 } else {
 107                     usb_extra_system_send(SYSTEM_POWER_DOWN);
 108                 }
 109                 _delay_ms(1000);
 110             }
 111
 112             // normal keys
 113             else {
 114                 // TODO: fix ugly code
 115                 int8_t i = 0;
 116                 int8_t empty = -1;
 117                 for (; i < KEYBOARD_REPORT_MAX; i++) {
 118                     if (usb_keyboard_keys_prev[i] == code) {
 119                         usb_keyboard_keys[i] = code;
 120                         break;
 121                     } else if (empty == -1 && usb_keyboard_keys_prev[i] == 0 && usb_keyboard_keys[i] == 0) {
 122                         empty = i;
 123                     }
 124                 }
 125                 if (i == KEYBOARD_REPORT_MAX) {
 126                     if (empty != -1) {
 127                         usb_keyboard_keys[empty] = code;
 128                     }
 129                 }
 130             }
 131         }
 132     }
 133
 134     if (modified) {
 135 #ifdef DEBUG_LED
 136         // LED flash for debug
 137         DEBUG_LED_CONFIG;
 138         DEBUG_LED_OFF;
 139 #endif
 140     }
 141
 142     layer_switching(fn_bits);
 143
 144     // TODO: clean code
 145     // when 4 left modifier keys down
 146     if (keymap_is_special_mode(fn_bits)) {
 147         switch (usb_keyboard_keys[0]) {
 148             case KB_H: // help
 149                 print_enable = true;
 150                 print("b: jump to bootloader\n");
 151                 print("d: debug print toggle\n");
 152                 print("x: matrix debug toggle\n");
 153                 print("k: keyboard debug toggle\n");
 154                 print("m: mouse debug toggle\n");
 155                 print("p: print enable toggle\n");
 156                 print("v: print version\n");
 157                 print("t: print timer count\n");
 158                 print("r: print registers\n");
 159                 print("ESC: power down/wake up\n");
 160                 _delay_ms(500);
 161                 print_enable = false;
 162                 break;
 163             case KB_B: // bootloader
 164                 usb_keyboard_clear_report();
 165                 usb_keyboard_send();
 166                 print_enable = true;
 167                 print("jump to bootloader...\n");
 168                 _delay_ms(1000);
 169                 jump_bootloader(); // not return
 170                 break;
 171             case KB_D: // debug all toggle
 172                 usb_keyboard_clear_report();
 173                 usb_keyboard_send();
 174                 debug_enable = !debug_enable;
 175                 if (debug_enable) {
 176                     print_enable = true;
 177                     print("debug enabled.\n");
 178                     debug_matrix = true;
 179                     debug_keyboard = true;
 180                     debug_mouse = true;
 181                 } else {
 182                     print("debug disabled.\n");
 183                     print_enable = false;
 184                     debug_matrix = false;
 185                     debug_keyboard = false;
 186                     debug_mouse = false;
 187                 }
 188                 _delay_ms(1000);
 189                 break;
 190             case KB_X: // debug matrix toggle
 191                 usb_keyboard_clear_report();
 192                 usb_keyboard_send();
 193                 debug_matrix = !debug_matrix;
 194                 if (debug_matrix)
 195                     print("debug matrix enabled.\n");
 196                 else
 197                     print("debug matrix disabled.\n");
 198                 _delay_ms(1000);
 199                 break;
 200             case KB_K: // debug keyboard toggle
 201                 usb_keyboard_clear_report();
 202                 usb_keyboard_send();
 203                 debug_keyboard = !debug_keyboard;
 204                 if (debug_keyboard)
 205                     print("debug keyboard enabled.\n");
 206                 else
 207                     print("debug keyboard disabled.\n");
 208                 _delay_ms(1000);
 209                 break;
 210             case KB_M: // debug mouse toggle
 211                 usb_keyboard_clear_report();
 212                 usb_keyboard_send();
 213                 debug_mouse = !debug_mouse;
 214                 if (debug_mouse)
 215                     print("debug mouse enabled.\n");
 216                 else
 217                     print("debug mouse disabled.\n");
 218                 _delay_ms(1000);
 219                 break;
 220             case KB_V: // print version & information
 221                 usb_keyboard_clear_report();
 222                 usb_keyboard_send();
 223                 print_enable = true;
 224                 print(STR(DESCRIPTION) "\n");
 225                 _delay_ms(1000);
 226                 break;
 227             case KB_T: // print timer
 228                 usb_keyboard_clear_report();
 229                 usb_keyboard_send();
 230                 print_enable = true;
 231                 print("timer: "); phex16(timer_count); print("\n");
 232                 _delay_ms(500);
 233                 break;
 234             case KB_P: // print toggle
 235                 usb_keyboard_clear_report();
 236                 usb_keyboard_send();
 237                 if (print_enable) {
 238                     print("print disabled.\n");
 239                     print_enable = false;
 240                 } else {
 241                     print_enable = true;
 242                     print("print enabled.\n");
 243                 }
 244                 _delay_ms(1000);
 245                 break;
 246             case KB_R:
 247                 usb_keyboard_clear_report();
 248                 usb_keyboard_send();
 249                 print("UDIEN: "); phex(UDIEN); print("\n");
 250                 print("UDINT: "); phex(UDINT); print("\n");
 251                 _delay_ms(1000);
 252                 break;
 253             case KB_ESC:
 254                 usb_keyboard_clear_report();
 255                 usb_keyboard_send();
 256                 if (suspend && remote_wakeup) {
 257                     usb_remote_wakeup();
 258                 } else {
 259                     usb_extra_system_send(SYSTEM_POWER_DOWN);
 260                 }
 261                 _delay_ms(1000);
 262                 break;
 263         }
 264     }
 265
 266
 267     // send mouse packet to host
 268     if (mouse_x || mouse_y || mouse_vwheel || mouse_hwheel || mouse_btn != mouse_buttons) {
 269         mouse_buttons = mouse_btn;
 270         if (mouse_x && mouse_y)
 271             usb_mouse_move(mouse_x*0.7, mouse_y*0.7, mouse_vwheel, mouse_hwheel);
 272         else
 273             usb_mouse_move(mouse_x, mouse_y, mouse_vwheel, mouse_hwheel);
 274         usb_mouse_print(mouse_x, mouse_y, mouse_vwheel, mouse_hwheel);
 275
 276         // acceleration
 277         _delay_ms(MOUSE_DELAY_MS);
 278         mouse_repeat++;
 279     } else {
 280         mouse_repeat = 0;
 281     }
 282
 283
 284     // send key packet to host
 285     if (modified) {
 286         usb_keyboard_send();
 287     }
 288 }