You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

401 lines
11 KiB

/*
Usage: Convert standard QWERTY keyboard to any keyboard layout you want
Default layout: QWERTY
Reserved key combination to switch layout:
Ctrl-Shift 0 => QWERTY (DEFAULT)
Ctrl-Shift 1 => tarmak1
Ctrl-Shift 2 => tarmak2
Ctrl-Shift 3 => tarmak3
Ctrl-Shift 4 => tarmak4
Ctrl-Shift 5 => Colemak
Ctrl-Shift 6 => Dvorak
Ctrl-Shift 7 => Workman
*/
#ifdef __MK66FX1M0__
/* Teensy 3.6 */
#define TEENSY_USB_HOST 1
#endif
#include <avr/pgmspace.h>
#ifdef TEENSY_USB_HOST
#include <USBHost_t36.h>
#else
#include <Usb.h>
#include <hidboot.h>
#endif
#include <Keyboard.h>
#include "keymapper_game.h"
//#define DEBUG
#define modeLED LED_BUILTIN
// function definitions
bool HandleReservedKeystrokes(uint8_t *buf);
inline void SendKeysToHost (uint8_t *buf);
void play_word_game(void);
inline void LatchKey (uint8_t keyToLatch);
// variable definitions
typedef enum
{
qwerty = 0,
tarmak1,
tarmak2,
tarmak3,
tarmak4,
colemak,
dvorak,
workman
} KeyboardLayout;
// Keymap based on the scancodes from 4 to 57, refer to the HID usage table on the meaning of each element
PROGMEM const uint8_t qwertyKeymap[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57};
PROGMEM const uint8_t tarmak1Keymap[] = {4, 5, 6, 7, 13, 9, 10, 11, 12, 17, 8, 15, 16, 14, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 42};
PROGMEM const uint8_t tarmak2Keymap[] = {4, 5, 6, 7, 9, 23, 13, 11, 12, 17, 8, 15, 16, 14, 18, 19, 20, 21, 22, 10, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 42};
PROGMEM const uint8_t tarmak3Keymap[] = {4, 5, 6, 7, 9, 23, 51, 11, 12, 17, 8, 15, 16, 14, 28, 19, 20, 21, 22, 10, 24, 25, 26, 27, 13, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 18, 52, 53, 54, 55, 56, 42};
PROGMEM const uint8_t tarmak4Keymap[] = {4, 5, 6, 7, 9, 23, 51, 11, 24, 17, 8, 12, 16, 14, 28, 19, 20, 21, 22, 10, 15, 25, 26, 27, 13, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 18, 52, 53, 54, 55, 56, 42};
PROGMEM const uint8_t colemakKeymap[] = {4, 5, 6, 22, 9, 23, 7, 11, 24, 17, 8, 12, 16, 14, 28, 51, 20, 19, 21, 10, 15, 25, 26, 27, 13, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 18, 52, 53, 54, 55, 56, 42};
PROGMEM const uint8_t dvorakKeymap[] = {4, 27, 13, 8, 55, 24, 12, 7, 6, 11, 23, 17, 16, 5, 21, 15, 52, 19, 18, 28, 10, 14, 54, 20, 9, 51, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 47, 48, 56, 46, 49, 50, 22, 45, 53, 26, 25, 29, 57};
PROGMEM const uint8_t workmanKeymap[] = {4, 25, 16, 11, 21, 23, 10, 28, 24, 17, 8, 18, 15, 14, 19, 51, 20, 26, 22, 5, 9, 6, 7, 27, 13, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 12, 52, 53, 54, 55, 56, 42};
const uint8_t *Keymap[] =
{
qwertyKeymap,
tarmak1Keymap,
tarmak2Keymap,
tarmak3Keymap,
tarmak4Keymap,
colemakKeymap,
dvorakKeymap,
workmanKeymap
};
// global variables
//uint32_t ledBlinkTime = millis();
//uint16_t ledBlinkDelay = 500;
KeyboardLayout CurrentLayout = qwerty;
uint8_t KeyBuffer[8] = {0, 0, 0, 0, 0, 0, 0, 0};
uint8_t specialKeyLatch = 0;
bool specialKeyLatchReleased = false;
void print_hex(const uint8_t *buf, size_t len)
{
#ifdef DEBUG
for (size_t i = 0; i < 8; i++) {
if (i) Serial.print(' ');
Serial.print(buf[i], HEX);
}
Serial.println();
#endif
}
// *******************************************************************************************
// Parse
// *******************************************************************************************
void remapper(uint8_t *buf, uint8_t len)
{
uint8_t i;
// On error - return
if (buf[2] == 1)
return;
print_hex(buf, len);
KeyBuffer[0] = buf[0];
if (!HandleReservedKeystrokes(buf))
{
specialKeyLatchReleased = true;
// remap all keys according to the existing keymap
for (i = 2; i < 8; i++)
{
// handle special case of Shift-CAPSLOCK to be ignored by the remapper
if (buf[i] == KEY_CAPS_LOCK && buf[0] & 0x22)
{
KeyBuffer[i] = KEY_CAPS_LOCK;
LatchKey(KEY_CAPS_LOCK);
}
else
{
// print the key based on the current layout
if (buf[i] >= 4 && buf[i] <= 57) // transpose of 4 becoz our array starts from 0 but A is 4
// limit check to 57, which is the last mappable key (CAPSLOCK)
{
// if it was a special key of shift-CAPS, then only allow mapping if the key has been released at least once
if (buf[i] != specialKeyLatch)
KeyBuffer[i] = pgm_read_byte(Keymap[CurrentLayout] + buf[i] - 4);
else // key is not released yet. do not allow mapping
{
// Serial.println("key is not released");
KeyBuffer[i] = 0;
specialKeyLatchReleased = false;
}
}
else
KeyBuffer[i] = buf[i];
}
}
// reset latch if key is released
if (specialKeyLatchReleased)
{
// Serial.println("latch is released");
specialKeyLatch = 0;
}
// send out key press
SendKeysToHost (KeyBuffer);
print_hex(KeyBuffer, 8);
}
}
bool HandleReservedKeystrokes(uint8_t *buf) // return true if it is a reserved keystroke
{
uint8_t mod = buf[0]; // read the modifier byte
uint8_t numKeysPressed = 0;
uint8_t keyPosition = 0;
// check that there is only 1 single key that is pressed
for (uint8_t i = 2; i < 8; i++) if (buf[i] > 0) {
numKeysPressed++;
keyPosition = i;
}
if (numKeysPressed != 1) return false; // only allow single keypress for reserved keystrokes (besides modifiers)
// check if we are changing layouts
if ((mod & 0x22) && (mod & 0x11)) { // Shift-Alt keystrokes
switch (buf[keyPosition]) {
case 0x27: // 0
CurrentLayout = qwerty;
digitalWrite(modeLED, LOW);
LatchKey(buf[keyPosition]);
return true;
case 0x1e: // 1
CurrentLayout = tarmak1;
digitalWrite(modeLED, HIGH);
LatchKey(buf[keyPosition]);
return true;
case 0x1f: // 2
CurrentLayout = tarmak2;
digitalWrite(modeLED, HIGH);
LatchKey(buf[keyPosition]);
return true;
case 0x20: // 3
CurrentLayout = tarmak3;
digitalWrite(modeLED, HIGH);
LatchKey(buf[keyPosition]);
return true;
case 0x21: // 4
CurrentLayout = tarmak4;
digitalWrite(modeLED, HIGH);
LatchKey(buf[keyPosition]);
return true;
case 0x22: // 5
CurrentLayout = colemak;
digitalWrite(modeLED, HIGH);
LatchKey(buf[keyPosition]);
return true;
case 0x23: // 6
CurrentLayout = dvorak;
digitalWrite(modeLED, HIGH);
LatchKey(buf[keyPosition]);
return true;
case 0x24: // 7
CurrentLayout = workman;
digitalWrite(modeLED, HIGH);
LatchKey(buf[keyPosition]);
return true;
case 0x2c: // space bar
play_word_game();
LatchKey(buf[keyPosition]);
return true;
}
}
return false;
}
inline void SendKeysToHost (uint8_t *buf)
{
#ifdef TEENSYDUINO
Keyboard.set_modifier(buf[0]);
Keyboard.set_key1(buf[2]);
Keyboard.set_key2(buf[3]);
Keyboard.set_key3(buf[4]);
Keyboard.set_key4(buf[5]);
Keyboard.set_key5(buf[6]);
Keyboard.set_key6(buf[7]);
Keyboard.send_now();
#else /* TEENSYDUINO */
HID().SendReport(2, buf, 8);
#endif /* TEENSYDUINO */
}
inline void LatchKey (uint8_t keyToLatch)
{
specialKeyLatch = keyToLatch;
specialKeyLatchReleased = false;
// Serial.print(keyToLatch);
// Serial.println(" is latched");
}
// *******************************************************************************************
// WORD GAME!!!
// *******************************************************************************************
void play_word_game(void)
{
char buffer[GAME_MAXWORDLENGTH];
char priorityAlphabets[10];
char *instrPtr;
uint16_t randNum;
switch (CurrentLayout) {
case tarmak1:
strcpy (priorityAlphabets, "nek");
break;
case tarmak2:
strcpy (priorityAlphabets, "ftg");
break;
case tarmak3:
strcpy (priorityAlphabets, "jyo");
break;
case tarmak4:
strcpy (priorityAlphabets, "lui");
break;
case colemak:
strcpy (priorityAlphabets, "rspd");
break;
default:
strcpy (priorityAlphabets, "");
}
Keyboard.print( "Word game! Letters being prioritised: " );
Keyboard.println( priorityAlphabets );
for (int i = 0; i < 15; i++) {
if (priorityAlphabets[0] != 0) {
instrPtr = NULL;
while (instrPtr == NULL) {
randNum = random(GAME_NUMWORDS);
strcpy_P(buffer, (char*)pgm_read_word(&(game_word_list[randNum])));
instrPtr = strpbrk (buffer, priorityAlphabets);
}
}
else {
randNum = random(GAME_NUMWORDS);
strcpy_P(buffer, (char*)pgm_read_word(&(game_word_list[randNum])));
}
Keyboard.print( buffer );
Keyboard.print( " " );
}
Keyboard.println( "" );
}
#ifdef TEENSY_USB_HOST
USBHost Usb;
KeyboardController keyboard_in(Usb);
/*
Key remap possiblities
Swap LeftCtrl and CapsLock. Put CapsLock in the corner where it belongs!
Switchable QWERTY, Dvorak, and colemak keyboard layouts
Hardware key macros
Remappings and macros that work even in BIOS and recovery mode.
Remappings and macros that work with KVMs and game consoles.
*/
void reportReader(uint8_t report[8])
{
remapper(report, 8);
}
#else /* TEENSY_USB_HOST */
class KbdRptParser : public KeyboardReportParser
{
protected:
virtual void Parse(USBHID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf);
};
void KbdRptParser::Parse(USBHID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf)
{
remapper(buf, len);
// Run parent class method so keyboard LEDs are updated.
KeyboardReportParser::Parse(hid, is_rpt_id, len, buf);
};
USB Usb;
//USBHub Hub(&Usb);
HIDBoot<USB_HID_PROTOCOL_KEYBOARD> ExtKeyboard(&Usb);
KbdRptParser Prs;
#endif /* TEENSY_USB_HOST */
void setup()
{
randomSeed(analogRead(0));
// initialize the digital pin as an output.
pinMode(modeLED, OUTPUT);
Keyboard.begin();
#ifdef DEBUG
Serial.begin( 115200 );
while (!Serial) delay(1);
Serial.println("Start");
#endif
#ifdef TEENSY_USB_HOST
Usb.begin();
keyboard_in.attachReportReader(reportReader);
#else
if (Usb.Init() == -1)
#ifdef DEBUG
Serial.println("USB host did not start.");
#else
delay( 1 );
#endif
delay( 200 );
ExtKeyboard.SetReportParser(0, (HIDReportParser*)&Prs);
#endif
}
void loop()
{
Usb.Task();
}