src/keyboard.c at rrdc-perf · doomsdayone/enhanced-x16-emulator

◆ rrdc-perf enhanced-x16-emulator / src / keyboard.c

5.1 KiB · C · last changed chore(): initial commit 25 days ago source blame history raw

#include <SDL.h>
#include <stdio.h>
#include <stdbool.h>
#include "glue.h"
#include "i2c.h"
#include "keyboard.h"

#define EXTENDED_FLAG 0x100
// #define ESC_IS_BREAK /* if enabled, Esc sends Break/Pause key instead of Esc */

int
keynum_from_SDL_Scancode(SDL_Scancode scancode)
{
	switch (scancode) {
		case SDL_SCANCODE_GRAVE:
			return 1;
		case SDL_SCANCODE_BACKSPACE:
			return 15;
		case SDL_SCANCODE_TAB:
			return 16;
		case SDL_SCANCODE_CLEAR:
			return 0;
		case SDL_SCANCODE_RETURN:
			return 43;
		case SDL_SCANCODE_PAUSE:
			return 126;
		case SDL_SCANCODE_ESCAPE:
#ifdef ESC_IS_BREAK
			return 126;
#else
			return 110;
#endif
		case SDL_SCANCODE_SPACE:
			return 61;
		case SDL_SCANCODE_APOSTROPHE:
			return 41;
		case SDL_SCANCODE_COMMA:
			return 53;
		case SDL_SCANCODE_MINUS:
			return 12;
		case SDL_SCANCODE_PERIOD:
			return 54;
		case SDL_SCANCODE_SLASH:
			return 55;
		case SDL_SCANCODE_0:
			return 11;
		case SDL_SCANCODE_1:
			return 2;
		case SDL_SCANCODE_2:
			return 3;
		case SDL_SCANCODE_3:
			return 4;
		case SDL_SCANCODE_4:
			return 5;
		case SDL_SCANCODE_5:
			return 6;
		case SDL_SCANCODE_6:
			return 7;
		case SDL_SCANCODE_7:
			return 8;
		case SDL_SCANCODE_8:
			return 9;
		case SDL_SCANCODE_9:
			return 10;
		case SDL_SCANCODE_SEMICOLON:
			return 40;
		case SDL_SCANCODE_EQUALS:
			return 13;
		case SDL_SCANCODE_LEFTBRACKET:
			return 27;
		case SDL_SCANCODE_BACKSLASH:
			return 29;
		case SDL_SCANCODE_RIGHTBRACKET:
			return 28;
		case SDL_SCANCODE_A:
			return 31;
		case SDL_SCANCODE_B:
			return 50;
		case SDL_SCANCODE_C:
			return 48;
		case SDL_SCANCODE_D:
			return 33;
		case SDL_SCANCODE_E:
			return 19;
		case SDL_SCANCODE_F:
			return 34;
		case SDL_SCANCODE_G:
			return 35;
		case SDL_SCANCODE_H:
			return 36;
		case SDL_SCANCODE_I:
			return 24;
		case SDL_SCANCODE_J:
			return 37;
		case SDL_SCANCODE_K:
			return 38;
		case SDL_SCANCODE_L:
			return 39;
		case SDL_SCANCODE_M:
			return 52;
		case SDL_SCANCODE_N:
			return 51;
		case SDL_SCANCODE_O:
			return 25;
		case SDL_SCANCODE_P:
			return 26;
		case SDL_SCANCODE_Q:
			return 17;
		case SDL_SCANCODE_R:
			return 20;
		case SDL_SCANCODE_S:
			return 32;
		case SDL_SCANCODE_T:
			return 21;
		case SDL_SCANCODE_U:
			return 23;
		case SDL_SCANCODE_V:
			return 49;
		case SDL_SCANCODE_W:
			return 18;
		case SDL_SCANCODE_X:
			return 47;
		case SDL_SCANCODE_Y:
			return 22;
		case SDL_SCANCODE_Z:
			return 46;
		case SDL_SCANCODE_DELETE:
			return 76;
		case SDL_SCANCODE_UP:
			return 83;
		case SDL_SCANCODE_DOWN:
			return 84;
		case SDL_SCANCODE_RIGHT:
			return 89;
		case SDL_SCANCODE_LEFT:
			return 79;
		case SDL_SCANCODE_INSERT:
			return 75;
		case SDL_SCANCODE_HOME:
			return 80;
		case SDL_SCANCODE_END:
			return 81;
		case SDL_SCANCODE_PAGEUP:
			return 85;
		case SDL_SCANCODE_PAGEDOWN:
			return 86;
		case SDL_SCANCODE_F1:
			return 112;
		case SDL_SCANCODE_F2:
			return 113;
		case SDL_SCANCODE_F3:
			return 114;
		case SDL_SCANCODE_F4:
			return 115;
		case SDL_SCANCODE_F5:
			return 116;
		case SDL_SCANCODE_F6:
			return 117;
		case SDL_SCANCODE_F7:
			return 118;
		case SDL_SCANCODE_F8:
			return 119;
		case SDL_SCANCODE_F9:
			return 120;
		case SDL_SCANCODE_F10:
			return 121;
		case SDL_SCANCODE_F11:
			return 122;
		case SDL_SCANCODE_F12:
			return 123;
		case SDL_SCANCODE_SCROLLLOCK:
			return 125;
		case SDL_SCANCODE_RSHIFT:
			return 57;
		case SDL_SCANCODE_LSHIFT:
			return 44;
		case SDL_SCANCODE_CAPSLOCK:
			return 30;
		case SDL_SCANCODE_LCTRL:
			return 58;
		case SDL_SCANCODE_RCTRL:
			return 64;
		case SDL_SCANCODE_LALT:
			return 60;
		case SDL_SCANCODE_RALT:
			return 62;
		case SDL_SCANCODE_LGUI:
			return 59;
		case SDL_SCANCODE_RGUI:
			return 63;
		case SDL_SCANCODE_APPLICATION: // Menu
			return 65;
		case SDL_SCANCODE_NONUSBACKSLASH:
			return 45;
		case SDL_SCANCODE_KP_ENTER:
			return 108;
		case SDL_SCANCODE_KP_0:
			return 99;
		case SDL_SCANCODE_KP_1:
			return 93;
		case SDL_SCANCODE_KP_2:
			return 98;
		case SDL_SCANCODE_KP_3:
			return 103;
		case SDL_SCANCODE_KP_4:
			return 92;
		case SDL_SCANCODE_KP_5:
			return 97;
		case SDL_SCANCODE_KP_6:
			return 102;
		case SDL_SCANCODE_KP_7:
			return 91;
		case SDL_SCANCODE_KP_8:
			return 96;
		case SDL_SCANCODE_KP_9:
			return 101;
		case SDL_SCANCODE_KP_PERIOD:
			return 104;
		case SDL_SCANCODE_KP_PLUS:
			return 106;
		case SDL_SCANCODE_KP_MINUS:
			return 105;
		case SDL_SCANCODE_KP_MULTIPLY:
			return 100;
		case SDL_SCANCODE_KP_DIVIDE:
			return 95;
		case SDL_SCANCODE_NUMLOCKCLEAR:
			return 90;
		case SDL_SCANCODE_INTERNATIONAL1:
			return 56;
		default:
			return 0;
	}
}

void
handle_keyboard(bool down, SDL_Keycode sym, SDL_Scancode scancode)
{
	int keynum = keynum_from_SDL_Scancode(scancode);
	
	if (keynum == 0) return;

	if (down) {
		if (log_keyboard) {
			printf("DOWN 0x%02X\n", scancode);
			fflush(stdout);
		}

		if (keynum & EXTENDED_FLAG) {
			i2c_kbd_buffer_add(0x7f);
		}
		i2c_kbd_buffer_add(keynum & 0xff);
	} else {
		if (log_keyboard) {
			printf("UP   0x%02X\n", scancode);
			fflush(stdout);
		}

		keynum = keynum | 0b10000000;
		if (keynum & EXTENDED_FLAG) {
			i2c_kbd_buffer_add(0xff);
		}
		i2c_kbd_buffer_add(keynum & 0xff);
	}
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1	#include <SDL.h>
2	#include <stdio.h>
3	#include <stdbool.h>
4	#include "glue.h"
5	#include "i2c.h"
6	#include "keyboard.h"
7
8	#define EXTENDED_FLAG 0x100
9	// #define ESC_IS_BREAK /* if enabled, Esc sends Break/Pause key instead of Esc */
10
11	int
12	keynum_from_SDL_Scancode(SDL_Scancode scancode)
13	{
14	switch (scancode) {
15	case SDL_SCANCODE_GRAVE:
16	return 1;
17	case SDL_SCANCODE_BACKSPACE:
18	return 15;
19	case SDL_SCANCODE_TAB:
20	return 16;
21	case SDL_SCANCODE_CLEAR:
22	return 0;
23	case SDL_SCANCODE_RETURN:
24	return 43;
25	case SDL_SCANCODE_PAUSE:
26	return 126;
27	case SDL_SCANCODE_ESCAPE:
28	#ifdef ESC_IS_BREAK
29	return 126;
30	#else
31	return 110;
32	#endif
33	case SDL_SCANCODE_SPACE:
34	return 61;
35	case SDL_SCANCODE_APOSTROPHE:
36	return 41;
37	case SDL_SCANCODE_COMMA:
38	return 53;
39	case SDL_SCANCODE_MINUS:
40	return 12;
41	case SDL_SCANCODE_PERIOD:
42	return 54;
43	case SDL_SCANCODE_SLASH:
44	return 55;
45	case SDL_SCANCODE_0:
46	return 11;
47	case SDL_SCANCODE_1:
48	return 2;
49	case SDL_SCANCODE_2:
50	return 3;
51	case SDL_SCANCODE_3:
52	return 4;
53	case SDL_SCANCODE_4:
54	return 5;
55	case SDL_SCANCODE_5:
56	return 6;
57	case SDL_SCANCODE_6:
58	return 7;
59	case SDL_SCANCODE_7:
60	return 8;
61	case SDL_SCANCODE_8:
62	return 9;
63	case SDL_SCANCODE_9:
64	return 10;
65	case SDL_SCANCODE_SEMICOLON:
66	return 40;
67	case SDL_SCANCODE_EQUALS:
68	return 13;
69	case SDL_SCANCODE_LEFTBRACKET:
70	return 27;
71	case SDL_SCANCODE_BACKSLASH:
72	return 29;
73	case SDL_SCANCODE_RIGHTBRACKET:
74	return 28;
75	case SDL_SCANCODE_A:
76	return 31;
77	case SDL_SCANCODE_B:
78	return 50;
79	case SDL_SCANCODE_C:
80	return 48;
81	case SDL_SCANCODE_D:
82	return 33;
83	case SDL_SCANCODE_E:
84	return 19;
85	case SDL_SCANCODE_F:
86	return 34;
87	case SDL_SCANCODE_G:
88	return 35;
89	case SDL_SCANCODE_H:
90	return 36;
91	case SDL_SCANCODE_I:
92	return 24;
93	case SDL_SCANCODE_J:
94	return 37;
95	case SDL_SCANCODE_K:
96	return 38;
97	case SDL_SCANCODE_L:
98	return 39;
99	case SDL_SCANCODE_M:
100	return 52;
101	case SDL_SCANCODE_N:
102	return 51;
103	case SDL_SCANCODE_O:
104	return 25;
105	case SDL_SCANCODE_P:
106	return 26;
107	case SDL_SCANCODE_Q:
108	return 17;
109	case SDL_SCANCODE_R:
110	return 20;
111	case SDL_SCANCODE_S:
112	return 32;
113	case SDL_SCANCODE_T:
114	return 21;
115	case SDL_SCANCODE_U:
116	return 23;
117	case SDL_SCANCODE_V:
118	return 49;
119	case SDL_SCANCODE_W:
120	return 18;
121	case SDL_SCANCODE_X:
122	return 47;
123	case SDL_SCANCODE_Y:
124	return 22;
125	case SDL_SCANCODE_Z:
126	return 46;
127	case SDL_SCANCODE_DELETE:
128	return 76;
129	case SDL_SCANCODE_UP:
130	return 83;
131	case SDL_SCANCODE_DOWN:
132	return 84;
133	case SDL_SCANCODE_RIGHT:
134	return 89;
135	case SDL_SCANCODE_LEFT:
136	return 79;
137	case SDL_SCANCODE_INSERT:
138	return 75;
139	case SDL_SCANCODE_HOME:
140	return 80;
141	case SDL_SCANCODE_END:
142	return 81;
143	case SDL_SCANCODE_PAGEUP:
144	return 85;
145	case SDL_SCANCODE_PAGEDOWN:
146	return 86;
147	case SDL_SCANCODE_F1:
148	return 112;
149	case SDL_SCANCODE_F2:
150	return 113;
151	case SDL_SCANCODE_F3:
152	return 114;
153	case SDL_SCANCODE_F4:
154	return 115;
155	case SDL_SCANCODE_F5:
156	return 116;
157	case SDL_SCANCODE_F6:
158	return 117;
159	case SDL_SCANCODE_F7:
160	return 118;
161	case SDL_SCANCODE_F8:
162	return 119;
163	case SDL_SCANCODE_F9:
164	return 120;
165	case SDL_SCANCODE_F10:
166	return 121;
167	case SDL_SCANCODE_F11:
168	return 122;
169	case SDL_SCANCODE_F12:
170	return 123;
171	case SDL_SCANCODE_SCROLLLOCK:
172	return 125;
173	case SDL_SCANCODE_RSHIFT:
174	return 57;
175	case SDL_SCANCODE_LSHIFT:
176	return 44;
177	case SDL_SCANCODE_CAPSLOCK:
178	return 30;
179	case SDL_SCANCODE_LCTRL:
180	return 58;
181	case SDL_SCANCODE_RCTRL:
182	return 64;
183	case SDL_SCANCODE_LALT:
184	return 60;
185	case SDL_SCANCODE_RALT:
186	return 62;
187	case SDL_SCANCODE_LGUI:
188	return 59;
189	case SDL_SCANCODE_RGUI:
190	return 63;
191	case SDL_SCANCODE_APPLICATION: // Menu
192	return 65;
193	case SDL_SCANCODE_NONUSBACKSLASH:
194	return 45;
195	case SDL_SCANCODE_KP_ENTER:
196	return 108;
197	case SDL_SCANCODE_KP_0:
198	return 99;
199	case SDL_SCANCODE_KP_1:
200	return 93;
201	case SDL_SCANCODE_KP_2:
202	return 98;
203	case SDL_SCANCODE_KP_3:
204	return 103;
205	case SDL_SCANCODE_KP_4:
206	return 92;
207	case SDL_SCANCODE_KP_5:
208	return 97;
209	case SDL_SCANCODE_KP_6:
210	return 102;
211	case SDL_SCANCODE_KP_7:
212	return 91;
213	case SDL_SCANCODE_KP_8:
214	return 96;
215	case SDL_SCANCODE_KP_9:
216	return 101;
217	case SDL_SCANCODE_KP_PERIOD:
218	return 104;
219	case SDL_SCANCODE_KP_PLUS:
220	return 106;
221	case SDL_SCANCODE_KP_MINUS:
222	return 105;
223	case SDL_SCANCODE_KP_MULTIPLY:
224	return 100;
225	case SDL_SCANCODE_KP_DIVIDE:
226	return 95;
227	case SDL_SCANCODE_NUMLOCKCLEAR:
228	return 90;
229	case SDL_SCANCODE_INTERNATIONAL1:
230	return 56;
231	default:
232	return 0;
233	}
234	}
235
236	void
237	handle_keyboard(bool down, SDL_Keycode sym, SDL_Scancode scancode)
238	{
239	int keynum = keynum_from_SDL_Scancode(scancode);
240
241	if (keynum == 0) return;
242
243	if (down) {
244	if (log_keyboard) {
245	printf("DOWN 0x%02X\n", scancode);
246	fflush(stdout);
247	}
248
249	if (keynum & EXTENDED_FLAG) {
250	i2c_kbd_buffer_add(0x7f);
251	}
252	i2c_kbd_buffer_add(keynum & 0xff);
253	} else {
254	if (log_keyboard) {
255	printf("UP 0x%02X\n", scancode);
256	fflush(stdout);
257	}
258
259	keynum = keynum \| 0b10000000;
260	if (keynum & EXTENDED_FLAG) {
261	i2c_kbd_buffer_add(0xff);
262	}
263	i2c_kbd_buffer_add(keynum & 0xff);
264	}
265	}

Keyboard