moparisthebest/USBHost_t36
1
0
Fork 0
mirror of https://github.com/gdsports/USBHost_t36 synced 2024-11-21 16:45:04 -05:00
Code Issues Releases Wiki Activity

Keyboard LEDs and data parsing (Kurt & Frank)

Browse Source
This commit is contained in:
PaulStoffregen 2017-10-08 12:56:39 -07:00
parent 5ea0d568a1
commit d3b6abe878
2 changed files with 176 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
USBHost_t36.h
View File

@ -532,6 +532,18 @@ private:
class KeyboardController : public USBDriver /* , public USBHIDInput */ {
public:
typedef union {
struct {
uint8_t numLock : 1;
uint8_t capsLock : 1;
uint8_t scrollLock : 1;
uint8_t compose : 1;
uint8_t kana : 1;
uint8_t reserved : 3;
};
uint8_t byte;
} KBDLeds_t;
public:
KeyboardController(USBHost &host) { init(); }
KeyboardController(USBHost *host) { init(); }
@ -542,6 +554,15 @@ public:
uint8_t getOemKey() { return keyOEM; }
void attachPress(void (*f)(int unicode)) { keyPressedFunction = f; }
void attachRelease(void (*f)(int unicode)) { keyReleasedFunction = f; }
void LEDS(uint8_t leds);
uint8_t LEDS() {return leds_.byte;}
void updateLEDS(void);
bool numLock() {return leds_.numLock;}
bool capsLock() {return leds_.capsLock;}
bool scrollLock() {return leds_.scrollLock;}
void numLock(bool f);
void capsLock(bool f);
void scrollLock(bool f);
protected:
virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
virtual void control(const Transfer_t *transfer);
@ -563,6 +584,9 @@ private:
uint8_t modifiers;
uint8_t keyOEM;
uint8_t prev_report[8];
KBDLeds_t leds_ = {0};
bool update_leds_ = false;
bool processing_new_data_ = false;
Pipe_t mypipes[2] __attribute__ ((aligned(32)));
Transfer_t mytransfers[4] __attribute__ ((aligned(32)));
};

153
keyboard.cpp
View File

@ -25,6 +25,49 @@
#include "USBHost_t36.h" // Read this header first for key info
#include "keylayouts.h" // from Teensyduino core library
typedef struct {
KEYCODE_TYPE code;
uint8_t ascii;
} keycode_extra_t;
typedef struct {
KEYCODE_TYPE code;
KEYCODE_TYPE codeNumlockOff;
uint8_t charNumlockOn; // We will assume when num lock is on we have all characters...
} keycode_numlock_t;
#ifdef M
#undef M
#endif
#define M(n) ((n) & KEYCODE_MASK)
keycode_extra_t keycode_extras[] = {
{M(KEY_ENTER), '\n'},
{M(KEY_ESC), 0x1b},
{M(KEY_TAB), 0x9 }
};
// Some of these mapped to key + shift.
keycode_numlock_t keycode_numlock[] = {
{M(KEYPAD_SLASH), '/', '/'},
{M(KEYPAD_ASTERIX), '*', '*'},
{M(KEYPAD_MINUS), '-', '-'},
{M(KEYPAD_PLUS), '+', '+'},
{M(KEYPAD_ENTER), '\n', '\n'},
{M(KEYPAD_1), 0x80 | M(KEY_END), '1'},
{M(KEYPAD_2), 0x80 | M(KEY_DOWN), '2'},
{M(KEYPAD_3), 0x80 | M(KEY_PAGE_DOWN), '3'},
{M(KEYPAD_4), 0x80 | M(KEY_LEFT), '4'},
{M(KEYPAD_5), 0x00, '5'},
{M(KEYPAD_6), 0x80 | M(KEY_RIGHT), '6'},
{M(KEYPAD_7), 0x80 | M(KEY_HOME), '7'},
{M(KEYPAD_8), 0x80 | M(KEY_UP), '8'},
{M(KEYPAD_9), 0x80 | M(KEY_PAGE_UP), '9'},
{M(KEYPAD_0), 0x80 | M(KEY_INSERT), '0'},
{M(KEYPAD_PERIOD), 0x80 | M(KEY_DELETE), '.'}
};
void KeyboardController::init()
{
@ -58,7 +101,9 @@ bool KeyboardController::claim(Device_t *dev, int type, const uint8_t *descripto
if (descriptors[21] != 3) return false; // must be interrupt type
uint32_t size = descriptors[22] | (descriptors[23] << 8);
println("packet size = ", size);
if (size != 8) return false; // must be 8 bytes for Keyboard Boot Protocol
if (size != 8) {
return false; // must be 8 bytes for Keyboard Boot Protocol
}
uint32_t interval = descriptors[24];
println("polling interval = ", interval);
datapipe = new_Pipe(dev, 3, endpoint, 1, 8, interval);
@ -106,6 +151,7 @@ static bool contains(uint8_t b, const uint8_t *data)
void KeyboardController::new_data(const Transfer_t *transfer)
{
processing_new_data_ = true;
println("KeyboardController Callback (member)");
print(" KB Data: ");
print_hexbytes(transfer->buffer, 8);
@ -123,6 +169,34 @@ void KeyboardController::new_data(const Transfer_t *transfer)
}
memcpy(prev_report, report, 8);
queue_Data_Transfer(datapipe, report, 8, this);
processing_new_data_ = false;
// See if we have any outstanding leds to update
if (update_leds_) {
updateLEDS();
}
}
void KeyboardController::numLock(bool f) {
if (leds_.numLock != f) {
leds_.numLock = f;
updateLEDS();
}
}
void KeyboardController::capsLock(bool f) {
if (leds_.capsLock != f) {
leds_.capsLock = f;
updateLEDS();
}
}
void KeyboardController::scrollLock(bool f) {
if (leds_.scrollLock != f) {
leds_.scrollLock = f;
updateLEDS();
}
}
void KeyboardController::key_press(uint32_t mod, uint32_t key)
@ -146,12 +220,24 @@ void KeyboardController::key_release(uint32_t mod, uint32_t key)
println(" release, key=", key);
modifiers = mod;
keyOEM = key;
// Look for modifier keys
if (key == M(KEY_NUM_LOCK)) {
numLock(!leds_.numLock);
// Lets toggle Numlock
} else if (key == M(KEY_CAPS_LOCK)) {
capsLock(!leds_.capsLock);
} else if (key == M(KEY_SCROLL_LOCK)) {
scrollLock(!leds_.scrollLock);
} else {
keyCode = convert_to_unicode(mod, key);
if (keyReleasedFunction) {
keyReleasedFunction(keyCode);
} else {
keyReleased();
}
}
}
uint16_t KeyboardController::convert_to_unicode(uint32_t mod, uint32_t key)
@ -159,10 +245,43 @@ uint16_t KeyboardController::convert_to_unicode(uint32_t mod, uint32_t key)
// TODO: special keys
// TODO: caps lock
// TODO: dead key sequences
if ((mod & 0x02) || (mod & 0x20)) key |= SHIFT_MASK;
for (int i=0; i < 96; i++) {
if (keycodes_ascii[i] == key) return i + 32;
if (key & SHIFT_MASK) {
// Many of these keys will look like they are other keys with shift mask...
// Check for any of our mapped extra keys
for (uint8_t i = 0; i < (sizeof(keycode_numlock)/sizeof(keycode_numlock[0])); i++) {
if (keycode_numlock[i].code == key) {
// See if the user is using numlock or not...
if (leds_.numLock) {
return keycode_numlock[i].charNumlockOn;
} else {
key = keycode_numlock[i].codeNumlockOff;
if (!(key & 0x80)) return key; // we have hard coded value
key &= 0x7f; // mask off the extra and break out to process as other characters...
break;
}
}
}
// If we made it here without doing something then return 0;
if (key & SHIFT_MASK) return 0;
}
if ((mod & 0x02) || (mod & 0x20)) key |= SHIFT_MASK;
if (leds_.capsLock) key ^= SHIFT_MASK; // Caps lock will switch the Shift;
for (int i=0; i < 96; i++) {
if (keycodes_ascii[i] == key) {
if ((mod & 1) || (mod & 0x10)) return (i+32) & 0x1f; // Control key is down
return i + 32;
}
}
// Check for any of our mapped extra keys
for (uint8_t i = 0; i < (sizeof(keycode_extras)/sizeof(keycode_extras[0])); i++) {
if (keycode_extras[i].code == key) {
return keycode_extras[i].ascii;
}
}
#ifdef ISO_8859_1_A0
for (int i=0; i < 96; i++) {
if (keycodes_iso_8859_1[i] == key) return i + 160;
@ -171,6 +290,31 @@ uint16_t KeyboardController::convert_to_unicode(uint32_t mod, uint32_t key)
return 0;
}
void KeyboardController::LEDS(uint8_t leds) {
println("Keyboard setLEDS ", leds, HEX);
leds_.byte = leds;
updateLEDS();
}
void KeyboardController::updateLEDS() {
println("KBD: Update LEDS", leds_.byte, HEX);
if (processing_new_data_) {
println(" Update defered");
update_leds_ = true;
return; // defer until later
}
// Now lets tell keyboard new state.
static uint8_t keyboard_keys_report[1] = {0};
setup_t keys_setup;
keyboard_keys_report[0] = leds_.byte;
queue_Data_Transfer(datapipe, report, 8, this);
mk_setup(keys_setup, 0x21, 9, 0x200, 0, sizeof(keyboard_keys_report)); // hopefully this sets leds
queue_Control_Transfer(device, &keys_setup, keyboard_keys_report, this);
update_leds_ = false;
}
@ -181,4 +325,3 @@ uint16_t KeyboardController::convert_to_unicode(uint32_t mod, uint32_t key)