1 /* Copyright (C) 2011 by Jacob Alexander
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to deal
5 * in the Software without restriction, including without limitation the rights
6 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 * copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 #include <avr/pgmspace.h>
24 #include <avr/interrupt.h>
25 #include <util/delay.h>
28 //#include "usb_keyboard.h"
31 #include "usb_keyboard_debug.h"
34 #define CPU_PRESCALE(n) (CLKPR = 0x80, CLKPR = (n))
37 #define KEYBOARD_SIZE 63
38 #define KEYPAD_SIZE 16
42 #define SAMPLE_THRESHOLD 110
43 #define MAX_SAMPLES 127 // Max is 127, reaching 128 is very bad
46 // Verified Keypress Defines
47 #define USB_TRANSFER_DIVIDER 10 // 1024 == 1 Send of keypresses per second, 1 == 1 Send of keypresses per ~1 millisecond
51 #define DRIVE_reg_1 PORTD
52 #define DRIVE_reg_2 PORTD
53 #define DRIVE_reg_3 PORTD
54 #define DRIVE_reg_4 PORTD
55 #define DRIVE_reg_5 PORTD
56 #define DRIVE_reg_6 PORTD
57 #define DRIVE_reg_7 PORTE
58 #define DRIVE_reg_8 PORTE
59 #define DRIVE_reg_9 PORTE
60 #define DRIVE_reg_10 <blank>
61 #define DRIVE_reg_11 <blank>
62 #define DRIVE_reg_12 <blank>
73 #define DRIVE_pin_10 <blank>
74 #define DRIVE_pin_11 <blank>
75 #define DRIVE_pin_12 <blank>
77 // Detect Pin/Group Defines
78 #define DETECT_group_1 1
79 #define DETECT_group_2 2
80 #define DETECT_group_3 3
81 #define DETECT_group_4 4
82 #define DETECT_group_5 5
83 #define DETECT_group_6 6
84 #define DETECT_group_7 7
85 #define DETECT_group_8 8
86 #define DETECT_group_9 9
87 #define DETECT_group_10 <blank>
88 #define DETECT_group_11 <blank>
89 #define DETECT_group_12 <blank>
91 #define DETECT_group_size_1 7
92 #define DETECT_group_size_2 7
93 #define DETECT_group_size_3 6
94 #define DETECT_group_size_4 8
95 #define DETECT_group_size_5 7
96 #define DETECT_group_size_6 7
97 #define DETECT_group_size_7 8
98 #define DETECT_group_size_8 8
99 #define DETECT_group_size_9 4
100 #define DETECT_group_size_10 <blank>
101 #define DETECT_group_size_11 <blank>
102 #define DETECT_group_size_12 <blank>
105 #define DETECT_group_array_1 {55,22,6 ,40,43,27,11}
106 #define DETECT_group_array_2 {56,23,7 ,41,58,26,10}
107 #define DETECT_group_array_3 {57,24,8 ,42,25,9}
108 #define DETECT_group_array_4 {54,21,5 ,39,44,28,12,59}
109 #define DETECT_group_array_5 {53,20,4 ,38,45,29,13}
110 #define DETECT_group_array_6 {52,19,3 ,37,46,30,14}
111 #define DETECT_group_array_7 {51,18,2 ,36,61,31,15,63}
112 #define DETECT_group_array_8 {50,17,1 ,35,47,32,16,62}
113 #define DETECT_group_array_9 {48,49,33,34} // 49/60 are the same line
114 #define DETECT_group_array_10 <blank>
115 #define DETECT_group_array_11 <blank>
116 #define DETECT_group_array_12 <blank>
120 // Drive Macros (Generally don't need to be changed), except for maybe DRIVE_DETECT
121 // Sleep is for signal debouncing
122 #define DRIVE_DETECT(reg,pin,group) \
123 reg &= ~(1 << pin); \
128 #define DD_CASE(number) \
130 DRIVE_DETECT(DRIVE_reg_##number, DRIVE_pin_##number, DETECT_group_##number)
132 #define DD_CASE_ORD(number) \
136 #define DD_CASE_END(number,var) \
142 // Updates the current detection sample and last sample bit
143 // Detection Macros (Probably don't need to be changed, but depending the matrix, may have to be)
144 // Determine if key is either normal or a modifier
145 #define DET_GROUP_CHECK(index,test) \
147 keyDetectArray[groupArray[index]]++; \
151 // XXX - Detection Groups
152 // Checks each of the specified pins, and then if press detected, determine if the key is normal or a modifier
153 // Inverse logic applies for the PINs
155 // Used for 1 detection group (Special group)
156 #define DET_GROUP_1 \
157 DET_GROUP_CHECK(0,!( PINB & (1 << 7) )) \
158 DET_GROUP_CHECK(1,!( PINC & (1 << 0) )) \
159 DET_GROUP_CHECK(2,!( PIND & (1 << 0) )) \
160 DET_GROUP_CHECK(3,!( PIND & (1 << 1) )) \
162 // Used for 4 detection groups (Skips J1 P9)
163 #define DET_GROUP_2 \
164 DET_GROUP_CHECK(0,!( PINE & (1 << 7) )) \
165 DET_GROUP_CHECK(1,!( PINB & (1 << 0) )) \
166 DET_GROUP_CHECK(2,!( PINB & (1 << 1) )) \
167 DET_GROUP_CHECK(3,!( PINB & (1 << 2) )) \
168 DET_GROUP_CHECK(4,!( PINB & (1 << 3) )) \
169 DET_GROUP_CHECK(5,!( PINB & (1 << 4) )) \
170 DET_GROUP_CHECK(6,!( PINB & (1 << 5) )) \
172 // Used for 1 detection group (Skips J1 P6 and J1 P9)
173 #define DET_GROUP_3 \
174 DET_GROUP_CHECK(0,!( PINE & (1 << 7) )) \
175 DET_GROUP_CHECK(1,!( PINB & (1 << 0) )) \
176 DET_GROUP_CHECK(2,!( PINB & (1 << 1) )) \
177 DET_GROUP_CHECK(3,!( PINB & (1 << 2) )) \
178 DET_GROUP_CHECK(4,!( PINB & (1 << 4) )) \
179 DET_GROUP_CHECK(5,!( PINB & (1 << 5) )) \
181 // Used for 3 detection groups (No skips, except special group 1)
182 #define DET_GROUP_4 \
183 DET_GROUP_CHECK(0,!( PINE & (1 << 7) )) \
184 DET_GROUP_CHECK(1,!( PINB & (1 << 0) )) \
185 DET_GROUP_CHECK(2,!( PINB & (1 << 1) )) \
186 DET_GROUP_CHECK(3,!( PINB & (1 << 2) )) \
187 DET_GROUP_CHECK(4,!( PINB & (1 << 3) )) \
188 DET_GROUP_CHECK(5,!( PINB & (1 << 4) )) \
189 DET_GROUP_CHECK(6,!( PINB & (1 << 5) )) \
190 DET_GROUP_CHECK(7,!( PINB & (1 << 6) )) \
192 // Combines the DET_GROUP_Xs above for the given groupArray
193 #define DET_GROUP(group,det_group) \
196 uint8_t groupArray[DETECT_group_size_##group] = DETECT_group_array_##group; \
198 DET_GROUP_##det_group \
203 // Loop over all of the sampled keys of the given array
204 // If the number of samples is higher than the sample threshold, flag the high bit, clear otherwise
205 // This should be resetting VERY quickly, cutting off a potentially valid keypress is not an issue
206 #define DEBOUNCE_ASSESS(table,size) \
207 for ( uint8_t key = 1; key < size + 1; key++ ) {\
208 table[key] = ( table[key] & ~(1 << 7) ) > SAMPLE_THRESHOLD ? (1 << 7) : 0x00; \
213 // Each switch has it's own detection line, inverse logic
214 #define KEYPAD_DETECT(test,switch_code) \
216 keypadDetectArray[switch_code]++; \
220 // NOTE: Highest Bit: Valid keypress (0x80 is valid keypress)
221 // Other Bits: Pressed state sample counter
222 uint8_t keyDetectArray[KEYBOARD_SIZE + 1];
223 uint8_t keypadDetectArray[KEYPAD_SIZE + 1];
225 // Interrupt Variables
226 uint16_t sendKeypressCounter = 0;
227 volatile uint8_t sendKeypresses = 0;
230 void detection( int group )
232 // XXX Modify for different detection groups <-> groupArray mappings
248 // XXX This part is configurable
249 inline void pinSetup(void)
251 // For each pin, 0=input, 1=output
260 // Setting pins to either high or pull-up resistor
269 // Given a sampling array, and the current number of detected keypress
270 // Add as many keypresses from the sampling array to the USB key send array as possible.
271 void keyPressDetection( uint8_t *keys, uint8_t *validKeys, uint8_t numberOfKeys, uint8_t *modifiers, uint8_t numberOfModifiers, uint8_t *map ) {
272 for ( uint8_t key = 0; key < numberOfKeys + 1; key++ ) {
273 if ( keys[key] & (1 << 7) ) {
276 uint8_t modFound = 0;
278 // Determine if the key is a modifier
279 for ( uint8_t mod = 0; mod < numberOfModifiers; mod++ ) {
281 if ( modifiers[mod] == key ) {
282 keyboard_modifier_keys |= map[key];
291 if ( *validKeys == 6 )
294 // Allow ignoring keys with 0's
296 keyboard_keys[(*validKeys)++] = map[key];
303 // Setup with 16 MHz clock
309 // Initialize the USB, and then wait for the host to set configuration.
310 // If the Teensy is powered without a PC connected to the USB port,
311 // this will wait forever.
313 while ( !usb_configured() ) /* wait */ ;
315 // Wait an extra second for the PC's operating system to load drivers
316 // and do whatever it does to actually be ready for input
319 // Setup ISR Timer for flagging a kepress send to USB
320 // Set to 256 * 1024 (8 bit timer with Clock/1024 prescalar) timer
323 TIMSK0 = (1 << TOIE0);
325 // Main Detection Loop
329 // XXX Change number of ORDs if number of lines (RowsxColumns) differ
330 // Determine which keys are being pressed
343 // Check all Keyboard keys first
348 KEYPAD_DETECT(PINA & (1 << 0),11)
349 KEYPAD_DETECT(PINA & (1 << 1),3)
350 KEYPAD_DETECT(PINA & (1 << 2),7)
351 KEYPAD_DETECT(PINA & (1 << 3),4)
352 KEYPAD_DETECT(PINA & (1 << 4),15)
353 KEYPAD_DETECT(PINA & (1 << 5),6)
354 KEYPAD_DETECT(PINA & (1 << 6),2)
355 KEYPAD_DETECT(PINA & (1 << 7),10)
356 KEYPAD_DETECT(PINF & (1 << 0),8)
357 KEYPAD_DETECT(PINF & (1 << 1),12)
358 KEYPAD_DETECT(PINF & (1 << 2),16)
359 KEYPAD_DETECT(PINF & (1 << 3),13)
360 KEYPAD_DETECT(PINF & (1 << 4),1)
361 KEYPAD_DETECT(PINF & (1 << 5),5)
362 KEYPAD_DETECT(PINF & (1 << 6),9)
363 KEYPAD_DETECT(PINF & (1 << 7),14)
365 // Check count to see if the sample threshold may have been reached, otherwise collect more data
367 if ( count < MAX_SAMPLES )
370 // Reset Sample Counter
373 // Assess debouncing sample table
374 DEBOUNCE_ASSESS(keyDetectArray,KEYBOARD_SIZE)
375 DEBOUNCE_ASSESS(keypadDetectArray,KEYPAD_SIZE)
377 // Send keypresses over USB if the ISR has signalled that it's time
378 if ( !sendKeypresses )
381 // Detect Valid Keypresses - TODO
382 uint8_t validKeys = 0;
384 uint8_t *keyboard_MODMASK = keyboard_modifierMask;
385 uint8_t keyboard_NUMMODS = MODIFIERS_KEYBOARD;
386 uint8_t *keyboard_MAP = defaultMap;
387 uint8_t *keypad_MODMASK = keypad_modifierMask;
388 uint8_t keypad_NUMMODS = MODIFIERS_KEYPAD;
389 uint8_t *keypad_MAP = keypadDefaultMap;
391 // Map selection - CapsLock FN
392 if ( keyDetectArray[34] & (1 << 7) ) { // CapsLock FN Modifier
393 keyboard_MAP = colemakMap;
394 keyboard_MODMASK = alternate_modifierMask;
395 keyboard_NUMMODS = 5;
398 if ( keyDetectArray[61] & (1 << 7) ) {
399 keyboard_MAP = navigationMap;
403 keyPressDetection( keyDetectArray, &validKeys, KEYBOARD_SIZE, keyboard_MODMASK, keyboard_NUMMODS, keyboard_MAP );
404 keyPressDetection( keypadDetectArray, &validKeys, KEYPAD_SIZE, keypad_MODMASK, keypad_NUMMODS, keypad_MAP );
407 // TODO undo potentially old keys
408 for ( uint8_t c = validKeys; c < 6; c++ )
409 keyboard_keys[c] = 0;
414 // Clear sendKeypresses Flag
418 keyboard_modifier_keys = 0;
424 // Timer Interrupt for flagging a send of the sampled key detection data to the USB host
425 ISR( TIMER0_OVF_vect )
427 sendKeypressCounter++;
428 if ( sendKeypressCounter > USB_TRANSFER_DIVIDER ) {
429 sendKeypressCounter = 0;