Add files via upload

Example_Keyboards/Dell_Inspiron_1525/Dell Inspiron 1525 Keyboard D9K01.txt

@@ -0,0 +1,86 @@
+Cntrl-L			15	19	
+Cntrl-R			15	24	
+Shift-L			20	14	
+Shift-R			14	24	
+Alt-L			13	18	
+Alt-R			13	25	
+GUI				16	21	
+Fn				17	23	
+A				12	23	
+B				9	25	
+C				10	24	
+D				10	23	
+E				10	22	
+F				23	9	
+G				18	9	
+H				7	18	
+I				22	6	
+J				23	7	
+K				6	23	
+L				4	23	
+M				24	7	
+N				7	25	
+O				4	22	
+P				5	22	
+Q				12	22	
+R				9	22	
+S				11	23	
+T				9	20	
+U				7	22	
+V				24	9	
+W				11	22	
+X				11	24	
+Y				7	20	
+Z				12	24	
+`				12	19	
+1				21	12	
+2				11	21	
+3				10	21	
+4				9	21	
+5				9	19	
+6				7	19	
+7				21	7	
+8				6	21	
+9				4	21	
+0				5	21	
+-				5	19	
+=				6	19	
+Back Space		20	8	
+Esc				12	18	
+F1				11	19	
+F2				10	19	
+F3				10	20	
+F4				10	18	
+F5				8	18	
+F6				6	18	
+F7				4	20	
+F8				4	19	
+F9				8	19	
+F10				8	21	
+F11				2	21	
+F12				1	21	
+Insert			19	1	
+Delete			2	19	
+Arrow-Right		1	25	
+Arrow-Left		3	25	
+Arrow-Up		3	18	
+Arrow-Down		2	25	
+Menu			3	20	
+/				5	25	
+.				4	24	
+,				6	24	
+;				5	23	
+'				5	18	
+Enter			8	24	
+[				5	20	
+]				20	6	
+\				8	23	
+Caps-Lock		11	20	
+Tab				12	20	
+Space			8	25	
+Home			3	19	
+End				3	21	
+Page-Up			16	22	
+Page-Down		23	16	
+Num-Lock		13	22	
+Print Screen	13	21	

Example_Keyboards/Dell_Inspiron_1525/Dell_1525_Keyboard.ino

@@ -0,0 +1,344 @@
+// This software is in the public domain
+// It implements a Dell Inspiron 1525 Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 25 pin FPC connector. The keyboard part number is D9K01.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 13, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 17; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+// 
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,KEY_INSERT,0,KEY_F12,0,0,0,KEY_RIGHT},
+  {0,KEY_DELETE,0,KEY_F11,0,0,0,KEY_DOWN},
+  {KEY_UP,KEY_HOME,KEY_MENU,KEY_END,0,0,0,KEY_LEFT},
+  {0,KEY_F8,KEY_F7,KEY_9,KEY_O,KEY_L,KEY_PERIOD,0},
+  {KEY_QUOTE,KEY_MINUS,KEY_LEFT_BRACE,KEY_0,KEY_P,KEY_SEMICOLON,0,KEY_SLASH},
+  {KEY_F6,KEY_EQUAL,KEY_RIGHT_BRACE,KEY_8,KEY_I,KEY_K,KEY_COMMA,0},
+  {KEY_H,KEY_6,KEY_Y,KEY_7,KEY_U,KEY_J,KEY_M,KEY_N},
+  {KEY_F5,KEY_F9,KEY_BACKSPACE,KEY_F10,0,KEY_BACKSLASH,KEY_ENTER,KEY_SPACE},
+  {KEY_G,KEY_5,KEY_T,KEY_4,KEY_R,KEY_F,KEY_V,KEY_B},
+  {KEY_F4,KEY_F2,KEY_F3,KEY_3,KEY_E,KEY_D,KEY_C,0},
+  {0,KEY_F1,KEY_CAPS_LOCK,KEY_2,KEY_W,KEY_S,KEY_X,0},
+  {KEY_ESC,KEY_TILDE,KEY_TAB,KEY_1,KEY_Q,KEY_A,KEY_Z,0},
+  {0,0,0,KEY_PRINTSCREEN,KEY_NUM_LOCK,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,KEY_PAGE_UP,KEY_PAGE_DOWN,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},    
+  {MODIFIERKEY_LEFT_ALT,0,0,0,0,0,0,MODIFIERKEY_RIGHT_ALT},
+  {0,0,MODIFIERKEY_LEFT_SHIFT,0,0,0,MODIFIERKEY_RIGHT_SHIFT,0},
+  {0,MODIFIERKEY_LEFT_CTRL,0,0,0,0,MODIFIERKEY_RIGHT_CTRL,0},
+  {0,0,0,MODIFIERKEY_GUI,0,0,0,0},
+  {0,0,0,0,0,MODIFIERKEY_FN,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,16,17
+// Teensy I/O  # 23,00,22,01,24,02,21,03,25,04,20,05,19,06,18,07,17
+int Row_IO[rows_max] = {23,0,22,1,24,2,21,3,25,4,20,5,19,6,18,7,17}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 18,19,20,21,22,23,24,25
+// Teensy I/O     # 08,16,09,15,10,14,11,26
+int Col_IO[cols_max] = {8,16,9,15,10,14,11,26};                       // Teensy LC I/O numbers for columns
+
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/Dell_Latitude_131L/Dell Latitude 131L Keyboard V-0511BIAS1-US.txt

@@ -0,0 +1,87 @@
+Cntrl-L					15	19	
+Cntrl-R					15	24	
+Shift-L					14	20	
+Shift-R					14	24	
+Alt-L					13	18	
+Alt-R					13	25	
+GUI						16	21	
+Fn						17	23	
+A						12	23	
+B						25	9	
+C						10	24	
+D						10	23	
+E						10	22	
+F						9	23	
+G						9	18	
+H						7	18	
+I						6	22	
+J						7	23	
+K						6	23	
+L						4	23	
+M						7	24	
+N						7	25	
+O						4	22	
+P						5	22	
+Q						12	22	
+R						9	22	
+S						11	23	
+T						9	20	
+U						7	22	
+V						24	9	
+W						11	22	
+X						11	24	
+Y						20	7	
+Z						12	24	
+`						12	19	
+1						12	21	
+2						21	11	
+3						10	21	
+4						9	21	
+5						9	19	
+6						19	7	
+7						21	7	
+8						21	6	
+9						4	21	
+0						5	21	
+-						19	5	
+=						19	6	
+Back Space				8	20	
+Esc						18	12	
+F1						19	11	
+F2						19	10	
+F3						10	20	
+F4						18	10	
+F5						8	18	
+F6						6	18	
+F7						4	20	
+F8						4	19	
+F9						8	19	
+F10						8	21	
+F11						2	21	
+F12						1	21	
+Insert					1	19	
+Delete					2	19	
+Arrow-Right				25	1	
+Arrow-Left				25	3	
+Arrow-Up				3	18	
+Arrow-Down				2	25	
+Menu					3	20	
+/						5	25	
+.						4	24	
+,						6	24	
+;						5	23	
+'						18	5	
+Enter					8	24	
+[						5	20	
+]						6	20	
+\						8	23	
+Caps-Lock				11	20	
+Tab						12	20	
+Space					8	25	
+Home					19	3	
+End						3	21	
+Pg-Up					16	22	
+Pg-Dn					16	23	
+Pause					24	3	
+Num-Lock				13	22	
+Print Scrn				13	21	

Example_Keyboards/Dell_Latitude_131L/Dell_131L_Keyboard.ino

@@ -0,0 +1,343 @@
+// This software is in the public domain
+// It implements a Dell Latitude 131L Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 25 pin FPC connector. The keyboard part number is V-0511BIAS1-US.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 13, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 17; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+// 
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,KEY_INSERT,0,KEY_F12,0,0,0,KEY_RIGHT},
+  {0,KEY_DELETE,0,KEY_F11,0,0,0,KEY_DOWN},
+  {KEY_UP,KEY_HOME,KEY_MENU,KEY_END,0,0,KEY_PAUSE,KEY_LEFT},
+  {0,KEY_F8,KEY_F7,KEY_9,KEY_O,KEY_L,KEY_PERIOD,0},
+  {KEY_QUOTE,KEY_MINUS,KEY_LEFT_BRACE,KEY_0,KEY_P,KEY_SEMICOLON,0,KEY_SLASH},
+  {KEY_F6,KEY_EQUAL,KEY_RIGHT_BRACE,KEY_8,KEY_I,KEY_K,KEY_COMMA,0},
+  {KEY_H,KEY_6,KEY_Y,KEY_7,KEY_U,KEY_J,KEY_M,KEY_N},
+  {KEY_F5,KEY_F9,KEY_BACKSPACE,KEY_F10,0,KEY_BACKSLASH,KEY_ENTER,KEY_SPACE},
+  {KEY_G,KEY_5,KEY_T,KEY_4,KEY_R,KEY_F,KEY_V,KEY_B},
+  {KEY_F4,KEY_F2,KEY_F3,KEY_3,KEY_E,KEY_D,KEY_C,0},
+  {0,KEY_F1,KEY_CAPS_LOCK,KEY_2,KEY_W,KEY_S,KEY_X,0},
+  {KEY_ESC,KEY_TILDE,KEY_TAB,KEY_1,KEY_Q,KEY_A,KEY_Z,0},
+  {0,0,0,KEY_PRINTSCREEN,KEY_NUM_LOCK,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,KEY_PAGE_UP,KEY_PAGE_DOWN,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},    
+  {MODIFIERKEY_LEFT_ALT,0,0,0,0,0,0,MODIFIERKEY_RIGHT_ALT},
+  {0,0,MODIFIERKEY_LEFT_SHIFT,0,0,0,MODIFIERKEY_RIGHT_SHIFT,0},
+  {0,MODIFIERKEY_LEFT_CTRL,0,0,0,0,MODIFIERKEY_RIGHT_CTRL,0},
+  {0,0,0,MODIFIERKEY_GUI,0,0,0,0},
+  {0,0,0,0,0,MODIFIERKEY_FN,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,16,17
+// Teensy I/O  # 23,00,22,01,24,02,21,03,25,04,20,05,19,06,18,07,17
+int Row_IO[rows_max] = {23,0,22,1,24,2,21,3,25,4,20,5,19,6,18,7,17}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 18,19,20,21,22,23,24,25
+// Teensy I/O     # 08,16,09,15,10,14,11,26
+int Col_IO[cols_max] = {8,16,9,15,10,14,11,26};                       // Teensy LC I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/Dell_Latitude_D630/Dell Latitude D630 keyboard DPN 0DR160 .txt

@@ -0,0 +1,91 @@
+cntrl-l			16	20	
+cntrl-r			16	25	
+shift-l			15	21	
+shift-r			15	25	
+alt-l			14	19	
+alt-r			14	26	
+gui				17	22	
+fn				18	24	
+a				13	24	
+b				10	26	
+c				11	25	
+d				11	24	
+e				11	23	
+f				10	24	
+g				10	19	
+h				8	19	
+i				23	7	
+j				8	24	
+k				7	24	
+l				5	24	
+m				8	25	
+n				8	26	
+o				5	23	
+p				6	23	
+q				23	13	
+r				10	23	
+s				24	12	
+t				21	10	
+u				8	23	
+v				10	25	
+w				12	23	
+x				12	25	
+y				8	21	
+z				25	13	
+`				13	20	
+1				22	13	
+2				12	22	
+3				11	22	
+4				22	10	
+5				20	10	
+6				20	8	
+7				8	22	
+8				7	22	
+9				5	22	
+0				6	22	
+-				20	6	
+=				7	20	
+bckspace		9	21	
+esc				19	13	
+f1				12	20	
+f2				11	20	
+f3				21	11	
+f4				11	19	
+f5				19	9	
+f6				7	19	
+f7				21	5	
+f8				5	20	
+f9				20	9	
+f10				9	22	
+f11				3	22	
+f12				2	22	
+insert			2	20	
+delete			3	20	
+home			20	4	
+pg-up			17	23	
+pg-dn			24	17	
+end				4	22	
+arrow-r			2	26	
+arrow-l			4	26	
+arrow-u			4	19	
+arrow-d			26	3	
+menu			4	21	
+/				6	26	
+period			5	25	
+comma			7	25	
+;				6	24	
+'				6	19	
+enter			9	25	
+[				6	21	
+]				21	7	
+\				9	24	
+caps-lck		12	21	
+tab				13	21	
+space			9	26	
+prt-sc			22	14	
+num-lk			14	23	
+pause			4	25	
+vol dn			22	31
+vol up			24	31		
+mute			25	31	
+power			27	33

Example_Keyboards/Dell_Latitude_D630/Dell_D630_Keyboard.ino

@@ -0,0 +1,343 @@
+// This software is in the public domain
+// It implements a Dell Latitude D630 Laptop Keyboard Controller using a Teensy 3.2 on 
+// a daughterboard with a 32 pin FPC connector. The keyboard part number is DP/N 0DR160.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Oct 10, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 17; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+//
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,KEY_INSERT,0,KEY_F12,0,0,0,KEY_RIGHT},
+  {0,KEY_DELETE,0,KEY_F11,0,0,0,KEY_DOWN},
+  {KEY_UP,KEY_HOME,KEY_MENU,KEY_END,0,0,KEY_PAUSE,KEY_LEFT},
+  {0,KEY_F8,KEY_F7,KEY_9,KEY_O,KEY_L,KEY_PERIOD,0},
+  {KEY_QUOTE,KEY_MINUS,KEY_LEFT_BRACE,KEY_0,KEY_P,KEY_SEMICOLON,0,KEY_SLASH},
+  {KEY_F6,KEY_EQUAL,KEY_RIGHT_BRACE,KEY_8,KEY_I,KEY_K,KEY_COMMA,0},
+  {KEY_H,KEY_6,KEY_Y,KEY_7,KEY_U,KEY_J,KEY_M,KEY_N},
+  {KEY_F5,KEY_F9,KEY_BACKSPACE,KEY_F10,0,KEY_BACKSLASH,KEY_ENTER,KEY_SPACE},
+  {KEY_G,KEY_5,KEY_T,KEY_4,KEY_R,KEY_F,KEY_V,KEY_B},
+  {KEY_F4,KEY_F2,KEY_F3,KEY_3,KEY_E,KEY_D,KEY_C,0},
+  {0,KEY_F1,KEY_CAPS_LOCK,KEY_2,KEY_W,KEY_S,KEY_X,0},
+  {KEY_ESC,KEY_TILDE,KEY_TAB,KEY_1,KEY_Q,KEY_A,KEY_Z,0},
+  {0,0,0,KEY_PRINTSCREEN,KEY_NUM_LOCK,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,KEY_PAGE_UP,KEY_PAGE_DOWN,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {MODIFIERKEY_LEFT_ALT,0,0,0,0,0,0,MODIFIERKEY_RIGHT_ALT},    
+  {0,0,MODIFIERKEY_LEFT_SHIFT,0,0,0,MODIFIERKEY_RIGHT_SHIFT,0},
+  {0,MODIFIERKEY_LEFT_CTRL,0,0,0,0,MODIFIERKEY_RIGHT_CTRL,0},
+  {0,0,0,MODIFIERKEY_GUI,0,0,0,0},
+  {0,0,0,0,0,MODIFIERKEY_FN,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy 3.2 I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 02,03,04,05,06,07,08,09,10,11,12,13,14,15,16,17,18
+// Teensy I/O  # 00,22,01,21,02,20,03,19,04,18,05,17,06,24,07,25,08
+int Row_IO[rows_max] = {0,22,1,21,2,20,3,19,4,18,5,17,6,24,7,25,8}; // Teensy 3.2 I/O numbers for rows
+//
+// Column FPC pin # 19,20,21,22,23,24,25,26
+// Teensy I/O     # 33,09,26,10,27,11,28,12
+int Col_IO[cols_max] = {33,9,26,10,27,11,28,12};  // Teensy 3.2 I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Host to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/Dell_Latitude_X1/Dell Latitude X1 Keyboard 0M6607.txt

@@ -0,0 +1,86 @@
+Cntrl-L					23	3	
+Cntrl-R					4	23	
+Shift-L					1	24	
+Shift-R					2	24	
+Alt-L					5	22	
+Alt-R					6	22	
+GUI						7	19	
+Fn						8	21	
+A						21	3	
+B						7	20	
+C						7	21	
+D						5	20	
+E						7	16	
+F						6	20	
+G						7	17	
+H						6	18	
+I						15	5	
+J						18	7	
+K						6	15	
+L						14	6	
+M						7	15	
+N						8	18	
+O						5	14	
+P						13	6	
+Q						3	20	
+R						8	16	
+S						2	21	
+T						5	18	
+U						5	16	
+V						20	8	
+W						2	20	
+X						6	21	
+Y						16	6	
+Z						21	5	
+`						18	3	
+1						4	18	
+2						17	4	
+3						5	17	
+4						3	16	
+5						4	16	
+6						3	15	
+7						4	15	
+8						3	14	
+9						14	4	
+0						13	3	
+-						13	4	
+=						2	12	
+Back Space				1	9	
+Esc						1	18	
+F1						18	2	
+F2						1	17	
+F3						2	17	
+F4						3	17	
+F5						1	16	
+F6						16	2	
+F7						15	1	
+F8						2	15	
+F9						1	14	
+F10						2	14	
+F11						1	13	
+F12						2	13	
+Insert					10	2	
+Delete					10	1	
+Arrow-Right				5	11	
+Arrow-Left				11	7	
+Arrow-Up				6	9	
+Arrow-Down				7	10	
+Menu					3	10	
+/						5	12	
+.						7	14	
+,						8	13	
+;						7	13	
+'						12	4	
+Enter					6	10	
+[						13	5	
+]						12	3	
+\						4	10	
+Caps-Lock				21	4	
+Tab						4	20	
+Space					8	17	
+Home					12	1	
+End						2	9	
+Pg-Up					3	9	
+Pg-Dn					4	9	
+Num-Lock				
+Print Scrn				

Example_Keyboards/Dell_Latitude_X1/Dell_X1_Keyboard.ino

@@ -0,0 +1,340 @@
+// This software is in the public domain
+// It implements a Dell Latitude X1 Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 24 pin FPC connector. The keyboard part number is 0M6607.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 14, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 16; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+// 
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {KEY_BACKSPACE,KEY_END,KEY_PAGE_UP,KEY_PAGE_DOWN,0,KEY_UP,0,0},
+  {KEY_DELETE,KEY_INSERT,KEY_MENU,KEY_BACKSLASH,0,KEY_ENTER,KEY_DOWN,0},
+  {0,0,0,0,KEY_RIGHT,0,KEY_LEFT,0},
+  {KEY_HOME,KEY_EQUAL,KEY_RIGHT_BRACE,KEY_QUOTE,KEY_SLASH,0,0,0},
+  {KEY_F11,KEY_F12,KEY_0,KEY_MINUS,KEY_LEFT_BRACE,KEY_P,KEY_SEMICOLON,KEY_COMMA},
+  {KEY_F9,KEY_F10,KEY_8,KEY_9,KEY_O,KEY_L,KEY_PERIOD,0},
+  {KEY_F7,KEY_F8,KEY_6,KEY_7,KEY_I,KEY_K,KEY_M,0},
+  {KEY_F5,KEY_F6,KEY_4,KEY_5,KEY_U,KEY_Y,KEY_E,KEY_R},
+  {KEY_F2,KEY_F3,KEY_F4,KEY_2,KEY_3,0,KEY_G,KEY_SPACE},
+  {KEY_ESC,KEY_F1,KEY_TILDE,KEY_1,KEY_T,KEY_H,KEY_J,KEY_N},
+  {0,0,0,0,0,0,0,0},
+  {0,KEY_W,KEY_Q,KEY_TAB,KEY_D,KEY_F,KEY_B,KEY_V},
+  {0,KEY_S,KEY_A,KEY_CAPS_LOCK,KEY_Z,KEY_X,KEY_C,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,MODIFIERKEY_GUI,0},    
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,MODIFIERKEY_FN},
+  {0,0,0,0,MODIFIERKEY_LEFT_ALT,MODIFIERKEY_RIGHT_ALT,0,0},
+  {0,0,MODIFIERKEY_LEFT_CTRL,MODIFIERKEY_RIGHT_CTRL,0,0,0,0},
+  {MODIFIERKEY_LEFT_SHIFT,MODIFIERKEY_RIGHT_SHIFT,0,0,0,0,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 09,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24
+// Teensy I/O  # 25,04,20,05,19,06,18,07,17,08,16,09,15,10,14,11
+int Row_IO[rows_max] = {25,4,20,5,19,6,18,7,17,8,16,9,15,10,14,11}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 01,02,03,04,05,06,07,08
+// Teensy I/O     # 23,00,22,01,24,02,21,03
+int Col_IO[cols_max] = {23,0,22,1,24,2,21,3};                       // Teensy LC I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/HP_Pavilion_DV9000/HP Pavilion DV9000 Keyboard AEAT5U00110.txt

@@ -0,0 +1,112 @@
+Cntrl-L			19	20	
+Cntrl-R			20	22	
+Shift-L			21	23	
+Shift-R			23	25	
+Alt-L			7	24	
+Alt-R			7	15	
+GUI				9	26	
+Fn				12	18	
+A				16	22	
+B				13	15	
+C				14	21	
+D				14	22	
+E				14	25	
+F				13	22	
+G				13	26	
+H				11	26	
+I				10	25	
+J				11	22	
+K				10	22	
+L				5	22	
+M				11	21	
+N				11	15	
+O				5	25	
+P				4	25	
+Q				16	25	
+R				13	25	
+S				17	22	
+T				13	19	
+U				11	25	
+V				13	21	
+W				17	25	
+X				17	21	
+Y				11	19	
+Z				16	21	
+`				16	18	
+1				16	24	
+2				17	24	
+3				14	24	
+4				13	24	
+5				13	18	
+6				11	18	
+7				11	24	
+8				10	24	
+9				5	24	
+0				4	24	
+-				4	18	
+=				4	15	
+Back Space		6	26	
+Esc				16	26	
+F1				14	15	
+F2				14	18	
+F3				14	19	
+F4				14	26	
+F5				17	18	
+F6				17	19	
+F7				17	26	
+F8				15	17	
+F9				5	18	
+F10				5	19	
+F11				5	26	
+F12				5	15	
+Insert			3	26	
+Delete			3	15	
+Arrow-Right		3	24	
+Arrow-Left		3	25	
+Arrow-Up		6	25	
+Arrow-Down		6	24	
+Menu			8	18	
+/				4	21	
+.				5	21	
+,				10	21	
+;				4	22	
+'				4	26	
+Enter			6	22	
+[				4	19	
+]				10	19	
+\				6	18	
+Caps-Lock		15	16	
+Tab				16	19	
+Space			6	21	
+Home			3	19	
+End				3	21	
+Pg-Up			3	18	
+Pg-Dn			3	22	
+Num-Lock		6	19	
+Pad /			2	15	
+Pad *			2	26	
+Pad -			2	19	
+Pad 7			1	15	
+Pad 8			1	26	
+Pad 9			1	19	
+Pad +			1	18	
+Pad 4			2	24	
+Pad 5			2	21	
+Pad 6			2	18	
+Pad 1			1	24	
+Pad 2			1	21	
+Pad 3			1	22	
+Pad 0			2	25	
+Pad .			2	22	
+Pad Enter		1	25	
+
+
+
+
+
+
+
+
+
+
+

Example_Keyboards/HP_Pavilion_DV9000/HP_DV9000_Keyboard.ino

@@ -0,0 +1,346 @@
+// This software is in the public domain
+// It implements an HP Pavilion DV9000 Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 26 pin FPC connector. The keyboard part number is AEAT5U00110.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 12, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 18; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+//
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {KEYPAD_7,KEYPAD_PLUS,KEYPAD_9,KEYPAD_2,KEYPAD_3,KEYPAD_1,KEYPAD_ENTER,KEYPAD_8},
+  {KEYPAD_SLASH,KEYPAD_6,KEYPAD_MINUS,KEYPAD_5,KEYPAD_PERIOD,KEYPAD_4,KEYPAD_0,KEYPAD_ASTERIX},
+  {KEY_DELETE,KEY_PAGE_UP,KEY_HOME,KEY_END,KEY_PAGE_DOWN,KEY_RIGHT,KEY_LEFT,KEY_INSERT},
+  {KEY_EQUAL,KEY_MINUS,KEY_LEFT_BRACE,KEY_SLASH,KEY_SEMICOLON,KEY_0,KEY_P,KEY_QUOTE},
+  {KEY_F12,KEY_F9,KEY_F10,KEY_PERIOD,KEY_L,KEY_9,KEY_O,KEY_F11},
+  {0,KEY_BACKSLASH,KEY_NUM_LOCK,KEY_SPACE,KEY_ENTER,KEY_DOWN,KEY_UP,KEY_BACKSPACE},
+  {0,0,0,0,0,0,0,0},
+  {0,KEY_MENU,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,0},
+  {0,0,KEY_RIGHT_BRACE,KEY_COMMA,KEY_K,KEY_8,KEY_I,0},
+  {KEY_N,KEY_6,KEY_Y,KEY_M,KEY_J,KEY_7,KEY_U,KEY_H},
+  {0,0,0,0,0,0,0,0},    
+  {KEY_B,KEY_5,KEY_T,KEY_V,KEY_F,KEY_4,KEY_R,KEY_G},
+  {KEY_F1,KEY_F2,KEY_F3,KEY_C,KEY_D,KEY_3,KEY_E,KEY_F4},
+  {KEY_CAPS_LOCK,KEY_TILDE,KEY_TAB,KEY_Z,KEY_A,KEY_1,KEY_Q,KEY_ESC},
+  {KEY_F8,KEY_F5,KEY_F6,KEY_X,KEY_S,KEY_2,KEY_W,KEY_F7},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {MODIFIERKEY_RIGHT_ALT,0,0,0,0,MODIFIERKEY_LEFT_ALT,0,0},
+  {0,0,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,MODIFIERKEY_GUI},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,MODIFIERKEY_FN,0,0,0,0,0,0},    
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,MODIFIERKEY_LEFT_CTRL,0,MODIFIERKEY_RIGHT_CTRL,0,0,0},
+  {0,0,0,MODIFIERKEY_LEFT_SHIFT,0,0,MODIFIERKEY_RIGHT_SHIFT,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 01,02,03,04,05,06,07,08,09,10,11,12,13,14,16,17,20,23
+// Teensy I/O  # 23,00,22,01,24,02,21,03,25,04,20,05,19,06,07,17,09,14
+int Row_IO[rows_max] = {23,0,22,1,24,2,21,3,25,4,20,5,19,6,7,17,9,14}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 15,18,19,21,22,24,25,26
+// Teensy I/O     # 18,08,16,15,10,11,26,12
+int Col_IO[cols_max] = {18,8,16,15,10,11,26,12};                       // Teensy LC I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/HP_Presario_2100/HP Compaq Presario 2100 Keyboard AEKT1TPU011.txt

@@ -0,0 +1,87 @@
+Cntrl-L						25	1	
+Cntrl-R						1	19	
+Shift-L						7	23	
+Shift-R						7	19	
+Alt-L						20	4	
+Alt-R						22	4	
+GUI							5	24	
+Fn							14	18	
+A							18	2	
+B							22	8	
+C							6	19	
+D							6	18	
+E							6	24	
+F							8	18	
+G							8	20	
+H							20	10	
+I							11	24	
+J							10	18	
+K							11	18	
+L							12	18	
+M							10	19	
+N							10	22	
+O							12	24	
+P							13	24	
+Q							2	24	
+R							8	24	
+S							3	18	
+T							8	23	
+U							10	24	
+V							8	19	
+W							3	24	
+X							3	19	
+Y							10	23	
+Z							2	19	
+`							2	25	
+1							2	21	
+2							3	21	
+3							6	21	
+4							8	21	
+5							8	25	
+6							10	25	
+7							21	10	
+8							11	21	
+9							12	21	
+0							13	21	
+-							13	25	
+=							11	25	
+Back Space					9	23	
+Esc							2	20	
+F1							3	25	
+F2							6	25	
+F3							6	23	
+F4							6	20	
+F5							9	20	
+F6							11	20	
+F7							12	23	
+F8							12	25	
+F9							9	25	
+F10							9	21	
+F11							16	21	
+F12							14	21	
+Insert						14	25	
+Delete						16	25	
+Arrow-Right					14	22	
+Arrow-Left					15	22	
+Arrow-Up					15	20	
+Arrow-Down					16	22	
+Menu						15	23	
+/							13	22	
+.							12	19	
+,							11	19	
+;							18	13	
+'							13	20	
+Enter						19	9	
+[							13	23	
+]							11	23	
+\							9	18	
+Caps-Lock					3	23	
+Tab							2	23	
+Space						9	22	
+Home						15	25	
+End							15	21	
+Pg-Up						15	24	
+Pg-Dn						15	18	
+Pause						15	19	
+Num-Lock					16	19	
+Print Scrn					4	21	

Example_Keyboards/HP_Presario_2100/HP_2100_Keyboard.ino

@@ -0,0 +1,343 @@
+// This software is in the public domain
+// It implements an HP Compaq Presario 2100 Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 25 pin FPC connector. The keyboard part number is AEKT1TPU011.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 14, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 17; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+// 
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {KEY_A,KEY_Z,KEY_ESC,KEY_1,0,KEY_TAB,KEY_Q,KEY_TILDE},
+  {KEY_S,KEY_X,0,KEY_2,0,KEY_CAPS_LOCK,KEY_W,KEY_F1},
+  {0,0,0,KEY_PRINTSCREEN,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {KEY_D,KEY_C,KEY_F4,KEY_3,0,KEY_F3,KEY_E,KEY_F2},
+  {0,0,0,0,0,0,0,0},
+  {KEY_F,KEY_V,KEY_G,KEY_4,KEY_B,KEY_T,KEY_R,KEY_5},
+  {KEY_BACKSLASH,KEY_ENTER,KEY_F5,KEY_F10,KEY_SPACE,KEY_BACKSPACE,0,KEY_F9},
+  {KEY_J,KEY_M,KEY_H,KEY_7,KEY_N,KEY_Y,KEY_U,KEY_6},
+  {KEY_K,KEY_COMMA,KEY_F6,KEY_8,0,KEY_RIGHT_BRACE,KEY_I,KEY_EQUAL},
+  {KEY_L,KEY_PERIOD,0,KEY_9,0,KEY_F7,KEY_O,KEY_F8},
+  {KEY_SEMICOLON,KEY_QUOTE,0,KEY_0,KEY_SLASH,KEY_LEFT_BRACE,KEY_P,KEY_MINUS},
+  {0,0,0,KEY_F12,KEY_RIGHT,0,0,KEY_INSERT},
+  {KEY_PAGE_DOWN,KEY_PAUSE,KEY_UP,KEY_END,KEY_LEFT,KEY_MENU,KEY_UP,KEY_HOME},
+  {0,KEY_NUM_LOCK,0,KEY_F11,KEY_DOWN,0,0,KEY_DELETE},
+  {0,0,0,0,0,0,0,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,MODIFIERKEY_RIGHT_CTRL,0,0,0,0,0,MODIFIERKEY_LEFT_CTRL},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,MODIFIERKEY_LEFT_ALT,0,MODIFIERKEY_RIGHT_ALT,0,0,0},
+  {0,0,0,0,0,0,MODIFIERKEY_GUI,0},
+  {0,0,0,0,0,0,0,0},
+  {0,MODIFIERKEY_RIGHT_SHIFT,0,0,0,MODIFIERKEY_LEFT_SHIFT,0,0},
+  {0,0,0,0,0,0,0,0}, 
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},    
+  {0,0,0,0,0,0,0,0},
+  {MODIFIERKEY_FN,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,16,17
+// Teensy I/O  # 23,00,22,01,24,02,21,03,25,04,20,05,19,06,18,07,17
+int Row_IO[rows_max] = {23,0,22,1,24,2,21,3,25,4,20,5,19,6,18,7,17}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 18,19,20,21,22,23,24,25
+// Teensy I/O     # 08,16,09,15,10,14,11,26
+int Col_IO[cols_max] = {8,16,9,15,10,14,11,26};                       // Teensy LC I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/HP_Presario_V4000/HP Compaq Presario V4000 Keyboard NSK-H3L01.txt

@@ -0,0 +1,88 @@
+Cntrl-L					8	7	
+Cntrl-R					5	7	
+Shift-L					4	6	
+Shift-R					2	4	
+Alt-L					3	20	
+Alt-R					12	20	
+GUI						1	18	
+Fn						9	15	
+A						5	11	
+B						12	14	
+C						6	13	
+D						5	13	
+E						2	13	
+F						14	5	
+G						1	14	
+H						1	16	
+I						17	2	
+J						5	16	
+K						17	5	
+L						5	22	
+M						6	16	
+N						12	16	
+O						2	22	
+P						2	23	
+Q						2	11	
+R						2	14	
+S						5	10	
+T						8	14	
+U						16	2	
+V						6	14	
+W						2	10	
+X						10	6	
+Y						8	16	
+Z						6	11	
+`						9	11	
+1						3	11	
+2						3	10	
+3						13	3	
+4						3	14	
+5						9	14	
+6						9	16	
+7						16	3	
+8						3	17	
+9						22	3	
+0						23	3	
+-						9	23	
+=						12	23	
+Back Space				21	1	
+Esc						1	11	
+F1						12	13	
+F2						13	9	
+F3						8	13	
+F4						13	1	
+F5						9	10	
+F6						8	10	
+F7						1	10	
+F8						10	12	
+F9						9	22	
+F10						8	22	
+F11						1	22	
+F12						12	22	
+Insert					1	24	
+Delete					12	24	
+Arrow-Right				3	24	
+Arrow-Left				2	24	
+Arrow-Up				2	21	
+Arrow-Down				3	21	
+Menu					9	19	
+/						23	6	
+.						6	22	
+,						17	6	
+;						5	23	
+'						1	23	
+Enter					5	21	
+[						8	23	
+]						8	17	
+\						9	21	
+Caps-Lock				11	12	
+Tab						8	11	
+Space					6	21	
+Home					8	24	
+End						6	24	
+Pg-Up					24	9	
+Pg-Dn					5	24	
+Scroll					1	17	
+Pause					12	21	
+Num-Lock	(Fn under scroll)			
+Print Scrn	(Fn under insert)			

Example_Keyboards/HP_Presario_V4000/HP_V4000_Keyboard.ino

@@ -0,0 +1,340 @@
+// This software is in the public domain
+// It implements an HP Compaq Presario V4000 Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 24 pin FPC connector. The keyboard part number is NSK-H3L01.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 14, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 16; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+// 
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {KEY_F7,KEY_W,KEY_2,KEY_S,KEY_X,KEY_F6,KEY_F5,KEY_F8},
+  {KEY_ESC,KEY_Q,KEY_1,KEY_A,KEY_Z,KEY_TAB,KEY_TILDE,KEY_CAPS_LOCK},
+  {KEY_F4,KEY_E,KEY_3,KEY_D,KEY_C,KEY_F3,KEY_F2,KEY_F1},
+  {KEY_G,KEY_R,KEY_4,KEY_F,KEY_V,KEY_T,KEY_5,KEY_B},
+  {0,0,0,0,0,0,0,0},
+  {KEY_H,KEY_U,KEY_7,KEY_J,KEY_M,KEY_Y,KEY_6,KEY_N},
+  {KEY_SCROLL_LOCK,KEY_I,KEY_8,KEY_K,KEY_COMMA,KEY_RIGHT_BRACE,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,KEY_MENU,0},
+  {0,0,0,0,0,0,0,0},
+  {KEY_BACKSPACE,KEY_UP,KEY_DOWN,KEY_ENTER,KEY_SPACE,0,KEY_BACKSLASH,KEY_PAUSE},
+  {KEY_F11,KEY_O,KEY_9,KEY_L,KEY_PERIOD,KEY_F10,KEY_F9,KEY_F12},
+  {KEY_QUOTE,KEY_P,KEY_0,KEY_SEMICOLON,KEY_SLASH,KEY_LEFT_BRACE,KEY_MINUS,KEY_EQUAL},
+  {KEY_INSERT,KEY_LEFT,KEY_RIGHT,KEY_DOWN,KEY_END,KEY_HOME,KEY_UP,KEY_DELETE}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,MODIFIERKEY_RIGHT_SHIFT,0,0,MODIFIERKEY_LEFT_SHIFT,0,0,},
+  {0,0,0,MODIFIERKEY_RIGHT_CTRL,0,MODIFIERKEY_LEFT_CTRL,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,MODIFIERKEY_FN,0},
+  {0,0,0,0,0,0,0,0}, 
+  {0,0,0,0,0,0,0,0},
+  {MODIFIERKEY_GUI,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},    
+  {0,0,MODIFIERKEY_LEFT_ALT,0,0,0,0,MODIFIERKEY_RIGHT_ALT},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1} 
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 04,07,10,11,13,14,15,16,17,18,19,20,21,22,23,24
+// Teensy I/O  # 01,21,04,20,19,06,18,07,17,08,16,09,15,10,14,11
+int Row_IO[rows_max] = {1,21,4,20,19,6,18,7,17,8,16,9,15,10,14,11}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 01,02,03,05,06,08,09,12
+// Teensy I/O     # 23,00,22,24,02,03,25,05
+int Col_IO[cols_max] = {23,0,22,24,2,3,25,5};                       // Teensy LC I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/Sony_Vaio_PCG-K25/Sony Vaio PCG-K25 Keyboard KFRMBA151B.txt

@@ -0,0 +1,84 @@
+cntrl-l		1	17	
+cntrl-r		1	11	
+shift-l		14	20	
+shift-r		18	20	
+alt-l		12	22	
+alt-r		7	22	
+gui			13	23	
+fn			6	24	
+a			11	21	
+b			9	11	
+c			15	17	
+d			16	17	
+e			12	16	
+f			8	17	
+g			10	11	
+h			10	17	
+i			8	12	
+j			9	17	
+k			10	13	
+l			5	17	
+m			7	9	
+n			7	10	
+o			9	14	
+p			4	14	
+q			12	19	
+r			13	15	
+s			11	15	
+t			12	15	
+u			9	13	
+v			7	15	
+w			17	19	
+x			7	16	
+y			10	12	
+z			7	19	
+`			6	21	
+1			14	19	
+2			13	19	
+3			14	16	
+4			13	16	
+5			14	15	
+6			10	18	
+7			10	14	
+8			9	12	
+9			8	14	
+0			8	13	
+-			4	17	
+=			3	14	
+bckspace	4	18	
+esc			18	21	
+f1			6	19	
+f2			18	19	
+f3			6	16	
+f4			16	18	
+f5			6	15	
+f6			15	18	
+f7			6	10	
+f8			6	9	
+f9			9	18	
+f10			6	8	
+f11			8	18	
+f12			4	6	
+insert		5	6	
+delete		5	18	
+home		5	14	
+pg-up		2	14	
+pg-dn		2	13	
+end			2	17	
+arrow-r		2	18	
+arrow-l		2	7	
+arrow-u		2	12	
+arrow-d		2	11	
+menu		4	7	
+/			4	11	
+period		8	11	
+comma		7	8	
+;			4	12	
+'			3	17	
+enter		3	7	
+[			4	13	
+]			3	12	
+\			5	13	
+caps-lck	14	21	
+tab			13	21	
+space		11	19	

Example_Keyboards/Sony_Vaio_PCG-K25/Sony_PCGK25_Keyboard.ino

@@ -0,0 +1,339 @@
+// This software is in the public domain
+// It implements a Sony Vaio PCG-K25 Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 24 pin FPC connector. The keyboard part number is KFRMBA151B.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 15, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 16; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+// 
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+int normal[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,KEY_LEFT,KEY_DOWN,KEY_UP,KEY_PAGE_DOWN,KEY_PAGE_UP,KEY_END,KEY_RIGHT},
+  {0,KEY_ENTER,0,KEY_RIGHT_BRACE,0,KEY_EQUAL,KEY_QUOTE,0},
+  {KEY_F12,KEY_MENU,KEY_SLASH,KEY_SEMICOLON,KEY_LEFT_BRACE,KEY_P,KEY_MINUS,KEY_BACKSPACE},
+  {KEY_INSERT,0,0,0,KEY_BACKSLASH,KEY_HOME,KEY_L,KEY_DELETE},
+  {KEY_F10,KEY_COMMA,KEY_PERIOD,KEY_I,KEY_0,KEY_9,KEY_F,KEY_F11},
+  {KEY_F8,KEY_M,KEY_B,KEY_8,KEY_U,KEY_O,KEY_J,KEY_F9},
+  {KEY_F7,KEY_N,KEY_G,KEY_Y,KEY_K,KEY_7,KEY_H,KEY_6},
+  {KEY_F5,KEY_V,KEY_S,KEY_T,KEY_R,KEY_5,KEY_C,KEY_F6},
+  {KEY_F3,KEY_X,0,KEY_E,KEY_4,KEY_3,KEY_D,KEY_F4},
+  {KEY_F1,KEY_Z,KEY_SPACE,KEY_Q,KEY_2,KEY_1,KEY_W,KEY_F2},
+  {0,0,0,0,0,0,0,0},
+  {KEY_TILDE,0,KEY_A,0,KEY_TAB,KEY_CAPS_LOCK,0,KEY_ESC},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,MODIFIERKEY_RIGHT_CTRL,0,0,0,MODIFIERKEY_LEFT_CTRL,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}, 
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},    
+  {0,0,0,0,0,MODIFIERKEY_LEFT_SHIFT,0,MODIFIERKEY_RIGHT_SHIFT},
+  {0,0,0,0,0,0,0,0},
+  {0,MODIFIERKEY_RIGHT_ALT,0,MODIFIERKEY_LEFT_ALT,0,0,0,0},
+  {0,0,0,0,MODIFIERKEY_GUI,0,0,0},
+  {MODIFIERKEY_FN,0,0,0,0,0,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1} 
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 01,02,03,04,05,08,09,10,15,16,19,20,21,22,23,24
+// Teensy I/O  # 23,00,22,01,24,03,25,04,18,07,16,09,15,10,14,11
+int Row_IO[rows_max] = {23,0,22,1,24,3,25,4,18,7,16,9,15,10,14,11}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 06,07,11,12,13,14,17,18
+// Teensy I/O     # 02,21,20,05,19,06,17,08
+int Col_IO[cols_max] = {2,21,20,5,19,6,17,8};                       // Teensy LC I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/Sony_Vaio_VPCCW/Sony Vaio VPCCW Keyboard 148754321.txt

@@ -0,0 +1,82 @@
+Cntrl-L				2	22		
+Cntrl-R				8	2	
+Shift-L				1	23	
+Shift-R				1	9	
+Alt-L				11	17	
+Alt-R				6	17	
+GUI					16	24	
+Fn					18	3	
+A					8	12	
+B					5	8	
+C					8	10	
+D					9	12	
+E					11	12	
+F					9	10	
+G					7	11	
+H					9	7	
+I					5	11	
+J					5	9	
+K					7	8	
+L					4	9	
+M					5	6	
+N					6	7	
+O					4	11	
+P					15	23	
+Q					11	13	
+R					10	24	
+S					13	8	
+T					10	11	
+U					24	5	
+V					6	10	
+W					9	13	
+X					6	12	
+Y					7	24	
+Z					13	6	
+`					14	18	
+1					13	23	
+2					13	24	
+3					12	23	
+4					12	24	
+5					10	23	
+6					7	18	
+7					7	23	
+8					5	23	
+9					4	23	
+0					4	24	
+-					15	18	
+=					19	23	
+Back Space			21	23	
+Esc					14	22	
+F1					13	22	
+F2					13	18	
+F3					12	22	
+F4					12	18	
+F5					10	22	
+F6					10	18	
+F7					7	22	
+F8					5	22	
+F9					5	18	
+F10					22	4	
+F11					4	18	
+F12					15	22	
+Insert				22	21	
+Delete				18	21	
+Arrow-Right			9	20	
+Arrow-Left			20	6	
+Arrow-Up			11	20	
+Arrow-Down			8	20	
+Menu				6	15	
+/					8	15	
+.					8	4	
+,					4	6	
+;					11	14	
+'					19	9	
+Enter				11	21	
+[					15	24	
+]					11	19	
+\					8	21	
+Caps-Lock			14	24	
+Tab					14	23	
+Space				9	14	
+Num-Lock			19	22	
+Print Scrn			18	19	

Example_Keyboards/Sony_Vaio_VPCCW/Sony_VPCCW_Keyboard.ino

@@ -0,0 +1,340 @@
+// This software is in the public domain
+// It implements an Sony Vaio VPCCW Laptop Keyboard Controller using a Teensy LC on 
+// a daughterboard with a 24 pin FPC connector. The keyboard part number is 148754321.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Sept 14, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 16; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+// 
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {KEY_COMMA,KEY_PERIOD,KEY_L,KEY_O,KEY_F11,KEY_F10,KEY_9,KEY_0},
+  {KEY_M,KEY_B,KEY_J,KEY_I,KEY_F9,KEY_F8,KEY_8,KEY_U},
+  {KEY_N,KEY_K,KEY_H,KEY_G,KEY_6,KEY_F7,KEY_7,KEY_Y},
+  {KEY_V,KEY_C,KEY_F,KEY_T,KEY_F6,KEY_F5,KEY_5,KEY_R},
+  {KEY_X,KEY_A,KEY_D,KEY_E,KEY_F4,KEY_F3,KEY_3,KEY_4},
+  {KEY_Z,KEY_S,KEY_W,KEY_Q,KEY_F2,KEY_F1,KEY_1,KEY_2},
+  {0,0,KEY_SPACE,KEY_SEMICOLON,KEY_TILDE,KEY_ESC,KEY_TAB,KEY_CAPS_LOCK},
+  {KEY_MENU,KEY_SLASH,0,0,KEY_MINUS,KEY_F12,KEY_P,KEY_LEFT_BRACE},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,KEY_QUOTE,KEY_RIGHT_BRACE,KEY_PRINTSCREEN,KEY_NUM_LOCK,KEY_EQUAL,0},
+  {KEY_LEFT,KEY_DOWN,KEY_RIGHT,KEY_UP,0,0,0,0},
+  {0,KEY_BACKSLASH,0,KEY_ENTER,KEY_DELETE,KEY_INSERT,KEY_BACKSPACE,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,MODIFIERKEY_RIGHT_SHIFT,0,0,0,MODIFIERKEY_LEFT_SHIFT,0},
+  {0,MODIFIERKEY_RIGHT_CTRL,0,0,0,MODIFIERKEY_LEFT_CTRL,0,0},
+  {0,0,0,0,MODIFIERKEY_FN,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}, 
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},    
+  {0,0,0,0,0,0,0,MODIFIERKEY_GUI},
+  {MODIFIERKEY_RIGHT_ALT,0,0,MODIFIERKEY_LEFT_ALT,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1} 
+};
+//
+// Define the Teensy LC I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 01,02,03,04,05,07,10,12,13,14,15,16,17,19,20,21
+// Teensy I/O  # 23,00,22,01,24,21,04,05,19,06,18,07,17,16,09,15
+int Row_IO[rows_max] = {23,0,22,1,24,21,4,5,19,6,18,7,17,16,9,15}; // Teensy LC I/O numbers for rows
+//
+// Column FPC pin # 06,08,09,11,18,22,23,24
+// Teensy I/O     # 02,03,25,20,08,10,14,11
+int Col_IO[cols_max] = {2,3,25,20,8,10,14,11};                       // Teensy LC I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Pi to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/Sony_Vaio_VPCEA/Sony Vaio VPCEA Keyboard A-1765-621-A.txt

@@ -0,0 +1,86 @@
+cntrl-l			3	23	
+cntrl-r			3	9	
+shift-l			24	2	
+shift-r			2	10	
+alt-l			18	12	
+alt-r			7	18	
+gui				17	25	
+fn				4	19	
+a				9	13	
+b				6	9	
+c				9	11	
+d				10	13	
+e				12	13	
+f				11	10	
+g				12	8	
+h				8	10	
+i				6	12	
+j				6	10	
+k				8	9	
+l				5	10	
+m				7	6	
+n				7	8	
+o				5	12	
+p				16	24	
+q				12	14	
+r				11	25	
+s				9	14	
+t				12	11	
+u				25	6	
+v				7	11	
+w				10	14	
+x				7	13	
+y				8	25	
+z				7	14	
+`				15	19	
+1				14	24	
+2				14	25	
+3				13	24	
+4				13	25	
+5				11	24	
+6				19	8	
+7				8	24	
+8				6	24	
+9				5	24	
+0				5	25	
+-				16	19	
+=				24	20	
+bckspace		22	24	
+esc				15	23	
+f1				14	23	
+f2				14	19	
+f3				13	23	
+f4				13	19	
+f5				11	23	
+f6				11	19	
+f7				8	23	
+f8				23	6	
+f9				6	19	
+f10				5	23	
+f11				19	5	
+f12				16	23	
+insert			22	23	
+delete			19	22	
+home			19	21	
+pg-up			21	25	
+pg-dn			23	21	
+end				21	24	
+arrow-r			10	21	
+arrow-l			7	21	
+arrow-u			12	21	
+arrow-d			9	21	
+menu			7	16	
+/				16	9	
+period			5	9	
+comma			5	7	
+;				12	15	
+'				10	20	
+enter			22	12	
+[				25	16	
+]				12	20	
+\				9	22	
+caps-lck		15	25	
+tab				15	24	
+space			10	15	
+num-lk			20	23	
+prt-sc			19	20	

Example_Keyboards/Sony_Vaio_VPCEA/Sony_VPCEA_Keyboard.ino

@@ -0,0 +1,340 @@
+// This software is in the public domain
+// It implements a Sony Vaio VPCEA Laptop Keyboard Controller using a Teensy 3.2 on 
+// a daughterboard with a 32 pin FPC connector. The keyboard part number is A-1765-621.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Oct 10, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 16; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+//
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {KEY_COMMA,KEY_PERIOD,KEY_L,KEY_O,KEY_F11,KEY_F10,KEY_9,KEY_0},
+  {KEY_M,KEY_B,KEY_J,KEY_I,KEY_F9,KEY_F8,KEY_8,KEY_U},
+  {KEY_N,KEY_K,KEY_H,KEY_G,KEY_6,KEY_F7,KEY_7,KEY_Y},
+  {KEY_V,KEY_C,KEY_F,KEY_T,KEY_F6,KEY_F5,KEY_5,KEY_R},
+  {KEY_X,KEY_A,KEY_D,KEY_E,KEY_F4,KEY_F3,KEY_3,KEY_4},
+  {KEY_Z,KEY_S,KEY_W,KEY_Q,KEY_F2,KEY_F1,KEY_1,KEY_2},
+  {0,0,KEY_SPACE,KEY_SEMICOLON,KEY_TILDE,KEY_ESC,KEY_TAB,KEY_CAPS_LOCK},
+  {KEY_MENU,KEY_SLASH,0,0,KEY_MINUS,KEY_F12,KEY_P,KEY_LEFT_BRACE},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,KEY_QUOTE,KEY_RIGHT_BRACE,KEY_PRINTSCREEN,KEY_NUM_LOCK,KEY_EQUAL,0},
+  {KEY_LEFT,KEY_DOWN,KEY_RIGHT,KEY_UP,KEY_HOME,KEY_PAGE_DOWN,KEY_END,KEY_PAGE_UP},
+  {0,KEY_BACKSLASH,0,KEY_ENTER,KEY_DELETE,KEY_INSERT,KEY_BACKSPACE,0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,MODIFIERKEY_RIGHT_SHIFT,0,0,0,MODIFIERKEY_LEFT_SHIFT,0},
+  {0,MODIFIERKEY_RIGHT_CTRL,0,0,0,MODIFIERKEY_LEFT_CTRL,0,0},
+  {0,0,0,0,MODIFIERKEY_FN,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,MODIFIERKEY_GUI},    
+  {MODIFIERKEY_RIGHT_ALT,0,0,MODIFIERKEY_LEFT_ALT,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy 3.2 I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 02,03,04,05,06,08,11,13,14,15,16,17,18,20,21,22
+// Teensy I/O  # 00,22,01,21,02,03,18,17,06,24,07,25,08,09,26,10
+int Row_IO[rows_max] = {0,22,1,21,2,3,18,17,6,24,7,25,8,9,26,10}; // Teensy 3.2 I/O numbers for rows
+//
+// Column FPC pin # 07,09,10,12,19,23,24,25
+// Teensy I/O     # 20,19,04,05,33,27,11,28
+int Col_IO[cols_max] = {20,19,4,5,33,27,11,28};  // Teensy 3.2 I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Host to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}

Example_Keyboards/Sony_Vaio_VPCEB4/Sony Vaio VPCEB4 Keyboard A-1766-425-A.txt

@@ -0,0 +1,103 @@
+cntrl-l			3	23	
+cntrl-r			9	3	
+shift-l			2	24	
+shift-r			10	2	
+alt-l			12	18	
+alt-r			7	18	
+gui				17	25	
+fn				19	4	
+a				13	9	
+b				9	6	
+c				9	11	
+d				10	13	
+e				12	13	
+f				11	10	
+g				12	8	
+h				8	10	
+i				6	12	
+j				6	10	
+k				8	9	
+l				5	10	
+m				6	7	
+n				7	8	
+o				12	5	
+p				16	24	
+q				12	14	
+r				11	25	
+s				9	14	
+t				11	12	
+u				6	25	
+v				11	7	
+w				10	14	
+x				7	13	
+y				8	25	
+z				7	14	
+`				19	15	
+1				14	24	
+2				14	25	
+3				13	24	
+4				13	25	
+5				11	24	
+6				19	8	
+7				8	24	
+8				24	6	
+9				5	24	
+0				25	5	
+-				16	19	
+=				24	20	
+bckspace		24	22	
+esc				15	23	
+f1				14	23	
+f2				14	19	
+f3				23	13	
+f4				13	19	
+f5				23	11	
+f6				11	19	
+f7				23	8	
+f8				6	23	
+f9				6	19	
+f10				5	23	
+f11				19	5	
+f12				16	23
+Prt Scrn		19	20	
+Pause			22	25		
+insert			22	23	
+delete			19	22	
+home			19	21	
+end				21	24	
+pg-up			25	21	
+pg-dn			21	23	
+Num-Lk			20	23	
+arrow-r			10	21	
+arrow-l			7	21	
+arrow-u			12	21	
+arrow-d			9	21	
+menu			7	16	
+/				9	16	
+period			5	9	
+comma			7	5	
+;				12	15	
+'				10	20	
+enter			12	22	
+[				16	25	
+]				12	20	
+\				9	22	
+caps-lck		15	25	
+tab				24	15	
+space			10	15	
+Pad /			7	27	
+Pad *			7	26	
+Pad -			9	26	
+Pad 7			27	9	
+Pad 8			10	27	
+Pad 9			10	26	
+Pad +			19	26	
+Pad 4			12	27	
+Pad 5			19	27	
+Pad 6			12	26	
+Pad 1			23	27	
+Pad 2			24	27	
+Pad 3			23	26	
+Pad 0			25	27	
+Pad .			24	26	
+Pad Enter		25	26	

Example_Keyboards/Sony_Vaio_VPCEB4/Sony_VPCEB4_Keyboard.ino

@@ -0,0 +1,346 @@
+// This software is in the public domain
+// It implements a Sony Vaio VPCEB4 Laptop Keyboard Controller using a Teensy 3.2 on 
+// a daughterboard with a 32 pin FPC connector. The keyboard part number is A-1766-425-A.
+// This routine uses the Teensyduino "Micro-Manager Method" to send Normal and Modifier 
+// keys over USB. Multi-media keys are not supported by this routine.
+// Description of Teensyduino keyboard functions is at www.pjrc.com/teensy/td_keyboard.html
+// 
+// Revision History
+// Initial Release Oct 10, 2018
+//
+//
+#define MODIFIERKEY_FN 0x8f   // give Fn key a HID code 
+#define CAPS_LED 13 // Teensy LED shows Caps-Lock
+//
+const byte rows_max = 18; // sets the number of rows in the matrix
+const byte cols_max = 8; // sets the number of columns in the matrix
+//
+// Load the normal key matrix with the Teensyduino key names described at www.pjrc.com/teensy/td_keyboard.html
+// A zero indicates no normal key at that location.
+//
+int normal[rows_max][cols_max] = {
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {KEY_COMMA,KEY_PERIOD,KEY_L,KEY_O,KEY_F11,KEY_F10,KEY_9,KEY_0},
+  {KEY_M,KEY_B,KEY_J,KEY_I,KEY_F9,KEY_F8,KEY_8,KEY_U},
+  {KEY_N,KEY_K,KEY_H,KEY_G,KEY_6,KEY_F7,KEY_7,KEY_Y},
+  {KEY_V,KEY_C,KEY_F,KEY_T,KEY_F6,KEY_F5,KEY_5,KEY_R},
+  {KEY_X,KEY_A,KEY_D,KEY_E,KEY_F4,KEY_F3,KEY_3,KEY_4},
+  {KEY_Z,KEY_S,KEY_W,KEY_Q,KEY_F2,KEY_F1,KEY_1,KEY_2},
+  {0,0,KEY_SPACE,KEY_SEMICOLON,KEY_TILDE,KEY_ESC,KEY_TAB,KEY_CAPS_LOCK},
+  {KEY_MENU,KEY_SLASH,0,0,KEY_MINUS,KEY_F12,KEY_P,KEY_LEFT_BRACE},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,KEY_QUOTE,KEY_RIGHT_BRACE,KEY_PRINTSCREEN,KEY_NUM_LOCK,KEY_EQUAL,0},
+  {KEY_LEFT,KEY_DOWN,KEY_RIGHT,KEY_UP,KEY_HOME,KEY_PAGE_DOWN,KEY_END,KEY_PAGE_UP},
+  {0,KEY_BACKSLASH,0,KEY_ENTER,KEY_DELETE,KEY_INSERT,KEY_BACKSPACE,KEY_PAUSE},
+  {KEYPAD_ASTERIX,KEYPAD_MINUS,KEYPAD_9,KEYPAD_6,KEYPAD_PLUS,KEYPAD_3,KEYPAD_PERIOD,KEYPAD_ENTER},
+  {KEYPAD_SLASH,KEYPAD_7,KEYPAD_8,KEYPAD_4,KEYPAD_5,KEYPAD_1,KEYPAD_2,KEYPAD_0}
+};
+// Load the modifier key matrix with key names at the correct row-column location. 
+// A zero indicates no modifier key at that location.
+int modifier[rows_max][cols_max] = {
+  {0,0,MODIFIERKEY_RIGHT_SHIFT,0,0,0,MODIFIERKEY_LEFT_SHIFT,0},
+  {0,MODIFIERKEY_RIGHT_CTRL,0,0,0,MODIFIERKEY_LEFT_CTRL,0,0},
+  {0,0,0,0,MODIFIERKEY_FN,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},   
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,MODIFIERKEY_GUI},    
+  {MODIFIERKEY_RIGHT_ALT,0,0,MODIFIERKEY_LEFT_ALT,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0},
+  {0,0,0,0,0,0,0,0}
+};
+// Initialize the old_key matrix with one's. 
+// 1 = key not pressed, 0 = key is pressed
+boolean old_key[rows_max][cols_max] = {
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1},
+  {1,1,1,1,1,1,1,1}
+};
+//
+// Define the Teensy 3.2 I/O numbers (translated from the FPC pin #)
+// Row FPC pin # 02,03,04,05,06,08,11,13,14,15,16,17,18,20,21,22,26,27
+// Teensy I/O  # 00,22,01,21,02,03,18,17,06,24,07,25,08,09,26,10,12,32
+int Row_IO[rows_max] = {0,22,1,21,2,3,18,17,6,24,7,25,8,9,26,10,12,32}; // Teensy 3.2 I/O numbers for rows
+//
+// Column FPC pin # 07,09,10,12,19,23,24,25
+// Teensy I/O     # 20,19,04,05,33,27,11,28
+int Col_IO[cols_max] = {20,19,4,5,33,27,11,28};  // Teensy 3.2 I/O numbers for columns
+
+// Declare variables that will be used by functions
+boolean slots_full = LOW; // Goes high when slots 1 thru 6 contain normal keys
+// slot 1 thru slot 6 hold the normal key values to be sent over USB. 
+int slot1 = 0; //value of 0 means the slot is empty and can be used.  
+int slot2 = 0; 
+int slot3 = 0; 
+int slot4 = 0; 
+int slot5 = 0; 
+int slot6 = 0;
+//
+int mod_shift_l = 0; // These variables are sent over USB as modifier keys.
+int mod_shift_r = 0; // Each is either set to 0 or MODIFIER_ ... 
+int mod_ctrl_l = 0;   
+int mod_ctrl_r = 0;
+int mod_alt_l = 0;
+int mod_alt_r = 0;
+int mod_gui = 0;
+//
+// Function to load the key name into the first available slot
+void load_slot(int key) {
+  if (!slot1)  {
+    slot1 = key;
+  }
+  else if (!slot2) {
+    slot2 = key;
+  }
+  else if (!slot3) {
+    slot3 = key;
+  }
+  else if (!slot4) {
+    slot4 = key;
+  }
+  else if (!slot5) {
+    slot5 = key;
+  }
+  else if (!slot6) {
+    slot6 = key;
+  }
+  if (!slot1 || !slot2 || !slot3 || !slot4 || !slot5 || !slot6)  {
+    slots_full = LOW; // slots are not full
+  }
+  else {
+    slots_full = HIGH; // slots are full
+  } 
+}
+//
+// Function to clear the slot that contains the key name
+void clear_slot(int key) {
+  if (slot1 == key) {
+    slot1 = 0;
+  }
+  else if (slot2 == key) {
+    slot2 = 0;
+  }
+  else if (slot3 == key) {
+    slot3 = 0;
+  }
+  else if (slot4 == key) {
+    slot4 = 0;
+  }
+  else if (slot5 == key) {
+    slot5 = 0;
+  }
+  else if (slot6 == key) {
+    slot6 = 0;
+  }
+  slots_full = LOW;
+}
+//
+// Function to load the modifier key name into the appropriate mod variable
+void load_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = m_key;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = m_key;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = m_key;
+  }
+}
+//
+// Function to load 0 into the appropriate mod variable
+void clear_mod(int m_key) {
+  if (m_key == MODIFIERKEY_LEFT_SHIFT)  {
+    mod_shift_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_SHIFT)  {
+    mod_shift_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_CTRL)  {
+    mod_ctrl_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_CTRL)  {
+    mod_ctrl_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_LEFT_ALT)  {
+    mod_alt_l = 0;
+  }
+  else if (m_key == MODIFIERKEY_RIGHT_ALT)  {
+    mod_alt_r = 0;
+  }
+  else if (m_key == MODIFIERKEY_GUI)  {
+    mod_gui = 0;
+  }
+}
+//
+// Function to send the modifier keys over usb
+void send_mod() {
+  Keyboard.set_modifier(mod_shift_l | mod_shift_r | mod_ctrl_l | mod_ctrl_r | mod_alt_l | mod_alt_r | mod_gui);
+  Keyboard.send_now();
+}
+//
+// Function to send the normal keys in the 6 slots over usb
+void send_normals() {
+  Keyboard.set_key1(slot1);
+  Keyboard.set_key2(slot2);
+  Keyboard.set_key3(slot3);
+  Keyboard.set_key4(slot4);
+  Keyboard.set_key5(slot5);
+  Keyboard.set_key6(slot6);
+  Keyboard.send_now();
+}
+//
+// Function to set a pin to high impedance (acts like open drain output)
+void go_z(int pin)
+{
+  pinMode(pin, INPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to set a pin as an input with a pullup
+void go_pu(int pin)
+{
+  pinMode(pin, INPUT_PULLUP);
+  digitalWrite(pin, HIGH);
+}
+//
+// Function to send a pin to a logic low
+void go_0(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, LOW);
+}
+//
+// Function to send a pin to a logic high
+void go_1(int pin)
+{
+  pinMode(pin, OUTPUT);
+  digitalWrite(pin, HIGH);
+}
+//
+//----------------------------------Setup-------------------------------------------
+void setup() {
+  for (int a = 0; a < cols_max; a++) {  // loop thru all column pins 
+    go_pu(Col_IO[a]); // set each column pin as an input with a pullup
+  }
+//
+  for (int b = 0; b < rows_max; b++) {  // loop thru all row pins 
+    go_z(Row_IO[b]); // set each row pin as a floating output
+  }  
+}
+//
+boolean Fn_pressed = HIGH; // Initialize Fn key to HIGH = "not pressed"
+extern volatile uint8_t keyboard_leds; // 8 bits sent from Host to Teensy that give keyboard LED status. Caps lock is bit D1.
+//
+//---------------------------------Main Loop---------------------------------------------
+//
+void loop() {   
+// Scan keyboard matrix with an outer loop that drives each row low and an inner loop that reads every column (with pull ups).
+// The routine looks at each key's present state (by reading the column input pin) and also the previous state from the last scan
+// that was 30msec ago. The status of a key that was just pressed or just released is sent over USB and the state is saved in the old_key matrix. 
+// The keyboard keys will read as logic low if they are pressed (negative logic).
+// The old_key matrix also uses negative logic (low=pressed). 
+//
+  for (int x = 0; x < rows_max; x++) {   // loop thru the rows
+    go_0(Row_IO[x]); // Activate Row (send it low)
+    delayMicroseconds(10); // give the row time to go low and settle out
+    for (int y = 0; y < cols_max; y++) {   // loop thru the columns
+// **********Modifier keys including the Fn special case
+      if (modifier[x][y] != 0) {  // check if modifier key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y])) {  // Read column to see if key is low (pressed) and was previously not pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) {   // Exclude Fn modifier key  
+            load_mod(modifier[x][y]); // function reads which modifier key is pressed and loads it into the appropriate mod_... variable   
+            send_mod(); // function sends the state of all modifier keys over usb including the one that just got pressed
+            old_key[x][y] = LOW; // Save state of key as "pressed"
+          }
+          else {   
+            Fn_pressed = LOW; // Fn status variable is active low
+            old_key[x][y] = LOW; // old_key state is "pressed" (active low)
+          }
+        }
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) {  //check if key is not pressed and was previously pressed
+          if (modifier[x][y] != MODIFIERKEY_FN) { // Exclude Fn modifier key 
+            clear_mod(modifier[x][y]); // function reads which modifier key was released and loads 0 into the appropriate mod_... variable
+            send_mod(); // function sends all mod's over usb including the one that just released
+            old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          }
+          else {
+            Fn_pressed = HIGH; // Fn is no longer active
+            old_key[x][y] = HIGH; // old_key state is "not pressed" 
+          }
+        }
+      } 
+// ***********end of modifier section
+//
+// ***********Normal keys section
+      else if (normal[x][y] != 0) {  // check if normal key exists at this location in the array (a non-zero value)
+        if (!digitalRead(Col_IO[y]) && (old_key[x][y]) && (Fn_pressed)) { // check if key is pressed and was not previously pressed and no Fn pressed
+          old_key[x][y] = LOW; // Save state of key as "pressed"
+          load_slot(normal[x][y]); //update first available slot with normal key name
+          send_normals(); // send all slots over USB including the key that just got pressed 
+        }          
+        else if (digitalRead(Col_IO[y]) && (!old_key[x][y])) { //check if key is not pressed, but was previously pressed 
+          old_key[x][y] = HIGH; // Save state of key as "not pressed"
+          clear_slot(normal[x][y]); //clear the slot that contains the normal key name
+          send_normals(); // send all slots over USB including the key that was just released 
+        }
+      } 
+// **************end of normal section
+//
+// ******Add Multi-Media key coding here if needed
+//
+    }
+    go_z(Row_IO[x]); // De-activate Row (send it to hi-z)
+  }
+//
+// **********keyboard scan complete
+//
+// Turn on the LED on the Teensy for Caps Lock based on bit 1 in the keyboard_leds variable controlled by the USB host computer
+//
+  if (keyboard_leds & 1<<1) {  // mask off all bits but D1 and test if set
+    go_1(CAPS_LED); // turn on the LED
+  }
+  else {
+    go_0(CAPS_LED); // turn off the LED
+  }
+//
+  delay(25); // The overall keyboard scanning rate is about 30ms
+}