// Do not remove the include below #include "ArduinoKeyboard.h" // Copyright 2013 Jesse Vincent // All Rights Reserved. (To be licensed under an opensource license // before the release of the keyboard.io model 01 #include static const int COLS = 14; static const int ROWS = 5; static int colPins[COLS] = { 16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; static int rowPins[ROWS] = { A2, A3, A4, A5, 15 }; byte matrixState[ROWS][COLS]; long counter = 0; static const int LAYERS = 2; int current_layer = 0; int previous_keymap = 0; static const Key keymaps[LAYERS][ROWS][COLS] = { { { NoKey, Key_1, Key_2, Key_3, Key_4, Key_5, NoKey, NoKey, Key_6, Key_7, Key_8, Key_9, Key_0, NoKey }, { Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, NoKey, NoKey, Key_Y, Key_U, Key_I, Key_O, Key_P, Key_Equals}, { Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G, Key_Tab, Key_Return, Key_H, Key_J, Key_K, Key_L, Key_Semicolon, Key_Quote }, { Key_PageDn, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Esc, Key_Return, Key_N, Key_M, Key_Comma, Key_Period, Key_Slash, Key_Minus}, { Key_LGUI, Key_Backspace, Key_LShift, Key_LCtrl, NextKeymap, NoKey, NoKey, NoKey, NoKey, NextKeymap, Key_RCtrl, Key_RShift, Key_Space, Key_RAlt } }, { { NoKey, Key_1, Key_2, Key_3, Key_4, Key_5, NoKey, NoKey, Key_6, Key_7, Key_8, Key_9, Key_0, NoKey }, { Key_Backtick, Key_Q, mouseBtnL, mouseBtnM, mouseBtnR, Key_T, NoKey, NoKey, Key_LCurlyBracket, Key_RCurlyBracket, Key_LSquareBracket, Key_RSquareBracket, Key_P, Key_Equals}, { Key_PageUp, mouseL, mouseUp, mouseDn, mouseR, Key_G, Key_Tab, Key_Return, Key_LArrow, Key_DnArrow, Key_UpArrow, Key_RArrow, Key_Semicolon, Key_Quote}, { Key_PageDn, Key_Z, mouseBtnL, mouseBtnM, mouseBtnR, Key_B, Key_Esc, Key_Return, Key_Pipe, Key_M, Key_Comma, Key_Period, Key_Backslash, Key_Minus}, { Key_LGUI, Key_Backspace, Key_LShift, Key_LCtrl, NextKeymap, NoKey, NoKey, NoKey, NoKey, NextKeymap, Key_RCtrl, Key_RShift, Key_Space, Key_RAlt } } }; boolean key_was_pressed (byte keyState) { if ( byte((keyState >> 4)) ^ B00001111 ) { return false; } else { return true; } } boolean key_was_not_pressed (byte keyState) { if ( byte((keyState >> 4)) ^ B00000000 ) { return false; } else { return true; } } boolean key_is_pressed (byte keyState) { if ( byte((keyState << 4)) ^ B11110000 ) { return false; } else { return true; } } boolean key_is_not_pressed (byte keyState) { if ( byte((keyState << 4)) ^ B00000000 ) { return false; } else { return true; } } boolean key_toggled_on(byte keyState) { if (key_is_pressed(keyState) && key_was_not_pressed(keyState)) { return true; } else { return false; } } boolean key_toggled_off(byte keyState) { if (key_was_pressed(keyState) && key_is_not_pressed(keyState)) { return true; } else { return false; } } void reset_matrix() { for (int col = 0; col < COLS; col++) { for (int row = 0; row < ROWS; row++) { matrixState[row][col] <<= 1; } } } void send_key_events(int layer) { //for every newly pressed button, figure out what logical key it is and send a key down event // for every newly released button, figure out what logical key it is and send a key up event // TODO:switch to sending raw HID packets for (int row = 0; row < ROWS; row++) { for (int col = 0; col < COLS; col++) { int x = 0; int y = 0; byte switchState = matrixState[row][col]; Key mappedKey = keymaps[layer][row][col]; if (mappedKey.flags & MOUSE_KEY ) { if (key_is_pressed(switchState)){ if (mappedKey.rawKey & MOUSE_UP) { y--; } if (mappedKey.rawKey & MOUSE_DN) { y++; } if (mappedKey.rawKey & MOUSE_L) { x--; } if (mappedKey.rawKey & MOUSE_R) { x++; } Mouse.move(x, y, 0); } } else { if (key_toggled_on (switchState)){ Keyboard.press(mappedKey.rawKey); } else if (key_toggled_off (switchState)) { Keyboard.release(mappedKey.rawKey); } } } } } void setup_matrix() { //set up the row pins as outputs for (int row = 0; row < ROWS; row++) { pinMode(rowPins[row], OUTPUT); digitalWrite(rowPins[row], HIGH); } for (int col = 0; col < COLS; col++) { pinMode(colPins[col], INPUT); digitalWrite(colPins[col], HIGH); //drive em high by default s it seems to be more reliable than driving em low } //blank out the matrix. for (int col = 0; col < COLS; col++) { for (int row = 0; row < ROWS; row++) { matrixState[row][col] = 0; } } } void scan_matrix() { int active_layer = current_layer; //scan the Keyboard matrix looking for connections for (int row = 0; row < ROWS; row++) { digitalWrite(rowPins[row], LOW); for (int col = 0; col < COLS; col++) { //If we see an electrical connection on I->J, if (digitalRead(colPins[col])) { matrixState[row][col] |= 0; // noop. just here for clarity } else { matrixState[row][col] |= 1; // noop. just here for clarity } // while we're inspecting the electrical matrix, we look // to see if the Key being held is a firmware level // metakey, so we can act on it, lest we only discover // that we should be looking at a seconary Keymap halfway through the matrix scan if (! (keymaps[active_layer][row][col].flags ^ ( MOMENTARY | SWITCH_TO_LAYER))) { // this logic sucks. there is a better way TODO this if (key_is_pressed(matrixState[row][col])) { active_layer = keymaps[current_layer][row][col].rawKey; } } } digitalWrite(rowPins[row], HIGH); } send_key_events(active_layer); } void report_matrix() { if (counter++ %100 == 0 ) { for (int row = 0; row < ROWS; row++) { for (int col = 0; col < COLS; col++) { Serial.print(matrixState[row][col],HEX); Serial.print(", "); } Serial.println(""); } Serial.println(""); } } void report(int row, int col, boolean value) { Serial.print("Detected a change on "); Serial.print(col); Serial.print(" "); Serial.print(row); Serial.print(" to "); Serial.print(value); Serial.println("."); } void setup() { Keyboard.begin(); Mouse.begin(); Serial.begin(115200); setup_matrix(); } void loop() { scan_matrix(); // report_matrix(); reset_matrix(); }