CS 380 Lab 4 Keyboard Input Assigned 2/11/10 30 Points

Transcription

1 CS 380 ab 4 Keyboard Input Assigned 2/11/10 30 Points In this lab we will see how a kernel can get data from the keyboard. We will adapt code to allow us to perform a number of important operations. Part 1 Keyboards support one or more of three broad keyboard types. Each type has a value assigned to each key. These values are called scan codes. The default scan code supported by all modern keyboards is the Scan Code Set 2. The mapping for scan codes 1 and 2 are found in appendices A and B. The INTE 8042 microcontroller converts electrical signals from the keyboard and generates a series of make and break codes for each key. A make code is generated whenever a key is pressed. A break code is generated whenever a key is released. A repeat code is also generated when a key is held down longer than the typematic delay. We need to get the make code in order to determine which key/character was pressed. In addition, we need to know the state of the keyboard. For example, if the A key was pressed, was it pressed in combination with the shift or alt keys. Most make and break codes are one byte long. However, other codes are 2 to 4 bytes long. These longer make codes start with an E0, E1, or F0. Single byte break codes always have the most significant bit set to a 1. Getting a Scan Code Scan codes are obtained through interrupts or by polling. Since we haven t set up interrupts yet. We will need to use polling. To get a scan code from the INTE 8042, the byte is read from port 0x60. The byte may or not be ready to be read. In order to determine if the scan code is ready to be read, port 0x64 is read and the least significant bit is checked. If the bit is a zero then the scan code is not ready to be read. If the bit is a one then the scan code can be read from port 0x60. To read a byte from a port use the following function which uses inline assembly code: inline unsigned char inportb(unsigned short port) { unsigned char ret_val; asm volatile("inb %w1,%b0" : "=a"(ret_val) 1

2 ; : "d"(port)); return ret_val; Exercise Add the following functions to your kernel from ab 3: Function void putchar(char c); char getscancode(); Purpose Displays a character at the current cursor position and advance the cursor by one position. Returns a scan code form the keyboard Test these function in your kernel. When the user enters a character don t try to display that character. Instead, display a single character such as the pound symbol. Part 2 Scan codes are nice but need to be converted to determine what is the actual character. The table in Appendices A and B hints at how a function could be written to convert scan codes to characters. However, two functions have been provided to assist in this process: ScanCode2Ascii Converts scan codes to a short number SetsKybdState Sets up the state of the keyboard These two functions and related declarations are found in Appendix C. Exercise Incorporate these functions into your kernel so that you are able to read and display common ASCII characters. The general process will be to: 1) Use getscancode to get a scan code 2) Use SetsKybdState with the scan code to set the state 3) Check to see of the scan code is a break code, if so ignore it 4) Use ScanCode2Ascii to convert a valid scan code to a short value 5) Extract the ASCII character and display it using putchar 2

3 Appendix A - Keyboard Scan Codes: Set 1 Source: *All values are in hexadecimal 101-, 102-, and 104-key keyboards: KE Y MAK E BREA K KEY MAKE BREA K KEY MAK E BREA K A 1E 9E 9 0A 8A [ 1A 9A B 30 B0 ` INSER T E0,52 E0,D2 C 2E AE - 0C 8C HOME E0,47 E0,97 D 20 A0 = 0D 8D PG UP E0,49 E0,C9 E \ 2B AB DEET E E0,53 E0,D3 F 21 A1 BKSP 0E 8E END E0,4F E0,CF G 22 A2 SPACE 39 B9 PG DN E0,51 E0,D1 H 23 A3 TAB 0F 8F I CAPS 3A BA J 24 A4 K 25 A5 SHFT CTR 2A 1D AA 9D U D R E0,48 E0,C8 E0,4B E0,CB E0,50 E0,D0 E0,4D E0,CD 26 A6 GUI E0,5B E0,DB NUM 45 C5 M 32 B2 AT 38 B8 KP / E0,35 E0,B5 N 31 B1 O R SHFT R CTR 36 B6 KP * 37 B7 E0,1D E0,9D KP - 4A CA P R GUI E0,5C E0,DC KP + 4E CE Q R AT E0,38 E0,B8 KP EN E0,1C E0,9C R APPS E0,5D E0,DD KP. 53 D3 S 1F 9F ENTER 1C 9C KP 0 52 D2 T ESC KP 1 4F CF U F1 3B BB KP 2 50 D0 V 2F AF F2 3C BC KP 3 51 D1 W F3 3D BD KP 4 4B CB 3

4 X 2D AD F4 3E BE KP 5 4C CC Y F5 3F BF KP 6 4D CD Z 2C AC F6 40 C0 KP 7 47 C7 0 0B 8B F7 41 C1 KP 8 48 C F8 42 C2 KP 9 49 C F9 43 C3 ] 1B 9B F10 44 C4 ; 27 A F11 57 D7 ' 28 A F12 58 D8, 33 B PRNT SCRN SCRO PAUSE ACPI Scan Codes: E0,2A, E0,37 E0,B7, E0,AA. 34 B4 46 C6 / 35 B5 E1,1D,4 5 E1,9D,C 5 -NONE- Key Make Code Break Code Power E0, 5E E0, DE Sleep E0, 5F E0, DF Wake E0, 63 E0, E3 Windows Multimedia Scan Codes: Key Make Code Break Code Next Track E0, 19 E0, 99 Previous Track E0, 10 E0, 90 Stop E0, 24 E0, A4 Play/Pause E0, 22 E0, A2 Mute E0, 20 E0, A0 Volume Up E0, 30 E0, B0 Volume Down E0, 2E E0, AE Media Select E0, 6D E0, ED E0, 6C E0, EC Calculator E0, 21 E0, A1 My Computer E0, 6B E0, EB 4

5 WWW Search E0, 65 E0, E5 WWW Home E0, 32 E0, B2 WWW Back E0, 6A E0, EA WWW Forward E0, 69 E0, E9 WWW Stop E0, 68 E0, E8 WWW Refresh E0, 67 E0, E7 WWW Favorites E0, 66 E0, E6 5

6 Appendix B - Keyboard Scan Codes: Set 2 *All values are in hexadecimal 101-, 102-, and 104-key keyboards: KE Y MAK E BREA K KEY MAKE BREAK KEY MAK E BREAK A 1C F0,1C 9 46 F0,46 [ 54 FO,54 B 32 F0,32 ` 0E F0,0E INSER T E0,70 E0,F0,7 0 C 21 F0,21-4E F0,4E HOME E0,6C E0,F0,6 C D 23 F0,23 = 55 FO,55 PG UP E0,7D E0,F0,7 D E 24 F0,24 \ 5D F0,5D DEET E E0,71 E0,F0,7 1 F 2B F0,2B BKSP 66 F0,66 END E0,69 E0,F0,6 9 G 34 F0,34 SPACE 29 F0,29 PG DN E0,7A E0,F0,7 A H 33 F0,33 TAB 0D F0,0D I 43 F0,43 CAPS 58 F0,58 J 3B F0,3B K 42 F0,42 SHFT CTR 4B F0,4B GUI E0,1F 12 FO,12 14 FO,14 E0,F0,1 F U D R E0,F0,7 E0,75 5 E0,F0,6 E0,6B B E0,F0,7 E0,72 2 E0,F0,7 E0,74 4 NUM 77 F0,77 M 3A F0,3A AT 11 F0,11 KP / E0,4A E0,F0,4 A R N 31 F0,31 59 F0,59 KP * 7C F0,7C SHFT O 44 F0,44 R CTR E0,14 P 4D F0,4D R GUI E0,27 Q 15 F0,15 R AT E0,11 R 2D F0,2D APPS E0,2F E0,F0,1 4 E0,F0,2 7 E0,F0,1 1 E0,F0,2 F KP - 7B F0,7B KP + 79 F0,79 KP EN E0,5A E0,F0,5 A KP. 71 F0,71 S 1B F0,1B ENTER 5A F0,5A KP 0 70 F0,70 T 2C F0,2C ESC 76 F0,76 KP 1 69 F0,69 U 3C F0,3C F1 05 F0,05 KP 2 72 F0,72 V 2A F0,2A F2 06 F0,06 KP 3 7A F0,7A 6

7 W 1D F0,1D F3 04 F0,04 KP 4 6B F0,6B X 22 F0,22 F4 0C F0,0C KP 5 73 F0,73 Y 35 F0,35 F5 03 F0,03 KP 6 74 F0,74 Z 1A F0,1A F6 0B F0,0B KP 7 6C F0,6C 0 45 F0,45 F7 83 F0,83 KP 8 75 F0, F0,16 F8 0A F0,0A KP 9 7D F0,7D 2 1E F0,1E F9 01 F0,01 ] 5B F0,5B 3 26 F0,26 F10 09 F0,09 ; 4C F0,4C 4 25 F0,25 F11 78 F0,78 ' 52 F0,52 5 2E F0,2E F12 07 F0,07, 41 F0, F0,36 7 3D F0,3D PRNT SCRN SCRO 8 3E F0,3E PAUSE E0,12, E0,7C E0,F0, 7C,E0, F0, F0,49 7E F0,7E / 4A F0,4A E1,14,77, E1,F0,14, F0,77 -NONE- ACPI Scan Codes: Key Make Code Break Code Power E0, 37 E0, F0, 37 Sleep E0, 3F E0, F0, 3F Wake E0, 5E E0, F0, 5E Windows Multimedia Scan Codes: Key Make Code Break Code Next Track E0, 4D E0, F0, 4D Previous Track E0, 15 E0, F0, 15 Stop E0, 3B E0, F0, 3B Play/Pause E0, 34 E0, F0, 34 Mute E0, 23 E0, F0, 23 Volume Up E0, 32 E0, F0, 32 Volume Down E0, 21 E0, F0, 21 Media Select E0, 50 E0, F0, 50 E0, 48 E0, F0, 48 7

8 Calculator E0, 2B E0, F0, 2B My Computer E0, 40 E0, F0, 40 WWW Search E0, 10 E0, F0, 10 WWW Home E0, 3A E0, F0, 3A WWW Back E0, 38 E0, F0, 38 WWW Forward E0, 30 E0, F0, 30 WWW Stop E0, 28 E0, F0, 28 WWW Refresh E0, 20 E0, F0, 20 WWW Favorites E0, 18 E0, F0, 18 8

9 Appendix C /* ============================================================ This code is adapted from the keyboard GCC files ============================================================ */ typedef int typedef unsigned char typedef unsigned short int typedef unsigned long int #defineprivate static BOO; BYTE8; WORD16; DWORD32; #ifndef TRUE #definetrue 1 #endif #ifndef FASE #definefase 0 #endif #defineentries(a) (sizeof(a)/sizeof(a[0])) typedef struct STATE { BOO ins ; BOO rshift ; BOO lshift ; BOO alt ; BOO ctrl ; BOO caps ; BOO scrl ; BOO num ; attribute ((packed)) STATE ; #definekybd_sts_port 0x64 #definekybd_dat_port 0x60 #definekybd_dat_rdy 0x01 #definebreak_code 0x80 #definesize 20 PRIVATE STATE state ; /* Initialized to all FASE by loader */ 9

10 PRIVATE BYTE8 scan_codes[size] ; PRIVATE unsigned int nq = 0 ; PRIVATE unsigned int dq = 0 ; PRIVATE unsigned int count = 0 ; /* */ /* Scan code translation table. */ /* The incoming scan code from the keyboard selects a row. */ /* The modifier status selects the column. */ /* The word at the intersection of the two is the scan/ascii code to */ /* put into the PC's type ahead buffer. */ /* If the value fetched from the table is zero, then we do not put the */ /* character into the type ahead buffer. */ /* */ PRIVATE WORD16 scan_ascii[][8] = { /* norm, shft, ctrl, alt, num, caps, shcap, shnum */ /*--*/ {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*ESC*/ {0x011B, 0x011B, 0x011B, 0x011B, 0x011B, 0x011B, 0x011B, 0x011B, /*1!*/ {0x0231, 0x0221, 0x0000, 0x7800, 0x0231, 0x0231, 0x0231, 0x0321, {0x0332, 0x0340, 0x0300, 0x7900, 0x0332, 0x0332, 0x0332, 0x0332, /*3 #*/ {0x0433, 0x0423, 0x0000, 0x7A00, 0x0433, 0x0433, 0x0423, 0x0423, /*4 $*/ {0x0534, 0x0524, 0x0000, 0x7B00, 0x0534, 0x0534, 0x0524, 0x0524, /*5 %*/ {0x0635, 0x0625, 0x0000, 0x7C00, 0x0635, 0x0635, 0x0625, 0x0625, /*6 ^*/ {0x0736, 0x075E, 0x071E, 0x7D00, 0x0736, 0x0736, 0x075E, 0x075E, /*7 &*/ {0x0837, 0x0826, 0x0000, 0x7E00, 0x0837, 0x0837, 0x0826, 0x0826, /*8 **/ {0x0938, 0x092A, 0x0000, 0x7F00, 0x0938, 0x0938, 0x092A, 0x092A, /*9 (*/ {0x0A39, 0x0A28, 0x0000, 0x8000, 0x0A39, 0x0A39, 0x0A28, 0x0A28, /*0 )*/ {0x0B30, 0x0B29, 0x0000, 0x8100, 0x0B30, 0x0B30, 0x0B29, 0x0B29, /*- _*/ {0x0C2D, 0x0C5F, 0x0000, 0x8200, 0x0C2D, 0x0C2D, 0x0C5F, 0x0C5F, /*= +*/ {0x0D3D, 0x0D2B, 0x0000, 0x8300, 0x0D3D, 0x0D3D, 0x0D2B, 0x0D2B, /*bksp*/ {0x0E08, 0x0E08, 0x0E7F, 0x0000, 0x0E08, 0x0E08, 0x0E08, 0x0E08, /*Tab*/ {0x0F09, 0x0F00, 0x0000, 0x0000, 0x0F09, 0x0F09, 0x0F00, 0x0F00, /*Q*/ {0x1071, 0x1051, 0x1011, 0x1000, 0x1071, 0x1051, 0x1051, 0x1071, /*W*/ {0x1177, 0x1057, 0x1017, 0x1100, 0x1077, 0x1057, 0x1057, 0x1077, /*E*/ {0x1265, 0x1245, 0x1205, 0x1200, 0x1265, 0x1245, 0x1245, 0x1265, /*R*/ {0x1372, 0x1352, 0x1312, 0x1300, 0x1272, 0x1252, 0x1252, 0x1272, /*T*/ {0x1474, 0x1454, 0x1414, 0x1400, 0x1474, 0x1454, 0x1454, 0x1474, /*Y*/ {0x1579, 0x1559, 0x1519, 0x1500, 0x1579, 0x1559, 0x1579, 0x1559, /*U*/ {0x1675, 0x1655, 0x1615, 0x1600, 0x1675, 0x1655, 0x1675, 0x1655, /*I*/ {0x1769, 0x1749, 0x1709, 0x1700, 0x1769, 0x1749, 0x1769, 0x1749, /*O*/ {0x186F, 0x184F, 0x180F, 0x1800, 0x186F, 0x184F, 0x186F, 0x184F, /*P*/ {0x1970, 0x1950, 0x1910, 0x1900, 0x1970, 0x1950, 0x1970, 0x1950, /*[ {*/ {0x1A5B, 0x1A7B, 0x1A1B, 0x0000, 0x1A5B, 0x1A5B, 0x1A7B, 0x1A7B, /*] */ {0x1B5D, 0x1B7D, 0x1B1D, 0x0000, 0x1B5D, 0x1B5D, 0x1B7D, 0x1B7D, /*entr*/ {0x1C0D, 0x1C0D, 0x1C0A, 0x0000, 0x1C0D, 0x1C0D, 0x1C0A, 0x1C0A, /*ctrl*/ {0x1D00, 0x1D00, 0x1D00, 0x1D00, 0x1D00, 0x1D00, 0x1D00, 0x1D00, /*A*/ {0x1E61, 0x1E41, 0x1E01, 0x1E00, 0x1E61, 0x1E41, 0x1E61, 0x1E41, /*S*/ {0x1F73, 0x1F53, 0x1F13, 0x1F00, 0x1F73, 0x1F53, 0x1F73, 0x1F53, /*D*/ {0x2064, 0x2044, 0x2004, 0x2000, 0x2064, 0x2044, 0x2064, 0x2044, /*F*/ {0x2166, 0x2146, 0x2106, 0x2100, 0x2166, 0x2146, 0x2166, 0x2146, /*G*/ {0x2267, 0x2247, 0x2207, 0x2200, 0x2267, 0x2247, 0x2267, 0x2247, /*H*/ {0x2368, 0x2348, 0x2308, 0x2300, 0x2368, 0x2348, 0x2368, 0x2348, /*J*/ {0x246A, 0x244A, 0x240A, 0x2400, 0x246A, 0x244A, 0x246A, 0x244A, 10

11 /*K*/ {0x256B, 0x254B, 0x250B, 0x2500, 0x256B, 0x254B, 0x256B, 0x254B, /**/ {0x266C, 0x264C, 0x260C, 0x2600, 0x266C, 0x264C, 0x266C, 0x264C, /*; :*/ {0x273B, 0x273A, 0x0000, 0x0000, 0x273B, 0x273B, 0x273A, 0x273A, /*' "*/ {0x2827, 0x2822, 0x0000, 0x0000, 0x2827, 0x2827, 0x2822, 0x2822, /*` ~*/ {0x2960, 0x297E, 0x0000, 0x0000, 0x2960, 0x2960, 0x297E, 0x297E, /*Shf*/ {0x2A00, 0x2A00, 0x2A00, 0x2A00, 0x2A00, 0x2A00, 0x2A00, 0x2A00, /*\ */ {0x2B5C, 0x2B7C, 0x2B1C, 0x0000, 0x2B5C, 0x2B5C, 0x2B7C, 0x2B7C, /*Z*/ {0x2C7A, 0x2C5A, 0x2C1A, 0x2C00, 0x2C7A, 0x2C5A, 0x2C7A, 0x2C5A, /*X*/ {0x2D78, 0x2D58, 0x2D18, 0x2D00, 0x2D78, 0x2D58, 0x2D78, 0x2D58, /*C*/ {0x2E63, 0x2E43, 0x2E03, 0x2E00, 0x2E63, 0x2E43, 0x2E63, 0x2E43, /*V*/ {0x2F76, 0x2F56, 0x2F16, 0x2F00, 0x2F76, 0x2F56, 0x2F76, 0x2F56, /*B*/ {0x3062, 0x3042, 0x3002, 0x3000, 0x3062, 0x3042, 0x3062, 0x3042, /*N*/ {0x316E, 0x314E, 0x310E, 0x3100, 0x316E, 0x314E, 0x316E, 0x314E, /*M*/ {0x326D, 0x324D, 0x320D, 0x3200, 0x326D, 0x324D, 0x326D, 0x324D, /*, <*/ {0x332C, 0x333C, 0x0000, 0x0000, 0x332C, 0x332C, 0x333C, 0x333C, /*. >*/ {0x342E, 0x343E, 0x0000, 0x0000, 0x342E, 0x342E, 0x343E, 0x343E, /*/?*/ {0x352F, 0x353F, 0x0000, 0x0000, 0x352F, 0x352F, 0x353F, 0x353F, /*rshf*/ {0x3600, 0x3600, 0x3600, 0x3600, 0x3600, 0x3600, 0x3600, 0x3600, /** PS*/ {0x372A, 0x0000, 0x3710, 0x0000, 0x372A, 0x372A, 0x0000, 0x0000, /*alt*/ {0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, /*spc*/ {0x3920, 0x3920, 0x3920, 0x0000, 0x3920, 0x3920, 0x3920, 0x3920, /*caps*/ {0x3A00, 0x3A00, 0x3A00, 0x3A00, 0x3A00, 0x3A00, 0x3A00, 0x3A00, /*F1*/ {0x3B00, 0x5400, 0x5E00, 0x6800, 0x3B00, 0x3B00, 0x5400, 0x5400, /*F2*/ {0x3C00, 0x5500, 0x5F00, 0x6900, 0x3C00, 0x3C00, 0x5500, 0x5500, /*F3*/ {0x3D00, 0x5600, 0x6000, 0x6A00, 0x3D00, 0x3D00, 0x5600, 0x5600, /*F4*/ {0x3E00, 0x5700, 0x6100, 0x6B00, 0x3E00, 0x3E00, 0x5700, 0x5700, /*F5*/ {0x3F00, 0x5800, 0x6200, 0x6C00, 0x3F00, 0x3F00, 0x5800, 0x5800, /*F6*/ {0x4000, 0x5900, 0x6300, 0x6D00, 0x4000, 0x4000, 0x5900, 0x5900, /*F7*/ {0x4100, 0x5A00, 0x6400, 0x6E00, 0x4100, 0x4100, 0x5A00, 0x5A00, /*F8*/ {0x4200, 0x5B00, 0x6500, 0x6F00, 0x4200, 0x4200, 0x5B00, 0x5B00, /*F9*/ {0x4300, 0x5C00, 0x6600, 0x7000, 0x4300, 0x4300, 0x5C00, 0x5C00, /*F10*/ {0x4400, 0x5D00, 0x6700, 0x7100, 0x4400, 0x4400, 0x5D00, 0x5D00, /*num*/ {0x4500, 0x4500, 0x4500, 0x4500, 0x4500, 0x4500, 0x4500, 0x4500, /*scrl*/ {0x4600, 0x4600, 0x4600, 0x4600, 0x4600, 0x4600, 0x4600, 0x4600, /*home*/ {0x4700, 0x4737, 0x7700, 0x0000, 0x4737, 0x4700, 0x4737, 0x4700, /*up*/ {0x4800, 0x4838, 0x0000, 0x0000, 0x4838, 0x4800, 0x4838, 0x4800, /*pgup*/ {0x4900, 0x4939, 0x8400, 0x0000, 0x4939, 0x4900, 0x4939, 0x4900, /*-*/ {0x4A2D, 0x4A2D, 0x0000, 0x0000, 0x4A2D, 0x4A2D, 0x4A2D, 0x4A2D, /*left*/ {0x4B00, 0x4B34, 0x7300, 0x0000, 0x4B34, 0x4B00, 0x4B34, 0x4B00, /*Cntr*/ {0x4C00, 0x4C35, 0x0000, 0x0000, 0x4C35, 0x4C00, 0x4C35, 0x4C00, /*rght*/ {0x4D00, 0x4D36, 0x7400, 0x0000, 0x4D36, 0x4D00, 0x4D36, 0x4D00, /*+*/ {0x4E2B, 0x4E2B, 0x0000, 0x0000, 0x4E2B, 0x4E2B, 0x4E2B, 0x4E2B, /*end*/ {0x4F00, 0x4F31, 0x7500, 0x0000, 0x4F31, 0x4F00, 0x4F31, 0x4F00, /*down*/ {0x5000, 0x5032, 0x0000, 0x0000, 0x5032, 0x5000, 0x5032, 0x5000, /*pgdn*/ {0x5100, 0x5133, 0x7600, 0x0000, 0x5133, 0x5100, 0x5133, 0x5100, /*ins*/ {0x5200, 0x5230, 0x0000, 0x0000, 0x5230, 0x5200, 0x5230, 0x5200, /*del*/ {0x5300, 0x532E, 0x0000, 0x0000, 0x532E, 0x5300, 0x532E, 0x5300, /*--*/ {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*--*/ {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*--*/ {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /*F11*/ {0x5700, 0x0000, 0x0000, 0x0000, 0x5700, 0x5700, 0x0000, 0x0000, /*F12*/ {0x5800, 0x0000, 0x0000, 0x0000, 0x5800, 0x5800, 0x0000, 0x0000 ; WORD16 ScanCode2Ascii(BYTE8 code) { if (code == 0xE0 code == 0xE1) return 0x0000 ; /* ignore */ if (code & 0x80) return code << 8 ; /* KeyUp */ 11

12 if (code >= ENTRIES(scan_ascii)) return 0x0000 ; /* ignore */ if (state.alt) return scan_ascii[code][3] ; if (state.ctrl) return scan_ascii[code][2] ; if (code >= 0x47) { if (state.num) { if (state.lshift state.rshift) { return scan_ascii[code][7] ; return scan_ascii[code][4] ; else if (state.caps) { if (state.lshift state.rshift) { return scan_ascii[code][6] ; return scan_ascii[code][5] ; if (state.lshift state.rshift) { return scan_ascii[code][1] ; return scan_ascii[code][0] ; BOO SetsKybdState(BYTE8 code) { switch (code) { case 0x36: state.rshift = TRUE ; break ; case 0xB6: state.rshift = FASE ; break ; case 0x2A: state.lshift = TRUE ; break ; case 0xAA: state.lshift = FASE ; break ; case 0x38: state.alt = TRUE ; break ; case 0xB8: state.alt = FASE ; break ; case 0x1D: state.ctrl = TRUE ; break ; case 0x9D: state.ctrl = FASE ; break ; case 0x3A: state.caps =!state.caps ; case 0xBA: break ; case 0x46: state.scrl =!state.scrl ; case 0xC6: break ; 12

13 return TRUE ; case 0x45: state.num =!state.num ; case 0xC5: break ; case 0x52: state.ins =!state.ins ; case 0xD2: break ; default: return FASE ; 13

14 ASCII Table Decimal Octal Hex Binary Value NU (Null char.) SOH (Start of Header) STX (Start of Text) ETX (End of Text) EOT (End of Transmission) ENQ (Enquiry) ACK (Acknowledgment) BE (Bell) BS (Backspace) HT (Horizontal Tab) A F (ine Feed) B VT (Vertical Tab) C FF (Form Feed) D CR (Carriage Return) E SO (Shift Out) F SI (Shift In) DE (Data ink Escape) DC1 (XON) (Device Control 1) DC2 (Device Control 2) DC3 (XOFF)(Device Control 3) DC4 (Device Control 4) NAK (Negative Acknowledgement) SYN (Synchronous Idle) ETB (End of Trans. Block) CAN (Cancel) EM (End of Medium) A SUB (Substitute) B ESC (Escape) C FS (File Separator) D GS (Group Separator) E RS (Request to Send)(Record Separator) F US (Unit Separator) SP (Space) ! (exclamation mark) " (double quote) # (number sign) $ (dollar sign) % (percent) & (ampersand) ' (single quote) ( (left/opening parenthesis) ) (right/closing parenthesis) A * (asterisk) B (plus) C , (comma) D (minus or dash) E (dot) F / (forward slash) A : (colon) B ; (semi-colon) C < (less than) D = (equal sign) E > (greater than) F ? (question mark) (AT symbol) 14

15 A B C D E F G H I A J B K C D M E N F O P Q R S T U V W X Y A Z B [ (left/opening bracket) C \ (back slash) D ] (right/closing bracket) E ^ (caret/cirumflex) F _ (underscore) ` a b c d e f g h i A j B k C l D m E n F o p q r s t u v w x y A z B { (left/opening brace) C (vertical bar) D (right/closing brace) E ~ (tilde) F DE (delete) 15