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 "layer.h"
  14 #include "matrix_skel.h"
  15 #include "keymap_skel.h"
  16 #include "controller.h"
  17 #include "key_process.h"
  18
  19
  20 #define MOUSE_MOVE_UNIT 10
  21 #define MOUSE_MOVE_ACCEL (mouse_repeat < 50 ? mouse_repeat/5 : 10)
  22
  23 #ifndef MOUSE_DELAY_TIME
  24 #   define MOUSE_DELAY_TIME 255
  25 #endif
  26 #define MOUSE_DELAY_MS (MOUSE_DELAY_TIME >> (mouse_repeat < 5 ? mouse_repeat : 4))
  27
  28
  29 // TODO: refactoring
  30 void proc_matrix(void) {
  31     static int mouse_repeat = 0;
  32
  33     bool modified = false;
  34     //bool has_ghost = false;
  35     int key_index = 0;
  36     uint8_t mouse_btn = 0;
  37     int8_t mouse_x = 0;
  38     int8_t mouse_y = 0;
  39     int8_t mouse_vwheel = 0;
  40     int8_t mouse_hwheel = 0;
  41     uint8_t fn_bits = 0;
  42
  43     matrix_scan();
  44     modified = matrix_is_modified();
  45
  46     if (modified) {
  47         if (debug_matrix) matrix_print();
  48 #ifdef DEBUG_LED
  49         // LED flash for debug
  50         DEBUG_LED_CONFIG;
  51         DEBUG_LED_ON;
  52 #endif
  53     }
  54
  55     if (matrix_has_ghost()) {
  56         // should send error?
  57         debug("matrix has ghost!!\n");
  58         return;
  59     }
  60
  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             uint8_t code = layer_get_keycode(row, col);
  67             if (code == KB_NO) {
  68                 // do nothing
  69             } else if (IS_MOD(code)) {
  70                 usb_keyboard_mods |= MOD_BIT(code);
  71             } else if (IS_MOUSE(code)) {
  72                 // mouse
  73                 if (code == MS_UP)
  74                     mouse_y -= MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  75                 if (code == MS_DOWN)
  76                     mouse_y += MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  77                 if (code == MS_LEFT)
  78                     mouse_x -= MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  79                 if (code == MS_RIGHT)
  80                     mouse_x += MOUSE_MOVE_UNIT + MOUSE_MOVE_ACCEL;
  81                 if (code == MS_BTN1) mouse_btn |= BIT_BTN1;
  82                 if (code == MS_BTN2) mouse_btn |= BIT_BTN2;
  83                 if (code == MS_BTN3) mouse_btn |= BIT_BTN3;
  84                 if (code == MS_BTN4) mouse_btn |= BIT_BTN4;
  85                 if (code == MS_BTN5) mouse_btn |= BIT_BTN5;
  86                 if (code == MS_WH_UP)    mouse_vwheel  += 1;
  87                 if (code == MS_WH_DOWN)  mouse_vwheel  -= 1;
  88                 if (code == MS_WH_LEFT)  mouse_hwheel -= 1;
  89                 if (code == MS_WH_RIGHT) mouse_hwheel += 1;
  90             } else if (IS_FN(code)) {
  91                 fn_bits |= FN_BIT(code);
  92             } else if (code == KB_MUTE) {
  93                 usb_extra_send(AUDIO_MUTE);
  94                 usb_extra_send(0);
  95                 _delay_ms(500);
  96             } else if (code == KB_VOLU) {
  97                 usb_extra_send(AUDIO_VOL_UP);
  98                 usb_extra_send(0);
  99                 _delay_ms(100);
 100             } else if (code == KB_VOLD) {
 101                 usb_extra_send(AUDIO_VOL_DOWN);
 102                 usb_extra_send(0);
 103                 _delay_ms(100);
 104             } else {
 105                 // normal keys
 106                 if (key_index < 6)
 107                     usb_keyboard_keys[key_index] = code;
 108                 key_index++;
 109             }
 110         }
 111     }
 112
 113     if (modified) {
 114 #ifdef DEBUG_LED
 115         // LED flash for debug
 116         DEBUG_LED_CONFIG;
 117         DEBUG_LED_OFF;
 118 #endif
 119     }
 120
 121     layer_switching(fn_bits);
 122
 123     // when 4 left modifier keys down
 124     if (keymap_is_special_mode(fn_bits)) {
 125         switch (usb_keyboard_keys[0]) {
 126             case KB_H: // help
 127                 print_enable = true;
 128                 print("b: jump to bootloader\n");
 129                 print("d: debug print toggle\n");
 130                 print("k: keyboard debug toggle\n");
 131                 print("m: mouse debug toggle\n");
 132                 print("x: matrix debug toggle\n");
 133                 print("v: print version\n");
 134                 print("t: print timer count\n");
 135                 print("p: print enable toggle\n");
 136                 _delay_ms(500);
 137                 print_enable = false;
 138                 break;
 139             case KB_B: // bootloader
 140                 usb_keyboard_clear_report();
 141                 usb_keyboard_send();
 142                 print_enable = true;
 143                 print("jump to bootloader...\n");
 144                 _delay_ms(1000);
 145                 jump_bootloader(); // not return
 146                 break;
 147             case KB_D: // debug all toggle
 148                 usb_keyboard_clear_report();
 149                 usb_keyboard_send();
 150                 debug_enable = !debug_enable;
 151                 if (debug_enable) {
 152                     print_enable = true;
 153                     print("debug enabled.\n");
 154                     debug_matrix = true;
 155                     debug_keyboard = true;
 156                     debug_mouse = true;
 157                 } else {
 158                     print("debug disabled.\n");
 159                     print_enable = false;
 160                     debug_matrix = false;
 161                     debug_keyboard = false;
 162                     debug_mouse = false;
 163                 }
 164                 _delay_ms(1000);
 165                 break;
 166             case KB_X: // debug matrix toggle
 167                 usb_keyboard_clear_report();
 168                 usb_keyboard_send();
 169                 debug_matrix = !debug_matrix;
 170                 if (debug_matrix)
 171                     print("debug matrix enabled.\n");
 172                 else
 173                     print("debug matrix disabled.\n");
 174                 _delay_ms(1000);
 175                 break;
 176             case KB_K: // debug keyboard toggle
 177                 usb_keyboard_clear_report();
 178                 usb_keyboard_send();
 179                 debug_keyboard = !debug_keyboard;
 180                 if (debug_keyboard)
 181                     print("debug keyboard enabled.\n");
 182                 else
 183                     print("debug keyboard disabled.\n");
 184                 _delay_ms(1000);
 185                 break;
 186             case KB_M: // debug mouse toggle
 187                 usb_keyboard_clear_report();
 188                 usb_keyboard_send();
 189                 debug_mouse = !debug_mouse;
 190                 if (debug_mouse)
 191                     print("debug mouse enabled.\n");
 192                 else
 193                     print("debug mouse disabled.\n");
 194                 _delay_ms(1000);
 195                 break;
 196             case KB_V: // print version & information
 197                 usb_keyboard_clear_report();
 198                 usb_keyboard_send();
 199                 print_enable = true;
 200                 print(STR(DESCRIPTION) "\n");
 201                 _delay_ms(1000);
 202                 break;
 203             case KB_T: // print timer
 204                 usb_keyboard_clear_report();
 205                 usb_keyboard_send();
 206                 print_enable = true;
 207                 print("timer: "); phex16(timer_count); print("\n");
 208                 _delay_ms(500);
 209                 break;
 210             case KB_P: // print toggle
 211                 usb_keyboard_clear_report();
 212                 usb_keyboard_send();
 213                 if (print_enable) {
 214                     print("print disabled.\n");
 215                     print_enable = false;
 216                 } else {
 217                     print_enable = true;
 218                     print("print enabled.\n");
 219                 }
 220                 _delay_ms(1000);
 221                 break;
 222         }
 223     }
 224
 225
 226     // send mouse packet to host
 227     if (mouse_x || mouse_y || mouse_vwheel || mouse_hwheel || mouse_btn != mouse_buttons) {
 228         mouse_buttons = mouse_btn;
 229         if (mouse_x && mouse_y)
 230             usb_mouse_move(mouse_x*0.7, mouse_y*0.7, mouse_vwheel, mouse_hwheel);
 231         else
 232             usb_mouse_move(mouse_x, mouse_y, mouse_vwheel, mouse_hwheel);
 233         usb_mouse_print(mouse_x, mouse_y, mouse_vwheel, mouse_hwheel);
 234
 235         // acceleration
 236         _delay_ms(MOUSE_DELAY_MS);
 237         mouse_repeat++;
 238     } else {
 239         mouse_repeat = 0;
 240     }
 241
 242
 243     // send key packet to host
 244     if (modified) {
 245         if (key_index > 6) {
 246             //Rollover
 247         }
 248         usb_keyboard_send();
 249     }
 250 }