From b4e1868d199e8b6cecfdbaa7d4f3a00308fa63a7 Mon Sep 17 00:00:00 2001 From: Jacob Alexander Date: Wed, 28 Sep 2011 23:25:51 -0700 Subject: [PATCH] Reorganization for use with the CMake "Modules" - 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 --- CMakeLists.txt | 14 +- Debug/basic/print.c | 190 +++++++++ Debug/basic/print.h | 87 ++++ Debug/basic/setup.cmake | 22 + Keymap/keymap.h | 228 +++++++++++ Keymap/usb_keys.h | 244 +++++++++++ LoadFile/load | 8 + Macro/basic/setup.cmake | 21 + Scan/matrix/matrix.c | 181 ++++++++ Scan/matrix/matrix.h | 151 +++++++ Scan/matrix/scan_loop.c | 137 +++++++ Scan/matrix/scan_loop.h | 31 ++ Scan/matrix/setup.cmake | 23 ++ USB/pjrc/setup.cmake | 22 + USB/pjrc/usb_keyboard.c | 592 +++++++++++++++++++++++++++ USB/pjrc/usb_keyboard.h | 16 + USB/pjrc/usb_keyboard_debug.c | 750 ++++++++++++++++++++++++++++++++++ USB/pjrc/usb_keyboard_debug.h | 91 +++++ setup.cmake | 109 +++++ 19 files changed, 2910 insertions(+), 7 deletions(-) create mode 100644 Debug/basic/print.c create mode 100644 Debug/basic/print.h create mode 100644 Debug/basic/setup.cmake create mode 100644 Keymap/keymap.h create mode 100644 Keymap/usb_keys.h create mode 100755 LoadFile/load create mode 100644 Macro/basic/setup.cmake create mode 100644 Scan/matrix/matrix.c create mode 100644 Scan/matrix/matrix.h create mode 100644 Scan/matrix/scan_loop.c create mode 100644 Scan/matrix/scan_loop.h create mode 100644 Scan/matrix/setup.cmake create mode 100644 USB/pjrc/setup.cmake create mode 100644 USB/pjrc/usb_keyboard.c create mode 100644 USB/pjrc/usb_keyboard.h create mode 100644 USB/pjrc/usb_keyboard_debug.c create mode 100644 USB/pjrc/usb_keyboard_debug.h create mode 100644 setup.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index e98f474..7e3a474 100644 --- 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} ) diff --git a/Debug/basic/print.c b/Debug/basic/print.c new file mode 100644 index 0000000..e721ec4 --- /dev/null +++ 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 + +// AVR Includes +#include +#include + +// 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); +} + diff --git a/Debug/basic/print.h b/Debug/basic/print.h new file mode 100644 index 0000000..f792623 --- /dev/null +++ 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 + +// 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 + diff --git a/Debug/basic/setup.cmake b/Debug/basic/setup.cmake new file mode 100644 index 0000000..04231d9 --- /dev/null +++ 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 +# + diff --git a/Keymap/keymap.h b/Keymap/keymap.h new file mode 100644 index 0000000..a0a0739 --- /dev/null +++ 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 + diff --git a/Keymap/usb_keys.h b/Keymap/usb_keys.h new file mode 100644 index 0000000..762c52a --- /dev/null +++ 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 + diff --git a/LoadFile/load b/LoadFile/load new file mode 100755 index 0000000..dce63f9 --- /dev/null +++ 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 + diff --git a/Macro/basic/setup.cmake b/Macro/basic/setup.cmake new file mode 100644 index 0000000..5e2abaf --- /dev/null +++ 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 +# + diff --git a/Scan/matrix/matrix.c b/Scan/matrix/matrix.c new file mode 100644 index 0000000..8bf3f62 --- /dev/null +++ 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 +} + diff --git a/Scan/matrix/matrix.h b/Scan/matrix/matrix.h new file mode 100644 index 0000000..4b728df --- /dev/null +++ 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 + + diff --git a/Scan/matrix/scan_loop.c b/Scan/matrix/scan_loop.c new file mode 100644 index 0000000..d490c6b --- /dev/null +++ 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 +#include +#include +// 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 ); + } +} + diff --git a/Scan/matrix/scan_loop.h b/Scan/matrix/scan_loop.h new file mode 100644 index 0000000..52c358d --- /dev/null +++ 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 + diff --git a/Scan/matrix/setup.cmake b/Scan/matrix/setup.cmake new file mode 100644 index 0000000..6c6bd8c --- /dev/null +++ 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 ) + diff --git a/USB/pjrc/setup.cmake b/USB/pjrc/setup.cmake new file mode 100644 index 0000000..9cb10e8 --- /dev/null +++ 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 +# + diff --git a/USB/pjrc/usb_keyboard.c b/USB/pjrc/usb_keyboard.c new file mode 100644 index 0000000..89b2e9b --- /dev/null +++ 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<= NUM_DESC_LIST) { + UECONX = (1< desc_length) len = desc_length; + do { + // wait for host ready for IN packet + do { + i = UEINTX; + } while (!(i & ((1<= 1 && i <= MAX_ENDPOINT) { + usb_send_in(); + UENUM = i; + if (bRequest == SET_FEATURE) { + UECONX = (1<> 8); + keyboard_idle_count = 0; + usb_send_in(); + return; + } + if (bRequest == HID_SET_PROTOCOL) { + keyboard_protocol = wValue; + usb_send_in(); + return; + } + } + } + } + UECONX = (1< + +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 + diff --git a/USB/pjrc/usb_keyboard_debug.c b/USB/pjrc/usb_keyboard_debug.c new file mode 100644 index 0000000..f427da1 --- /dev/null +++ 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<= NUM_DESC_LIST) { + UECONX = (1< desc_length) len = desc_length; + do { + // wait for host ready for IN packet + do { + i = UEINTX; + } while (!(i & ((1<= 1 && i <= MAX_ENDPOINT) { + usb_send_in(); + UENUM = i; + if (bRequest == SET_FEATURE) { + UECONX = (1<> 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< + +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 +#include +#include + +#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< ) +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}") +