- Include option is currently "hacked" and needs to be fixed - Builds on Linux, but Mac and Windows needs to be tested - Loader script generation isn't complete

12 jaren geleden · b4e1868d19
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,13 +33,13 @@ cmake_minimum_required( VERSION 2.8 )
 # Source Defines
 #

 #| Sources 
 set( SRCS
 ./main.c
 ./print.c
 ./usb_keyboard_debug.c
 ./scan_loop.c
 )
 #| Sources (see setup.h for configuring in/away code blocks or other complete modules)
 #| XXX Not set here in this project, see setup.cmake
 #set( SRCS ./main.c )

 #| Instead, include the module source selector
 include( setup.cmake )
 set( SRCS main.c ${SCAN_SRCS} ${MACRO_SRCS} ${USB_SRCS} ${DEBUG_SRCS} )



--- a/Debug/basic/print.c
+++ b/Debug/basic/print.c
@@ -0,0 +1,190 @@
 /* Copyright (C) 2011 by Jacob Alexander
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

 // Compiler Includes
 #include <stdarg.h>

 // AVR Includes
 #include <avr/io.h>
 #include <avr/pgmspace.h>

 // Project Includes
 #include "print.h"

 // Defines


 // USB HID String Output
 void usb_debug_putstr( char* s )
 {
 while ( *s != '\0' )
 usb_debug_putchar( *s++ );
 }

 // Multiple string Output
 void usb_debug_putstrs( char* first, ... )
 {
 // Initialize the variadic function parameter list
 va_list ap;

 // Get the first parameter
 va_start( ap, first );
 char *cur = first;

 // Loop through the variadic list until "\0\0\0" is found
 while ( !( cur[0] == '\0' && cur[1] == '\0' && cur[2] == '\0' ) )
 {
 // Print out the given string
 usb_debug_putstr( cur );

 // Get the next argument ready
 cur = va_arg( ap, char* );
 }

 va_end( ap ); // Not required, but good practice
 }

 // Print a constant string
 void _print(const char *s)
 {
 char c;

 // Acquire the character from flash, and print it, as long as it's not NULL
 // Also, if a newline is found, print a carrige return as well
 while ( ( c = pgm_read_byte(s++) ) != '\0' )
 {
 if ( c == '\n' )
 usb_debug_putchar('\r');
 usb_debug_putchar(c);
 }
 }




 // String Functions
 void int8ToStr( uint8_t in, char* out )
 {
 // Position and sign containers
 uint8_t pos;
 pos = 0;

 // Evaluate through digits as decimal
 do
 {
 out[pos++] = in % 10 + '0';
 }
 while ( (in /= 10) > 0 );

 // Append null
 out[pos] = '\0';

 // Reverse the string to the correct order
 revsStr(out);
 }


 void int16ToStr( uint16_t in, char* out )
 {
 // Position and sign containers
 uint16_t pos;
 pos = 0;

 // Evaluate through digits as decimal
 do
 {
 out[pos++] = in % 10 + '0';
 }
 while ( (in /= 10) > 0 );

 // Append null
 out[pos] = '\0';

 // Reverse the string to the correct order
 revsStr(out);
 }


 void hexToStr_op( uint16_t in, char* out, uint8_t op )
 {
 // Position container
 uint16_t pos = 0;

 // Evaluate through digits as hex
 do
 {
 uint16_t cur = in % 16;
 out[pos++] = cur + (( cur < 10 ) ? '0' : 'A' - 10);
 }
 while ( (in /= 16) > 0 );

 // Output formatting options
 switch ( op )
 {
 case 1: // Add 0x
 out[pos++] = 'x';
 out[pos++] = '0';
 break;
 case 2: // 8-bit padding
 case 4: // 16-bit padding
 while ( pos < op )
 out[pos++] = '0';
 break;
 }

 // Append null
 out[pos] = '\0';

 // Reverse the string to the correct order
 revsStr(out);
 }


 void revsStr( char* in )
 {
 // Iterators
 int i, j;

 // Temp storage
 char c;

 // Loop through the string, and reverse the order of the characters
 for ( i = 0, j = lenStr( in ) - 1; i < j; i++, j-- )
 {
 c = in[i];
 in[i] = in[j];
 in[j] = c;
 }
 }


 uint16_t lenStr( char* in )
 {
 // Iterator
 char *pos;

 // Loop until null is found
 for ( pos = in; *pos; pos++ );

 // Return the difference between the pointers of in and pos (which is the string length)
 return (pos - in);
 }

--- a/Debug/basic/print.h
+++ b/Debug/basic/print.h
@@ -0,0 +1,87 @@
 /* Copyright (C) 2011 by Jacob Alexander
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

 #ifndef print_h__
 #define print_h__

 // AVR Includes
 #include <avr/pgmspace.h>

 // Project Includes
 #include "usb_keyboard_debug.h"

 // Defines
 #define NL "\r\n"


 /* XXX
 * Note that all the variadic functions below, take comma separated string lists, they are purposely not printf style (simplicity)
 */

 // Function Aliases
 #define dPrint(c) usb_debug_putchar(c)
 #define dPrintStr(c) usb_debug_putstr (c)
 #define dPrintStrs(...) usb_debug_putstrs(__VA_ARGS__, "\0\0\0") // Convenience Variadic Macro
 #define dPrintStrNL(c) dPrintStrs (c, NL) // Appends New Line Macro
 #define dPrintStrsNL(...) usb_debug_putstrs(__VA_ARGS__, NL, "\0\0\0") // Appends New Line Macro

 // Special Msg Constructs (Uses VT100 tags)
 #define dPrintMsg(colour_code_str,msg,...) \
 usb_debug_putstrs("\033[", colour_code_str, "m", msg, "\033[0m - ", __VA_ARGS__, NL, "\0\0\0")
 #define printMsg(colour_code_str,msg,str) \
 print("\033[" colour_code_str "m" msg "\033[0m - " str NL)

 // Info Messages
 #define info_dPrint(...) dPrintMsg ("1;32", "INFO", __VA_ARGS__) // Info Msg
 #define info_print(str) printMsg ("1;32", "INFO", str) // Info Msg

 // Warning Messages
 #define warn_dPrint(...) dPrintMsg ("1;33", "WARNING", __VA_ARGS__) // Warning Msg
 #define warn_print(str) printMsg ("1;33", "WARNING", str) // Warning Msg

 // Error Messages
 #define erro_dPrint(...) dPrintMsg ("1;5;31", "ERROR", __VA_ARGS__) // Error Msg
 #define erro_print(str) printMsg ("1;5;31", "ERROR", str) // Error Msg

 // Debug Messages
 #define dbug_dPrint(...) dPrintMsg ("1;35", "DEBUG", __VA_ARGS__) // Debug Msg
 #define dbug_print(str) printMsg ("1;35", "DEBUG", str) // Debug Msg

 // Static String Printing
 #define print(s) _print(PSTR(s))

 void _print(const char *s);
 void usb_debug_putstr( char* s );
 void usb_debug_putstrs( char* first, ... );



 // String Functions
 #define hexToStr(hex, out) hexToStr_op(hex, out, 1)

 void int8ToStr ( uint8_t in, char* out );
 void int16ToStr ( uint16_t in, char* out );
 void hexToStr_op( uint16_t in, char* out, uint8_t op );
 void revsStr ( char* in );
 uint16_t lenStr ( char* in );

 #endif

--- a/Debug/basic/setup.cmake
+++ b/Debug/basic/setup.cmake
@@ -0,0 +1,22 @@
 ###| CMake Kiibohd Controller Debug Module |###
 #
 # Written by Jacob Alexander in 2011 for the Kiibohd Controller
 #
 # Released into the Public Domain
 #
 ###


 ###
 # Module C files
 #

 set( DEBUG_SRCS
 print.c
 )


 ###
 # Module Specific Options
 #

--- a/Keymap/keymap.h
+++ b/Keymap/keymap.h
@@ -0,0 +1,228 @@
 #ifndef __KEYMAP_h
 #define __KEYMAP_h

 #include "usb_keys.h"

 // Modifier Mask
 #define MODIFIERS_KEYPAD 0
 #define MODIFIERS_KEYBOARD 4
 static uint8_t keypad_modifierMask[] = {};
 static uint8_t keyboard_modifierMask[] = { 1, 17, 33, 49 };
 static uint8_t alternate_modifierMask[] = { 1, 17, 33, 49, 62 };

 // Default 1-indexed key mappings
 static uint8_t keypadDefaultMap[] = { 0,
 KEYPAD_7,
 KEYPAD_8,
 KEYPAD_9,
 KEYPAD_SLASH,
 KEYPAD_4,
 KEYPAD_5,
 KEYPAD_6,
 KEYPAD_ASTERIX,
 KEYPAD_1,
 KEYPAD_2,
 KEYPAD_3,
 KEYPAD_MINUS,
 KEYPAD_ENTER,
 KEYPAD_0,
 KEYPAD_PERIOD,
 KEYPAD_PLUS };

 static uint8_t defaultMap[] = { 0,
 KEY_GUI,
 KEY_1,
 KEY_2,
 KEY_3,
 KEY_4,
 KEY_5,
 KEY_6,
 KEY_7,
 KEY_8,
 KEY_9,
 KEY_0,
 KEY_MINUS,
 KEY_EQUAL,
 KEY_BACKSLASH,
 KEY_TILDE,
 KEY_BACKSPACE,
 KEY_ALT,
 KEY_TAB,
 KEY_Q,
 KEY_W,
 KEY_E,
 KEY_R,
 KEY_T,
 KEY_Y,
 KEY_U,
 KEY_I,
 KEY_O,
 KEY_P,
 KEY_LEFT_BRACE,
 KEY_RIGHT_BRACE,
 KEY_DELETE,
 KEY_UP,
 KEY_CTRL,
 KEY_CAPS_LLOCK,
 KEY_A,
 KEY_S,
 KEY_D,
 KEY_F,
 KEY_G,
 KEY_H,
 KEY_J,
 KEY_K,
 KEY_L,
 KEY_SEMICOLON,
 KEY_QUOTE,
 KEY_ENTER,
 KEY_DOWN,
 KEY_ESC,
 KEY_LEFT_SHIFT,
 KEY_Z,
 KEY_X,
 KEY_C,
 KEY_V,
 KEY_B,
 KEY_N,
 KEY_M,
 KEY_COMMA,
 KEY_PERIOD,
 KEY_SLASH,
 KEY_RIGHT_SHIFT,
 KEY_LEFT,
 KEY_RIGHT,
 KEY_SPACE };

 static uint8_t navigationMap[] = { 0,
 KEY_GUI,
 KEY_F1,
 KEY_F2,
 KEY_F3,
 KEY_F4,
 KEY_F5,
 KEY_F6,
 KEY_F7,
 KEY_F8,
 KEY_F9,
 KEY_F10,
 KEY_F11,
 KEY_F12,
 KEY_INSERT,
 KEY_DELETE,
 KEY_BACKSPACE,
 KEY_ALT,
 KEY_CAPS_LOCK,
 0,
 0,
 0,
 0,
 0,
 0,
 0,
 KEY_SYSREQ_ATT,
 KEY_SCROLL_LOCK,
 KEY_PAUSE,
 KEY_UP,
 0,
 0,
 0,
 KEY_CTRL,
 KEY_CAPS_LLOCK,
 0,
 0,
 0,
 0,
 0,
 KEYPAD_ASTERIX,
 KEYPAD_SLASH,
 KEY_HOME,
 KEY_PAGE_UP,
 KEY_LEFT,
 KEY_RIGHT,
 KEY_ENTER,
 0,
 KEY_ESC,
 KEY_LEFT_SHIFT,
 0,
 0,
 0,
 0,
 0,
 KEYPAD_PLUS,
 KEYPAD_MINUS,
 KEY_END,
 KEY_PAGE_DOWN,
 KEY_DOWN,
 KEY_RIGHT_SHIFT,
 165,
 KEY_RIGHT_ALT,
 KEY_SPACE };

 static uint8_t colemakMap[] = { 0,
 KEY_GUI,
 KEY_1,
 KEY_2,
 KEY_3,
 KEY_4,
 KEY_5,
 KEY_6,
 KEY_7,
 KEY_8,
 KEY_9,
 KEY_0,
 KEY_MINUS,
 KEY_EQUAL,
 KEY_BACKSLASH,
 KEY_TILDE,
 KEY_BACKSPACE,
 KEY_ALT,
 KEY_TAB,
 KEY_Q,
 KEY_W,
 KEY_F,
 KEY_P,
 KEY_G,
 KEY_J,
 KEY_L,
 KEY_U,
 KEY_Y,
 KEY_SEMICOLON,
 KEY_LEFT_BRACE,
 KEY_RIGHT_BRACE,
 KEY_DELETE,
 KEY_PAGE_UP,
 KEY_CTRL,
 KEY_CAPS_LLOCK,
 KEY_A,
 KEY_R,
 KEY_S,
 KEY_T,
 KEY_D,
 KEY_H,
 KEY_N,
 KEY_E,
 KEY_I,
 KEY_O,
 KEY_QUOTE,
 KEY_ENTER,
 KEY_PAGE_DOWN,
 KEY_ESC,
 KEY_LEFT_SHIFT,
 KEY_Z,
 KEY_X,
 KEY_C,
 KEY_V,
 KEY_B,
 KEY_K,
 KEY_M,
 KEY_COMMA,
 KEY_PERIOD,
 KEY_SLASH,
 KEY_RIGHT_SHIFT,
 165,
 KEY_RIGHT_ALT,
 KEY_SPACE };

 #endif

--- a/Keymap/usb_keys.h
+++ b/Keymap/usb_keys.h
@@ -0,0 +1,244 @@
 #ifndef __usb_keys_h
 #define __usb_keys_h


 // List of Modifiers
 #define KEY_CTRL 0x01
 #define KEY_SHIFT 0x02
 #define KEY_ALT 0x04
 #define KEY_GUI 0x08
 #define KEY_LEFT_CTRL 0x01
 #define KEY_LEFT_SHIFT 0x02
 #define KEY_LEFT_ALT 0x04
 #define KEY_LEFT_GUI 0x08
 #define KEY_RIGHT_CTRL 0x10
 #define KEY_RIGHT_SHIFT 0x20
 #define KEY_RIGHT_ALT 0x40
 #define KEY_RIGHT_GUI 0x80

 // List of Keycodes
 #define KEY_A 4
 #define KEY_B 5
 #define KEY_C 6
 #define KEY_D 7
 #define KEY_E 8
 #define KEY_F 9
 #define KEY_G 10
 #define KEY_H 11
 #define KEY_I 12
 #define KEY_J 13
 #define KEY_K 14
 #define KEY_L 15
 #define KEY_M 16
 #define KEY_N 17
 #define KEY_O 18
 #define KEY_P 19
 #define KEY_Q 20
 #define KEY_R 21
 #define KEY_S 22
 #define KEY_T 23
 #define KEY_U 24
 #define KEY_V 25
 #define KEY_W 26
 #define KEY_X 27
 #define KEY_Y 28
 #define KEY_Z 29
 #define KEY_1 30
 #define KEY_2 31
 #define KEY_3 32
 #define KEY_4 33
 #define KEY_5 34
 #define KEY_6 35
 #define KEY_7 36
 #define KEY_8 37
 #define KEY_9 38
 #define KEY_0 39
 #define KEY_ENTER 40
 #define KEY_ESC 41
 #define KEY_BACKSPACE 42
 #define KEY_TAB 43
 #define KEY_SPACE 44
 #define KEY_MINUS 45
 #define KEY_EQUAL 46
 #define KEY_LEFT_BRACE 47
 #define KEY_RIGHT_BRACE 48
 #define KEY_BACKSLASH 49
 #define KEY_NUMBER 50
 #define KEY_SEMICOLON 51
 #define KEY_QUOTE 52
 #define KEY_TILDE 53
 #define KEY_COMMA 54
 #define KEY_PERIOD 55
 #define KEY_SLASH 56
 #define KEY_CAPS_LOCK 57
 #define KEY_F1 58
 #define KEY_F2 59
 #define KEY_F3 60
 #define KEY_F4 61
 #define KEY_F5 62
 #define KEY_F6 63
 #define KEY_F7 64
 #define KEY_F8 65
 #define KEY_F9 66
 #define KEY_F10 67
 #define KEY_F11 68
 #define KEY_F12 69
 #define KEY_PRINTSCREEN 70
 #define KEY_SCROLL_LOCK 71
 #define KEY_PAUSE 72
 #define KEY_INSERT 73
 #define KEY_HOME 74
 #define KEY_PAGE_UP 75
 #define KEY_DELETE 76
 #define KEY_END 77
 #define KEY_PAGE_DOWN 78
 #define KEY_RIGHT 79
 #define KEY_LEFT 80
 #define KEY_DOWN 81
 #define KEY_UP 82
 #define KEY_NUM_LOCK 83
 #define KEYPAD_SLASH 84
 #define KEYPAD_ASTERIX 85
 #define KEYPAD_MINUS 86
 #define KEYPAD_PLUS 87
 #define KEYPAD_ENTER 88
 #define KEYPAD_1 89
 #define KEYPAD_2 90
 #define KEYPAD_3 91
 #define KEYPAD_4 92
 #define KEYPAD_5 93
 #define KEYPAD_6 94
 #define KEYPAD_7 95
 #define KEYPAD_8 96
 #define KEYPAD_9 97
 #define KEYPAD_0 98
 #define KEYPAD_PERIOD 99
 #define KEY_ISO_BACKSLASH 100
 #define KEY_APP 101
 #define KEYBOARD_ERROR 102 // See spec
 #define KEYPAD_EQUAL 103
 #define KEY_F13 104
 #define KEY_F14 105
 #define KEY_F15 106
 #define KEY_F16 107
 #define KEY_F17 108
 #define KEY_F18 109
 #define KEY_F19 110
 #define KEY_F20 111
 #define KEY_F21 112
 #define KEY_F22 113
 #define KEY_F23 114
 #define KEY_F24 115
 #define KEY_EXEC 116
 #define KEY_HELP 117
 #define KEY_MENU 118
 #define KEY_SELECT 119
 #define KEY_STOP 120
 #define KEY_AGAIN 121
 #define KEY_UNDO 122
 #define KEY_CUT 123
 #define KEY_COPY 124
 #define KEY_PASTE 125
 #define KEY_FIND 126
 #define KEY_MUTE 127
 #define KEY_VOL_UP 128
 #define KEY_VOL_DOWN 129
 #define KEY_CAPS_LLOCK 130 // "Locking" Scroll Lock (Old keyboards with Locking Caps Lock)
 #define KEY_NUM_LLOCK 131
 #define KEY_SCROLL_LLOCK 132
 #define KEYPAD_COMMA 133 // Brazillian (See spec)
 #define KEYPAD_EQUAL_AS 134 // AS/400 Keyboard (See spec)
 #define KEY_INTER1 135 // Brazillian and Japanese "Ru"
 #define KEY_INTER2 136 // Japanese Katakana/Hiragana
 #define KEY_INTER3 137 // Japanese Yen
 #define KEY_INTER4 138 // Japanese Henkan
 #define KEY_INTER5 139 // Japanese Muhenkan
 #define KEY_INTER6 140 // PC98 Comma (Ka-m-ma)
 #define KEY_INTER7 141 // Double-Byte/Single-Byte Toggle
 #define KEY_INTER8 142 // Undefined
 #define KEY_INTER9 143 // Undefined
 #define KEY_LANG1 144 // Korean Hangul/English Toggle
 #define KEY_LANG2 145 // Korean Hanja Conversion
 #define KEY_LANG3 146 // Japanese Katakana Key (USB)
 #define KEY_LANG4 147 // Japanese Hiragana Key (USB)
 #define KEY_LANG5 148 // Japanese Zenkaku/Hankaku Key (USB)
 #define KEY_LANG6 149 // Reserved (Application Specific)
 #define KEY_LANG7 150 // Reserved (Application Specific)
 #define KEY_LANG8 151 // Reserved (Application Specific)
 #define KEY_LANG9 152 // Reserved (Application Specific)
 #define KEY_ALT_ERASE 153 // Special Erase (See Spec)
 #define KEY_SYSREQ_ATT 154 // Modifier Type
 #define KEY_CANCEL 155
 #define KEY_CLEAR 156
 #define KEY_PRIOR 157
 #define KEY_RETURN 158
 #define KEY_SEPARATOR 159
 #define KEY_OUT 160
 #define KEY_OPER 161
 #define KEY_CLEAR_AGAIN 162
 #define KEY_CRSEL_PROPS 163
 #define KEY_EXSEL 164
 // 165 - 175 Reserved
 #define KEYPAD_00 176
 #define KEYPAD_000 177
 #define KEY_1000_SEP 178
 #define KEY_DECIMAL_SEP 179
 #define KEY_CURRENCY_MAIN 180
 #define KEY_CURRENCY_SUB 181
 #define KEYPAD_LPAREN 182
 #define KEYPAD_RPAREN 183
 #define KEYPAD_LBRACE 184
 #define KEYPAD_RBRACE 185
 #define KEYPAD_TAB 186
 #define KEYPAD_BACKSPACE 187
 #define KEYPAD_A 188
 #define KEYPAD_B 189
 #define KEYPAD_C 190
 #define KEYPAD_D 191
 #define KEYPAD_E 192
 #define KEYPAD_F 193
 #define KEYPAD_XOR 194
 #define KEYPAD_CHEVRON 195
 #define KEYPAD_PERCENT 196
 #define KEYPAD_LTHAN 197
 #define KEYPAD_GTHAN 198
 #define KEYPAD_AND 199
 #define KEYPAD_AND_AND 200
 #define KEYPAD_OR 201
 #define KEYPAD_OR_OR 202
 #define KEYPAD_COLON 203
 #define KEYPAD_POUND 204
 #define KEYPAD_SPACE 205
 #define KEYPAD_AT 206
 #define KEYPAD_EXCLAIM 207
 #define KEYPAD_MEM_STORE 208
 #define KEYPAD_MEM_RECALL 209
 #define KEYPAD_MEM_CLEAR 210
 #define KEYPAD_MEM_ADD 211
 #define KEYPAD_MEM_SUB 212
 #define KEYPAD_MEM_MULT 213
 #define KEYPAD_MEM_DIV 214
 #define KEYPAD_PLUS_MINUS 215
 #define KEYPAD_CLEAR 216
 #define KEYPAD_CLEAR_ENTRY 217
 #define KEYPAD_BINARY 218
 #define KEYPAD_OCTAL 219
 #define KEYPAD_DECIMAL 220
 #define KEYPAD_HEX 221
 // 222 - 223 Reserved
 #define KEYS_LCTRL 224
 #define KEYS_LSHIFT 225
 #define KEYS_LALT 226
 #define KEYS_LGUI 227
 #define KEYS_RCTRL 228
 #define KEYS_RSHIFT 229
 #define KEYS_RALT 230
 #define KEYS_RGUI 231
 // 232 - 65535 Reserved





 #endif

--- a/LoadFile/load
+++ b/LoadFile/load
@@ -0,0 +1,8 @@
 #!/bin/bash

 #| Loads the hex file onto the teensy++ 2.0

 sudo teensy-loader-cli -mmcu=at90usb1286 -w Build/main.hex

 exit 0

--- a/Macro/basic/setup.cmake
+++ b/Macro/basic/setup.cmake
@@ -0,0 +1,21 @@
 ###| CMake Kiibohd Controller Macro Module |###
 #
 # Written by Jacob Alexander in 2011 for the Kiibohd Controller
 #
 # Released into the Public Domain
 #
 ###


 ###
 # Module C files
 #

 set( MACRO_SRCS
 )


 ###
 # Module Specific Options
 #

--- a/Scan/matrix/matrix.c
+++ b/Scan/matrix/matrix.c
@@ -0,0 +1,181 @@
 /* Copyright (C) 2011 by Jacob Alexander
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

 #include "matrix.h"

 #define REG_SET(reg) reg |= (1 << ( matrix[row][col] % 10 ) )
 
 #define PIN_SET_COL(pin) \
 switch ( scanMode ) { \
 case scanCol: \
 case scanCol_powrRow: \
 case scanDual: \
 REG_SET(port##pin); break; \
 case scanRow_powrCol: REG_SET(ddr##pin); REG_SET(port##pin); break; \
 } \
 break

 #define PIN_SET_ROW(pin) \
 switch ( scanMode ) { \
 case scanRow: \
 case scanRow_powrCol: \
 case scanDual: \
 REG_SET(port##pin); break; \
 case scanCol_powrRow: REG_SET(ddr##pin); REG_SET(port##pin); break; \
 } \
 break

 #define PIN_CASE(pinLetter) \
 case pin##pinLetter##0: \
 case pin##pinLetter##1: \
 case pin##pinLetter##2: \
 case pin##pinLetter##3: \
 case pin##pinLetter##4: \
 case pin##pinLetter##5: \
 case pin##pinLetter##6: \
 case pin##pinLetter##7

 #define PIN_TEST_COL(pin) \
 if ( !( pin & ( 1 << ( matrix[0][col] % 10 ) ) \
 detectArray[matrix[row][col]]++; \
 break


 void matrix_pinSetup( uint8_t *matrix )
 {
 // Setup the variables
 uint8_t portA = 0x00;
 uint8_t portB = 0x00;
 uint8_t portC = 0x00;
 uint8_t portD = 0x00;
 uint8_t portE = 0x00;
 uint8_t portF = 0x00;

 uint8_t ddrA = 0x00;
 uint8_t ddrB = 0x00;
 uint8_t ddrC = 0x00;
 uint8_t ddrD = 0x00;
 uint8_t ddrE = 0x00;
 uint8_t ddrF = 0x00;

 // Loop through all the pin assignments, for the initial pin settings
 int row, col;

 // Rows
 for ( row = 1; row < sizeof(matrix); row++ ) {
 switch ( matrix[row][col] ) {
 PIN_CASE(A):
 PIN_SET_ROW(A);
 PIN_CASE(B):
 PIN_SET_ROW(B);
 PIN_CASE(C):
 PIN_SET_ROW(C);
 PIN_CASE(D):
 PIN_SET_ROW(D);
 PIN_CASE(E):
 PIN_SET_ROW(E);
 PIN_CASE(F):
 PIN_SET_ROW(F);

 default:
 continue;
 }
 }

 // Columns
 for ( col = 1; col < sizeof(matrix[0]); row++ ) {
 switch ( matrix[row][col] ) {
 PIN_CASE(A):
 PIN_SET_COL(A);
 PIN_CASE(B):
 PIN_SET_COL(B);
 PIN_CASE(C):
 PIN_SET_COL(C);
 PIN_CASE(D):
 PIN_SET_COL(D);
 PIN_CASE(E):
 PIN_SET_COL(E);
 PIN_CASE(F):
 PIN_SET_COL(F);

 default:
 continue;
 }
 }

 // Setting the pins
 DDRA = ddrA;
 DDRB = ddrB;
 DDRC = ddrC;
 DDRD = ddrD;
 DDRE = ddrE;
 DDRF = ddrF;

 PORTA = portA;
 PORTB = portB;
 PORTC = portC;
 PORTD = portD;
 PORTE = portE;
 PORTF = portF;
 }

 // TODO Proper matrix scanning
 void matrix_scan( uint8_t *matrix, uint8_t *detectArray )
 {
 // Column Scan
 #if scanMode == scanCol
 uint8_t col = 1;
 uint8_t row = 1;
 for ( ; col < sizeof(matrix[1]); col++ ) {
 switch ( matrix[0][col] / 10 ) {
 case 0: // PINA
 PIN_TEST_COL(PINA);
 case 1: // PINB
 PIN_TEST_COL(PINB);
 case 2: // PINC
 PIN_TEST_COL(PINC);
 case 3: // PIND
 PIN_TEST_COL(PIND);
 case 4: // PINE
 PIN_TEST_COL(PINE);
 case 5: // PINF
 PIN_TEST_COL(PINF);
 }
 }
 #endif

 // Row Scan
 #if scanMode == scanRow
 #endif

 // Column Scan, Power Row
 #if scanMode == scanCol_powrRow
 #endif

 // Row Scan, Power Column
 #if scanMode == scanRow_powrCol
 #endif

 // Dual Scan
 #if scanMode == scanDual
 #endif
 }

--- a/Scan/matrix/matrix.h
+++ b/Scan/matrix/matrix.h
@@ -0,0 +1,151 @@
 /* Copyright (C) 2011 by Jacob Alexander
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

 #ifndef __MATRIX_H
 #define __MATRIX_H

 // ----- Quick Map (don't change) -----
 #define pinA0 0
 #define pinA1 1
 #define pinA2 2
 #define pinA3 3
 #define pinA4 4
 #define pinA5 5
 #define pinA6 6
 #define pinA7 7

 #define pinB0 10
 #define pinB1 11
 #define pinB2 12
 #define pinB3 13
 #define pinB4 14
 #define pinB5 15
 #define pinB6 16
 #define pinB7 17

 #define pinC0 20
 #define pinC1 21
 #define pinC2 22
 #define pinC3 23
 #define pinC4 24
 #define pinC5 25
 #define pinC6 26
 #define pinC7 27

 #define pinD0 30
 #define pinD1 31
 #define pinD2 32
 #define pinD3 33
 #define pinD4 34
 #define pinD5 35
 #define pinD6 36
 #define pinD7 37

 #define pinE0 40
 #define pinE1 41
 #define pinE2 42
 #define pinE3 43
 #define pinE4 44
 #define pinE5 45
 #define pinE6 46
 #define pinE7 47

 #define pinF0 50
 #define pinF1 51
 #define pinF2 52
 #define pinF3 53
 #define pinF4 54
 #define pinF5 55
 #define pinF6 56
 #define pinF7 57

 #define pinNULL 128



 // ----- Scan Mode (usually dual-scan) -----
 // Ordered by increasing memory/CPU usage
 #define scanRow 0 // Needed for powered switches (Hall-Effect)
 #define scanCol 1 // Opposite of scanRow
 #define scanRow_powrCol 2 // NKRO supported (simple detection)
 #define scanCol_powrRow 3 // Opposite of scanRow_powrCol
 #define scanDual 4 // Typical ~2KRO matrix



 // ----- Scan Mode Setting -----
 #define scanMode scanCol



 // ----- Key Settings -----
 #define keyboardSize 16 // # of keys



 // ----- Matrix Configuration -----
 static uint8_t matrix_pinout[][] = {



 // Just layout the matrix by rows and columns
 // Usually you'll want to set the scanMode above to scanDual or scanCol_powrRow/scanRow_powrCol
 // The mode allows for optimization in the kind of scanning algorithms that are done
 // 
 // The key numbers are used to translate into the keymap table (array) (and always start from 1, not 0).
 // See the keymap.h file for the various preconfigured arrays.

 // Scan Mode | Col 1 | Col 2 | Col 3 | Col 4 | Col 4 | ...
 // -------------------------------------------------------
 // Row 1 | Key 1 Key 7 Key32 ...
 // Row 2 | Key 3 Key92 ...
 // Row 3 | Key23 ...
 // Row 4 | ...
 // Row 5 |
 // ... |


 { scanMode, pinF4, pinA6, pinA1, pinA3, pinF5, pinA5, pinA2, pinF0, pinF6, pinA7, pinA0, pinF1, pinF3, pinF7, pinA4, pinF2 },
 { pinNULL, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },


 // Example Rows
 //{ pinE0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
 //{ pinE1, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, },


 };


 // ----- Variables -----

 // NOTE: Highest Bit: Valid keypress (0x80 is valid keypress)
 // Other Bits: Pressed state sample counter
 uint8_t keyboardDetectArray[keyboardSize + 1];



 // ----- Functions -----


 #endif // __MATRIX_H


--- a/Scan/matrix/scan_loop.c
+++ b/Scan/matrix/scan_loop.c
@@ -0,0 +1,137 @@
 /* Copyright (C) 2011 by Jacob Alexander
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */


 #include <stdint.h>
 #include <usb_keyboard_debug.h>
 #include <keymap.h>
 // Debouncing Defines
 #define SAMPLE_THRESHOLD 110
 #define MAX_SAMPLES 127 // Max is 127, reaching 128 is very bad
 // Loop over all of the sampled keys of the given array
 // If the number of samples is higher than the sample threshold, flag the high bit, clear otherwise
 // This should be resetting VERY quickly, cutting off a potentially valid keypress is not an issue
 #define DEBOUNCE_ASSESS(table,size) \
 for ( uint8_t key = 1; key < size + 1; key++ ) {\
 table[key] = ( table[key] & ~(1 << 7) ) > SAMPLE_THRESHOLD ? (1 << 7) : 0x00; \
 } \

 // NOTE: Highest Bit: Valid keypress (0x80 is valid keypress)
 // Other Bits: Pressed state sample counter
 #define KEYBOARD_SIZE 23
 uint8_t keyboardDetectArray[KEYBOARD_SIZE + 1];

 // Interrupt Variable
 volatile uint8_t sendKeypresses = 0;

 // USB Data Send
 void usb_send( uint8_t validKeys )
 {
 // TODO undo potentially old keys
 for ( uint8_t c = validKeys; c < 6; c++ )
 keyboard_keys[c] = 0;

 // Send keypresses
 usb_keyboard_send();

 // Clear sendKeypresses Flag
 sendKeypresses = 0;

 // Clear modifiers
 keyboard_modifier_keys = 0;
 }


 // Given a sampling array, and the current number of detected keypress
 // Add as many keypresses from the sampling array to the USB key send array as possible.
 void keyPressDetection( uint8_t *keys, uint8_t *validKeys, uint8_t numberOfKeys, uint8_t *modifiers, uint8_t numberOfModifiers, uint8_t *map ) {
 for ( uint8_t key = 0; key < numberOfKeys + 1; key++ ) {
 if ( keys[key] & (1 << 7) ) {
 pint8( key );
 //print(" ");
 uint8_t modFound = 0;

 // Determine if the key is a modifier
 for ( uint8_t mod = 0; mod < numberOfModifiers; mod++ ) {
 // Modifier found
 if ( modifiers[mod] == key ) {
 keyboard_modifier_keys |= map[key];
 modFound = 1;
 break;
 }
 }
 if ( modFound )
 continue;

 // Too many keys
 if ( *validKeys == 6 )
 break;

 // Allow ignoring keys with 0's
 if ( map[key] != 0 )
 keyboard_keys[(*validKeys)++] = map[key];
 }
 }
 }


 // Main Detection Loop
 void scan_loop( void )
 {
 //matrix_pinSetup( matrix_pinout );
 uint8_t count = 0;

 for ( ;; ) {
 //matrix_scan( matrix_pinout, keyboardDetectArray );

 // Check count to see if the sample threshold may have been reached, otherwise collect more data
 if ( count++ < MAX_SAMPLES )
 continue;

 // Reset Sample Counter
 count = 0;

 // Assess debouncing sample table
 //DEBOUNCE_ASSESS(keyDetectArray,KEYBOARD_SIZE)

 // Send keypresses over USB if the ISR has signalled that it's time
 if ( !sendKeypresses )
 continue;

 // Layout Setup
 uint8_t validKeys = 0;

 uint8_t *keyboard_MODMASK = keyboard_modifierMask;
 uint8_t keyboard_NUMMODS = MODIFIERS_KEYBOARD;
 uint8_t *keyboard_MAP = defaultMap;

 // TODO Layout Switching

 // TODO Macro Processing

 // Debounce Sampling Array to USB Data Array
 keyPressDetection( keyboardDetectArray, &validKeys, KEYBOARD_SIZE, keyboard_MODMASK, keyboard_NUMMODS, keyboard_MAP );

 // Send USB Data
 usb_send( validKeys );
 }
 }

--- a/Scan/matrix/scan_loop.h
+++ b/Scan/matrix/scan_loop.h
@@ -0,0 +1,31 @@
 /* Copyright (C) 2011 by Jacob Alexander
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

 #ifndef __SCAN_LOOP_H
 #define __SCAN_LOOP_H

 //extern uint8_t keyboardDetectArray[KEYBOARDZ
 extern volatile uint8_t sendKeypresses;

 void scan_loop( void );

 #endif // __SCAN_LOOP_H

--- a/Scan/matrix/setup.cmake
+++ b/Scan/matrix/setup.cmake
@@ -0,0 +1,23 @@
 ###| CMake Kiibohd Controller Scan Module |###
 #
 # Written by Jacob Alexander in 2011 for the Kiibohd Controller
 #
 # Released into the Public Domain
 #
 ###


 ###
 # Module C files
 #

 set( SCAN_SRCS
 scan_loop.c
 )


 ###
 # Module Specific Options TODO Fixme!! (../)
 #
 add_definitions( -I../Keymap )

--- a/USB/pjrc/setup.cmake
+++ b/USB/pjrc/setup.cmake
@@ -0,0 +1,22 @@
 ###| CMake Kiibohd Controller USB Module |###
 #
 # Written by Jacob Alexander in 2011 for the Kiibohd Controller
 #
 # Released into the Public Domain
 #
 ###


 ###
 # Module C files
 #

 set( USB_SRCS
 usb_keyboard_debug.c
 )


 ###
 # Module Specific Options
 #

--- a/USB/pjrc/usb_keyboard.c
+++ b/USB/pjrc/usb_keyboard.c
@@ -0,0 +1,592 @@
 /* USB Keyboard Example for Teensy USB Development Board
 * http://www.pjrc.com/teensy/usb_keyboard.html
 * Copyright (c) 2009 PJRC.COM, LLC
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

 // Version 1.0: Initial Release
 // Version 1.1: Add support for Teensy 2.0

 #define USB_SERIAL_PRIVATE_INCLUDE
 #include "usb_keyboard.h"

 /**************************************************************************
 *
 * Configurable Options
 *
 **************************************************************************/

 // You can change these to give your code its own name.
 #define STR_MANUFACTURER L"MfgName"
 #define STR_PRODUCT L"Keyboard"


 // Mac OS-X and Linux automatically load the correct drivers. On
 // Windows, even though the driver is supplied by Microsoft, an
 // INF file is needed to load the driver. These numbers need to
 // match the INF file.
 #define VENDOR_ID 0x16C0
 #define PRODUCT_ID 0x047C


 // USB devices are supposed to implment a halt feature, which is
 // rarely (if ever) used. If you comment this line out, the halt
 // code will be removed, saving 102 bytes of space (gcc 4.3.0).
 // This is not strictly USB compliant, but works with all major
 // operating systems.
 #define SUPPORT_ENDPOINT_HALT



 /**************************************************************************
 *
 * Endpoint Buffer Configuration
 *
 **************************************************************************/

 #define ENDPOINT0_SIZE 32

 #define KEYBOARD_INTERFACE 0
 #define KEYBOARD_ENDPOINT 3
 #define KEYBOARD_SIZE 8
 #define KEYBOARD_BUFFER EP_DOUBLE_BUFFER

 static const uint8_t PROGMEM endpoint_config_table[] = {
 0,
 0,
 1, EP_TYPE_INTERRUPT_IN, EP_SIZE(KEYBOARD_SIZE) | KEYBOARD_BUFFER,
 0
 };


 /**************************************************************************
 *
 * Descriptor Data
 *
 **************************************************************************/

 // Descriptors are the data that your computer reads when it auto-detects
 // this USB device (called "enumeration" in USB lingo). The most commonly
 // changed items are editable at the top of this file. Changing things
 // in here should only be done by those who've read chapter 9 of the USB
 // spec and relevant portions of any USB class specifications!


 static uint8_t PROGMEM device_descriptor[] = {
 18, // bLength
 1, // bDescriptorType
 0x00, 0x02, // bcdUSB
 0, // bDeviceClass
 0, // bDeviceSubClass
 0, // bDeviceProtocol
 ENDPOINT0_SIZE, // bMaxPacketSize0
 LSB(VENDOR_ID), MSB(VENDOR_ID), // idVendor
 LSB(PRODUCT_ID), MSB(PRODUCT_ID), // idProduct
 0x00, 0x01, // bcdDevice
 1, // iManufacturer
 2, // iProduct
 0, // iSerialNumber
 1 // bNumConfigurations
 };

 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 static uint8_t PROGMEM keyboard_hid_report_desc[] = {
 0x05, 0x01, // Usage Page (Generic Desktop),
 0x09, 0x06, // Usage (Keyboard),
 0xA1, 0x01, // Collection (Application),
 0x75, 0x01, // Report Size (1),
 0x95, 0x08, // Report Count (8),
 0x05, 0x07, // Usage Page (Key Codes),
 0x19, 0xE0, // Usage Minimum (224),
 0x29, 0xE7, // Usage Maximum (231),
 0x15, 0x00, // Logical Minimum (0),
 0x25, 0x01, // Logical Maximum (1),
 0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte
 0x95, 0x01, // Report Count (1),
 0x75, 0x08, // Report Size (8),
 0x81, 0x03, // Input (Constant), ;Reserved byte
 0x95, 0x05, // Report Count (5),
 0x75, 0x01, // Report Size (1),
 0x05, 0x08, // Usage Page (LEDs),
 0x19, 0x01, // Usage Minimum (1),
 0x29, 0x05, // Usage Maximum (5),
 0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report
 0x95, 0x01, // Report Count (1),
 0x75, 0x03, // Report Size (3),
 0x91, 0x03, // Output (Constant), ;LED report padding
 0x95, 0x06, // Report Count (6),
 0x75, 0x08, // Report Size (8),
 0x15, 0x00, // Logical Minimum (0),
 0x25, 0x68, // Logical Maximum(104),
 0x05, 0x07, // Usage Page (Key Codes),
 0x19, 0x00, // Usage Minimum (0),
 0x29, 0x68, // Usage Maximum (104),
 0x81, 0x00, // Input (Data, Array),
 0xc0 // End Collection
 };

 #define CONFIG1_DESC_SIZE (9+9+9+7)
 #define KEYBOARD_HID_DESC_OFFSET (9+9)
 static uint8_t PROGMEM config1_descriptor[CONFIG1_DESC_SIZE] = {
 // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10
 9, // bLength;
 2, // bDescriptorType;
 LSB(CONFIG1_DESC_SIZE), // wTotalLength
 MSB(CONFIG1_DESC_SIZE),
 1, // bNumInterfaces
 1, // bConfigurationValue
 0, // iConfiguration
 0xC0, // bmAttributes
 50, // bMaxPower
 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 9, // bLength
 4, // bDescriptorType
 KEYBOARD_INTERFACE, // bInterfaceNumber
 0, // bAlternateSetting
 1, // bNumEndpoints
 0x03, // bInterfaceClass (0x03 = HID)
 0x01, // bInterfaceSubClass (0x01 = Boot)
 0x01, // bInterfaceProtocol (0x01 = Keyboard)
 0, // iInterface
 // HID interface descriptor, HID 1.11 spec, section 6.2.1
 9, // bLength
 0x21, // bDescriptorType
 0x11, 0x01, // bcdHID
 0, // bCountryCode
 1, // bNumDescriptors
 0x22, // bDescriptorType
 sizeof(keyboard_hid_report_desc), // wDescriptorLength
 0,
 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 7, // bLength
 5, // bDescriptorType
 KEYBOARD_ENDPOINT | 0x80, // bEndpointAddress
 0x03, // bmAttributes (0x03=intr)
 KEYBOARD_SIZE, 0, // wMaxPacketSize
 1 // bInterval
 };

 // If you're desperate for a little extra code memory, these strings
 // can be completely removed if iManufacturer, iProduct, iSerialNumber
 // in the device desciptor are changed to zeros.
 struct usb_string_descriptor_struct {
 uint8_t bLength;
 uint8_t bDescriptorType;
 int16_t wString[];
 };
 static struct usb_string_descriptor_struct PROGMEM string0 = {
 4,
 3,
 {0x0409}
 };
 static struct usb_string_descriptor_struct PROGMEM string1 = {
 sizeof(STR_MANUFACTURER),
 3,
 STR_MANUFACTURER
 };
 static struct usb_string_descriptor_struct PROGMEM string2 = {
 sizeof(STR_PRODUCT),
 3,
 STR_PRODUCT
 };

 // This table defines which descriptor data is sent for each specific
 // request from the host (in wValue and wIndex).
 static struct descriptor_list_struct {
 uint16_t wValue;
 uint16_t wIndex;
 const uint8_t *addr;
 uint8_t length;
 } PROGMEM descriptor_list[] = {
 {0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},
 {0x0200, 0x0000, config1_descriptor, sizeof(config1_descriptor)},
 {0x2200, KEYBOARD_INTERFACE, keyboard_hid_report_desc, sizeof(keyboard_hid_report_desc)},
 {0x2100, KEYBOARD_INTERFACE, config1_descriptor+KEYBOARD_HID_DESC_OFFSET, 9},
 {0x0300, 0x0000, (const uint8_t *)&string0, 4},
 {0x0301, 0x0409, (const uint8_t *)&string1, sizeof(STR_MANUFACTURER)},
 {0x0302, 0x0409, (const uint8_t *)&string2, sizeof(STR_PRODUCT)}
 };
 #define NUM_DESC_LIST (sizeof(descriptor_list)/sizeof(struct descriptor_list_struct))


 /**************************************************************************
 *
 * Variables - these are the only non-stack RAM usage
 *
 **************************************************************************/

 // zero when we are not configured, non-zero when enumerated
 static volatile uint8_t usb_configuration=0;

 // which modifier keys are currently pressed
 // 1=left ctrl, 2=left shift, 4=left alt, 8=left gui
 // 16=right ctrl, 32=right shift, 64=right alt, 128=right gui
 uint8_t keyboard_modifier_keys=0;

 // which keys are currently pressed, up to 6 keys may be down at once
 uint8_t keyboard_keys[6]={0,0,0,0,0,0};

 // protocol setting from the host. We use exactly the same report
 // either way, so this variable only stores the setting since we
 // are required to be able to report which setting is in use.
 static uint8_t keyboard_protocol=1;

 // the idle configuration, how often we send the report to the
 // host (ms * 4) even when it hasn't changed
 static uint8_t keyboard_idle_config=125;

 // count until idle timeout
 static uint8_t keyboard_idle_count=0;

 // 1=num lock, 2=caps lock, 4=scroll lock, 8=compose, 16=kana
 volatile uint8_t keyboard_leds=0;


 /**************************************************************************
 *
 * Public Functions - these are the API intended for the user
 *
 **************************************************************************/


 // initialize USB
 void usb_init(void)
 {
 HW_CONFIG();
 USB_FREEZE(); // enable USB
 PLL_CONFIG(); // config PLL
 while (!(PLLCSR & (1<<PLOCK))) ; // wait for PLL lock
 USB_CONFIG(); // start USB clock
 UDCON = 0; // enable attach resistor
 usb_configuration = 0;
 UDIEN = (1<<EORSTE)|(1<<SOFE);
 sei();
 }

 // return 0 if the USB is not configured, or the configuration
 // number selected by the HOST
 uint8_t usb_configured(void)
 {
 return usb_configuration;
 }


 // perform a single keystroke
 int8_t usb_keyboard_press(uint8_t key, uint8_t modifier)
 {
 int8_t r;

 keyboard_modifier_keys = modifier;
 keyboard_keys[0] = key;
 r = usb_keyboard_send();
 if (r) return r;
 keyboard_modifier_keys = 0;
 keyboard_keys[0] = 0;
 return usb_keyboard_send();
 }

 // send the contents of keyboard_keys and keyboard_modifier_keys
 int8_t usb_keyboard_send(void)
 {
 uint8_t i, intr_state, timeout;

 if (!usb_configuration) return -1;
 intr_state = SREG;
 cli();
 UENUM = KEYBOARD_ENDPOINT;
 timeout = UDFNUML + 50;
 while (1) {
 // are we ready to transmit?
 if (UEINTX & (1<<RWAL)) break;
 SREG = intr_state;
 // has the USB gone offline?
 if (!usb_configuration) return -1;
 // have we waited too long?
 if (UDFNUML == timeout) return -1;
 // get ready to try checking again
 intr_state = SREG;
 cli();
 UENUM = KEYBOARD_ENDPOINT;
 }
 UEDATX = keyboard_modifier_keys;
 UEDATX = 0;
 for (i=0; i<6; i++) {
 UEDATX = keyboard_keys[i];
 }
 UEINTX = 0x3A;
 keyboard_idle_count = 0;
 SREG = intr_state;
 return 0;
 }

 /**************************************************************************
 *
 * Private Functions - not intended for general user consumption....
 *
 **************************************************************************/



 // USB Device Interrupt - handle all device-level events
 // the transmit buffer flushing is triggered by the start of frame
 //
 ISR(USB_GEN_vect)
 {
 uint8_t intbits, t, i;
 static uint8_t div4=0;

 intbits = UDINT;
 UDINT = 0;
 if (intbits & (1<<EORSTI)) {
 UENUM = 0;
 UECONX = 1;
 UECFG0X = EP_TYPE_CONTROL;
 UECFG1X = EP_SIZE(ENDPOINT0_SIZE) | EP_SINGLE_BUFFER;
 UEIENX = (1<<RXSTPE);
 usb_configuration = 0;
 }
 if ((intbits & (1<<SOFI)) && usb_configuration) {
 if (keyboard_idle_config && (++div4 & 3) == 0) {
 UENUM = KEYBOARD_ENDPOINT;
 if (UEINTX & (1<<RWAL)) {
 keyboard_idle_count++;
 if (keyboard_idle_count == keyboard_idle_config) {
 keyboard_idle_count = 0;
 UEDATX = keyboard_modifier_keys;
 UEDATX = 0;
 for (i=0; i<6; i++) {
 UEDATX = keyboard_keys[i];
 }
 UEINTX = 0x3A;
 }
 }
 }
 }
 }



 // Misc functions to wait for ready and send/receive packets
 static inline void usb_wait_in_ready(void)
 {
 while (!(UEINTX & (1<<TXINI))) ;
 }
 static inline void usb_send_in(void)
 {
 UEINTX = ~(1<<TXINI);
 }
 static inline void usb_wait_receive_out(void)
 {
 while (!(UEINTX & (1<<RXOUTI))) ;
 }
 static inline void usb_ack_out(void)
 {
 UEINTX = ~(1<<RXOUTI);
 }



 // USB Endpoint Interrupt - endpoint 0 is handled here. The
 // other endpoints are manipulated by the user-callable
 // functions, and the start-of-frame interrupt.
 //
 ISR(USB_COM_vect)
 {
 uint8_t intbits;
 const uint8_t *list;
 const uint8_t *cfg;
 uint8_t i, n, len, en;
 uint8_t bmRequestType;
 uint8_t bRequest;
 uint16_t wValue;
 uint16_t wIndex;
 uint16_t wLength;
 uint16_t desc_val;
 const uint8_t *desc_addr;
 uint8_t desc_length;

 UENUM = 0;
 intbits = UEINTX;
 if (intbits & (1<<RXSTPI)) {
 bmRequestType = UEDATX;
 bRequest = UEDATX;
 wValue = UEDATX;
 wValue |= (UEDATX << 8);
 wIndex = UEDATX;
 wIndex |= (UEDATX << 8);
 wLength = UEDATX;
 wLength |= (UEDATX << 8);
 UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));
 if (bRequest == GET_DESCRIPTOR) {
 list = (const uint8_t *)descriptor_list;
 for (i=0; ; i++) {
 if (i >= NUM_DESC_LIST) {
 UECONX = (1<<STALLRQ)|(1<<EPEN); //stall
 return;
 }
 desc_val = pgm_read_word(list);
 if (desc_val != wValue) {
 list += sizeof(struct descriptor_list_struct);
 continue;
 }
 list += 2;
 desc_val = pgm_read_word(list);
 if (desc_val != wIndex) {
 list += sizeof(struct descriptor_list_struct)-2;
 continue;
 }
 list += 2;
 desc_addr = (const uint8_t *)pgm_read_word(list);
 list += 2;
 desc_length = pgm_read_byte(list);
 break;
 }
 len = (wLength < 256) ? wLength : 255;
 if (len > desc_length) len = desc_length;
 do {
 // wait for host ready for IN packet
 do {
 i = UEINTX;
 } while (!(i & ((1<<TXINI)|(1<<RXOUTI))));
 if (i & (1<<RXOUTI)) return; // abort
 // send IN packet
 n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;
 for (i = n; i; i--) {
 UEDATX = pgm_read_byte(desc_addr++);
 }
 len -= n;
 usb_send_in();
 } while (len || n == ENDPOINT0_SIZE);
 return;
 }
 if (bRequest == SET_ADDRESS) {
 usb_send_in();
 usb_wait_in_ready();
 UDADDR = wValue | (1<<ADDEN);
 return;
 }
 if (bRequest == SET_CONFIGURATION && bmRequestType == 0) {
 usb_configuration = wValue;
 usb_send_in();
 cfg = endpoint_config_table;
 for (i=1; i<5; i++) {
 UENUM = i;
 en = pgm_read_byte(cfg++);
 UECONX = en;
 if (en) {
 UECFG0X = pgm_read_byte(cfg++);
 UECFG1X = pgm_read_byte(cfg++);
 }
 }
 UERST = 0x1E;
 UERST = 0;
 return;
 }
 if (bRequest == GET_CONFIGURATION && bmRequestType == 0x80) {
 usb_wait_in_ready();
 UEDATX = usb_configuration;
 usb_send_in();
 return;
 }

 if (bRequest == GET_STATUS) {
 usb_wait_in_ready();
 i = 0;
 #ifdef SUPPORT_ENDPOINT_HALT
 if (bmRequestType == 0x82) {
 UENUM = wIndex;
 if (UECONX & (1<<STALLRQ)) i = 1;
 UENUM = 0;
 }
 #endif
 UEDATX = i;
 UEDATX = 0;
 usb_send_in();
 return;
 }
 #ifdef SUPPORT_ENDPOINT_HALT
 if ((bRequest == CLEAR_FEATURE || bRequest == SET_FEATURE)
 && bmRequestType == 0x02 && wValue == 0) {
 i = wIndex & 0x7F;
 if (i >= 1 && i <= MAX_ENDPOINT) {
 usb_send_in();
 UENUM = i;
 if (bRequest == SET_FEATURE) {
 UECONX = (1<<STALLRQ)|(1<<EPEN);
 } else {
 UECONX = (1<<STALLRQC)|(1<<RSTDT)|(1<<EPEN);
 UERST = (1 << i);
 UERST = 0;
 }
 return;
 }
 }
 #endif
 if (wIndex == KEYBOARD_INTERFACE) {
 if (bmRequestType == 0xA1) {
 if (bRequest == HID_GET_REPORT) {
 usb_wait_in_ready();
 UEDATX = keyboard_modifier_keys;
 UEDATX = 0;
 for (i=0; i<6; i++) {
 UEDATX = keyboard_keys[i];
 }
 usb_send_in();
 return;
 }
 if (bRequest == HID_GET_IDLE) {
 usb_wait_in_ready();
 UEDATX = keyboard_idle_config;
 usb_send_in();
 return;
 }
 if (bRequest == HID_GET_PROTOCOL) {
 usb_wait_in_ready();
 UEDATX = keyboard_protocol;
 usb_send_in();
 return;
 }
 }
 if (bmRequestType == 0x21) {
 if (bRequest == HID_SET_REPORT) {
 usb_wait_receive_out();
 keyboard_leds = UEDATX;
 usb_ack_out();
 usb_send_in();
 return;
 }
 if (bRequest == HID_SET_IDLE) {
 keyboard_idle_config = (wValue >> 8);
 keyboard_idle_count = 0;
 usb_send_in();
 return;
 }
 if (bRequest == HID_SET_PROTOCOL) {
 keyboard_protocol = wValue;
 usb_send_in();
 return;
 }
 }
 }
 }
 UECONX = (1<<STALLRQ) | (1<<EPEN); // stall
 }


--- a/USB/pjrc/usb_keyboard.h
+++ b/USB/pjrc/usb_keyboard.h
@@ -0,0 +1,16 @@
 #ifndef usb_serial_h__
 #define usb_serial_h__

 #include <stdint.h>

 void usb_init(void); // initialize everything
 uint8_t usb_configured(void); // is the USB port configured

 int8_t usb_keyboard_press(uint8_t key, uint8_t modifier);
 int8_t usb_keyboard_send(void);
 extern uint8_t keyboard_modifier_keys;
 extern uint8_t keyboard_keys[6];
 extern volatile uint8_t keyboard_leds;

 #endif

--- a/USB/pjrc/usb_keyboard_debug.c
+++ b/USB/pjrc/usb_keyboard_debug.c
@@ -0,0 +1,750 @@
 /* USB Keyboard Plus Debug Channel Example for Teensy USB Development Board
 * http://www.pjrc.com/teensy/usb_keyboard.html
 * Copyright (c) 2009 PJRC.COM, LLC
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

 // Version 1.0: Initial Release
 // Version 1.1: Add support for Teensy 2.0

 #define USB_SERIAL_PRIVATE_INCLUDE
 #include "usb_keyboard_debug.h"

 /**************************************************************************
 *
 * Configurable Options
 *
 **************************************************************************/

 // You can change these to give your code its own name.
 #define STR_MANUFACTURER L"MfgName"
 #define STR_PRODUCT L"Keyboard"


 // Mac OS-X and Linux automatically load the correct drivers. On
 // Windows, even though the driver is supplied by Microsoft, an
 // INF file is needed to load the driver. These numbers need to
 // match the INF file.
 #define VENDOR_ID 0x16C0
 #define PRODUCT_ID 0x047D


 // USB devices are supposed to implment a halt feature, which is
 // rarely (if ever) used. If you comment this line out, the halt
 // code will be removed, saving 102 bytes of space (gcc 4.3.0).
 // This is not strictly USB compliant, but works with all major
 // operating systems.
 #define SUPPORT_ENDPOINT_HALT



 /**************************************************************************
 *
 * Endpoint Buffer Configuration
 *
 **************************************************************************/

 #define ENDPOINT0_SIZE 32

 #define KEYBOARD_INTERFACE 0
 #define KEYBOARD_ENDPOINT 3
 #define KEYBOARD_SIZE 8
 #define KEYBOARD_BUFFER EP_DOUBLE_BUFFER

 #define DEBUG_INTERFACE 1
 #define DEBUG_TX_ENDPOINT 4
 #define DEBUG_TX_SIZE 32
 #define DEBUG_TX_BUFFER EP_DOUBLE_BUFFER

 static const uint8_t PROGMEM endpoint_config_table[] = {
 0,
 0,
 1, EP_TYPE_INTERRUPT_IN, EP_SIZE(KEYBOARD_SIZE) | KEYBOARD_BUFFER,
 1, EP_TYPE_INTERRUPT_IN, EP_SIZE(DEBUG_TX_SIZE) | DEBUG_TX_BUFFER
 };


 /**************************************************************************
 *
 * Descriptor Data
 *
 **************************************************************************/

 // Descriptors are the data that your computer reads when it auto-detects
 // this USB device (called "enumeration" in USB lingo). The most commonly
 // changed items are editable at the top of this file. Changing things
 // in here should only be done by those who've read chapter 9 of the USB
 // spec and relevant portions of any USB class specifications!


 static const uint8_t PROGMEM device_descriptor[] = {
 18, // bLength
 1, // bDescriptorType
 0x00, 0x02, // bcdUSB
 0, // bDeviceClass
 0, // bDeviceSubClass
 0, // bDeviceProtocol
 ENDPOINT0_SIZE, // bMaxPacketSize0
 LSB(VENDOR_ID), MSB(VENDOR_ID), // idVendor
 LSB(PRODUCT_ID), MSB(PRODUCT_ID), // idProduct
 0x00, 0x01, // bcdDevice
 1, // iManufacturer
 2, // iProduct
 0, // iSerialNumber
 1 // bNumConfigurations
 };

 // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60
 static const uint8_t PROGMEM keyboard_hid_report_desc[] = {
 0x05, 0x01, // Usage Page (Generic Desktop),
 0x09, 0x06, // Usage (Keyboard),
 0xA1, 0x01, // Collection (Application),
 0x75, 0x01, // Report Size (1),
 0x95, 0x08, // Report Count (8),
 0x05, 0x07, // Usage Page (Key Codes),
 0x19, 0xE0, // Usage Minimum (224),
 0x29, 0xE7, // Usage Maximum (231),
 0x15, 0x00, // Logical Minimum (0),
 0x25, 0x01, // Logical Maximum (1),
 0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte
 0x95, 0x01, // Report Count (1),
 0x75, 0x08, // Report Size (8),
 0x81, 0x03, // Input (Constant), ;Reserved byte
 0x95, 0x05, // Report Count (5),
 0x75, 0x01, // Report Size (1),
 0x05, 0x08, // Usage Page (LEDs),
 0x19, 0x01, // Usage Minimum (1),
 0x29, 0x05, // Usage Maximum (5),
 0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report
 0x95, 0x01, // Report Count (1),
 0x75, 0x03, // Report Size (3),
 0x91, 0x03, // Output (Constant), ;LED report padding
 0x95, 0x06, // Report Count (6),
 0x75, 0x08, // Report Size (8),
 0x15, 0x00, // Logical Minimum (0),
 0x25, 0x68, // Logical Maximum(104),
 0x05, 0x07, // Usage Page (Key Codes),
 0x19, 0x00, // Usage Minimum (0),
 0x29, 0x68, // Usage Maximum (104),
 0x81, 0x00, // Input (Data, Array),
 0xc0 // End Collection
 };

 static const uint8_t PROGMEM debug_hid_report_desc[] = {
 0x06, 0x31, 0xFF, // Usage Page 0xFF31 (vendor defined)
 0x09, 0x74, // Usage 0x74
 0xA1, 0x53, // Collection 0x53
 0x75, 0x08, // report size = 8 bits
 0x15, 0x00, // logical minimum = 0
 0x26, 0xFF, 0x00, // logical maximum = 255
 0x95, DEBUG_TX_SIZE, // report count
 0x09, 0x75, // usage
 0x81, 0x02, // Input (array)
 0xC0 // end collection
 };

 #define CONFIG1_DESC_SIZE (9+9+9+7+9+9+7)
 #define KEYBOARD_HID_DESC_OFFSET (9+9)
 #define DEBUG_HID_DESC_OFFSET (9+9+9+7+9)
 static const uint8_t PROGMEM config1_descriptor[CONFIG1_DESC_SIZE] = {
 // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10
 9, // bLength;
 2, // bDescriptorType;
 LSB(CONFIG1_DESC_SIZE), // wTotalLength
 MSB(CONFIG1_DESC_SIZE),
 2, // bNumInterfaces
 1, // bConfigurationValue
 0, // iConfiguration
 0xC0, // bmAttributes
 50, // bMaxPower
 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 9, // bLength
 4, // bDescriptorType
 KEYBOARD_INTERFACE, // bInterfaceNumber
 0, // bAlternateSetting
 1, // bNumEndpoints
 0x03, // bInterfaceClass (0x03 = HID)
 0x01, // bInterfaceSubClass (0x01 = Boot)
 0x01, // bInterfaceProtocol (0x01 = Keyboard)
 0, // iInterface
 // HID interface descriptor, HID 1.11 spec, section 6.2.1
 9, // bLength
 0x21, // bDescriptorType
 0x11, 0x01, // bcdHID
 0, // bCountryCode
 1, // bNumDescriptors
 0x22, // bDescriptorType
 sizeof(keyboard_hid_report_desc), // wDescriptorLength
 0,
 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 7, // bLength
 5, // bDescriptorType
 KEYBOARD_ENDPOINT | 0x80, // bEndpointAddress
 0x03, // bmAttributes (0x03=intr)
 KEYBOARD_SIZE, 0, // wMaxPacketSize
 1, // bInterval
 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 9, // bLength
 4, // bDescriptorType
 DEBUG_INTERFACE, // bInterfaceNumber
 0, // bAlternateSetting
 1, // bNumEndpoints
 0x03, // bInterfaceClass (0x03 = HID)
 0x00, // bInterfaceSubClass
 0x00, // bInterfaceProtocol
 0, // iInterface
 // HID interface descriptor, HID 1.11 spec, section 6.2.1
 9, // bLength
 0x21, // bDescriptorType
 0x11, 0x01, // bcdHID
 0, // bCountryCode
 1, // bNumDescriptors
 0x22, // bDescriptorType
 sizeof(debug_hid_report_desc), // wDescriptorLength
 0,
 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 7, // bLength
 5, // bDescriptorType
 DEBUG_TX_ENDPOINT | 0x80, // bEndpointAddress
 0x03, // bmAttributes (0x03=intr)
 DEBUG_TX_SIZE, 0, // wMaxPacketSize
 1 // bInterval
 };

 // If you're desperate for a little extra code memory, these strings
 // can be completely removed if iManufacturer, iProduct, iSerialNumber
 // in the device desciptor are changed to zeros.
 struct usb_string_descriptor_struct {
 uint8_t bLength;
 uint8_t bDescriptorType;
 int16_t wString[];
 };
 static const struct usb_string_descriptor_struct PROGMEM string0 = {
 4,
 3,
 {0x0409}
 };
 static const struct usb_string_descriptor_struct PROGMEM string1 = {
 sizeof(STR_MANUFACTURER),
 3,
 STR_MANUFACTURER
 };
 static const struct usb_string_descriptor_struct PROGMEM string2 = {
 sizeof(STR_PRODUCT),
 3,
 STR_PRODUCT
 };

 // This table defines which descriptor data is sent for each specific
 // request from the host (in wValue and wIndex).
 static const struct descriptor_list_struct {
 uint16_t wValue;
 uint16_t wIndex;
 const uint8_t *addr;
 uint8_t length;
 } PROGMEM descriptor_list[] = {
 {0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},
 {0x0200, 0x0000, config1_descriptor, sizeof(config1_descriptor)},
 {0x2200, KEYBOARD_INTERFACE, keyboard_hid_report_desc, sizeof(keyboard_hid_report_desc)},
 {0x2100, KEYBOARD_INTERFACE, config1_descriptor+KEYBOARD_HID_DESC_OFFSET, 9},
 {0x2200, DEBUG_INTERFACE, debug_hid_report_desc, sizeof(debug_hid_report_desc)},
 {0x2100, DEBUG_INTERFACE, config1_descriptor+DEBUG_HID_DESC_OFFSET, 9},
 {0x0300, 0x0000, (const uint8_t *)&string0, 4},
 {0x0301, 0x0409, (const uint8_t *)&string1, sizeof(STR_MANUFACTURER)},
 {0x0302, 0x0409, (const uint8_t *)&string2, sizeof(STR_PRODUCT)}
 };
 #define NUM_DESC_LIST (sizeof(descriptor_list)/sizeof(struct descriptor_list_struct))


 /**************************************************************************
 *
 * Variables - these are the only non-stack RAM usage
 *
 **************************************************************************/

 // zero when we are not configured, non-zero when enumerated
 static volatile uint8_t usb_configuration=0;

 // the time remaining before we transmit any partially full
 // packet, or send a zero length packet.
 static volatile uint8_t debug_flush_timer=0;

 // which modifier keys are currently pressed
 // 1=left ctrl, 2=left shift, 4=left alt, 8=left gui
 // 16=right ctrl, 32=right shift, 64=right alt, 128=right gui
 uint8_t keyboard_modifier_keys=0;

 // which keys are currently pressed, up to 6 keys may be down at once
 uint8_t keyboard_keys[6]={0,0,0,0,0,0};

 // protocol setting from the host. We use exactly the same report
 // either way, so this variable only stores the setting since we
 // are required to be able to report which setting is in use.
 static uint8_t keyboard_protocol=1;

 // the idle configuration, how often we send the report to the
 // host (ms * 4) even when it hasn't changed
 static uint8_t keyboard_idle_config=125;

 // count until idle timeout
 static uint8_t keyboard_idle_count=0;

 // 1=num lock, 2=caps lock, 4=scroll lock, 8=compose, 16=kana
 volatile uint8_t keyboard_leds=0;


 /**************************************************************************
 *
 * Public Functions - these are the API intended for the user
 *
 **************************************************************************/


 // initialize USB
 void usb_init(void)
 {
 HW_CONFIG();
 USB_FREEZE(); // enable USB
 PLL_CONFIG(); // config PLL
 while (!(PLLCSR & (1<<PLOCK))) ; // wait for PLL lock
 USB_CONFIG(); // start USB clock
 UDCON = 0; // enable attach resistor
 usb_configuration = 0;
 UDIEN = (1<<EORSTE)|(1<<SOFE);
 sei();
 }

 // return 0 if the USB is not configured, or the configuration
 // number selected by the HOST
 uint8_t usb_configured(void)
 {
 return usb_configuration;
 }


 // perform a single keystroke
 int8_t usb_keyboard_press(uint8_t key, uint8_t modifier)
 {
 int8_t r;

 keyboard_modifier_keys = modifier;
 keyboard_keys[0] = key;
 r = usb_keyboard_send();
 if (r) return r;
 keyboard_modifier_keys = 0;
 keyboard_keys[0] = 0;
 return usb_keyboard_send();
 }

 // send the contents of keyboard_keys and keyboard_modifier_keys
 int8_t usb_keyboard_send(void)
 {
 uint8_t i, intr_state, timeout;

 if (!usb_configuration) return -1;
 intr_state = SREG;
 cli();
 UENUM = KEYBOARD_ENDPOINT;
 timeout = UDFNUML + 50;
 while (1) {
 // are we ready to transmit?
 if (UEINTX & (1<<RWAL)) break;
 SREG = intr_state;
 // has the USB gone offline?
 if (!usb_configuration) return -1;
 // have we waited too long?
 if (UDFNUML == timeout) return -1;
 // get ready to try checking again
 intr_state = SREG;
 cli();
 UENUM = KEYBOARD_ENDPOINT;
 }
 UEDATX = keyboard_modifier_keys;
 UEDATX = 0;
 for (i=0; i<6; i++) {
 UEDATX = keyboard_keys[i];
 }
 UEINTX = 0x3A;
 keyboard_idle_count = 0;
 SREG = intr_state;
 return 0;
 }

 // transmit a character. 0 returned on success, -1 on error
 int8_t usb_debug_putchar(uint8_t c)
 {
 static uint8_t previous_timeout=0;
 uint8_t timeout, intr_state;

 // if we're not online (enumerated and configured), error
 if (!usb_configuration) return -1;
 // interrupts are disabled so these functions can be
 // used from the main program or interrupt context,
 // even both in the same program!
 intr_state = SREG;
 cli();
 UENUM = DEBUG_TX_ENDPOINT;
 // if we gave up due to timeout before, don't wait again
 if (previous_timeout) {
 if (!(UEINTX & (1<<RWAL))) {
 SREG = intr_state;
 return -1;
 }
 previous_timeout = 0;
 }
 // wait for the FIFO to be ready to accept data
 timeout = UDFNUML + 4;
 while (1) {
 // are we ready to transmit?
 if (UEINTX & (1<<RWAL)) break;
 SREG = intr_state;
 // have we waited too long?
 if (UDFNUML == timeout) {
 previous_timeout = 1;
 return -1;
 }
 // has the USB gone offline?
 if (!usb_configuration) return -1;
 // get ready to try checking again
 intr_state = SREG;
 cli();
 UENUM = DEBUG_TX_ENDPOINT;
 }
 // actually write the byte into the FIFO
 UEDATX = c;
 // if this completed a packet, transmit it now!
 if (!(UEINTX & (1<<RWAL))) {
 UEINTX = 0x3A;
 debug_flush_timer = 0;
 } else {
 debug_flush_timer = 2;
 }
 SREG = intr_state;
 return 0;
 }


 // immediately transmit any buffered output.
 void usb_debug_flush_output(void)
 {
 uint8_t intr_state;

 intr_state = SREG;
 cli();
 if (debug_flush_timer) {
 UENUM = DEBUG_TX_ENDPOINT;
 while ((UEINTX & (1<<RWAL))) {
 UEDATX = 0;
 }
 UEINTX = 0x3A;
 debug_flush_timer = 0;
 }
 SREG = intr_state;
 }



 /**************************************************************************
 *
 * Private Functions - not intended for general user consumption....
 *
 **************************************************************************/



 // USB Device Interrupt - handle all device-level events
 // the transmit buffer flushing is triggered by the start of frame
 //
 ISR(USB_GEN_vect)
 {
 uint8_t intbits, t, i;
 static uint8_t div4=0;

 intbits = UDINT;
 UDINT = 0;
 if (intbits & (1<<EORSTI)) {
 UENUM = 0;
 UECONX = 1;
 UECFG0X = EP_TYPE_CONTROL;
 UECFG1X = EP_SIZE(ENDPOINT0_SIZE) | EP_SINGLE_BUFFER;
 UEIENX = (1<<RXSTPE);
 usb_configuration = 0;
 }
 if ((intbits & (1<<SOFI)) && usb_configuration) {
 t = debug_flush_timer;
 if (t) {
 debug_flush_timer = -- t;
 if (!t) {
 UENUM = DEBUG_TX_ENDPOINT;
 while ((UEINTX & (1<<RWAL))) {
 UEDATX = 0;
 }
 UEINTX = 0x3A;
 }
 }
 if (keyboard_idle_config && (++div4 & 3) == 0) {
 UENUM = KEYBOARD_ENDPOINT;
 if (UEINTX & (1<<RWAL)) {
 keyboard_idle_count++;
 if (keyboard_idle_count == keyboard_idle_config) {
 keyboard_idle_count = 0;
 UEDATX = keyboard_modifier_keys;
 UEDATX = 0;
 for (i=0; i<6; i++) {
 UEDATX = keyboard_keys[i];
 }
 UEINTX = 0x3A;
 }
 }
 }
 }
 }



 // Misc functions to wait for ready and send/receive packets
 static inline void usb_wait_in_ready(void)
 {
 while (!(UEINTX & (1<<TXINI))) ;
 }
 static inline void usb_send_in(void)
 {
 UEINTX = ~(1<<TXINI);
 }
 static inline void usb_wait_receive_out(void)
 {
 while (!(UEINTX & (1<<RXOUTI))) ;
 }
 static inline void usb_ack_out(void)
 {
 UEINTX = ~(1<<RXOUTI);
 }



 // USB Endpoint Interrupt - endpoint 0 is handled here. The
 // other endpoints are manipulated by the user-callable
 // functions, and the start-of-frame interrupt.
 //
 ISR(USB_COM_vect)
 {
 uint8_t intbits;
 const uint8_t *list;
 const uint8_t *cfg;
 uint8_t i, n, len, en;
 uint8_t bmRequestType;
 uint8_t bRequest;
 uint16_t wValue;
 uint16_t wIndex;
 uint16_t wLength;
 uint16_t desc_val;
 const uint8_t *desc_addr;
 uint8_t desc_length;

 UENUM = 0;
 intbits = UEINTX;
 if (intbits & (1<<RXSTPI)) {
 bmRequestType = UEDATX;
 bRequest = UEDATX;
 wValue = UEDATX;
 wValue |= (UEDATX << 8);
 wIndex = UEDATX;
 wIndex |= (UEDATX << 8);
 wLength = UEDATX;
 wLength |= (UEDATX << 8);
 UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));
 if (bRequest == GET_DESCRIPTOR) {
 list = (const uint8_t *)descriptor_list;
 for (i=0; ; i++) {
 if (i >= NUM_DESC_LIST) {
 UECONX = (1<<STALLRQ)|(1<<EPEN); //stall
 return;
 }
 desc_val = pgm_read_word(list);
 if (desc_val != wValue) {
 list += sizeof(struct descriptor_list_struct);
 continue;
 }
 list += 2;
 desc_val = pgm_read_word(list);
 if (desc_val != wIndex) {
 list += sizeof(struct descriptor_list_struct)-2;
 continue;
 }
 list += 2;
 desc_addr = (const uint8_t *)pgm_read_word(list);
 list += 2;
 desc_length = pgm_read_byte(list);
 break;
 }
 len = (wLength < 256) ? wLength : 255;
 if (len > desc_length) len = desc_length;
 do {
 // wait for host ready for IN packet
 do {
 i = UEINTX;
 } while (!(i & ((1<<TXINI)|(1<<RXOUTI))));
 if (i & (1<<RXOUTI)) return; // abort
 // send IN packet
 n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;
 for (i = n; i; i--) {
 UEDATX = pgm_read_byte(desc_addr++);
 }
 len -= n;
 usb_send_in();
 } while (len || n == ENDPOINT0_SIZE);
 return;
 }
 if (bRequest == SET_ADDRESS) {
 usb_send_in();
 usb_wait_in_ready();
 UDADDR = wValue | (1<<ADDEN);
 return;
 }
 if (bRequest == SET_CONFIGURATION && bmRequestType == 0) {
 usb_configuration = wValue;
 usb_send_in();
 cfg = endpoint_config_table;
 for (i=1; i<5; i++) {
 UENUM = i;
 en = pgm_read_byte(cfg++);
 UECONX = en;
 if (en) {
 UECFG0X = pgm_read_byte(cfg++);
 UECFG1X = pgm_read_byte(cfg++);
 }
 }
 UERST = 0x1E;
 UERST = 0;
 return;
 }
 if (bRequest == GET_CONFIGURATION && bmRequestType == 0x80) {
 usb_wait_in_ready();
 UEDATX = usb_configuration;
 usb_send_in();
 return;
 }

 if (bRequest == GET_STATUS) {
 usb_wait_in_ready();
 i = 0;
 #ifdef SUPPORT_ENDPOINT_HALT
 if (bmRequestType == 0x82) {
 UENUM = wIndex;
 if (UECONX & (1<<STALLRQ)) i = 1;
 UENUM = 0;
 }
 #endif
 UEDATX = i;
 UEDATX = 0;
 usb_send_in();
 return;
 }
 #ifdef SUPPORT_ENDPOINT_HALT
 if ((bRequest == CLEAR_FEATURE || bRequest == SET_FEATURE)
 && bmRequestType == 0x02 && wValue == 0) {
 i = wIndex & 0x7F;
 if (i >= 1 && i <= MAX_ENDPOINT) {
 usb_send_in();
 UENUM = i;
 if (bRequest == SET_FEATURE) {
 UECONX = (1<<STALLRQ)|(1<<EPEN);
 } else {
 UECONX = (1<<STALLRQC)|(1<<RSTDT)|(1<<EPEN);
 UERST = (1 << i);
 UERST = 0;
 }
 return;
 }
 }
 #endif
 if (wIndex == KEYBOARD_INTERFACE) {
 if (bmRequestType == 0xA1) {
 if (bRequest == HID_GET_REPORT) {
 usb_wait_in_ready();
 UEDATX = keyboard_modifier_keys;
 UEDATX = 0;
 for (i=0; i<6; i++) {
 UEDATX = keyboard_keys[i];
 }
 usb_send_in();
 return;
 }
 if (bRequest == HID_GET_IDLE) {
 usb_wait_in_ready();
 UEDATX = keyboard_idle_config;
 usb_send_in();
 return;
 }
 if (bRequest == HID_GET_PROTOCOL) {
 usb_wait_in_ready();
 UEDATX = keyboard_protocol;
 usb_send_in();
 return;
 }
 }
 if (bmRequestType == 0x21) {
 if (bRequest == HID_SET_REPORT) {
 usb_wait_receive_out();
 keyboard_leds = UEDATX;
 usb_ack_out();
 usb_send_in();
 return;
 }
 if (bRequest == HID_SET_IDLE) {
 keyboard_idle_config = (wValue >> 8);
 keyboard_idle_count = 0;
 //usb_wait_in_ready();
 usb_send_in();
 return;
 }
 if (bRequest == HID_SET_PROTOCOL) {
 keyboard_protocol = wValue;
 //usb_wait_in_ready();
 usb_send_in();
 return;
 }
 }
 }
 if (wIndex == DEBUG_INTERFACE) {
 if (bRequest == HID_GET_REPORT && bmRequestType == 0xA1) {
 len = wLength;
 do {
 // wait for host ready for IN packet
 do {
 i = UEINTX;
 } while (!(i & ((1<<TXINI)|(1<<RXOUTI))));
 if (i & (1<<RXOUTI)) return; // abort
 // send IN packet
 n = len < ENDPOINT0_SIZE ? len : ENDPOINT0_SIZE;
 for (i = n; i; i--) {
 UEDATX = 0;
 }
 len -= n;
 usb_send_in();
 } while (len || n == ENDPOINT0_SIZE);
 return;
 }
 }
 }
 UECONX = (1<<STALLRQ) | (1<<EPEN); // stall
 }


--- a/USB/pjrc/usb_keyboard_debug.h
+++ b/USB/pjrc/usb_keyboard_debug.h
@@ -0,0 +1,91 @@
 #ifndef usb_serial_h__
 #define usb_serial_h__

 #include <stdint.h>

 void usb_init(void); // initialize everything
 uint8_t usb_configured(void); // is the USB port configured

 int8_t usb_keyboard_press(uint8_t key, uint8_t modifier);
 int8_t usb_keyboard_send(void);
 extern uint8_t keyboard_modifier_keys;
 extern uint8_t keyboard_keys[6];
 extern volatile uint8_t keyboard_leds;

 int8_t usb_debug_putchar(uint8_t c); // transmit a character
 void usb_debug_flush_output(void); // immediately transmit any buffered output
 #define USB_DEBUG_HID


 // Everything below this point is only intended for usb_serial.c
 #ifdef USB_SERIAL_PRIVATE_INCLUDE
 #include <avr/io.h>
 #include <avr/pgmspace.h>
 #include <avr/interrupt.h>

 #define EP_TYPE_CONTROL 0x00
 #define EP_TYPE_BULK_IN 0x81
 #define EP_TYPE_BULK_OUT 0x80
 #define EP_TYPE_INTERRUPT_IN 0xC1
 #define EP_TYPE_INTERRUPT_OUT 0xC0
 #define EP_TYPE_ISOCHRONOUS_IN 0x41
 #define EP_TYPE_ISOCHRONOUS_OUT 0x40

 #define EP_SINGLE_BUFFER 0x02
 #define EP_DOUBLE_BUFFER 0x06

 #define EP_SIZE(s) ((s) == 64 ? 0x30 : \
 ((s) == 32 ? 0x20 : \
 ((s) == 16 ? 0x10 : \
 0x00)))

 #define MAX_ENDPOINT 4

 #define LSB(n) (n & 255)
 #define MSB(n) ((n >> 8) & 255)

 #if defined(__AVR_AT90USB162__)
 #define HW_CONFIG() 
 #define PLL_CONFIG() (PLLCSR = ((1<<PLLE)|(1<<PLLP0)))
 #define USB_CONFIG() (USBCON = (1<<USBE))
 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 #elif defined(__AVR_ATmega32U4__)
 #define HW_CONFIG() (UHWCON = 0x01)
 #define PLL_CONFIG() (PLLCSR = 0x12)
 #define USB_CONFIG() (USBCON = ((1<<USBE)|(1<<OTGPADE)))
 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 #elif defined(__AVR_AT90USB646__)
 #define HW_CONFIG() (UHWCON = 0x81)
 #define PLL_CONFIG() (PLLCSR = 0x1A)
 #define USB_CONFIG() (USBCON = ((1<<USBE)|(1<<OTGPADE)))
 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 #elif defined(__AVR_AT90USB1286__)
 #define HW_CONFIG() (UHWCON = 0x81)
 #define PLL_CONFIG() (PLLCSR = 0x16)
 #define USB_CONFIG() (USBCON = ((1<<USBE)|(1<<OTGPADE)))
 #define USB_FREEZE() (USBCON = ((1<<USBE)|(1<<FRZCLK)))
 #endif

 // standard control endpoint request types
 #define GET_STATUS 0
 #define CLEAR_FEATURE 1
 #define SET_FEATURE 3
 #define SET_ADDRESS 5
 #define GET_DESCRIPTOR 6
 #define GET_CONFIGURATION 8
 #define SET_CONFIGURATION 9
 #define GET_INTERFACE 10
 #define SET_INTERFACE 11
 // HID (human interface device)
 #define HID_GET_REPORT 1
 #define HID_GET_IDLE 2
 #define HID_GET_PROTOCOL 3
 #define HID_SET_REPORT 9
 #define HID_SET_IDLE 10
 #define HID_SET_PROTOCOL 11
 // CDC (communication class device)
 #define CDC_SET_LINE_CODING 0x20
 #define CDC_GET_LINE_CODING 0x21
 #define CDC_SET_CONTROL_LINE_STATE 0x22
 #endif
 #endif
--- a/setup.cmake
+++ b/setup.cmake
@@ -0,0 +1,109 @@
 ###| CMAKE Kiibohd Controller Source Configurator |###
 #
 # Written by Jacob Alexander in 2011 for the Kiibohd Controller
 #
 # Released into the Public Domain
 #
 ###



 ###
 # Project Modules
 #

 #| Each module is defined by it's own folder (e.g. Scan/Matrix represents the "Matrix" module)
 #| All of the modules must be specified, as they generate the sources list of files to compile
 #| Any modifications to this file will cause a complete rebuild of the project

 #| Please the {Scan,Macro,USB,Debug}/module.txt for information on the modules and how to create new ones

 ##| Deals with acquiring the keypress information and turning it into a key index
 set( ScanModule "matrix" )

 ##| Uses the key index and potentially applies special conditions to it, mapping it to a usb key code
 set( MacroModule "basic" )

 ##| Sends the current list of usb key codes through USB HID
 set( USBModule "pjrc" )

 ##| Debugging source to use, each module has it's own set of defines that it sets
 set( DebugModule "basic" )



 ###
 # Path Setup
 # 
 set( ScanModulePath "Scan/${ScanModule}" )
 set( MacroModulePath "Macro/${MacroModule}" )
 set( USBModulePath "USB/${USBModule}" )
 set( DebugModulePath "Debug/${DebugModule}" )




 ###
 # Module Configuration
 #

 #| Additional options, usually define settings
 add_definitions()

 #| Include path for each of the modules TODO Fixme!! (../)
 add_definitions("
 -I../${ScanModulePath}
 -I../${MacroModulePath}
 -I../${USBModulePath}
 -I../${DebugModulePath}
 ")



 ###
 # Module Processing
 #

 #| Go through lists of sources and append paths
 #| Usage:
 #| PathPrepend( OutputListOfSources <Prepend Path> <InputListOfSources> )
 macro( PathPrepend Output SourcesPath )
 unset( tmpSource )

 # Loop through items
 foreach( item ${ARGN} )
 set( tmpSource ${tmpSource} "${SourcesPath}/${item}" )
 endforeach( item )

 # Finalize by writing the new list back over the old one
 set( ${Output} ${tmpSource} )
 endmacro( PathPrepend )


 #| Scan Module
 include( "${ScanModulePath}/setup.cmake" )
 PathPrepend( SCAN_SRCS ${ScanModulePath} ${SCAN_SRCS} )

 #| Macro Module
 include( "${MacroModulePath}/setup.cmake" )
 PathPrepend( MACRO_SRCS ${MacroModulePath} ${MACRO_SRCS} )

 #| USB Module
 include( "${USBModulePath}/setup.cmake" )
 PathPrepend( USB_SRCS ${USBModulePath} ${USB_SRCS} )

 #| Debugging Module
 include( "${DebugModulePath}/setup.cmake" )
 PathPrepend( DEBUG_SRCS ${DebugModulePath} ${DEBUG_SRCS} )


 #| Print list of all module sources
 message( STATUS "Detected Scan Module Source Files:
 ${SCAN_SRCS}")
 message( STATUS "Detected Macro Module Source Files:
 ${MACRO_SRCS}")
 message( STATUS "Detected USB Module Source Files:
 ${USB_SRCS}")
 message( STATUS "Detected Debug Module Source Files:
 ${DEBUG_SRCS}")