keymaps.ino 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536
  1. #include "devterm.h"
  2. #include "keyboard.h"
  3. #include "keys.h"
  4. #define EMP 0XFFFF
  5. /*
  6. B1 joystick up
  7. B2 joystick down
  8. B3 joystick left
  9. B4 joystick right
  10. B5 joystick A
  11. B6 joystick B
  12. B7 joystick X
  13. B8 joystick Y
  14. B9 left shift
  15. B10 Fn
  16. B11 left Ctrl
  17. B12 Cmd
  18. B13 left Alt
  19. B14 mouse left
  20. B15 mouse mid
  21. B16 mouse right
  22. */
  23. #define _PRINT_KEY KEY_PRNT_SCRN
  24. #define _PAUSE_KEY KEY_PAUSE
  25. #define _LEFT_SHIFT_KEY KEY_LEFT_SHIFT
  26. #define _LEFT_CTRL_KEY KEY_LEFT_CTRL
  27. #define _CMD_KEY KEY_RIGHT_GUI
  28. #define _LEFT_ALT KEY_LEFT_ALT
  29. #define _FN_KEY_UP_ARROW KEY_PAGE_UP
  30. #define _FN_KEY_DOWN_ARROW KEY_PAGE_DOWN
  31. #define _FN_KEY_LEFT_ARROW KEY_HOME
  32. #define _FN_KEY_RIGHT_ARROW KEY_END
  33. #define DEF_LAYER 0x00
  34. #define FN_LAYER 0x01
  35. /*
  36. * keyboard_maps
  37. * M11 - M18
  38. * M21 - M28
  39. * M31 - M38
  40. * M41 - M48
  41. * M51 - M58
  42. * M61 - M68
  43. * M71 - M78
  44. * M81 - M88
  45. */
  46. const uint16_t keyboard_maps[][MATRIX_KEYS] = {
  47. [DEF_LAYER] = { _SELECT_KEY,_START_KEY,_VOLUME_M,'`','[',']','-','=', \
  48. '1','2','3','4','5','6','7','8',\
  49. '9','0',KEY_ESC,KEY_TAB,EMP,EMP,EMP,EMP, \
  50. 'q','w','e','r','t','y','u','i', \
  51. 'o','p','a','s','d','f','g','h',\
  52. 'j','k','l','z','x','c','v','b', \
  53. 'n','m',',','.','/','\\',';','\'', \
  54. KEY_BACKSPACE,KEY_RETURN,_FN_KEY,_FN_KEY,' ',EMP,EMP,EMP},
  55. [FN_LAYER] = { _PRINT_KEY,_PAUSE_KEY,_VOLUME_MUTE,'`','[',']',KEY_F11,KEY_F12, \
  56. KEY_F1,KEY_F2,KEY_F3,KEY_F4,KEY_F5,KEY_F6,KEY_F7,KEY_F8,\
  57. KEY_F9,KEY_F10,_FN_LOCK_KEYBOARD,KEY_CAPS_LOCK,EMP,EMP,EMP,EMP, \
  58. 'q','w','e','r','t','y',KEY_PAGE_UP,KEY_INSERT, \
  59. 'o','p','a','s','d','f','g',KEY_HOME,\
  60. KEY_END,KEY_PAGE_DOWN,'l','z','x','c','v','b', \
  61. 'n','m',_FN_BRIGHTNESS_DOWN,_FN_BRIGHTNESS_UP,'/','\\',';','\'', \
  62. KEY_DELETE,KEY_RETURN,_FN_KEY,_FN_KEY,_FN_LIGHT_KEYBOARD,EMP,EMP,EMP}
  63. };
  64. static uint8_t fn_actions[MATRIX_KEYS]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  65. const uint16_t keys_maps[][KEYS_NUM] = {
  66. [DEF_LAYER] = {KEY_UP_ARROW,KEY_DOWN_ARROW, KEY_LEFT_ARROW,KEY_RIGHT_ARROW, \
  67. _JOYSTICK_A,_JOYSTICK_B, _JOYSTICK_X,_JOYSTICK_Y, \
  68. _LEFT_SHIFT_KEY,KEY_RIGHT_SHIFT,_LEFT_CTRL_KEY, KEY_RIGHT_CTRL, \
  69. _LEFT_ALT, _MOUSE_LEFT, KEY_RIGHT_ALT,_MOUSE_RIGHT, \
  70. _TRACKBALL_BTN },
  71. [FN_LAYER] = {_FN_KEY_UP_ARROW,_FN_KEY_DOWN_ARROW, _FN_KEY_LEFT_ARROW, _FN_KEY_RIGHT_ARROW, \
  72. _JOYSTICK_A,_JOYSTICK_B, _JOYSTICK_X,_JOYSTICK_Y, \
  73. _LEFT_SHIFT_KEY,KEY_RIGHT_SHIFT,_LEFT_CTRL_KEY, KEY_RIGHT_CTRL, \
  74. _CMD_KEY, _MOUSE_LEFT, KEY_RIGHT_ALT,_MOUSE_RIGHT, \
  75. _TRACKBALL_BTN },
  76. };
  77. const uint16_t backlight_vals[3] = {0,32,2000};
  78. uint8_t check_pd2(){ // if swtich 2 in back is set to on(HIGH)
  79. return digitalRead(PD2);
  80. }
  81. void dt_kbd_set_layer(DEVTERM*dv,uint8_t new_layer) {
  82. if( dv->Keyboard_state.layer != new_layer) {
  83. dv->Keyboard_state.prev_layer = dv->Keyboard_state.layer;
  84. dv->Keyboard_state.layer = new_layer;
  85. }
  86. }
  87. void dt_kbd_restore_layer(DEVTERM*dv) {
  88. dv->Keyboard_state.layer = dv->Keyboard_state.prev_layer;
  89. }
  90. void press_any_key_to_release_lock(DEVTERM*dv, KEYBOARD_LOCK*lock, uint16_t k,uint8_t mode) {
  91. if( lock->lock > 0 ) {
  92. if(mode == KEY_RELEASED
  93. && k != _LEFT_CTRL_KEY && k!= KEY_RIGHT_CTRL
  94. && k != _LEFT_ALT && k!= KEY_RIGHT_ALT
  95. && k != _LEFT_SHIFT_KEY && k!= KEY_RIGHT_SHIFT
  96. && k != _FN_KEY) {
  97. lock->lock = 0;
  98. if(lock->begin!= _FN_KEY) {
  99. dv->Keyboard->release(lock->begin);
  100. }
  101. lock->begin = 0;
  102. lock->time = 0;
  103. //dv->_Serial->println("ctrl lock released");
  104. }
  105. }
  106. }
  107. void keyboard_action(DEVTERM*dv,uint8_t row,uint8_t col,uint8_t mode) {
  108. uint16_t k;
  109. uint8_t addr;
  110. addr = row*MATRIX_COLS+col;
  111. if(dv->Keyboard_state.fn_on > 0){
  112. k = keyboard_maps[dv->Keyboard_state.fn_on][addr];
  113. fn_actions[addr] = 1;
  114. }else {
  115. k = keyboard_maps[dv->Keyboard_state.layer][addr];
  116. }
  117. if(k == EMP){
  118. return;
  119. }
  120. if(k != _FN_KEY && k != _FN_LOCK_KEYBOARD && dv->Keyboard_state.lock == 1) {
  121. return;
  122. }
  123. switch(k) {
  124. case KEY_CAPS_LOCK:
  125. if(mode == KEY_PRESSED) {
  126. dv->Keyboard->press(k);
  127. dv->Keyboard->setAdjustForHostCapsLock(true);
  128. }else if(mode == KEY_RELEASED) {
  129. dv->Keyboard->setAdjustForHostCapsLock(false);
  130. dv->Keyboard->release(k);
  131. }
  132. break;
  133. case _SELECT_KEY:
  134. if(check_pd2() == HIGH) {
  135. k = ' ';
  136. if(mode == KEY_PRESSED) {
  137. dv->Keyboard->press(k);
  138. }else if(mode == KEY_RELEASED) {
  139. dv->Keyboard->release(k);
  140. }
  141. }else {
  142. dv->Joystick->button(9,mode);
  143. }
  144. break;
  145. case _START_KEY:
  146. if(check_pd2() == HIGH) {
  147. k = KEY_RETURN;
  148. if(mode == KEY_PRESSED) {
  149. dv->Keyboard->press(k);
  150. }else if(mode == KEY_RELEASED) {
  151. dv->Keyboard->release(k);
  152. }
  153. }else {
  154. dv->Joystick->button(10,mode);
  155. }
  156. break;
  157. case _FN_BRIGHTNESS_UP:
  158. if(mode == KEY_PRESSED) {
  159. dv->Consumer->press(HIDConsumer::BRIGHTNESS_UP);
  160. }else {
  161. dv->Consumer->release();
  162. }
  163. break;
  164. case _FN_BRIGHTNESS_DOWN:
  165. if(mode == KEY_PRESSED) {
  166. dv->Consumer->press(HIDConsumer::BRIGHTNESS_DOWN);
  167. }else {
  168. dv->Consumer->release();
  169. }
  170. break;
  171. case _VOLUME_P:{
  172. if(mode == KEY_PRESSED) {
  173. dv->Consumer->press(HIDConsumer::VOLUME_UP);
  174. }else {
  175. dv->Consumer->release();
  176. }
  177. }break;
  178. case _VOLUME_M:{
  179. if(mode == KEY_PRESSED) {
  180. dv->Consumer->press(HIDConsumer::VOLUME_DOWN);
  181. }else {
  182. dv->Consumer->release();
  183. }
  184. }break;
  185. case _VOLUME_MUTE:{
  186. if(mode == KEY_PRESSED) {
  187. dv->Consumer->press(HIDConsumer::MUTE);
  188. }else {
  189. dv->Consumer->release();
  190. }
  191. }break;
  192. case _FN_LOCK_KEYBOARD:{
  193. if(mode == KEY_PRESSED) {
  194. dv->Keyboard_state.lock = dv->Keyboard_state.lock ^ 1;
  195. }
  196. }break;
  197. case _FN_LIGHT_KEYBOARD: {
  198. //dv->_Serial->println("light keyboard");
  199. if(mode == KEY_PRESSED) {
  200. dv->Keyboard_state.backlight ++;
  201. if(dv->Keyboard_state.backlight >= 3) {
  202. dv->Keyboard_state.backlight = 0;
  203. }
  204. timer.resume();
  205. pwmWrite(PA8,backlight_vals[ dv->Keyboard_state.backlight ] );
  206. }
  207. }break;
  208. case _FN_KEY:
  209. if(mode == KEY_PRESSED){
  210. if(dv->Keyboard_state.fn.lock == 0){
  211. dv->Keyboard_state.fn_on = FN_LAYER;
  212. dv->Keyboard_state.fn.begin = k;
  213. }
  214. }else if(mode == KEY_RELEASED ) {
  215. if(dv->Keyboard_state.fn.lock == 0){
  216. for(int i=0;i<64;i++) {
  217. if(fn_actions[i] !=0) {
  218. k = keyboard_maps[dv->Keyboard_state.fn_on][i];
  219. dv->Keyboard->release(k);
  220. fn_actions[i] = 0;
  221. }
  222. }
  223. dv->Keyboard_state.fn_on = 0;
  224. }
  225. dv->Keyboard_state.fn.begin = 0;
  226. dv->Keyboard_state.fn.time = 0;
  227. }
  228. break;
  229. default:
  230. if(mode == KEY_PRESSED) {
  231. dv->Keyboard->press(k);
  232. }else if(mode == KEY_RELEASED) {
  233. dv->Keyboard->release(k);
  234. if(dv->Keyboard_state.fn_on > 0){
  235. fn_actions[addr] = 0;
  236. }
  237. }
  238. break;
  239. }
  240. /*
  241. press_any_key_to_release_lock(dv,&dv->Keyboard_state.ctrl,k,mode);
  242. press_any_key_to_release_lock(dv,&dv->Keyboard_state.alt,k,mode);
  243. press_any_key_to_release_lock(dv,&dv->Keyboard_state.shift,k,mode);
  244. press_any_key_to_release_lock(dv,&dv->Keyboard_state.fn,k,mode);
  245. */
  246. }
  247. void keypad_action(DEVTERM*dv,uint8_t col,uint8_t mode) {
  248. uint16_t k;
  249. if(dv->Keyboard_state.fn_on > 0){
  250. k = keys_maps[dv->Keyboard_state.fn_on][col];
  251. }else {
  252. k = keys_maps[dv->Keyboard_state.layer][col];
  253. }
  254. if(k == EMP){
  255. return;
  256. }
  257. if(dv->Keyboard_state.lock == 1) {
  258. return;
  259. }
  260. switch(k) {
  261. case _LEFT_SHIFT_KEY:
  262. case KEY_RIGHT_SHIFT:
  263. if(mode == KEY_PRESSED) {
  264. if(dv->Keyboard_state.shift.lock == 0){
  265. dv->Keyboard->press(k);
  266. dv->Keyboard_state.shift.begin=k;
  267. }
  268. }else if(mode == KEY_RELEASED) {
  269. if(dv->Keyboard_state.shift.lock == 0){
  270. dv->Keyboard->release(k);
  271. dv->Keyboard_state.shift.begin = 0;
  272. dv->Keyboard_state.shift.time = 0;
  273. }
  274. }
  275. break;
  276. case _JOYSTICK_UP:
  277. if(check_pd2() == HIGH) {
  278. k = KEY_UP_ARROW;
  279. if(mode == KEY_PRESSED) {
  280. dv->Keyboard->press(k);
  281. }else if(mode == KEY_RELEASED) {
  282. dv->Keyboard->release(k);
  283. }
  284. }else {
  285. if(mode == KEY_RELEASED){
  286. dv->Joystick->Y(511);
  287. }else {
  288. dv->Joystick->Y(0);
  289. }
  290. }
  291. break;
  292. case _JOYSTICK_DOWN:
  293. if(check_pd2() == HIGH) {
  294. k = KEY_DOWN_ARROW;
  295. if(mode == KEY_PRESSED) {
  296. dv->Keyboard->press(k);
  297. }else if(mode == KEY_RELEASED) {
  298. dv->Keyboard->release(k);
  299. }
  300. }else {
  301. if(mode == KEY_RELEASED){
  302. dv->Joystick->Y(511);
  303. }else {
  304. dv->Joystick->Y(1023);
  305. }
  306. }
  307. break;
  308. case _JOYSTICK_LEFT:
  309. if(check_pd2() == HIGH) {
  310. k = KEY_LEFT_ARROW;
  311. if(mode == KEY_PRESSED) {
  312. dv->Keyboard->press(k);
  313. }else if(mode == KEY_RELEASED) {
  314. dv->Keyboard->release(k);
  315. }
  316. }else {
  317. if(mode == KEY_RELEASED){
  318. dv->Joystick->X(511);
  319. }else {
  320. dv->Joystick->X(0);
  321. }
  322. }
  323. break;
  324. case _JOYSTICK_RIGHT:
  325. if(check_pd2() == HIGH) {
  326. k = KEY_RIGHT_ARROW;
  327. if(mode == KEY_PRESSED) {
  328. dv->Keyboard->press(k);
  329. }else if(mode == KEY_RELEASED) {
  330. dv->Keyboard->release(k);
  331. }
  332. }else {
  333. if(mode == KEY_RELEASED){
  334. dv->Joystick->X(511);
  335. }else {
  336. dv->Joystick->X(1023);
  337. }
  338. }
  339. break;
  340. case _JOYSTICK_A:
  341. if(check_pd2() == HIGH) {
  342. k = 'j';
  343. if(mode == KEY_PRESSED) {
  344. dv->Keyboard->press(k);
  345. }else if(mode == KEY_RELEASED) {
  346. dv->Keyboard->release(k);
  347. }
  348. }else {
  349. dv->Joystick->button(2,mode);
  350. }
  351. break;
  352. case _JOYSTICK_B:
  353. if(check_pd2() == HIGH) {
  354. k = 'k';
  355. if(mode == KEY_PRESSED) {
  356. dv->Keyboard->press(k);
  357. }else if(mode == KEY_RELEASED) {
  358. dv->Keyboard->release(k);
  359. }
  360. }else {
  361. dv->Joystick->button(3,mode);
  362. }
  363. break;
  364. case _JOYSTICK_X:
  365. if(check_pd2() == HIGH) {
  366. k = 'u';
  367. if(mode == KEY_PRESSED) {
  368. dv->Keyboard->press(k);
  369. }else if(mode == KEY_RELEASED) {
  370. dv->Keyboard->release(k);
  371. }
  372. }else {
  373. dv->Joystick->button(1,mode);
  374. }
  375. break;
  376. case _JOYSTICK_Y:
  377. if(check_pd2() == HIGH) {
  378. k = 'i';
  379. if(mode == KEY_PRESSED) {
  380. dv->Keyboard->press(k);
  381. }else if(mode == KEY_RELEASED) {
  382. dv->Keyboard->release(k);
  383. }
  384. }else {
  385. dv->Joystick->button(4,mode);
  386. }
  387. break;
  388. case _MOUSE_LEFT:
  389. if(mode == KEY_PRESSED){
  390. dv->Mouse->press(1);
  391. }else if(mode == KEY_RELEASED){
  392. dv->Mouse->release(1);
  393. }
  394. break;
  395. case _MOUSE_MID:
  396. if(mode == KEY_PRESSED) {
  397. dv->state->pressMiddleClick();
  398. }else {
  399. if(dv->state->getScrolled() == false){
  400. //if no scrolling happend ,do as a normal mid mouse key click
  401. dv->Mouse->click(MOUSE_MIDDLE);
  402. }
  403. dv->state->releaseMiddleClick();
  404. }
  405. break;
  406. case _MOUSE_RIGHT:
  407. if(mode == KEY_PRESSED){
  408. dv->Mouse->press(2);
  409. }else if(mode == KEY_RELEASED){
  410. dv->Mouse->release(2);
  411. }
  412. break;
  413. //_LEFT_CTRL_KEY,_CMD_KEY , _LEFT_ALT
  414. case _LEFT_CTRL_KEY:
  415. case KEY_RIGHT_CTRL:
  416. if(mode == KEY_PRESSED){
  417. if(dv->Keyboard_state.ctrl.lock == 0){
  418. dv->Keyboard->press(k);
  419. dv->Keyboard_state.ctrl.begin = k;
  420. }
  421. }else {
  422. if(dv->Keyboard_state.ctrl.lock == 0){
  423. dv->Keyboard->release(k);
  424. dv->Keyboard_state.ctrl.begin = 0;
  425. dv->Keyboard_state.ctrl.time = 0;
  426. }
  427. }
  428. break;
  429. case _LEFT_ALT:
  430. case KEY_RIGHT_ALT:
  431. if(mode == KEY_PRESSED){
  432. if(dv->Keyboard_state.alt.lock == 0){
  433. dv->Keyboard->press(k);
  434. dv->Keyboard_state.alt.begin=k;
  435. }
  436. }else {
  437. if(dv->Keyboard_state.alt.lock == 0){
  438. dv->Keyboard->release(k);
  439. dv->Keyboard_state.alt.begin = 0;
  440. dv->Keyboard_state.alt.time = 0;
  441. }
  442. }
  443. break;
  444. case _CMD_KEY:
  445. if(mode == KEY_PRESSED){
  446. dv->Keyboard->press(k);
  447. }else {
  448. dv->Keyboard->release(k);
  449. }
  450. break;
  451. case _TRACKBALL_BTN:
  452. if(mode == KEY_PRESSED){
  453. dv->Mouse->press(MOUSE_MIDDLE);
  454. }else if(mode == KEY_RELEASED){
  455. dv->Mouse->release(MOUSE_MIDDLE);
  456. }
  457. break;
  458. default:
  459. if(mode == KEY_PRESSED) {
  460. dv->Keyboard->press(k);
  461. }else if(mode == KEY_RELEASED) {
  462. dv->Keyboard->release(k);
  463. }
  464. break;
  465. }
  466. /*
  467. press_any_key_to_release_lock(dv,&dv->Keyboard_state.ctrl,k,mode);
  468. press_any_key_to_release_lock(dv,&dv->Keyboard_state.alt,k,mode);
  469. press_any_key_to_release_lock(dv,&dv->Keyboard_state.shift,k,mode);
  470. press_any_key_to_release_lock(dv,&dv->Keyboard_state.fn,k,mode);
  471. */
  472. }