keymaps.ino 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542
  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. if(dv->Keyboard_state.sf_on == 1){
  181. dv->Consumer->press(HIDConsumer::VOLUME_UP);
  182. }else{
  183. dv->Consumer->press(HIDConsumer::VOLUME_DOWN);
  184. }
  185. }else {
  186. dv->Consumer->release();
  187. }
  188. }break;
  189. case _VOLUME_MUTE:{
  190. if(mode == KEY_PRESSED) {
  191. dv->Consumer->press(HIDConsumer::MUTE);
  192. }else {
  193. dv->Consumer->release();
  194. }
  195. }break;
  196. case _FN_LOCK_KEYBOARD:{
  197. if(mode == KEY_PRESSED) {
  198. dv->Keyboard_state.lock = dv->Keyboard_state.lock ^ 1;
  199. }
  200. }break;
  201. case _FN_LIGHT_KEYBOARD: {
  202. //dv->_Serial->println("light keyboard");
  203. if(mode == KEY_PRESSED) {
  204. dv->Keyboard_state.backlight ++;
  205. if(dv->Keyboard_state.backlight >= 3) {
  206. dv->Keyboard_state.backlight = 0;
  207. }
  208. timer.resume();
  209. pwmWrite(PA8,backlight_vals[ dv->Keyboard_state.backlight ] );
  210. }
  211. }break;
  212. case _FN_KEY:
  213. if(mode == KEY_PRESSED){
  214. if(dv->Keyboard_state.fn.lock == 0){
  215. dv->Keyboard_state.fn_on = FN_LAYER;
  216. dv->Keyboard_state.fn.begin = k;
  217. }
  218. }else if(mode == KEY_RELEASED ) {
  219. if(dv->Keyboard_state.fn.lock == 0){
  220. for(int i=0;i<64;i++) {
  221. if(fn_actions[i] !=0) {
  222. k = keyboard_maps[dv->Keyboard_state.fn_on][i];
  223. dv->Keyboard->release(k);
  224. fn_actions[i] = 0;
  225. }
  226. }
  227. dv->Keyboard_state.fn_on = 0;
  228. }
  229. dv->Keyboard_state.fn.begin = 0;
  230. dv->Keyboard_state.fn.time = 0;
  231. }
  232. break;
  233. default:
  234. if(mode == KEY_PRESSED) {
  235. dv->Keyboard->press(k);
  236. }else if(mode == KEY_RELEASED) {
  237. dv->Keyboard->release(k);
  238. if(dv->Keyboard_state.fn_on > 0){
  239. fn_actions[addr] = 0;
  240. }
  241. }
  242. break;
  243. }
  244. /*
  245. press_any_key_to_release_lock(dv,&dv->Keyboard_state.ctrl,k,mode);
  246. press_any_key_to_release_lock(dv,&dv->Keyboard_state.alt,k,mode);
  247. press_any_key_to_release_lock(dv,&dv->Keyboard_state.shift,k,mode);
  248. press_any_key_to_release_lock(dv,&dv->Keyboard_state.fn,k,mode);
  249. */
  250. }
  251. void keypad_action(DEVTERM*dv,uint8_t col,uint8_t mode) {
  252. uint16_t k;
  253. if(dv->Keyboard_state.fn_on > 0){
  254. k = keys_maps[dv->Keyboard_state.fn_on][col];
  255. }else {
  256. k = keys_maps[dv->Keyboard_state.layer][col];
  257. }
  258. if(k == EMP){
  259. return;
  260. }
  261. if(dv->Keyboard_state.lock == 1) {
  262. return;
  263. }
  264. switch(k) {
  265. case _LEFT_SHIFT_KEY:
  266. case KEY_RIGHT_SHIFT:
  267. if(mode == KEY_PRESSED) {
  268. dv->Keyboard_state.sf_on = 1;
  269. if(dv->Keyboard_state.shift.lock == 0){
  270. dv->Keyboard->press(k);
  271. dv->Keyboard_state.shift.begin=k;
  272. }
  273. }else if(mode == KEY_RELEASED) {
  274. dv->Keyboard_state.sf_on = 0;
  275. if(dv->Keyboard_state.shift.lock == 0){
  276. dv->Keyboard->release(k);
  277. dv->Keyboard_state.shift.begin = 0;
  278. dv->Keyboard_state.shift.time = 0;
  279. }
  280. }
  281. break;
  282. case _JOYSTICK_UP:
  283. if(check_pd2() == HIGH) {
  284. k = KEY_UP_ARROW;
  285. if(mode == KEY_PRESSED) {
  286. dv->Keyboard->press(k);
  287. }else if(mode == KEY_RELEASED) {
  288. dv->Keyboard->release(k);
  289. }
  290. }else {
  291. if(mode == KEY_RELEASED){
  292. dv->Joystick->Y(511);
  293. }else {
  294. dv->Joystick->Y(0);
  295. }
  296. }
  297. break;
  298. case _JOYSTICK_DOWN:
  299. if(check_pd2() == HIGH) {
  300. k = KEY_DOWN_ARROW;
  301. if(mode == KEY_PRESSED) {
  302. dv->Keyboard->press(k);
  303. }else if(mode == KEY_RELEASED) {
  304. dv->Keyboard->release(k);
  305. }
  306. }else {
  307. if(mode == KEY_RELEASED){
  308. dv->Joystick->Y(511);
  309. }else {
  310. dv->Joystick->Y(1023);
  311. }
  312. }
  313. break;
  314. case _JOYSTICK_LEFT:
  315. if(check_pd2() == HIGH) {
  316. k = KEY_LEFT_ARROW;
  317. if(mode == KEY_PRESSED) {
  318. dv->Keyboard->press(k);
  319. }else if(mode == KEY_RELEASED) {
  320. dv->Keyboard->release(k);
  321. }
  322. }else {
  323. if(mode == KEY_RELEASED){
  324. dv->Joystick->X(511);
  325. }else {
  326. dv->Joystick->X(0);
  327. }
  328. }
  329. break;
  330. case _JOYSTICK_RIGHT:
  331. if(check_pd2() == HIGH) {
  332. k = KEY_RIGHT_ARROW;
  333. if(mode == KEY_PRESSED) {
  334. dv->Keyboard->press(k);
  335. }else if(mode == KEY_RELEASED) {
  336. dv->Keyboard->release(k);
  337. }
  338. }else {
  339. if(mode == KEY_RELEASED){
  340. dv->Joystick->X(511);
  341. }else {
  342. dv->Joystick->X(1023);
  343. }
  344. }
  345. break;
  346. case _JOYSTICK_A:
  347. if(check_pd2() == HIGH) {
  348. k = 'j';
  349. if(mode == KEY_PRESSED) {
  350. dv->Keyboard->press(k);
  351. }else if(mode == KEY_RELEASED) {
  352. dv->Keyboard->release(k);
  353. }
  354. }else {
  355. dv->Joystick->button(2,mode);
  356. }
  357. break;
  358. case _JOYSTICK_B:
  359. if(check_pd2() == HIGH) {
  360. k = 'k';
  361. if(mode == KEY_PRESSED) {
  362. dv->Keyboard->press(k);
  363. }else if(mode == KEY_RELEASED) {
  364. dv->Keyboard->release(k);
  365. }
  366. }else {
  367. dv->Joystick->button(3,mode);
  368. }
  369. break;
  370. case _JOYSTICK_X:
  371. if(check_pd2() == HIGH) {
  372. k = 'u';
  373. if(mode == KEY_PRESSED) {
  374. dv->Keyboard->press(k);
  375. }else if(mode == KEY_RELEASED) {
  376. dv->Keyboard->release(k);
  377. }
  378. }else {
  379. dv->Joystick->button(1,mode);
  380. }
  381. break;
  382. case _JOYSTICK_Y:
  383. if(check_pd2() == HIGH) {
  384. k = 'i';
  385. if(mode == KEY_PRESSED) {
  386. dv->Keyboard->press(k);
  387. }else if(mode == KEY_RELEASED) {
  388. dv->Keyboard->release(k);
  389. }
  390. }else {
  391. dv->Joystick->button(4,mode);
  392. }
  393. break;
  394. case _MOUSE_LEFT:
  395. if(mode == KEY_PRESSED){
  396. dv->Mouse->press(1);
  397. }else if(mode == KEY_RELEASED){
  398. dv->Mouse->release(1);
  399. }
  400. break;
  401. case _MOUSE_MID:
  402. if(mode == KEY_PRESSED) {
  403. dv->state->pressMiddleClick();
  404. }else {
  405. if(dv->state->getScrolled() == false){
  406. //if no scrolling happend ,do as a normal mid mouse key click
  407. dv->Mouse->click(MOUSE_MIDDLE);
  408. }
  409. dv->state->releaseMiddleClick();
  410. }
  411. break;
  412. case _MOUSE_RIGHT:
  413. if(mode == KEY_PRESSED){
  414. dv->Mouse->press(2);
  415. }else if(mode == KEY_RELEASED){
  416. dv->Mouse->release(2);
  417. }
  418. break;
  419. //_LEFT_CTRL_KEY,_CMD_KEY , _LEFT_ALT
  420. case _LEFT_CTRL_KEY:
  421. case KEY_RIGHT_CTRL:
  422. if(mode == KEY_PRESSED){
  423. if(dv->Keyboard_state.ctrl.lock == 0){
  424. dv->Keyboard->press(k);
  425. dv->Keyboard_state.ctrl.begin = k;
  426. }
  427. }else {
  428. if(dv->Keyboard_state.ctrl.lock == 0){
  429. dv->Keyboard->release(k);
  430. dv->Keyboard_state.ctrl.begin = 0;
  431. dv->Keyboard_state.ctrl.time = 0;
  432. }
  433. }
  434. break;
  435. case _LEFT_ALT:
  436. case KEY_RIGHT_ALT:
  437. if(mode == KEY_PRESSED){
  438. if(dv->Keyboard_state.alt.lock == 0){
  439. dv->Keyboard->press(k);
  440. dv->Keyboard_state.alt.begin=k;
  441. }
  442. }else {
  443. if(dv->Keyboard_state.alt.lock == 0){
  444. dv->Keyboard->release(k);
  445. dv->Keyboard_state.alt.begin = 0;
  446. dv->Keyboard_state.alt.time = 0;
  447. }
  448. }
  449. break;
  450. case _CMD_KEY:
  451. if(mode == KEY_PRESSED){
  452. dv->Keyboard->press(k);
  453. }else {
  454. dv->Keyboard->release(k);
  455. }
  456. break;
  457. case _TRACKBALL_BTN:
  458. if(mode == KEY_PRESSED){
  459. dv->Mouse->press(MOUSE_MIDDLE);
  460. }else if(mode == KEY_RELEASED){
  461. dv->Mouse->release(MOUSE_MIDDLE);
  462. }
  463. break;
  464. default:
  465. if(mode == KEY_PRESSED) {
  466. dv->Keyboard->press(k);
  467. }else if(mode == KEY_RELEASED) {
  468. dv->Keyboard->release(k);
  469. }
  470. break;
  471. }
  472. /*
  473. press_any_key_to_release_lock(dv,&dv->Keyboard_state.ctrl,k,mode);
  474. press_any_key_to_release_lock(dv,&dv->Keyboard_state.alt,k,mode);
  475. press_any_key_to_release_lock(dv,&dv->Keyboard_state.shift,k,mode);
  476. press_any_key_to_release_lock(dv,&dv->Keyboard_state.fn,k,mode);
  477. */
  478. }