-
Notifications
You must be signed in to change notification settings - Fork 31
Expand file tree
/
Copy pathlib.rs
More file actions
2887 lines (2718 loc) · 103 KB
/
lib.rs
File metadata and controls
2887 lines (2718 loc) · 103 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//! Driver for a PS/2 PC keyboard.
//!
//! Supports PS/2 Scan Code Set 1 and 2, on a variety of keyboard layouts. See
//! [the OSDev Wiki](https://wiki.osdev.org/PS/2_Keyboard).
//!
//! ## Supports:
//!
//! - Scancode Set 1 (from the i8042 PC keyboard controller)
//! - Scancode Set 2 (direct from the AT or PS/2 interface keyboard)
//! - Several keyboard layouts:
//!
//! | Name | No. Keys | Description | Link |
//! | --------------------------------------- | -------- | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------- |
//! | [`Us104Key`](layouts::Us104Key) | 101/104 | North American standard English | [Wikipedia](https://en.wikipedia.org/wiki/QWERTY#United_States) |
//! | [`Uk105Key`](layouts::Uk105Key) | 102/105 | United Kingdom standard English | [Wikipedia](https://en.wikipedia.org/wiki/QWERTY#United_Kingdom) |
//! | [`Azerty`](layouts::Azerty) | 102/105 | Typically used in French locales | [Wikipedia](https://en.wikipedia.org/wiki/AZERTY) |
//! | [`De105Key`](layouts::De105Key) | 102/105 | German layout | [Wikipedia](https://en.wikipedia.org/wiki/QWERTZ) |
//! | [`FiSe105Key`](layouts::FiSe105Key) | 102/105 | Finnish/Swedish layout | [Wikipedia](https://en.wikipedia.org/wiki/QWERTY#Finnish%E2%80%93Swedish) |
//! | [`No105Key`](layouts::No105Key) | 102/105 | Norwegian layout | [Wikipedia](https://en.wikipedia.org/wiki/QWERTY#Norwegian) |
//! | [`Jis109Key`](layouts::Jis109Key) | 106/109 | JIS 109-key layout (Latin chars only) | [Wikipedia](https://en.wikipedia.org/wiki/Japanese_input_method#Japanese_keyboards) |
//! | [`Colemak`](layouts::Colemak) | 101/104 | A keyboard layout designed to make typing more efficient and comfortable | [Wikipedia](https://en.wikipedia.org/wiki/Colemak) |
//! | [`Dvorak104Key`](layouts::Dvorak104Key) | 101/104 | The more 'ergonomic' alternative to QWERTY | [Wikipedia](https://en.wikipedia.org/wiki/Dvorak_keyboard_layout) |
//! | [`DVP104Key`](layouts::DVP104Key) | 101/104 | Dvorak for Programmers | [Wikipedia](https://en.wikipedia.org/wiki/Dvorak_keyboard_layout#Programmer_Dvorak) |
//!
//! 101/104 keys is ANSI layout (wide Enter key) and 102/105 keys is ISO layout
//! (tall Enter key). The difference between 101 and 104 (and between 102 and
//! 105) comes from the two Windows keys and the Menu key that were added when
//! Windows 95 came out. JIS keyboards have extra keys, added by making the
//! space-bar and backspace keys shorter.
//!
//! ## Usage
//!
//! There are three basic steps to handling keyboard input. Your application
//! may bypass some of these.
//!
//! * `Ps2Decoder` - converts 11-bit PS/2 words into bytes, removing the start/stop
//! bits and checking the parity bits. Only needed if you talk to the PS/2
//! keyboard over GPIO pins and not required if you talk to the i8042 PC keyboard
//! controller.
//! * `ScancodeSet` - converts from Scancode Set 1 (i8042 PC keyboard controller) or
//! Scancode Set 2 (raw PS/2 keyboard output) into a symbolic `KeyCode` and an
//! up/down `KeyState`.
//! * `EventDecoder` - converts symbolic `KeyCode` and `KeyState` into a
//! Unicode characters (where possible) according to the currently selected
//! `KeyboardLayout`.
//!
//! There is also `PS2Keyboard` which combines the above three functions into a
//! single object.
//!
//! See the [`examples`](./examples) folder for more details.
//!
//! ## Keycodes
//!
//! This crate uses symbolic keycodes to abstract over Scancode Set 1 and
//! Scancode Set 2. They represented by the `KeyCode` enum. The scancodes can
//! come from one of three supported physical keyboard layouts: 102/105 key
//! ISO, 101/104 key ANSI and 106/109-key JIS. Note that the symbolic
//! keycodes for letter keys are named after how the keys are used on a US or
//! UK English Keyboard. If you use a French AZERTY layout, the `KeyCode::Q`
//! key will produce the Unicode character `'A'`.
//!
//! ### 102/105 key [ISO](PhysicalKeyboard::Iso)
//!
//! This is the mapping of `KeyCode` to a 102/105-key ISO keyboard:
//!
//! ```text
//! ┌────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┐
//! │Esc │ │ F1 │ F2 │ F3 │ F4 │ │ F5 │ F6 │ F7 │ F8 │ │ F9 │F10 │F11 │F12 │ │PrSc│Scrl│PBrk│
//! └────┘ └────┴────┴────┴────┘ └────┴────┴────┴────┘ └────┴────┴────┴────┘ └────┴────┴────┘
//!
//! ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬─────────┐ ┌────┬────┬────┐ ┌────┬────┬────┬────┐
//! │Oem8│Key1│Key2│Key3│Key4│Key5│Key6│Key7│Key8│Key9│Key0│Oem─│Oem+│Backspace│ │Inse│Home│PgUp│ │NumL│Num/│Num*│Num─│
//! ├────┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬────────┤ ├────┼────┼────┤ ├────┼────┼────┼────┤
//! │ Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │Oem4│Oem6│ Enter │ │Dele│End │PgDo│ │Num7│Num8│Num9│ │
//! ├─────┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┐ │ └────┴────┴────┘ ├────┼────┼────┤Num+│
//! │CapsLo│ A │ S │ D │ F │ G │ H │ J │ K │ L │Oem1│Oem3│Oem7│ │ │Num4│Num5│Num6│ │
//! ├────┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴────┴───────┤ ┌────┐ ├────┼────┼────┼────┤
//! │LShf│Oem5│ Z │ X │ C │ V │ B │ N │ M │OemC│OemP│Oem2│ RShift │ │ Up │ │Num1│Num2│Num3│ │
//! ├────┴┬───┴─┬──┴──┬─┴────┴────┴────┴────┴────┴───┬┴────┼────┴┬──────┬──────┤ ┌────┼────┼────┐ ├────┴────┼────┤Num │
//! │LCtrl│LWin │ Alt │ Space │AltGr│RWin │ Menu │RCtrl │ │Left│Down│Righ│ │Num0 │NumP│Ente│
//! └─────┴─────┴─────┴──────────────────────────────┴─────┴─────┴──────┴──────┘ └────┴────┴────┘ └─────────┴────┴────┘
//! ```
//!
//! The 102-key is missing `LWin`, `RWin`, and `Menu`.
//!
//! (Reference: <https://kbdlayout.info/KBDUK/scancodes+virtualkeys?arrangement=ISO105>)
//!
//! ### 101/104 key [ANSI](PhysicalKeyboard::Ansi)
//!
//! This is the mapping of `KeyCode` to a 101/104-key ANSI keyboard:
//!
//! ```text
//! ┌────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┐
//! │Esc │ │ F1 │ F2 │ F3 │ F4 │ │ F5 │ F6 │ F7 │ F8 │ │ F9 │F10 │F11 │F12 │ │PrSc│Scrl│PBrk│
//! └────┘ └────┴────┴────┴────┘ └────┴────┴────┴────┘ └────┴────┴────┴────┘ └────┴────┴────┘
//!
//! ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬─────────┐ ┌────┬────┬────┐ ┌────┬────┬────┬────┐
//! │Oem8│Key1│Key2│Key3│Key4│Key5│Key6│Key7│Key8│Key9│Key0│Oem─│Oem+│Backspace│ │Inse│Home│PgUp│ │NumL│Num/│Num*│Num─│
//! ├────┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬────────┤ ├────┼────┼────┤ ├────┼────┼────┼────┤
//! │ Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │Oem4│Oem6│ Oem7 │ │Dele│End │PgDo│ │Num7│Num8│Num9│ │
//! ├─────┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴────────┤ └────┴────┴────┘ ├────┼────┼────┤Num+│
//! │CapsLo│ A │ S │ D │ F │ G │ H │ J │ K │ L │Oem1│Oem3│ Enter │ │Num4│Num5│Num6│ │
//! ├──────┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴────────────┤ ┌────┐ ├────┼────┼────┼────┤
//! │ LShift │ Z │ X │ C │ V │ B │ N │ M │OemC│OemP│Oem2│ RShift │ │ Up │ │Num1│Num2│Num3│ │
//! ├─────┬───┴─┬──┴──┬─┴────┴────┴────┴────┴────┴───┬┴────┼────┴┬──────┬──────┤ ┌────┼────┼────┐ ├────┴────┼────┤Num │
//! │LCtrl│LWin │ Alt │ Space │AltGr│RWin │ Menu │RCtrl │ │Left│Down│Righ│ │Num0 │NumP│Ente│
//! └─────┴─────┴─────┴──────────────────────────────┴─────┴─────┴──────┴──────┘ └────┴────┴────┘ └─────────┴────┴────┘
//! ```
//!
//! Note that the `Oem5` key is missing on the 104-key ANSI keyboard.
//!
//! The 101-key is also missing `LWin`, `RWin`, and `Menu`.
//!
//! (Reference: <https://kbdlayout.info/KBDUK/scancodes+virtualkeys?arrangement=ANSI104>)
//!
//! ### 106/109 key [JIS](PhysicalKeyboard::Jis)
//!
//! This is the mapping of `KeyCode` to a 106/109-key JIS keyboard:
//!
//! ```text
//! ┌────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┬────┐ ┌────┬────┬────┐
//! │Esc │ │ F1 │ F2 │ F3 │ F4 │ │ F5 │ F6 │ F7 │ F8 │ │ F9 │F10 │F11 │F12 │ │PrSc│Scrl│PBrk│
//! └────┘ └────┴────┴────┴────┘ └────┴────┴────┴────┘ └────┴────┴────┴────┘ └────┴────┴────┘
//!
//! ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐ ┌────┬────┬────┐ ┌────┬────┬────┬────┐
//! │Oem8│Key1│Key2│Key3│Key4│Key5│Key6│Key7│Key8│Key9│Key0│Oem─│Oem+│Om13│BkSp│ │Inse│Home│PgUp│ │NumL│Num/│Num*│Num─│
//! ├────┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬────────┤ ├────┼────┼────┤ ├────┼────┼────┼────┤
//! │ Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │Oem4│Oem6│ Enter │ │Dele│End │PgDo│ │Num7│Num8│Num9│ │
//! ├─────┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┐ │ └────┴────┴────┘ ├────┼────┼────┤Num+│
//! │CapsLo│ A │ S │ D │ F │ G │ H │ J │ K │ L │Oem1│Oem3│Oem7│ │ │Num4│Num5│Num6│ │
//! ├──────┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴────┴───────┤ ┌────┐ ├────┼────┼────┼────┤
//! │LShift │ Z │ X │ C │ V │ B │ N │ M │OemC│OemP│Oem2│Oem12 │RShift │ │ Up │ │Num1│Num2│Num3│ │
//! ├─────┬───┴─┬──┴──┬─┴───┬┴────┴────┴────┴────┴┬───┴─┬──┴──┬─┴──┬───┴┬──────┤ ┌────┼────┼────┐ ├────┴────┼────┤Num │
//! │LCtrl│LWin │LAlt │Oem9 │ Space Bar │Oem10│Oem11│RWin│Menu│RCtrl │ │Left│Down│Righ│ │Num0 │NumP│Ente│
//! └─────┴─────┴─────┴─────┴─────────────────────┴─────┴─────┴────┴────┴──────┘ └────┴────┴────┘ └─────────┴────┴────┘
//! ```
//!
//! Note that the `Oem5` is missing on the 109-key JIS layout, but `Oem9`
//! (Muhenkan), `Oem10` (Henkan/Zenkouho), `Oem11`
//! (Hiragana/Katakana), `Oem12` (Backslash) and `Oem13` (¥) are added.
//!
//! The 106-key is missing `LWin`, `RWin`, and `Menu`.
//!
//! (Reference: <https://kbdlayout.info/KBDUK/scancodes+virtualkeys?arrangement=OADG109A>)
//!
//! ### Conversion Table
//!
//! Scancode Set 1 and Scancode Set 2 can be losslessly converted. Indeed, this is
//! what the i8042 keyboard controller in your PC does - it takes Scancode Set 2
//! from the keyboard and provides Scancode Set 1 to the Operating System. This
//! allowed them to change the keyboard design without breaking compatibility with
//! any MS-DOS applications that read raw scancodes from the keyboard.
//!
//! This table shows the correspondence between our symbolic KeyCode, Scancode Set 1
//! and Scancode Set 2. Any codes prefixed `0xE0` or `0xE1` are *extended* multi-byte
//! scancodes. Typically these are keys that were not on the IBM PC and PC/XT
//! keyboards so they they were added in such a way that if you ignored the 0xE0,
//! you got a reasonable result anyway. For example `ArrowLeft` is `0xE04B` in
//! Scancode Set 1 because `Numpad4` is `0x4B` and that was the left-arrow key on an
//! IBM PC or PC/XT.
//!
//! | Symbolic Key | Scancode Set 1 | Scancode Set 2 | USB HID |
//! | -------------- | -------------- | -------------- | ------- |
//! | Escape | 0x01 | 0x76 | 0x29 |
//! | F1 | 0x3B | 0x05 | 0x3A |
//! | F2 | 0x3C | 0x06 | 0x3B |
//! | F3 | 0x3D | 0x04 | 0x3C |
//! | F4 | 0x3E | 0x0C | 0x3D |
//! | F5 | 0x3F | 0x03 | 0x3E |
//! | F6 | 0x40 | 0x0B | 0x3F |
//! | F7 | 0x41 | 0x83 | 0x40 |
//! | F8 | 0x42 | 0x0A | 0x41 |
//! | F9 | 0x43 | 0x01 | 0x42 |
//! | F10 | 0x44 | 0x09 | 0x43 |
//! | F11 | 0x57 | 0x78 | 0x44 |
//! | F12 | 0x58 | 0x07 | 0x45 |
//! | PrintScreen | 0xE037 | 0xE07C | 0x46 |
//! | SysRq | 0x54 | 0x7F | -- |
//! | ScrollLock | 0x46 | 0x7E | 0x47 |
//! | PauseBreak | -- | -- | 0x48 |
//! | - | -- | -- | -- |
//! | Oem8 | 0x29 | 0x0E | 0x35 |
//! | Key1 | 0x02 | 0x16 | 0x1E |
//! | Key2 | 0x03 | 0x1E | 0x1F |
//! | Key3 | 0x04 | 0x26 | 0x20 |
//! | Key4 | 0x05 | 0x25 | 0x21 |
//! | Key5 | 0x06 | 0x2E | 0x22 |
//! | Key6 | 0x07 | 0x36 | 0x23 |
//! | Key7 | 0x08 | 0x3D | 0x24 |
//! | Key8 | 0x09 | 0x3E | 0x25 |
//! | Key9 | 0x0A | 0x46 | 0x26 |
//! | Key0 | 0x0B | 0x45 | 0x27 |
//! | OemMinus | 0x0C | 0x4E | 0x2D |
//! | OemPlus | 0x0D | 0x55 | 0x2E |
//! | Backspace | 0x0E | 0x66 | 0x2A |
//! | Insert | 0xE052 | 0xE070 | 0x49 |
//! | Home | 0xE047 | 0xE06C | 0x4A |
//! | PageUp | 0xE049 | 0xE07D | 0x4B |
//! | NumpadLock | 0x45 | 0x77 | 0x53 |
//! | NumpadDivide | 0xE035 | 0xE04A | 0x54 |
//! | NumpadMultiply | 0x37 | 0x7C | 0x55 |
//! | NumpadSubtract | 0x4A | 0x7B | 0x56 |
//! | - | -- | -- | -- |
//! | Tab | 0x0F | 0x0D | 0x2B |
//! | Q | 0x10 | 0x15 | 0x14 |
//! | W | 0x11 | 0x1D | 0x1A |
//! | E | 0x12 | 0x24 | 0x08 |
//! | R | 0x13 | 0x2D | 0x15 |
//! | T | 0x14 | 0x2C | 0x17 |
//! | Y | 0x15 | 0x35 | 0x1C |
//! | U | 0x16 | 0x3C | 0x18 |
//! | I | 0x17 | 0x43 | 0x0C |
//! | O | 0x18 | 0x44 | 0x12 |
//! | P | 0x19 | 0x4D | 0x13 |
//! | Oem4 | 0x1A | 0x54 | 0x2F |
//! | Oem6 | 0x1B | 0x5B | 0x30 |
//! | Oem5 | 0x56 | 0x61 | 0x64 |
//! | Oem7 | 0x2B | 0x5D | 0x31 |
//! | Delete | 0xE053 | 0xE071 | 0x4C |
//! | End | 0xE04F | 0xE069 | 0x4D |
//! | PageDown | 0xE051 | 0xE07A | 0x4E |
//! | Numpad7 | 0x47 | 0x6C | 0x5F |
//! | Numpad8 | 0x48 | 0x75 | 0x60 |
//! | Numpad9 | 0x49 | 0x7D | 0x61 |
//! | NumpadAdd | 0x4E | 0x79 | 0x57 |
//! | - | -- | -- | -- |
//! | CapsLock | 0x3A | 0x58 | 0x39 |
//! | A | 0x1E | 0x1C | 0x04 |
//! | S | 0x1F | 0x1B | 0x16 |
//! | D | 0x20 | 0x23 | 0x07 |
//! | F | 0x21 | 0x2B | 0x09 |
//! | G | 0x22 | 0x34 | 0x0A |
//! | H | 0x23 | 0x33 | 0x0B |
//! | J | 0x24 | 0x3B | 0x0D |
//! | K | 0x25 | 0x42 | 0x0E |
//! | L | 0x26 | 0x4B | 0x0F |
//! | Oem1 | 0x27 | 0x4C | 0x33 |
//! | Oem3 | 0x28 | 0x52 | 0x34 |
//! | Return | 0x1C | 0x5A | 0x28 |
//! | Numpad4 | 0x4B | 0x6B | 0x5C |
//! | Numpad5 | 0x4C | 0x73 | 0x5D |
//! | Numpad6 | 0x4D | 0x74 | 0x5E |
//! | - | -- | -- | -- |
//! | LShift | 0x2A | 0x12 | 0xE1 |
//! | Z | 0x2C | 0x1A | 0x1D |
//! | X | 0x2D | 0x22 | 0x1B |
//! | C | 0x2E | 0x21 | 0x06 |
//! | V | 0x2F | 0x2A | 0x19 |
//! | B | 0x30 | 0x32 | 0x05 |
//! | N | 0x31 | 0x31 | 0x11 |
//! | M | 0x32 | 0x3A | 0x10 |
//! | OemComma | 0x33 | 0x41 | 0x36 |
//! | OemPeriod | 0x34 | 0x49 | 0x37 |
//! | Oem2 | 0x35 | 0x4A | 0x38 |
//! | RShift | 0x36 | 0x59 | 0xE5 |
//! | ArrowUp | 0xE048 | 0xE075 | 0x52 |
//! | Numpad1 | 0x4F | 0x69 | 0x59 |
//! | Numpad2 | 0x50 | 0x72 | 0x5A |
//! | Numpad3 | 0x51 | 0x7A | 0x5B |
//! | NumpadEnter | 0xE01C | 0xE075 | 0x58 |
//! | - | -- | -- | -- |
//! | LControl | 0x1D | 0x14 | 0xE0 |
//! | LWin | 0xE05B | 0xE01F | 0xE3 |
//! | LAlt | 0x38 | 0x11 | 0xE2 |
//! | Spacebar | 0x39 | 0x29 | 0x2C |
//! | RAltGr | 0xE038 | 0xE011 | 0xE6 |
//! | RWin | 0xE05C | 0xE027 | 0xE7 |
//! | Apps | 0xE05C | 0xE02F | 0x65 |
//! | RControl | 0xE01D | 0xE014 | 0xE4 |
//! | ArrowLeft | 0xE04B | 0xE06B | 0x50 |
//! | ArrowDown | 0xE050 | 0xE072 | 0x51 |
//! | ArrowRight | 0xE04D | 0xE074 | 0x52 |
//! | Numpad0 | 0x52 | 0x70 | 0x62 |
//! | NumpadPeriod | 0x53 | 0x71 | 0x63 |
//! | - | -- | -- | -- |
//! | Oem9 | 0x7B | 0x67 | ?? |
//! | Oem10 | 0x79 | 0x64 | ?? |
//! | Oem11 | 0x70 | 0x13 | ?? |
//! | Oem12 | 0x73 | 0x51 | ?? |
//! | Oem13 | 0x7D | 0x6A | ?? |
//! | - | -- | -- | ?? |
//! | PrevTrack | 0xE010 | 0xE015 | ?? |
//! | NextTrack | 0xE019 | 0xE04D | ?? |
//! | Mute | 0xE020 | 0xE023 | ?? |
//! | Calculator | 0xE021 | 0xE02B | ?? |
//! | Play | 0xE022 | 0xE034 | ?? |
//! | Stop | 0xE024 | 0xE03B | ?? |
//! | VolumeDown | 0xE02E | 0xE021 | ?? |
//! | VolumeUp | 0xE030 | 0xE032 | ?? |
//! | WWWHome | 0xE032 | 0xE03A | ?? |
//! | TooManyKeys | -- | 0x00 | ?? |
//! | PowerOnTestOk | -- | 0xAA | ?? |
//! | RControl2 | 0xE11D | 0xE114 | ?? |
//! | RAlt2 | 0xE02A | 0xE012 | ?? |
//!
//! __Note 1:__ `PauseBreak` does not have a scancode because it's something we infer from a
//! sequence of other keypresses (`NumLock` with `RControl2` held).
//!
//! __Note 2:__ `SysReq` doesn't have a key on the diagram, because the scancode is
//! only generated when you do `Alt` + `PrintScreen`.
#![cfg_attr(not(test), no_std)]
// ****************************************************************************
//
// Modules
//
// ****************************************************************************
pub mod layouts;
mod scancodes;
pub use crate::scancodes::{ScancodeSet1, ScancodeSet2, UsbModifiers};
// ****************************************************************************
//
// Public Types
//
// ****************************************************************************
/// Encapsulates decode/sampling logic, and handles state transitions and key events for PS/2 Keyboards
#[derive(Debug)]
pub struct PS2Keyboard<L, S>
where
S: ScancodeSet,
L: KeyboardLayout,
{
ps2_decoder: Ps2Decoder,
scancode_set: S,
event_decoder: EventDecoder<L>,
}
/// Handles decoding of IBM PS/2 Keyboard (and IBM PC/AT Keyboard) bit-streams.
#[derive(Debug)]
pub struct Ps2Decoder {
register: u16,
num_bits: u8,
}
/// Encapsulates HID frame handling, and handles state transitions and key events for USB HID Keyboards
#[derive(Debug)]
pub struct UsbKeyboard<L>
where
L: KeyboardLayout,
{
event_decoder: EventDecoder<L>,
last_report: UsbBootKeyboardReport,
}
/// A USB HID report as received from a keyboard in Boot Mode
#[derive(Debug, Clone, Default)]
pub struct UsbBootKeyboardReport {
/// Modifier Keys - the first byte in the report
pub modifiers: u8,
/// Keycodes - the last six bytes in the report
pub keys: [u8; 6],
}
/// An Iterator that produces ['KeyEvent'] values
pub struct UsbKeyEventIter<'parent, L>
where
L: KeyboardLayout,
{
parent: &'parent mut UsbKeyboard<L>,
new_report: UsbBootKeyboardReport,
}
/// An Iterator that produces ['DecodedKey'] values, using an [`EventDecoder`]
pub struct UsbDecodedKeyIter<'parent, L>
where
L: KeyboardLayout,
{
inner: UsbKeyEventIter<'parent, L>,
}
/// Converts KeyEvents into Unicode, according to the current Keyboard Layout
#[derive(Debug)]
pub struct EventDecoder<L>
where
L: KeyboardLayout,
{
handle_ctrl: HandleControl,
modifiers: Modifiers,
layout: L,
}
/// Indicates different error conditions.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[non_exhaustive]
pub enum Error {
BadStartBit,
BadStopBit,
ParityError,
UnknownKeyCode,
}
/// Keycodes that can be generated by a keyboard.
///
/// We use this enum to abstract over Scan Code Set 1 and Scan Code Set 2.
///
/// See <https://kbdlayout.info/kbduk/shiftstates+virtualkeys/base>
#[derive(Debug, PartialEq, Eq, Copy, Clone, PartialOrd, Ord)]
#[repr(u8)]
pub enum KeyCode {
// ========= Row 1 (the F-keys) =========
/// Top Left of the Keyboard
Escape,
/// Function Key F1
F1,
/// Function Key F2
F2,
/// Function Key F3
F3,
/// Function Key F4
F4,
/// Function Key F5
F5,
/// Function Key F6
F6,
/// Function Key F7
F7,
/// Function Key F8
F8,
/// Function Key F9
F9,
/// Function Key F10
F10,
/// Function Key F11
F11,
/// Function Key F12
F12,
/// The Print Screen Key
PrintScreen,
/// The Sys Req key (you get this keycode with Alt + PrintScreen)
SysRq,
/// The Scroll Lock key
ScrollLock,
/// The Pause/Break key
PauseBreak,
// ========= Row 2 (the numbers) =========
/// Symbol key to the left of `Key1`
Oem8,
/// Number Line, Digit 1
Key1,
/// Number Line, Digit 2
Key2,
/// Number Line, Digit 3
Key3,
/// Number Line, Digit 4
Key4,
/// Number Line, Digit 5
Key5,
/// Number Line, Digit 6
Key6,
/// Number Line, Digit 7
Key7,
/// Number Line, Digit 8
Key8,
/// Number Line, Digit 9
Key9,
/// Number Line, Digit 0
Key0,
/// US Minus/Underscore Key (right of 'Key0')
OemMinus,
/// US Equals/Plus Key (right of 'OemMinus')
OemPlus,
/// Backspace
Backspace,
/// Top Left of the Extended Block
Insert,
/// Top Middle of the Extended Block
Home,
/// Top Right of the Extended Block
PageUp,
/// The Num Lock key
NumpadLock,
/// The Numpad Divide (or Slash) key
NumpadDivide,
/// The Numpad Multiple (or Star) key
NumpadMultiply,
/// The Numpad Subtract (or Minus) key
NumpadSubtract,
// ========= Row 3 (QWERTY) =========
/// The Tab Key
Tab,
/// Letters, Top Row #1
Q,
/// Letters, Top Row #2
W,
/// Letters, Top Row #3
E,
/// Letters, Top Row #4
R,
/// Letters, Top Row #5
T,
/// Letters, Top Row #6
Y,
/// Letters, Top Row #7
U,
/// Letters, Top Row #8
I,
/// Letters, Top Row #9
O,
/// Letters, Top Row #10
P,
/// US ANSI Left-Square-Bracket key
Oem4,
/// US ANSI Right-Square-Bracket key
Oem6,
/// US ANSI Backslash Key / UK ISO Backslash Key
Oem5,
/// The UK/ISO Hash/Tilde key (ISO layout only)
Oem7,
/// The Delete key - bottom Left of the Extended Block
Delete,
/// The End key - bottom Middle of the Extended Block
End,
/// The Page Down key - -bottom Right of the Extended Block
PageDown,
/// The Numpad 7/Home key
Numpad7,
/// The Numpad 8/Up Arrow key
Numpad8,
/// The Numpad 9/Page Up key
Numpad9,
/// The Numpad Add/Plus key
NumpadAdd,
// ========= Row 4 (ASDF) =========
/// Caps Lock
CapsLock,
/// Letters, Middle Row #1
A,
/// Letters, Middle Row #2
S,
/// Letters, Middle Row #3
D,
/// Letters, Middle Row #4
F,
/// Letters, Middle Row #5
G,
/// Letters, Middle Row #6
H,
/// Letters, Middle Row #7
J,
/// Letters, Middle Row #8
K,
/// Letters, Middle Row #9
L,
/// The US ANSI Semicolon/Colon key
Oem1,
/// The US ANSI Single-Quote/At key
Oem3,
/// The Return Key
Return,
/// The Numpad 4/Left Arrow key
Numpad4,
/// The Numpad 5 Key
Numpad5,
/// The Numpad 6/Right Arrow key
Numpad6,
// ========= Row 5 (ZXCV) =========
/// Left Shift
LShift,
/// Letters, Bottom Row #1
Z,
/// Letters, Bottom Row #2
X,
/// Letters, Bottom Row #3
C,
/// Letters, Bottom Row #4
V,
/// Letters, Bottom Row #5
B,
/// Letters, Bottom Row #6
N,
/// Letters, Bottom Row #7
M,
/// US ANSI `,<` key
OemComma,
/// US ANSI `.>` Key
OemPeriod,
/// US ANSI `/?` Key
Oem2,
/// Right Shift
RShift,
/// The up-arrow in the inverted-T
ArrowUp,
/// Numpad 1/End Key
Numpad1,
/// Numpad 2/Arrow Down Key
Numpad2,
/// Numpad 3/Page Down Key
Numpad3,
/// Numpad Enter
NumpadEnter,
// ========= Row 6 (modifers and space bar) =========
/// The left-hand Control key
LControl,
/// The left-hand 'Windows' key
LWin,
/// The left-hand Alt key
LAlt,
/// The Space Bar
Spacebar,
/// The right-hand AltGr key
RAltGr,
/// The right-hand Win key
RWin,
/// The 'Apps' key (aka 'Menu' or 'Right-Click')
Apps,
/// The right-hand Control key
RControl,
/// The left-arrow in the inverted-T
ArrowLeft,
/// The down-arrow in the inverted-T
ArrowDown,
/// The right-arrow in the inverted-T
ArrowRight,
/// The Numpad 0/Insert Key
Numpad0,
/// The Numppad Period/Delete Key
NumpadPeriod,
// ========= JIS 109-key extra keys =========
/// Extra JIS key (0x7B)
Oem9,
/// Extra JIS key (0x79)
Oem10,
/// Extra JIS key (0x70)
Oem11,
/// Extra JIS symbol key (0x73)
Oem12,
/// Extra JIS symbol key (0x7D)
Oem13,
// ========= Extra Keys =========
/// Multi-media keys - Previous Track
PrevTrack,
/// Multi-media keys - Next Track
NextTrack,
/// Multi-media keys - Volume Mute Toggle
Mute,
/// Multi-media keys - Open Calculator
Calculator,
/// Multi-media keys - Play
Play,
/// Multi-media keys - Stop
Stop,
/// Multi-media keys - Increase Volume
VolumeDown,
/// Multi-media keys - Decrease Volume
VolumeUp,
/// Multi-media keys - Open Browser
WWWHome,
/// Sent when the keyboard boots
PowerOnTestOk,
/// Sent by the keyboard when too many keys are pressed
TooManyKeys,
/// Used as a 'hidden' Right Control Key (Pause = RControl2 + Num Lock)
RControl2,
/// Used as a 'hidden' Right Alt Key (Print Screen = RAlt2 + PrntScr)
RAlt2,
/// Represents a key we don't know about
Unknown,
}
/// The new state for a key, as part of a key event.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum KeyState {
/// Key has just been released
Up,
/// Key has just been pressed
Down,
/// Key was pressed and then released as an atomic action. Or it's like a
/// PowerOnSelfTest event which doesn't have an 'Up' or a 'Down'.
SingleShot,
}
/// Options for how we can handle what happens when the Ctrl key is held down
/// and a letter is pressed.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum HandleControl {
/// If either Ctrl key is held down, convert the letters A through Z into
/// Unicode chars U+0001 through U+001A. If the Ctrl keys are not held
/// down, letters go through normally.
MapLettersToUnicode,
/// Don't do anything special - send through the Ctrl key up/down events,
/// and leave the letters as letters.
Ignore,
}
/// A event describing something happen to a key on your keyboard.
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct KeyEvent {
/// Which key this event is for
pub code: KeyCode,
/// The new state for the key
pub state: KeyState,
}
/// Describes a physical keyboard
pub enum PhysicalKeyboard {
/// 102 or 105 key ISO, as used by UK English keyboards (and others)
Iso,
/// 101 or 104 key ANSI, as used by US English keyboards (and others)
Ansi,
/// 106 or 109 key JIS, as used by Japanese keyboards (and others)
Jis,
}
/// Describes a Keyboard Layout.
///
/// Layouts might include "en_US", or "en_GB", or "de_GR".
pub trait KeyboardLayout {
/// Convert a `KeyCode` enum to a Unicode character, if possible.
/// `KeyCode::A` maps to `DecodedKey::Unicode('a')` (or
/// `DecodedKey::Unicode('A')` if shifted), while `KeyCode::LAlt` becomes
/// `DecodedKey::RawKey(KeyCode::LAlt)` because there's no Unicode equivalent.
fn map_keycode(
&self,
keycode: KeyCode,
modifiers: &Modifiers,
handle_ctrl: HandleControl,
) -> DecodedKey;
/// Which physical keyboard does this layout work on?
fn get_physical(&self) -> PhysicalKeyboard;
}
/// A mechanism to convert bytes from a Keyboard into [`KeyCode`] values.
///
/// This conversion is stateful.
pub trait ScancodeSet {
/// Handles the state logic for the decoding of scan codes into key events.
fn advance_state(&mut self, code: u8) -> Result<Option<KeyEvent>, Error>;
}
/// The set of modifier keys you have on a keyboard.
#[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
pub struct Modifiers {
/// The left shift key is down
pub lshift: bool,
/// The right shift key is down
pub rshift: bool,
/// The left control key is down
pub lctrl: bool,
/// The right control key is down
pub rctrl: bool,
/// The Num Lock toggle is on
pub numlock: bool,
/// The caps lock toggle is on
pub capslock: bool,
/// The left alt key is down
pub lalt: bool,
/// The right alt key is down
pub ralt: bool,
/// Special 'hidden' control key is down (used when you press Pause)
pub rctrl2: bool,
}
/// Contains either a Unicode character, or a raw key code.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum DecodedKey {
RawKey(KeyCode),
Unicode(char),
}
// ****************************************************************************
//
// Public Data
//
// ****************************************************************************
// None
// ****************************************************************************
//
// Private Types
//
// ****************************************************************************
/// Tracls
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum DecodeState {
Start,
Extended,
Release,
ExtendedRelease,
Extended2,
Extended2Release,
}
// ****************************************************************************
//
// Private Data
//
// ****************************************************************************
const KEYCODE_BITS: u8 = 11;
const EXTENDED_KEY_CODE: u8 = 0xE0;
const EXTENDED2_KEY_CODE: u8 = 0xE1;
const KEY_RELEASE_CODE: u8 = 0xF0;
const QUO: char = '\'';
const SLS: char = '\\';
// ****************************************************************************
//
// Public Functions and Implementation
//
// ****************************************************************************
impl<L, S> PS2Keyboard<L, S>
where
L: KeyboardLayout,
S: ScancodeSet,
{
/// Make a new Keyboard object with the given layout.
pub const fn new(scancode_set: S, layout: L, handle_ctrl: HandleControl) -> PS2Keyboard<L, S> {
PS2Keyboard {
ps2_decoder: Ps2Decoder::new(),
scancode_set,
event_decoder: EventDecoder::new(layout, handle_ctrl),
}
}
/// Get the current key modifier states.
pub const fn get_modifiers(&self) -> &Modifiers {
&self.event_decoder.modifiers
}
/// Change the Ctrl key mapping.
pub fn set_ctrl_handling(&mut self, new_value: HandleControl) {
self.event_decoder.set_ctrl_handling(new_value);
}
/// Get the current Ctrl key mapping.
pub const fn get_ctrl_handling(&self) -> HandleControl {
self.event_decoder.get_ctrl_handling()
}
/// Clears the bit register.
///
/// Call this when there is a timeout reading data from the keyboard.
pub fn clear(&mut self) {
self.ps2_decoder.clear();
}
/// Processes a 16-bit word from the keyboard.
///
/// * The start bit (0) must be in bit 0.
/// * The data octet must be in bits 1..8, with the LSB in bit 1 and the
/// MSB in bit 8.
/// * The parity bit must be in bit 9.
/// * The stop bit (1) must be in bit 10.
pub fn add_word(&mut self, word: u16) -> Result<Option<KeyEvent>, Error> {
let byte = self.ps2_decoder.add_word(word)?;
self.add_byte(byte)
}
/// Processes an 8-bit byte from the keyboard.
///
/// We assume the start, stop and parity bits have been processed and
/// verified.
pub fn add_byte(&mut self, byte: u8) -> Result<Option<KeyEvent>, Error> {
self.scancode_set.advance_state(byte)
}
/// Shift a bit into the register.
///
/// Call this /or/ call `add_word` - don't call both.
/// Until the last bit is added you get Ok(None) returned.
pub fn add_bit(&mut self, bit: bool) -> Result<Option<KeyEvent>, Error> {
if let Some(byte) = self.ps2_decoder.add_bit(bit)? {
self.scancode_set.advance_state(byte)
} else {
Ok(None)
}
}
/// Processes a `KeyEvent` returned from `add_bit`, `add_byte` or `add_word`
/// and produces a decoded key.
///
/// For example, the KeyEvent for pressing the '5' key on your keyboard
/// gives a DecodedKey of unicode character '5', unless the shift key is
/// held in which case you get the unicode character '%'.
pub fn process_keyevent(&mut self, ev: KeyEvent) -> Option<DecodedKey> {
self.event_decoder.process_keyevent(ev)
}
}
impl Ps2Decoder {
/// Build a new PS/2 protocol decoder.
pub const fn new() -> Ps2Decoder {
Ps2Decoder {
register: 0,
num_bits: 0,
}
}
/// Clears the bit register.
///
/// Call this when there is a timeout reading data from the keyboard.
pub fn clear(&mut self) {
self.register = 0;
self.num_bits = 0;
}
/// Shift a bit into the register.
///
/// Until the last bit is added you get Ok(None) returned.
pub fn add_bit(&mut self, bit: bool) -> Result<Option<u8>, Error> {
self.register |= (bit as u16) << self.num_bits;
self.num_bits += 1;
if self.num_bits == KEYCODE_BITS {
let word = self.register;
self.register = 0;
self.num_bits = 0;
let byte = Self::check_word(word)?;
Ok(Some(byte))
} else {
Ok(None)
}
}
/// Process an entire 11-bit word.
///
/// Must be packed into the bottom 11-bits of the 16-bit value.
pub fn add_word(&self, word: u16) -> Result<u8, Error> {
Self::check_word(word)
}
/// Check 11-bit word has 1 start bit, 1 stop bit and an odd parity bit.
const fn check_word(word: u16) -> Result<u8, Error> {
let start_bit = Self::get_bit(word, 0);
let parity_bit = Self::get_bit(word, 9);
let stop_bit = Self::get_bit(word, 10);
let data = ((word >> 1) & 0xFF) as u8;
if start_bit {
return Err(Error::BadStartBit);
}
if !stop_bit {
return Err(Error::BadStopBit);
}
// We have odd parity, so if there are an even number of 1 bits, we need
// the parity bit set to make it odd.
let need_parity = Self::has_even_number_bits(data);
if need_parity != parity_bit {
return Err(Error::ParityError);
}
Ok(data)
}
const fn get_bit(word: u16, offset: usize) -> bool {
((word >> offset) & 0x0001) != 0
}
const fn has_even_number_bits(data: u8) -> bool {
(data.count_ones() % 2) == 0
}
}
impl Default for Ps2Decoder {
fn default() -> Self {
Ps2Decoder::new()
}
}
impl<L> UsbKeyboard<L>
where
L: KeyboardLayout,
{
/// Construct USB HID keyboard handler
pub fn new(layout: L, handle_ctrl: HandleControl) -> UsbKeyboard<L> {
UsbKeyboard {
event_decoder: EventDecoder::new(layout, handle_ctrl),
last_report: Default::default(),
}
}