alpha
/
Kaleidoscope
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

driver/keyboardioHID: astyle

Browse Source 
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
f/driver/keyboardiohid-orig
Gergely Nagy 4 years ago committed by Jesse Vincent
parent 2c4a274cb3
commit 35b1fb239c
No known key found for this signature in database
GPG Key ID: 122F5DF7108E4046
23 changed files with 1122 additions and 1121 deletions
Show Stats Download Patch File Download Diff File

436
src/kaleidoscope/driver/hid/keyboardio/HID/BootKeyboard/BootKeyboard.cpp
Unescape View File

@ -29,199 +29,199 @@ THE SOFTWARE.
// See Appendix B of USB HID spec
static const uint8_t _hidReportDescriptorKeyboard[] PROGMEM = {
// Keyboard
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP,
D_USAGE, D_USAGE_KEYBOARD,
D_COLLECTION, D_APPLICATION,
// Modifiers
D_USAGE_PAGE, D_PAGE_KEYBOARD,
D_USAGE_MINIMUM, 0xe0,
D_USAGE_MAXIMUM, 0xe7,
D_LOGICAL_MINIMUM, 0x0,
D_LOGICAL_MAXIMUM, 0x1,
D_REPORT_SIZE, 0x1,
D_REPORT_COUNT, 0x8,
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE),
// Reserved byte
D_REPORT_COUNT, 0x1,
D_REPORT_SIZE, 0x8,
D_INPUT, (D_CONSTANT),
// LEDs
D_REPORT_COUNT, 0x5,
D_REPORT_SIZE, 0x1,
D_USAGE_PAGE, D_PAGE_LEDS,
D_USAGE_MINIMUM, 0x1,
D_USAGE_MAXIMUM, 0x5,
D_OUTPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE),
// Pad LEDs up to a byte
D_REPORT_COUNT, 0x1,
D_REPORT_SIZE, 0x3,
D_OUTPUT, (D_CONSTANT),
// Non-modifiers
D_REPORT_COUNT, 0x6,
D_REPORT_SIZE, 0x8,
D_LOGICAL_MINIMUM, 0x0,
D_LOGICAL_MAXIMUM, 0xff,
D_USAGE_PAGE, D_PAGE_KEYBOARD,
D_USAGE_MINIMUM, 0x0,
D_USAGE_MAXIMUM, 0xff,
D_INPUT, (D_DATA|D_ARRAY|D_ABSOLUTE),
D_END_COLLECTION
// Keyboard
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP,
D_USAGE, D_USAGE_KEYBOARD,
D_COLLECTION, D_APPLICATION,
// Modifiers
D_USAGE_PAGE, D_PAGE_KEYBOARD,
D_USAGE_MINIMUM, 0xe0,
D_USAGE_MAXIMUM, 0xe7,
D_LOGICAL_MINIMUM, 0x0,
D_LOGICAL_MAXIMUM, 0x1,
D_REPORT_SIZE, 0x1,
D_REPORT_COUNT, 0x8,
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE),
// Reserved byte
D_REPORT_COUNT, 0x1,
D_REPORT_SIZE, 0x8,
D_INPUT, (D_CONSTANT),
// LEDs
D_REPORT_COUNT, 0x5,
D_REPORT_SIZE, 0x1,
D_USAGE_PAGE, D_PAGE_LEDS,
D_USAGE_MINIMUM, 0x1,
D_USAGE_MAXIMUM, 0x5,
D_OUTPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE),
// Pad LEDs up to a byte
D_REPORT_COUNT, 0x1,
D_REPORT_SIZE, 0x3,
D_OUTPUT, (D_CONSTANT),
// Non-modifiers
D_REPORT_COUNT, 0x6,
D_REPORT_SIZE, 0x8,
D_LOGICAL_MINIMUM, 0x0,
D_LOGICAL_MAXIMUM, 0xff,
D_USAGE_PAGE, D_PAGE_KEYBOARD,
D_USAGE_MINIMUM, 0x0,
D_USAGE_MAXIMUM, 0xff,
D_INPUT, (D_DATA | D_ARRAY | D_ABSOLUTE),
D_END_COLLECTION
};
BootKeyboard_::BootKeyboard_(void) : PluggableUSBModule(1, 1, epType), protocol(HID_REPORT_PROTOCOL), idle(1), leds(0) {
epType[0] = EP_TYPE_INTERRUPT_IN;
epType[0] = EP_TYPE_INTERRUPT_IN;
}
int BootKeyboard_::getInterface(uint8_t* interfaceCount) {
*interfaceCount += 1; // uses 1
HIDDescriptor hidInterface = {
D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_BOOT_INTERFACE, HID_PROTOCOL_KEYBOARD),
D_HIDREPORT(sizeof(_hidReportDescriptorKeyboard)),
D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01)
};
return USB_SendControl(0, &hidInterface, sizeof(hidInterface));
*interfaceCount += 1; // uses 1
HIDDescriptor hidInterface = {
D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_BOOT_INTERFACE, HID_PROTOCOL_KEYBOARD),
D_HIDREPORT(sizeof(_hidReportDescriptorKeyboard)),
D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01)
};
return USB_SendControl(0, &hidInterface, sizeof(hidInterface));
}
int BootKeyboard_::getDescriptor(USBSetup& setup) {
// Check if this is a HID Class Descriptor request
if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) {
return 0;
}
if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) {
return 0;
}
// In a HID Class Descriptor wIndex cointains the interface number
if (setup.wIndex != pluggedInterface) {
return 0;
}
// Reset the protocol on reenumeration. Normally the host should not assume the state of the protocol
// due to the USB specs, but Windows and Linux just assumes its in report mode.
protocol = default_protocol;
return USB_SendControl(TRANSFER_PGM, _hidReportDescriptorKeyboard, sizeof(_hidReportDescriptorKeyboard));
// Check if this is a HID Class Descriptor request
if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) {
return 0;
}
if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) {
return 0;
}
// In a HID Class Descriptor wIndex cointains the interface number
if (setup.wIndex != pluggedInterface) {
return 0;
}
// Reset the protocol on reenumeration. Normally the host should not assume the state of the protocol
// due to the USB specs, but Windows and Linux just assumes its in report mode.
protocol = default_protocol;
return USB_SendControl(TRANSFER_PGM, _hidReportDescriptorKeyboard, sizeof(_hidReportDescriptorKeyboard));
}
void BootKeyboard_::begin(void) {
PluggableUSB().plug(this);
PluggableUSB().plug(this);
// Force API to send a clean report.
// This is important for and HID bridge where the receiver stays on,
// while the sender is resetted.
releaseAll();
sendReport();
// Force API to send a clean report.
// This is important for and HID bridge where the receiver stays on,
// while the sender is resetted.
releaseAll();
sendReport();
}
void BootKeyboard_::end(void) {
releaseAll();
sendReport();
releaseAll();
sendReport();
}
bool BootKeyboard_::setup(USBSetup& setup) {
if (pluggedInterface != setup.wIndex) {
return false;
}
if (pluggedInterface != setup.wIndex) {
return false;
}
uint8_t request = setup.bRequest;
uint8_t requestType = setup.bmRequestType;
uint8_t request = setup.bRequest;
uint8_t requestType = setup.bmRequestType;
if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE) {
if (request == HID_GET_REPORT) {
// TODO(anyone): HID_GetReport();
return true;
}
if (request == HID_GET_PROTOCOL) {
// TODO(anyone) improve
if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE) {
if (request == HID_GET_REPORT) {
// TODO(anyone): HID_GetReport();
return true;
}
if (request == HID_GET_PROTOCOL) {
// TODO(anyone) improve
#ifdef __AVR__
UEDATX = protocol;
UEDATX = protocol;
#endif
#ifdef ARDUINO_ARCH_SAM
USBDevice.armSend(0, &protocol, 1);
USBDevice.armSend(0, &protocol, 1);
#endif
return true;
}
if (request == HID_GET_IDLE) {
// TODO(anyone) improve
return true;
}
if (request == HID_GET_IDLE) {
// TODO(anyone) improve
#ifdef __AVR__
UEDATX = idle;
UEDATX = idle;
#endif
#ifdef ARDUINO_ARCH_SAM
USBDevice.armSend(0, &idle, 1);
USBDevice.armSend(0, &idle, 1);
#endif
return true;
}
return true;
}
}
if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE) {
if (request == HID_SET_PROTOCOL) {
protocol = setup.wValueL;
return true;
}
if (request == HID_SET_IDLE) {
// We currently ignore SET_IDLE, because we don't really do anything with it, and implementing
// it causes issues on OSX, such as key chatter. Other operating systems do not suffer if we
// force this to zero, either.
if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE) {
if (request == HID_SET_PROTOCOL) {
protocol = setup.wValueL;
return true;
}
if (request == HID_SET_IDLE) {
// We currently ignore SET_IDLE, because we don't really do anything with it, and implementing
// it causes issues on OSX, such as key chatter. Other operating systems do not suffer if we
// force this to zero, either.
#if 0
idle = setup.wValueL;
idle = setup.wValueL;
#else
idle = 0;
idle = 0;
#endif
return true;
return true;
}
if (request == HID_SET_REPORT) {
// Check if data has the correct length afterwards
int length = setup.wLength;
if (setup.wValueH == HID_REPORT_TYPE_OUTPUT) {
if (length == sizeof(leds)) {
USB_RecvControl(&leds, length);
return true;
}
if (request == HID_SET_REPORT) {
// Check if data has the correct length afterwards
int length = setup.wLength;
if (setup.wValueH == HID_REPORT_TYPE_OUTPUT) {
if (length == sizeof(leds)) {
USB_RecvControl(&leds, length);
return true;
}
} else { // Input (set HID report)
if (setup.wValueH == HID_REPORT_TYPE_INPUT) {
if (length == sizeof(_keyReport)) {
USB_RecvControl(&_keyReport, length);
return true;
}
}
}
} else { // Input (set HID report)
if (setup.wValueH == HID_REPORT_TYPE_INPUT) {
if (length == sizeof(_keyReport)) {
USB_RecvControl(&_keyReport, length);
return true;
}
}
}
}
}
return false;
return false;
}
uint8_t BootKeyboard_::getLeds(void) {
return leds;
return leds;
}
uint8_t BootKeyboard_::getProtocol(void) {
return protocol;
return protocol;
}
void BootKeyboard_::setProtocol(uint8_t protocol) {
this->protocol = protocol;
this->protocol = protocol;
}
int BootKeyboard_::sendReport(void) {
if (memcmp(&_lastKeyReport, &_keyReport, sizeof(_keyReport))) {
// if the two reports are different, send a report
int returnCode = USB_Send(pluggedEndpoint | TRANSFER_RELEASE, &_keyReport, sizeof(_keyReport));
HIDReportObserver::observeReport(HID_REPORTID_KEYBOARD, &_keyReport, sizeof(_keyReport), returnCode);
memcpy(&_lastKeyReport, &_keyReport, sizeof(_keyReport));
return returnCode;
}
return -1;
if (memcmp(&_lastKeyReport, &_keyReport, sizeof(_keyReport))) {
// if the two reports are different, send a report
int returnCode = USB_Send(pluggedEndpoint | TRANSFER_RELEASE, &_keyReport, sizeof(_keyReport));
HIDReportObserver::observeReport(HID_REPORTID_KEYBOARD, &_keyReport, sizeof(_keyReport), returnCode);
memcpy(&_lastKeyReport, &_keyReport, sizeof(_keyReport));
return returnCode;
}
return -1;
}
// press() adds the specified key (printing, non-printing, or modifier)
@ -231,35 +231,35 @@ int BootKeyboard_::sendReport(void) {
size_t BootKeyboard_::press(uint8_t k) {
uint8_t done = 0;
if ((k >= HID_KEYBOARD_FIRST_MODIFIER) && (k <= HID_KEYBOARD_LAST_MODIFIER)) {
// it's a modifier key
_keyReport.modifiers |= (0x01 << (k - HID_KEYBOARD_FIRST_MODIFIER));
} else {
// it's some other key:
// Add k to the key report only if it's not already present
// and if there is an empty slot.
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_keyReport.keycodes[i] != k) { // is k already in list?
if (0 == _keyReport.keycodes[i]) { // have we found an empty slot?
_keyReport.keycodes[i] = k;
done = 1;
break;
}
} else {
done = 1;
break;
}
}
// use separate variable to check if slot was found
// for style reasons - we do not know how the compiler
// handles the for() index when it leaves the loop
if (0 == done) {
return 0;
uint8_t done = 0;
if ((k >= HID_KEYBOARD_FIRST_MODIFIER) && (k <= HID_KEYBOARD_LAST_MODIFIER)) {
// it's a modifier key
_keyReport.modifiers |= (0x01 << (k - HID_KEYBOARD_FIRST_MODIFIER));
} else {
// it's some other key:
// Add k to the key report only if it's not already present
// and if there is an empty slot.
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_keyReport.keycodes[i] != k) { // is k already in list?
if (0 == _keyReport.keycodes[i]) { // have we found an empty slot?
_keyReport.keycodes[i] = k;
done = 1;
break;
}
} else {
done = 1;
break;
}
}
// use separate variable to check if slot was found
// for style reasons - we do not know how the compiler
// handles the for() index when it leaves the loop
if (0 == done) {
return 0;
}
return 1;
}
return 1;
}
@ -268,43 +268,43 @@ size_t BootKeyboard_::press(uint8_t k) {
// it shouldn't be repeated any more.
size_t BootKeyboard_::release(uint8_t k) {
if ((k >= HID_KEYBOARD_FIRST_MODIFIER) && (k <= HID_KEYBOARD_LAST_MODIFIER)) {
// it's a modifier key
_keyReport.modifiers = _keyReport.modifiers & (~(0x01 << (k - HID_KEYBOARD_FIRST_MODIFIER)));
} else {
// it's some other key:
// Test the key report to see if k is present. Clear it if it exists.
// Check all positions in case the key is present more than once (which it shouldn't be)
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_keyReport.keycodes[i] == k) {
_keyReport.keycodes[i] = 0;
}
}
if ((k >= HID_KEYBOARD_FIRST_MODIFIER) && (k <= HID_KEYBOARD_LAST_MODIFIER)) {
// it's a modifier key
_keyReport.modifiers = _keyReport.modifiers & (~(0x01 << (k - HID_KEYBOARD_FIRST_MODIFIER)));
} else {
// it's some other key:
// Test the key report to see if k is present. Clear it if it exists.
// Check all positions in case the key is present more than once (which it shouldn't be)
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_keyReport.keycodes[i] == k) {
_keyReport.keycodes[i] = 0;
}
}
// rearrange the keys list so that the free (= 0x00) are at the
// end of the keys list - some implementations stop for keys at the
// first occurence of an 0x00 in the keys list
// so (0x00)(0x01)(0x00)(0x03)(0x02)(0x00) becomes
// (0x03)(0x02)(0x01)(0x00)(0x00)(0x00)
uint8_t current = 0, nextpos = 0;
while (current < sizeof(_keyReport.keycodes)) {
if (_keyReport.keycodes[current]) {
uint8_t tmp = _keyReport.keycodes[nextpos];
_keyReport.keycodes[nextpos] = _keyReport.keycodes[current];
_keyReport.keycodes[current] = tmp;
++nextpos;
}
++current;
}
// rearrange the keys list so that the free (= 0x00) are at the
// end of the keys list - some implementations stop for keys at the
// first occurence of an 0x00 in the keys list
// so (0x00)(0x01)(0x00)(0x03)(0x02)(0x00) becomes
// (0x03)(0x02)(0x01)(0x00)(0x00)(0x00)
uint8_t current = 0, nextpos = 0;
while (current < sizeof(_keyReport.keycodes)) {
if (_keyReport.keycodes[current]) {
uint8_t tmp = _keyReport.keycodes[nextpos];
_keyReport.keycodes[nextpos] = _keyReport.keycodes[current];
_keyReport.keycodes[current] = tmp;
++nextpos;
}
++current;
}
}
return 1;
return 1;
}
void BootKeyboard_::releaseAll(void) {
memset(&_keyReport.bytes, 0x00, sizeof(_keyReport.bytes));
memset(&_keyReport.bytes, 0x00, sizeof(_keyReport.bytes));
}
@ -312,24 +312,24 @@ void BootKeyboard_::releaseAll(void) {
* Returns false in all other cases
* */
boolean BootKeyboard_::isKeyPressed(uint8_t k) {
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_keyReport.keycodes[i] == k) {
return true;
}
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_keyReport.keycodes[i] == k) {
return true;
}
return false;
}
return false;
}
/* Returns true if the non-modifer key passed in was sent during the previous key report
* Returns false in all other cases
* */
boolean BootKeyboard_::wasKeyPressed(uint8_t k) {
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_lastKeyReport.keycodes[i] == k) {
return true;
}
for (uint8_t i = 0; i < sizeof(_keyReport.keycodes); i++) {
if (_lastKeyReport.keycodes[i] == k) {
return true;
}
return false;
}
return false;
}
@ -338,36 +338,36 @@ boolean BootKeyboard_::wasKeyPressed(uint8_t k) {
* Returns false in all other cases
* */
boolean BootKeyboard_::isModifierActive(uint8_t k) {
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(_keyReport.modifiers & (1 << k));
}
return false;
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(_keyReport.modifiers & (1 << k));
}
return false;
}
/* Returns true if the modifer key passed in was being sent during the previous key report
* Returns false in all other cases
* */
boolean BootKeyboard_::wasModifierActive(uint8_t k) {
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(_lastKeyReport.modifiers & (1 << k));
}
return false;
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(_lastKeyReport.modifiers & (1 << k));
}
return false;
}
/* Returns true if any modifier key will be sent during this key report
* Returns false in all other cases
* */
boolean BootKeyboard_::isAnyModifierActive() {
return _keyReport.modifiers > 0;
return _keyReport.modifiers > 0;
}
/* Returns true if any modifier key was being sent during the previous key report
* Returns false in all other cases
* */
boolean BootKeyboard_::wasAnyModifierActive() {
return _lastKeyReport.modifiers > 0;
return _lastKeyReport.modifiers > 0;
}
BootKeyboard_ BootKeyboard;

86
src/kaleidoscope/driver/hid/keyboardio/HID/BootKeyboard/BootKeyboard.h
Unescape View File

@ -33,52 +33,52 @@ THE SOFTWARE.
#include "../HIDAliases.h"
typedef union {
// Low level key report: up to 6 keys and shift, ctrl etc at once
struct {
uint8_t modifiers;
uint8_t reserved;
uint8_t keycodes[6];
};
uint8_t bytes[8];
// Low level key report: up to 6 keys and shift, ctrl etc at once
struct {
uint8_t modifiers;
uint8_t reserved;
uint8_t keycodes[6];
};
uint8_t bytes[8];
} HID_BootKeyboardReport_Data_t;
class BootKeyboard_ : public PluggableUSBModule {
public:
BootKeyboard_(void);
size_t press(uint8_t);
void begin(void);
void end(void);
size_t release(uint8_t);
void releaseAll(void);
int sendReport(void);
boolean isModifierActive(uint8_t k);
boolean wasModifierActive(uint8_t k);
boolean isAnyModifierActive();
boolean wasAnyModifierActive();
boolean isKeyPressed(uint8_t k);
boolean wasKeyPressed(uint8_t k);
uint8_t getLeds(void);
uint8_t getProtocol(void);
void setProtocol(uint8_t protocol);
uint8_t default_protocol = HID_REPORT_PROTOCOL;
protected:
HID_BootKeyboardReport_Data_t _keyReport, _lastKeyReport;
// Implementation of the PUSBListNode
int getInterface(uint8_t* interfaceCount);
int getDescriptor(USBSetup& setup);
bool setup(USBSetup& setup);
EPTYPE_DESCRIPTOR_SIZE epType[1];
uint8_t protocol;
uint8_t idle;
uint8_t leds;
public:
BootKeyboard_(void);
size_t press(uint8_t);
void begin(void);
void end(void);
size_t release(uint8_t);
void releaseAll(void);
int sendReport(void);
boolean isModifierActive(uint8_t k);
boolean wasModifierActive(uint8_t k);
boolean isAnyModifierActive();
boolean wasAnyModifierActive();
boolean isKeyPressed(uint8_t k);
boolean wasKeyPressed(uint8_t k);
uint8_t getLeds(void);
uint8_t getProtocol(void);
void setProtocol(uint8_t protocol);
uint8_t default_protocol = HID_REPORT_PROTOCOL;
protected:
HID_BootKeyboardReport_Data_t _keyReport, _lastKeyReport;
// Implementation of the PUSBListNode
int getInterface(uint8_t* interfaceCount);
int getDescriptor(USBSetup& setup);
bool setup(USBSetup& setup);
EPTYPE_DESCRIPTOR_SIZE epType[1];
uint8_t protocol;
uint8_t idle;
uint8_t leds;
};
extern BootKeyboard_ BootKeyboard;

58
src/kaleidoscope/driver/hid/keyboardio/HID/DeviceAPIs/AbsoluteMouseAPI.h
Unescape View File

@ -65,38 +65,38 @@ THE SOFTWARE.
D_INPUT, (D_DATA|D_VARIABLE|D_RELATIVE),
typedef union {
// Absolute mouse report: 8 buttons, 2 absolute axis, wheel
struct {
uint8_t buttons;
uint16_t xAxis;
uint16_t yAxis;
int8_t wheel;
};
} HID_MouseAbsoluteReport_Data_t;
class AbsoluteMouseAPI {
public:
inline AbsoluteMouseAPI(void);
inline void begin(void);
inline void end(void);
inline void click(uint8_t b = MOUSE_LEFT);
inline void moveTo(uint16_t x, uint16_t y, signed char wheel = 0);
inline void move(int x, int y, signed char wheel = 0);
inline void press(uint8_t b = MOUSE_LEFT);
inline void release(uint8_t b = MOUSE_LEFT);
inline bool isPressed(uint8_t b = MOUSE_LEFT);
// Sending is public in the base class for advanced users.
virtual void sendReport(void* data, int length) {}
protected:
// Absolute mouse report: 8 buttons, 2 absolute axis, wheel
struct {
uint8_t buttons;
uint16_t xAxis;
uint16_t yAxis;
uint8_t _buttons;
int8_t wheel;
};
} HID_MouseAbsoluteReport_Data_t;
inline void buttons(uint8_t b);
inline int16_t qadd16(int16_t base, int16_t increment);
class AbsoluteMouseAPI {
public:
inline AbsoluteMouseAPI(void);
inline void begin(void);
inline void end(void);
inline void click(uint8_t b = MOUSE_LEFT);
inline void moveTo(uint16_t x, uint16_t y, signed char wheel = 0);
inline void move(int x, int y, signed char wheel = 0);
inline void press(uint8_t b = MOUSE_LEFT);
inline void release(uint8_t b = MOUSE_LEFT);
inline bool isPressed(uint8_t b = MOUSE_LEFT);
// Sending is public in the base class for advanced users.
virtual void sendReport(void* data, int length) {}
protected:
uint16_t xAxis;
uint16_t yAxis;
uint8_t _buttons;
inline void buttons(uint8_t b);
inline int16_t qadd16(int16_t base, int16_t increment);
};
#include "AbsoluteMouseAPI.hpp"

226
src/kaleidoscope/driver/hid/keyboardio/HID/HID.cpp
Unescape View File

@ -24,80 +24,80 @@
#if defined(USBCON)
HID_& HID() {
static HID_ obj;
return obj;
static HID_ obj;
return obj;
}
int HID_::getInterface(uint8_t* interfaceCount) {
*interfaceCount += 1; // uses 1
HIDDescriptor hidInterface = {
D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_NONE, HID_PROTOCOL_NONE),
D_HIDREPORT(descriptorSize),
D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01)
};
return USB_SendControl(0, &hidInterface, sizeof(hidInterface));
*interfaceCount += 1; // uses 1
HIDDescriptor hidInterface = {
D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_NONE, HID_PROTOCOL_NONE),
D_HIDREPORT(descriptorSize),
D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01)
};
return USB_SendControl(0, &hidInterface, sizeof(hidInterface));
}
int HID_::getDescriptor(USBSetup& setup) {
// Check if this is a HID Class Descriptor request
if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) {
return 0;
}
if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) {
return 0;
}
// In a HID Class Descriptor wIndex cointains the interface number
if (setup.wIndex != pluggedInterface) {
return 0;
}
int total = 0;
HIDSubDescriptor* node;
USB_PackMessages(true);
for (node = rootNode; node; node = node->next) {
int res = USB_SendControl(TRANSFER_PGM, node->data, node->length);
if (res == -1)
return -1;
total += res;
}
// Reset the protocol on reenumeration. Normally the host should not assume the state of the protocol
// due to the USB specs, but Windows and Linux just assumes its in report mode.
protocol = HID_REPORT_PROTOCOL;
// Check if this is a HID Class Descriptor request
if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) {
return 0;
}
if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) {
return 0;
}
USB_PackMessages(false);
return total;
// In a HID Class Descriptor wIndex cointains the interface number
if (setup.wIndex != pluggedInterface) {
return 0;
}
int total = 0;
HIDSubDescriptor* node;
USB_PackMessages(true);
for (node = rootNode; node; node = node->next) {
int res = USB_SendControl(TRANSFER_PGM, node->data, node->length);
if (res == -1)
return -1;
total += res;
}
// Reset the protocol on reenumeration. Normally the host should not assume the state of the protocol
// due to the USB specs, but Windows and Linux just assumes its in report mode.
protocol = HID_REPORT_PROTOCOL;
USB_PackMessages(false);
return total;
}
__attribute__((weak))
uint8_t HID_::getShortName(char *name) {
name[0] = 'k';
name[1] = 'b';
name[2] = 'i';
name[3] = 'o';
name[4] = '0';
name[5] = '1';
return 6;
name[0] = 'k';
name[1] = 'b';
name[2] = 'i';
name[3] = 'o';
name[4] = '0';
name[5] = '1';
return 6;
}
void HID_::AppendDescriptor(HIDSubDescriptor *node) {
if (!rootNode) {
rootNode = node;
} else {
HIDSubDescriptor *current = rootNode;
while (current->next) {
current = current->next;
}
current->next = node;
if (!rootNode) {
rootNode = node;
} else {
HIDSubDescriptor *current = rootNode;
while (current->next) {
current = current->next;
}
descriptorSize += node->length;
current->next = node;
}
descriptorSize += node->length;
}
int HID_::SendReport(uint8_t id, const void* data, int len) {
auto result = SendReport_(id, data, len);
HIDReportObserver::observeReport(id, data, len, result);
return result;
auto result = SendReport_(id, data, len);
HIDReportObserver::observeReport(id, data, len, result);
return result;
}
int HID_::SendReport_(uint8_t id, const void* data, int len) {
@ -109,78 +109,78 @@ int HID_::SendReport_(uint8_t id, const void* data, int len) {
* costs RAM, which is something scarce on AVR. So on that platform, we opt to
* send the id and the report separately instead. */
#ifdef ARDUINO_ARCH_SAMD
uint8_t p[64];
p[0] = id;
memcpy(&p[1], data, len);
return USB_Send(pluggedEndpoint, p, len+1);
uint8_t p[64];
p[0] = id;
memcpy(&p[1], data, len);
return USB_Send(pluggedEndpoint, p, len + 1);
#else
auto ret = USB_Send(pluggedEndpoint, &id, 1);
if (ret < 0) return ret;
auto ret2 = USB_Send(pluggedEndpoint | TRANSFER_RELEASE, data, len);
if (ret2 < 0) return ret2;
return ret + ret2;
auto ret = USB_Send(pluggedEndpoint, &id, 1);
if (ret < 0) return ret;
auto ret2 = USB_Send(pluggedEndpoint | TRANSFER_RELEASE, data, len);
if (ret2 < 0) return ret2;
return ret + ret2;
#endif
}
bool HID_::setup(USBSetup& setup) {
if (pluggedInterface != setup.wIndex) {
return false;
}
if (pluggedInterface != setup.wIndex) {
return false;
}
uint8_t request = setup.bRequest;
uint8_t requestType = setup.bmRequestType;
if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE) {
if (request == HID_GET_REPORT) {
// TODO(anyone): HID_GetReport();
return true;
}
if (request == HID_GET_PROTOCOL) {
// TODO(anyone): Send8(protocol);
return true;
}
if (request == HID_GET_IDLE) {
// TODO(anyone): Send8(idle);
}
}
uint8_t request = setup.bRequest;
uint8_t requestType = setup.bmRequestType;
if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE) {
if (request == HID_SET_PROTOCOL) {
// The USB Host tells us if we are in boot or report mode.
// This only works with a real boot compatible device.
protocol = setup.wValueL;
return true;
}
if (request == HID_SET_IDLE) {
idle = setup.wValueL;
return true;
}
if (request == HID_SET_REPORT) {
uint16_t length = setup.wLength;
if (length == sizeof(setReportData)) {
USB_RecvControl(&setReportData, length);
} else if (length == sizeof(setReportData.leds)) {
USB_RecvControl(&setReportData.leds, length);
setReportData.reportId = 0;
}
}
if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE) {
if (request == HID_GET_REPORT) {
// TODO(anyone): HID_GetReport();
return true;
}
if (request == HID_GET_PROTOCOL) {
// TODO(anyone): Send8(protocol);
return true;
}
if (request == HID_GET_IDLE) {
// TODO(anyone): Send8(idle);
}
}
if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE) {
if (request == HID_SET_PROTOCOL) {
// The USB Host tells us if we are in boot or report mode.
// This only works with a real boot compatible device.
protocol = setup.wValueL;
return true;
}
if (request == HID_SET_IDLE) {
idle = setup.wValueL;
return true;
}
if (request == HID_SET_REPORT) {
uint16_t length = setup.wLength;
if (length == sizeof(setReportData)) {
USB_RecvControl(&setReportData, length);
} else if (length == sizeof(setReportData.leds)) {
USB_RecvControl(&setReportData.leds, length);
setReportData.reportId = 0;
}
}
}
return false;
return false;
}
HID_::HID_(void) : PluggableUSBModule(1, 1, epType),
rootNode(NULL), descriptorSize(0),
protocol(HID_REPORT_PROTOCOL), idle(1) {
setReportData.reportId = 0;
setReportData.leds = 0;
epType[0] = EP_TYPE_INTERRUPT_IN;
PluggableUSB().plug(this);
rootNode(NULL), descriptorSize(0),
protocol(HID_REPORT_PROTOCOL), idle(1) {
setReportData.reportId = 0;
setReportData.leds = 0;
epType[0] = EP_TYPE_INTERRUPT_IN;
PluggableUSB().plug(this);
}
int HID_::begin(void) {
return 0;
return 0;
}
#endif /* if defined(USBCON) */

94
src/kaleidoscope/driver/hid/keyboardio/HID/HID.h
Unescape View File

@ -59,63 +59,63 @@
#define HID_REPORT_TYPE_FEATURE 3
typedef struct {
uint8_t len; // 9
uint8_t dtype; // 0x21
uint8_t addr;
uint8_t versionL; // 0x101
uint8_t versionH; // 0x101
uint8_t country;
uint8_t desctype; // 0x22 report
uint8_t descLenL;
uint8_t descLenH;
uint8_t len; // 9
uint8_t dtype; // 0x21
uint8_t addr;
uint8_t versionL; // 0x101
uint8_t versionH; // 0x101
uint8_t country;
uint8_t desctype; // 0x22 report
uint8_t descLenL;
uint8_t descLenH;
} HIDDescDescriptor;
typedef struct {
InterfaceDescriptor hid;
HIDDescDescriptor desc;
EndpointDescriptor in;
InterfaceDescriptor hid;
HIDDescDescriptor desc;
EndpointDescriptor in;
} HIDDescriptor;
class HIDSubDescriptor {
public:
HIDSubDescriptor *next = NULL;
HIDSubDescriptor(const void *d, const uint16_t l) : data(d), length(l) { }
public:
HIDSubDescriptor *next = NULL;
HIDSubDescriptor(const void *d, const uint16_t l) : data(d), length(l) { }
const void* data;
const uint16_t length;
const void* data;
const uint16_t length;
};
class HID_ : public PluggableUSBModule {
public:
HID_(void);
int begin(void);
int SendReport(uint8_t id, const void* data, int len);
void AppendDescriptor(HIDSubDescriptor* node);
uint8_t getLEDs(void) {
return setReportData.leds;
}
protected:
// Implementation of the PluggableUSBModule
int getInterface(uint8_t* interfaceCount);
int getDescriptor(USBSetup& setup);
bool setup(USBSetup& setup);
uint8_t getShortName(char* name);
int SendReport_(uint8_t id, const void* data, int len);
private:
EPTYPE_DESCRIPTOR_SIZE epType[1];
HIDSubDescriptor* rootNode;
uint16_t descriptorSize;
uint8_t protocol;
uint8_t idle;
struct {
uint8_t reportId;
uint8_t leds;
} setReportData;
public:
HID_(void);
int begin(void);
int SendReport(uint8_t id, const void* data, int len);
void AppendDescriptor(HIDSubDescriptor* node);
uint8_t getLEDs(void) {
return setReportData.leds;
}
protected:
// Implementation of the PluggableUSBModule
int getInterface(uint8_t* interfaceCount);
int getDescriptor(USBSetup& setup);
bool setup(USBSetup& setup);
uint8_t getShortName(char* name);
int SendReport_(uint8_t id, const void* data, int len);
private:
EPTYPE_DESCRIPTOR_SIZE epType[1];
HIDSubDescriptor* rootNode;
uint16_t descriptorSize;
uint8_t protocol;
uint8_t idle;
struct {
uint8_t reportId;
uint8_t leds;
} setReportData;
};
// Replacement for global singleton.

49
src/kaleidoscope/driver/hid/keyboardio/HID/HIDReportObserver.h
Unescape View File

@ -26,29 +26,30 @@ THE SOFTWARE.
#include <stdint.h>
class HIDReportObserver
{
public:
typedef void(*SendReportHook)(uint8_t id, const void* data,
int len, int result);
static void observeReport(uint8_t id, const void* data,
int len, int result) {
if(send_report_hook_) {
(*send_report_hook_)(id, data, len, result);
}
class HIDReportObserver {
public:
typedef void(*SendReportHook)(uint8_t id, const void* data,
int len, int result);
static void observeReport(uint8_t id, const void* data,
int len, int result) {
if (send_report_hook_) {
(*send_report_hook_)(id, data, len, result);
}
static SendReportHook currentHook() { return send_report_hook_; }
static SendReportHook resetHook(SendReportHook new_hook) {
auto previous_hook = send_report_hook_;
send_report_hook_ = new_hook;
return previous_hook;
}
private:
static SendReportHook send_report_hook_;
}
static SendReportHook currentHook() {
return send_report_hook_;
}
static SendReportHook resetHook(SendReportHook new_hook) {
auto previous_hook = send_report_hook_;
send_report_hook_ = new_hook;
return previous_hook;
}
private:
static SendReportHook send_report_hook_;
};

2
src/kaleidoscope/driver/hid/keyboardio/HID/HIDTables.h
Unescape View File

@ -38,7 +38,7 @@ THE SOFTWARE.
// Not every HID usage listed in this file is currently supported by Arduino
// In particular, any System Control or Consumer Control entry that doesn't
// have a comment indicating that it's "HID type OSC" may require additional
// code in the Arduino core to work, although // some keycodes with usage
// code in the Arduino core to work, although // some keycodes with usage
// type RTC (Re-Trigger Control) and OOC (On/Off Control) are also functional.
//
// Non-working usages are listed here in the interest of not having to manually

16
src/kaleidoscope/driver/hid/keyboardio/HID/LEDs.h
Unescape View File

@ -27,12 +27,12 @@ THE SOFTWARE.
// Keyboard Leds
enum KeyboardLeds : uint8_t {
LED_NUM_LOCK = (1 << 0),
LED_CAPS_LOCK = (1 << 1),
LED_SCROLL_LOCK = (1 << 2),
LED_COMPOSE = (1 << 3),
LED_KANA = (1 << 4),
LED_POWER = (1 << 5),
LED_SHIFT = (1 << 6),
LED_DO_NOT_DISTURB = (1 << 7),
LED_NUM_LOCK = (1 << 0),
LED_CAPS_LOCK = (1 << 1),
LED_SCROLL_LOCK = (1 << 2),
LED_COMPOSE = (1 << 3),
LED_KANA = (1 << 4),
LED_POWER = (1 << 5),
LED_SHIFT = (1 << 6),
LED_DO_NOT_DISTURB = (1 << 7),
};

24
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/AbsoluteMouse.cpp
Unescape View File

@ -27,27 +27,27 @@ THE SOFTWARE.
#include "../DescriptorPrimitives.h"
static const uint8_t _hidMultiReportDescriptorAbsoluteMouse[] PROGMEM = {
/* Mouse absolute */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) 54 */
D_USAGE, D_USAGE_MOUSE, /* USAGE (Mouse) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
D_REPORT_ID, HID_REPORTID_MOUSE_ABSOLUTE, /* REPORT_ID */
/* Mouse absolute */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) 54 */
D_USAGE, D_USAGE_MOUSE, /* USAGE (Mouse) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
D_REPORT_ID, HID_REPORTID_MOUSE_ABSOLUTE, /* REPORT_ID */
DESCRIPTOR_ABS_MOUSE_BUTTONS
DESCRIPTOR_ABS_MOUSE_XY
DESCRIPTOR_ABS_MOUSE_WHEEL
DESCRIPTOR_ABS_MOUSE_BUTTONS
DESCRIPTOR_ABS_MOUSE_XY
DESCRIPTOR_ABS_MOUSE_WHEEL
D_END_COLLECTION /* End */
D_END_COLLECTION /* End */
};
AbsoluteMouse_::AbsoluteMouse_(void) {
static HIDSubDescriptor node(_hidMultiReportDescriptorAbsoluteMouse, sizeof(_hidMultiReportDescriptorAbsoluteMouse));
HID().AppendDescriptor(&node);
static HIDSubDescriptor node(_hidMultiReportDescriptorAbsoluteMouse, sizeof(_hidMultiReportDescriptorAbsoluteMouse));
HID().AppendDescriptor(&node);
}
void AbsoluteMouse_::sendReport(void* data, int length) {
HID().SendReport(HID_REPORTID_MOUSE_ABSOLUTE, data, length);
HID().SendReport(HID_REPORTID_MOUSE_ABSOLUTE, data, length);
}
AbsoluteMouse_ AbsoluteMouse;

10
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/AbsoluteMouse.h
Unescape View File

@ -32,12 +32,12 @@ THE SOFTWARE.
#include "../DeviceAPIs/AbsoluteMouseAPI.h"
class AbsoluteMouse_ : public AbsoluteMouseAPI {
public:
AbsoluteMouse_(void);
public:
AbsoluteMouse_(void);
protected:
// Sending is public in the base class for advanced users.
virtual void sendReport(void* data, int length);
protected:
// Sending is public in the base class for advanced users.
virtual void sendReport(void* data, int length);
};
extern AbsoluteMouse_ AbsoluteMouse;

88
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/ConsumerControl.cpp
Unescape View File

@ -27,81 +27,81 @@ THE SOFTWARE.
#include "../DescriptorPrimitives.h"
static const uint8_t _hidMultiReportDescriptorConsumer[] PROGMEM = {
/* Consumer Control (Sound/Media keys) */
D_USAGE_PAGE, 0x0C, /* usage page (consumer device) */
D_USAGE, 0x01, /* usage -- consumer control */
D_COLLECTION, D_APPLICATION, /* collection (application) */
D_REPORT_ID, HID_REPORTID_CONSUMERCONTROL, /* report id */
/* 4 Media Keys */
D_LOGICAL_MINIMUM, 0x00, /* logical minimum */
D_MULTIBYTE(D_LOGICAL_MAXIMUM), 0xFF, 0x03, /* logical maximum (3ff) */
D_USAGE_MINIMUM, 0x00, /* usage minimum (0) */
D_MULTIBYTE(D_USAGE_MAXIMUM), 0xFF, 0x03, /* usage maximum (3ff) */
D_REPORT_COUNT, 0x04, /* report count (4) */
D_REPORT_SIZE, 0x10, /* report size (16) */
D_INPUT, 0x00, /* input */
D_END_COLLECTION /* end collection */
/* Consumer Control (Sound/Media keys) */
D_USAGE_PAGE, 0x0C, /* usage page (consumer device) */
D_USAGE, 0x01, /* usage -- consumer control */
D_COLLECTION, D_APPLICATION, /* collection (application) */
D_REPORT_ID, HID_REPORTID_CONSUMERCONTROL, /* report id */
/* 4 Media Keys */
D_LOGICAL_MINIMUM, 0x00, /* logical minimum */
D_MULTIBYTE(D_LOGICAL_MAXIMUM), 0xFF, 0x03, /* logical maximum (3ff) */
D_USAGE_MINIMUM, 0x00, /* usage minimum (0) */
D_MULTIBYTE(D_USAGE_MAXIMUM), 0xFF, 0x03, /* usage maximum (3ff) */
D_REPORT_COUNT, 0x04, /* report count (4) */
D_REPORT_SIZE, 0x10, /* report size (16) */
D_INPUT, 0x00, /* input */
D_END_COLLECTION /* end collection */
};
ConsumerControl_::ConsumerControl_(void) {
static HIDSubDescriptor node(_hidMultiReportDescriptorConsumer, sizeof(_hidMultiReportDescriptorConsumer));
HID().AppendDescriptor(&node);
static HIDSubDescriptor node(_hidMultiReportDescriptorConsumer, sizeof(_hidMultiReportDescriptorConsumer));
HID().AppendDescriptor(&node);
}
void ConsumerControl_::begin(void) {
// release all buttons
end();
// release all buttons
end();
}
void ConsumerControl_::end(void) {
memset(&_report, 0, sizeof(_report));
sendReport();
memset(&_report, 0, sizeof(_report));
sendReport();
}
void ConsumerControl_::write(uint16_t m) {
press(m);
release(m);
press(m);
release(m);
}
void ConsumerControl_::press(uint16_t m) {
// search for a free spot
for (uint8_t i = 0; i < sizeof(HID_ConsumerControlReport_Data_t) / 2; i++) {
if (_report.keys[i] == 0x00) {
_report.keys[i] = m;
break;
}
// search for a free spot
for (uint8_t i = 0; i < sizeof(HID_ConsumerControlReport_Data_t) / 2; i++) {
if (_report.keys[i] == 0x00) {
_report.keys[i] = m;
break;
}
}
}
void ConsumerControl_::release(uint16_t m) {
// search and release the keypress
for (uint8_t i = 0; i < sizeof(HID_ConsumerControlReport_Data_t) / 2; i++) {
if (_report.keys[i] == m) {
_report.keys[i] = 0x00;
// no break to delete multiple keys
}
// search and release the keypress
for (uint8_t i = 0; i < sizeof(HID_ConsumerControlReport_Data_t) / 2; i++) {
if (_report.keys[i] == m) {
_report.keys[i] = 0x00;
// no break to delete multiple keys
}
}
}
void ConsumerControl_::releaseAll(void) {
memset(&_report, 0, sizeof(_report));
memset(&_report, 0, sizeof(_report));
}
void ConsumerControl_::sendReportUnchecked(void) {
HID().SendReport(HID_REPORTID_CONSUMERCONTROL, &_report, sizeof(_report));
HID().SendReport(HID_REPORTID_CONSUMERCONTROL, &_report, sizeof(_report));
}
void ConsumerControl_::sendReport(void) {
// If the last report is different than the current report, then we need to send a report.
// We guard sendReport like this so that calling code doesn't end up spamming the host with empty reports
// if sendReport is called in a tight loop.
// If the last report is different than the current report, then we need to send a report.
// We guard sendReport like this so that calling code doesn't end up spamming the host with empty reports
// if sendReport is called in a tight loop.
// if the previous report is the same, return early without a new report.
if (memcmp(&_lastReport, &_report, sizeof(_report)) == 0)
return;
// if the previous report is the same, return early without a new report.
if (memcmp(&_lastReport, &_report, sizeof(_report)) == 0)
return;
sendReportUnchecked();
memcpy(&_lastReport, &_report, sizeof(_report));
sendReportUnchecked();
memcpy(&_lastReport, &_report, sizeof(_report));
}
ConsumerControl_ ConsumerControl;

46
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/ConsumerControl.h
Unescape View File

@ -31,35 +31,35 @@ THE SOFTWARE.
#include "../HID-Settings.h"
typedef union {
// Every usable Consumer key possible, up to 4 keys presses possible
uint16_t keys[4];
struct {
uint16_t key1;
uint16_t key2;
uint16_t key3;
uint16_t key4;
};
// Every usable Consumer key possible, up to 4 keys presses possible
uint16_t keys[4];
struct {
uint16_t key1;
uint16_t key2;
uint16_t key3;
uint16_t key4;
};
} HID_ConsumerControlReport_Data_t;
class ConsumerControl_ {
public:
ConsumerControl_(void);
void begin(void);
void end(void);
void write(uint16_t m);
void press(uint16_t m);
void release(uint16_t m);
void releaseAll(void);
public:
ConsumerControl_(void);
void begin(void);
void end(void);
void write(uint16_t m);
void press(uint16_t m);
void release(uint16_t m);
void releaseAll(void);
// Sending is public in the base class for advanced users.
void sendReport(void);
// Sending is public in the base class for advanced users.
void sendReport(void);
protected:
HID_ConsumerControlReport_Data_t _report;
HID_ConsumerControlReport_Data_t _lastReport;
protected:
HID_ConsumerControlReport_Data_t _report;
HID_ConsumerControlReport_Data_t _lastReport;
private:
void sendReportUnchecked(void);
private:
void sendReportUnchecked(void);
};
extern ConsumerControl_ ConsumerControl;

132
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/Gamepad.cpp
Unescape View File

@ -27,136 +27,136 @@ THE SOFTWARE.
#include "../DescriptorPrimitives.h"
static const uint8_t _hidMultiReportDescriptorGamepad[] PROGMEM = {
/* Gamepad with 32 buttons and 6 axis*/
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_USAGE, D_USAGE_JOYSTICK, /* USAGE (Joystick) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
D_REPORT_ID, HID_REPORTID_GAMEPAD, /* REPORT_ID */
/* 32 Buttons */
D_USAGE_PAGE, D_PAGE_BUTTON, /* USAGE_PAGE (Button) */
D_USAGE_MINIMUM, 0x01, /* USAGE_MINIMUM (Button 1) */
D_USAGE_MAXIMUM, 0x20, /* USAGE_MAXIMUM (Button 32) */
D_LOGICAL_MINIMUM, 0x00, /* _LOGICAL_MINIMUM (0) */
D_LOGICAL_MAXIMUM, 0x01, /* _LOGICAL_MAXIMUM (1) */
D_REPORT_SIZE, 0x01, /* REPORT_SIZE (1) */
D_REPORT_COUNT, 0x20, /* REPORT_COUNT (32) */
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
/* 4 16bit Axis */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_COLLECTION, D_PHYSICAL, /* COLLECTION (Physical) */
D_USAGE, 0x30, /* USAGE (X) */
D_USAGE, 0x31, /* USAGE (Y) */
D_USAGE, 0x33, /* USAGE (Rx) */
D_USAGE, 0x34, /* USAGE (Ry) */
D_MULTIBYTE(D_LOGICAL_MINIMUM), 0x00, 0x80, /* _LOGICAL_MINIMUM (-32768) */
D_MULTIBYTE(D_LOGICAL_MAXIMUM), 0xFF, 0x7F, /* _LOGICAL_MAXIMUM (32767) */
D_REPORT_SIZE, 0x10, /* REPORT_SIZE (16) */
D_REPORT_COUNT, 0x04, /* REPORT_COUNT (4) */
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
/* 2 8bit Axis */
D_USAGE, 0x32, /* USAGE (Z) */
D_USAGE, 0x35, /* USAGE (Rz) */
D_LOGICAL_MINIMUM, 0x80, /* _LOGICAL_MINIMUM (-128) */
D_LOGICAL_MAXIMUM, 0x7F, /* _LOGICAL_MAXIMUM (127) */
D_REPORT_SIZE, 0x08, /* REPORT_SIZE (8) */
D_REPORT_COUNT, 0x02, /* REPORT_COUNT (2) */
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
D_END_COLLECTION, /* END_COLLECTION */
/* 2 Hat Switches */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_USAGE, 0x39, /* USAGE (Hat switch) */
D_USAGE, 0x39, /* USAGE (Hat switch) */
D_LOGICAL_MINIMUM, 0x01, /* _LOGICAL_MINIMUM (1) */
D_LOGICAL_MAXIMUM, 0x08, /* _LOGICAL_MAXIMUM (8) */
D_REPORT_COUNT, 0x02, /* REPORT_COUNT (2) */
D_REPORT_SIZE, 0x04, /* REPORT_SIZE (4) */
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
D_END_COLLECTION /* END_COLLECTION */
/* Gamepad with 32 buttons and 6 axis*/
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_USAGE, D_USAGE_JOYSTICK, /* USAGE (Joystick) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
D_REPORT_ID, HID_REPORTID_GAMEPAD, /* REPORT_ID */
/* 32 Buttons */
D_USAGE_PAGE, D_PAGE_BUTTON, /* USAGE_PAGE (Button) */
D_USAGE_MINIMUM, 0x01, /* USAGE_MINIMUM (Button 1) */
D_USAGE_MAXIMUM, 0x20, /* USAGE_MAXIMUM (Button 32) */
D_LOGICAL_MINIMUM, 0x00, /* _LOGICAL_MINIMUM (0) */
D_LOGICAL_MAXIMUM, 0x01, /* _LOGICAL_MAXIMUM (1) */
D_REPORT_SIZE, 0x01, /* REPORT_SIZE (1) */
D_REPORT_COUNT, 0x20, /* REPORT_COUNT (32) */
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
/* 4 16bit Axis */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_COLLECTION, D_PHYSICAL, /* COLLECTION (Physical) */
D_USAGE, 0x30, /* USAGE (X) */
D_USAGE, 0x31, /* USAGE (Y) */
D_USAGE, 0x33, /* USAGE (Rx) */
D_USAGE, 0x34, /* USAGE (Ry) */
D_MULTIBYTE(D_LOGICAL_MINIMUM), 0x00, 0x80, /* _LOGICAL_MINIMUM (-32768) */
D_MULTIBYTE(D_LOGICAL_MAXIMUM), 0xFF, 0x7F, /* _LOGICAL_MAXIMUM (32767) */
D_REPORT_SIZE, 0x10, /* REPORT_SIZE (16) */
D_REPORT_COUNT, 0x04, /* REPORT_COUNT (4) */
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
/* 2 8bit Axis */
D_USAGE, 0x32, /* USAGE (Z) */
D_USAGE, 0x35, /* USAGE (Rz) */
D_LOGICAL_MINIMUM, 0x80, /* _LOGICAL_MINIMUM (-128) */
D_LOGICAL_MAXIMUM, 0x7F, /* _LOGICAL_MAXIMUM (127) */
D_REPORT_SIZE, 0x08, /* REPORT_SIZE (8) */
D_REPORT_COUNT, 0x02, /* REPORT_COUNT (2) */
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
D_END_COLLECTION, /* END_COLLECTION */
/* 2 Hat Switches */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_USAGE, 0x39, /* USAGE (Hat switch) */
D_USAGE, 0x39, /* USAGE (Hat switch) */
D_LOGICAL_MINIMUM, 0x01, /* _LOGICAL_MINIMUM (1) */
D_LOGICAL_MAXIMUM, 0x08, /* _LOGICAL_MAXIMUM (8) */
D_REPORT_COUNT, 0x02, /* REPORT_COUNT (2) */
D_REPORT_SIZE, 0x04, /* REPORT_SIZE (4) */
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE), /* INPUT (Data,Var,Abs) */
D_END_COLLECTION /* END_COLLECTION */
};
Gamepad_::Gamepad_(void) {
static HIDSubDescriptor node(_hidMultiReportDescriptorGamepad, sizeof(_hidMultiReportDescriptorGamepad));
HID().AppendDescriptor(&node);
static HIDSubDescriptor node(_hidMultiReportDescriptorGamepad, sizeof(_hidMultiReportDescriptorGamepad));
HID().AppendDescriptor(&node);
}
void Gamepad_::begin(void) {
// release all buttons
end();
// release all buttons
end();
}
void Gamepad_::end(void) {
memset(&_report, 0x00, sizeof(_report));
sendReport(&_report, sizeof(_report));
memset(&_report, 0x00, sizeof(_report));
sendReport(&_report, sizeof(_report));
}
void Gamepad_::write(void) {
sendReport(&_report, sizeof(_report));
sendReport(&_report, sizeof(_report));
}
void Gamepad_::press(uint8_t b) {
_report.buttons |= (uint32_t)1 << (b - 1);
_report.buttons |= (uint32_t)1 << (b - 1);
}
void Gamepad_::release(uint8_t b) {
_report.buttons &= ~((uint32_t)1 << (b - 1));
_report.buttons &= ~((uint32_t)1 << (b - 1));
}
void Gamepad_::releaseAll(void) {
memset(&_report, 0x00, sizeof(_report));
memset(&_report, 0x00, sizeof(_report));
}
void Gamepad_::buttons(uint32_t b) {
_report.buttons = b;
_report.buttons = b;
}
void Gamepad_::xAxis(int16_t a) {
_report.xAxis = a;
_report.xAxis = a;
}
void Gamepad_::yAxis(int16_t a) {
_report.yAxis = a;
_report.yAxis = a;
}
void Gamepad_::zAxis(int8_t a) {
_report.zAxis = a;
_report.zAxis = a;
}
void Gamepad_::rxAxis(int16_t a) {
_report.rxAxis = a;
_report.rxAxis = a;
}
void Gamepad_::ryAxis(int16_t a) {
_report.ryAxis = a;
_report.ryAxis = a;
}
void Gamepad_::rzAxis(int8_t a) {
_report.rzAxis = a;
_report.rzAxis = a;
}
void Gamepad_::dPad1(int8_t d) {
_report.dPad1 = d;
_report.dPad1 = d;
}
void Gamepad_::dPad2(int8_t d) {
_report.dPad2 = d;
_report.dPad2 = d;
}
void Gamepad_::sendReport(void* data, int length) {
HID().SendReport(HID_REPORTID_GAMEPAD, data, length);
HID().SendReport(HID_REPORTID_GAMEPAD, data, length);
}
Gamepad_ Gamepad;

150
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/Gamepad.h
Unescape View File

@ -43,83 +43,83 @@ THE SOFTWARE.
typedef union {
// 32 Buttons, 6 Axis, 2 D-Pads
uint32_t buttons;
struct {
uint8_t button1 : 1;
uint8_t button2 : 1;
uint8_t button3 : 1;
uint8_t button4 : 1;
uint8_t button5 : 1;
uint8_t button6 : 1;
uint8_t button7 : 1;
uint8_t button8 : 1;
uint8_t button9 : 1;
uint8_t button10 : 1;
uint8_t button11 : 1;
uint8_t button12 : 1;
uint8_t button13 : 1;
uint8_t button14 : 1;
uint8_t button15 : 1;
uint8_t button16 : 1;
uint8_t button17 : 1;
uint8_t button18 : 1;
uint8_t button19 : 1;
uint8_t button20 : 1;
uint8_t button21 : 1;
uint8_t button22 : 1;
uint8_t button23 : 1;
uint8_t button24 : 1;
uint8_t button25 : 1;
uint8_t button26 : 1;
uint8_t button27 : 1;
uint8_t button28 : 1;
uint8_t button29 : 1;
uint8_t button30 : 1;
uint8_t button31 : 1;
uint8_t button32 : 1;
int16_t xAxis;
int16_t yAxis;
int16_t rxAxis;
int16_t ryAxis;
int8_t zAxis;
int8_t rzAxis;
uint8_t dPad1 : 4;
uint8_t dPad2 : 4;
};
// 32 Buttons, 6 Axis, 2 D-Pads
uint32_t buttons;
struct {
uint8_t button1 : 1;
uint8_t button2 : 1;
uint8_t button3 : 1;
uint8_t button4 : 1;
uint8_t button5 : 1;
uint8_t button6 : 1;
uint8_t button7 : 1;
uint8_t button8 : 1;
uint8_t button9 : 1;
uint8_t button10 : 1;
uint8_t button11 : 1;
uint8_t button12 : 1;
uint8_t button13 : 1;
uint8_t button14 : 1;
uint8_t button15 : 1;
uint8_t button16 : 1;
uint8_t button17 : 1;
uint8_t button18 : 1;
uint8_t button19 : 1;
uint8_t button20 : 1;
uint8_t button21 : 1;
uint8_t button22 : 1;
uint8_t button23 : 1;
uint8_t button24 : 1;
uint8_t button25 : 1;
uint8_t button26 : 1;
uint8_t button27 : 1;
uint8_t button28 : 1;
uint8_t button29 : 1;
uint8_t button30 : 1;
uint8_t button31 : 1;
uint8_t button32 : 1;
int16_t xAxis;
int16_t yAxis;
int16_t rxAxis;
int16_t ryAxis;
int8_t zAxis;
int8_t rzAxis;
uint8_t dPad1 : 4;
uint8_t dPad2 : 4;
};
} HID_GamepadReport_Data_t;
class Gamepad_ {
public:
Gamepad_(void);
void begin(void);
void end(void);
void write(void);
void press(uint8_t b);
void release(uint8_t b);
void releaseAll(void);
void buttons(uint32_t b);
void xAxis(int16_t a);
void yAxis(int16_t a);
void zAxis(int8_t a);
void rxAxis(int16_t a);
void ryAxis(int16_t a);
void rzAxis(int8_t a);
void dPad1(int8_t d);
void dPad2(int8_t d);
void sendReport(void* data, int length);
protected:
HID_GamepadReport_Data_t _report;
public:
Gamepad_(void);
void begin(void);
void end(void);
void write(void);
void press(uint8_t b);
void release(uint8_t b);
void releaseAll(void);
void buttons(uint32_t b);
void xAxis(int16_t a);
void yAxis(int16_t a);
void zAxis(int8_t a);
void rxAxis(int16_t a);
void ryAxis(int16_t a);
void rzAxis(int8_t a);
void dPad1(int8_t d);
void dPad2(int8_t d);
void sendReport(void* data, int length);
protected:
HID_GamepadReport_Data_t _report;
};
extern Gamepad_ Gamepad;

304
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/Keyboard.cpp
Unescape View File

@ -27,161 +27,161 @@ THE SOFTWARE.
#include "../DescriptorPrimitives.h"
static const uint8_t _hidMultiReportDescriptorKeyboard[] PROGMEM = {
// NKRO Keyboard
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP,
D_USAGE, D_USAGE_KEYBOARD,
D_COLLECTION, D_APPLICATION,
D_REPORT_ID, HID_REPORTID_NKRO_KEYBOARD,
D_USAGE_PAGE, D_PAGE_KEYBOARD,
/* Key modifier byte */
D_USAGE_MINIMUM, HID_KEYBOARD_FIRST_MODIFIER,
D_USAGE_MAXIMUM, HID_KEYBOARD_LAST_MODIFIER,
D_LOGICAL_MINIMUM, 0x00,
D_LOGICAL_MAXIMUM, 0x01,
D_REPORT_SIZE, 0x01,
D_REPORT_COUNT, 0x08,
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE),
/* 5 LEDs for num lock etc, 3 left for advanced, custom usage */
D_USAGE_PAGE, D_PAGE_LEDS,
D_USAGE_MINIMUM, 0x01,
D_USAGE_MAXIMUM, 0x08,
D_REPORT_COUNT, 0x08,
D_REPORT_SIZE, 0x01,
D_OUTPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE),
/* NKRO Keyboard */
D_USAGE_PAGE, D_PAGE_KEYBOARD,
// Padding 4 bits, to skip NO_EVENT & 3 error states.
D_REPORT_SIZE, 0x04,
D_REPORT_COUNT, 0x01,
D_INPUT, (D_CONSTANT),
D_USAGE_MINIMUM, HID_KEYBOARD_A_AND_A,
D_USAGE_MAXIMUM, HID_LAST_KEY,
D_LOGICAL_MINIMUM, 0x00,
D_LOGICAL_MAXIMUM, 0x01,
D_REPORT_SIZE, 0x01,
D_REPORT_COUNT, (HID_LAST_KEY - HID_KEYBOARD_A_AND_A),
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE),
// Padding (3 bits) to round up the report to byte boundary.
D_REPORT_SIZE, 0x03,
D_REPORT_COUNT, 0x01,
D_INPUT, (D_CONSTANT),
D_END_COLLECTION,
// NKRO Keyboard
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP,
D_USAGE, D_USAGE_KEYBOARD,
D_COLLECTION, D_APPLICATION,
D_REPORT_ID, HID_REPORTID_NKRO_KEYBOARD,
D_USAGE_PAGE, D_PAGE_KEYBOARD,
/* Key modifier byte */
D_USAGE_MINIMUM, HID_KEYBOARD_FIRST_MODIFIER,
D_USAGE_MAXIMUM, HID_KEYBOARD_LAST_MODIFIER,
D_LOGICAL_MINIMUM, 0x00,
D_LOGICAL_MAXIMUM, 0x01,
D_REPORT_SIZE, 0x01,
D_REPORT_COUNT, 0x08,
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE),
/* 5 LEDs for num lock etc, 3 left for advanced, custom usage */
D_USAGE_PAGE, D_PAGE_LEDS,
D_USAGE_MINIMUM, 0x01,
D_USAGE_MAXIMUM, 0x08,
D_REPORT_COUNT, 0x08,
D_REPORT_SIZE, 0x01,
D_OUTPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE),
/* NKRO Keyboard */
D_USAGE_PAGE, D_PAGE_KEYBOARD,
// Padding 4 bits, to skip NO_EVENT & 3 error states.
D_REPORT_SIZE, 0x04,
D_REPORT_COUNT, 0x01,
D_INPUT, (D_CONSTANT),
D_USAGE_MINIMUM, HID_KEYBOARD_A_AND_A,
D_USAGE_MAXIMUM, HID_LAST_KEY,
D_LOGICAL_MINIMUM, 0x00,
D_LOGICAL_MAXIMUM, 0x01,
D_REPORT_SIZE, 0x01,
D_REPORT_COUNT, (HID_LAST_KEY - HID_KEYBOARD_A_AND_A),
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE),
// Padding (3 bits) to round up the report to byte boundary.
D_REPORT_SIZE, 0x03,
D_REPORT_COUNT, 0x01,
D_INPUT, (D_CONSTANT),
D_END_COLLECTION,
};
Keyboard_::Keyboard_(void) {
static HIDSubDescriptor node(_hidMultiReportDescriptorKeyboard, sizeof(_hidMultiReportDescriptorKeyboard));
HID().AppendDescriptor(&node);
static HIDSubDescriptor node(_hidMultiReportDescriptorKeyboard, sizeof(_hidMultiReportDescriptorKeyboard));
HID().AppendDescriptor(&node);
}
void Keyboard_::begin(void) {
// Force API to send a clean report.
// This is important for and HID bridge where the receiver stays on,
// while the sender is resetted.
releaseAll();
sendReportUnchecked();
// Force API to send a clean report.
// This is important for and HID bridge where the receiver stays on,
// while the sender is resetted.
releaseAll();
sendReportUnchecked();
}
void Keyboard_::end(void) {
releaseAll();
sendReportUnchecked();
releaseAll();
sendReportUnchecked();
}
int Keyboard_::sendReportUnchecked(void) {
return HID().SendReport(HID_REPORTID_NKRO_KEYBOARD, &keyReport, sizeof(keyReport));
return HID().SendReport(HID_REPORTID_NKRO_KEYBOARD, &keyReport, sizeof(keyReport));
}
int Keyboard_::sendReport(void) {
// If the last report is different than the current report, then we need to send a report.
// We guard sendReport like this so that calling code doesn't end up spamming the host with empty reports
// if sendReport is called in a tight loop.
if (memcmp(lastKeyReport.allkeys, keyReport.allkeys, sizeof(keyReport))) {
// if the two reports are different, send a report
// ChromeOS 51-60 (at least) bug: if a modifier and a normal keycode are added in the
// same report, in some cases the shift is not applied (e.g. `shift`+`[` doesn't yield
// `{`). To compensate for this, check to see if the modifier byte has changed.
// If modifiers are being turned on at the same time as any change
// to the non-modifier keys in the report, then we send the previous
// report with the new modifiers
if ( ( (lastKeyReport.modifiers ^ keyReport.modifiers) & keyReport.modifiers)
&& (memcmp(lastKeyReport.keys,keyReport.keys, sizeof(keyReport.keys)))) {
uint8_t last_mods = lastKeyReport.modifiers;
lastKeyReport.modifiers = keyReport.modifiers;
int returnCode = HID().SendReport(HID_REPORTID_NKRO_KEYBOARD, &lastKeyReport, sizeof(lastKeyReport));
lastKeyReport.modifiers = last_mods;
} else {
// If modifiers are being turned off, then we send the new report with the previous modifiers.
// We need to do this, at least on Linux 4.17 + Wayland.
// Jesse has observed that sending Shift + 3 key up events in the same report
// will sometimes result in a spurious '3' rather than '#', especially when the keys
// had been held for a while
if (( (lastKeyReport.modifiers ^ keyReport.modifiers) & lastKeyReport.modifiers)
&& (memcmp(lastKeyReport.keys,keyReport.keys, sizeof(keyReport.keys)))) {
uint8_t mods = keyReport.modifiers;
keyReport.modifiers = lastKeyReport.modifiers;
int returnCode = HID().SendReport(HID_REPORTID_NKRO_KEYBOARD, &keyReport, sizeof(lastKeyReport));
keyReport.modifiers = mods;
}
}
int returnCode = sendReportUnchecked();
if (returnCode > 0)
memcpy(lastKeyReport.allkeys, keyReport.allkeys, sizeof(keyReport));
return returnCode;
// If the last report is different than the current report, then we need to send a report.
// We guard sendReport like this so that calling code doesn't end up spamming the host with empty reports
// if sendReport is called in a tight loop.
if (memcmp(lastKeyReport.allkeys, keyReport.allkeys, sizeof(keyReport))) {
// if the two reports are different, send a report
// ChromeOS 51-60 (at least) bug: if a modifier and a normal keycode are added in the
// same report, in some cases the shift is not applied (e.g. `shift`+`[` doesn't yield
// `{`). To compensate for this, check to see if the modifier byte has changed.
// If modifiers are being turned on at the same time as any change
// to the non-modifier keys in the report, then we send the previous
// report with the new modifiers
if (((lastKeyReport.modifiers ^ keyReport.modifiers) & keyReport.modifiers)
&& (memcmp(lastKeyReport.keys, keyReport.keys, sizeof(keyReport.keys)))) {
uint8_t last_mods = lastKeyReport.modifiers;
lastKeyReport.modifiers = keyReport.modifiers;
int returnCode = HID().SendReport(HID_REPORTID_NKRO_KEYBOARD, &lastKeyReport, sizeof(lastKeyReport));
lastKeyReport.modifiers = last_mods;
} else {
// If modifiers are being turned off, then we send the new report with the previous modifiers.
// We need to do this, at least on Linux 4.17 + Wayland.
// Jesse has observed that sending Shift + 3 key up events in the same report
// will sometimes result in a spurious '3' rather than '#', especially when the keys
// had been held for a while
if (((lastKeyReport.modifiers ^ keyReport.modifiers) & lastKeyReport.modifiers)
&& (memcmp(lastKeyReport.keys, keyReport.keys, sizeof(keyReport.keys)))) {
uint8_t mods = keyReport.modifiers;
keyReport.modifiers = lastKeyReport.modifiers;
int returnCode = HID().SendReport(HID_REPORTID_NKRO_KEYBOARD, &keyReport, sizeof(lastKeyReport));
keyReport.modifiers = mods;
}
}
return -1;
int returnCode = sendReportUnchecked();
if (returnCode > 0)
memcpy(lastKeyReport.allkeys, keyReport.allkeys, sizeof(keyReport));
return returnCode;
}
return -1;
}
/* Returns true if the modifer key passed in will be sent during this key report
* Returns false in all other cases
* */
boolean Keyboard_::isModifierActive(uint8_t k) {
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(keyReport.modifiers & (1 << k));
}
return false;
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(keyReport.modifiers & (1 << k));
}
return false;
}
/* Returns true if the modifer key passed in was being sent during the previous key report
* Returns false in all other cases
* */
boolean Keyboard_::wasModifierActive(uint8_t k) {
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(lastKeyReport.modifiers & (1 << k));
}
return false;
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
k = k - HID_KEYBOARD_FIRST_MODIFIER;
return !!(lastKeyReport.modifiers & (1 << k));
}
return false;
}
/* Returns true if *any* modifier will be sent during this key report
* Returns false in all other cases
* */
boolean Keyboard_::isAnyModifierActive() {
return keyReport.modifiers > 0;
return keyReport.modifiers > 0;
}
/* Returns true if *any* modifier was being sent during the previous key report
* Returns false in all other cases
* */
boolean Keyboard_::wasAnyModifierActive() {
return lastKeyReport.modifiers > 0;
return lastKeyReport.modifiers > 0;
}
@ -189,11 +189,11 @@ boolean Keyboard_::wasAnyModifierActive() {
* Returns false in all other cases
* */
boolean Keyboard_::isKeyPressed(uint8_t k) {
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (uint8_t(k) % 8);
return !! (keyReport.keys[k / 8] & bit);
}
return false;
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (uint8_t(k) % 8);
return !!(keyReport.keys[k / 8] & bit);
}
return false;
}
/* Returns true if the non-modifer key passed in was sent during the previous key report
@ -201,55 +201,55 @@ boolean Keyboard_::isKeyPressed(uint8_t k) {
* */
boolean Keyboard_::wasKeyPressed(uint8_t k) {
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (uint8_t(k) % 8);
return !! (lastKeyReport.keys[k / 8] & bit);
}
return false;
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (uint8_t(k) % 8);
return !!(lastKeyReport.keys[k / 8] & bit);
}
return false;
}
size_t Keyboard_::press(uint8_t k) {
// If the key is in the range of 'printable' keys
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (uint8_t(k) % 8);
keyReport.keys[k / 8] |= bit;
return 1;
} else { // It's a modifier key
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
// Convert key into bitfield (0 - 7)
k = k - HID_KEYBOARD_FIRST_MODIFIER;
keyReport.modifiers |= (1 << k);
return 1;
}
// If the key is in the range of 'printable' keys
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (uint8_t(k) % 8);
keyReport.keys[k / 8] |= bit;
return 1;
} else { // It's a modifier key
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
// Convert key into bitfield (0 - 7)
k = k - HID_KEYBOARD_FIRST_MODIFIER;
keyReport.modifiers |= (1 << k);
return 1;
}
}
// No empty/pressed key was found
return 0;
// No empty/pressed key was found
return 0;
}
size_t Keyboard_::release(uint8_t k) {
// If we're releasing a printable key
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (k % 8);
keyReport.keys[k / 8] &= ~bit;
return 1;
} else { // It's a modifier key
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
// Convert key into bitfield (0 - 7)
k = k - HID_KEYBOARD_FIRST_MODIFIER;
keyReport.modifiers &= ~(1 << k);
return 1;
}
// If we're releasing a printable key
if (k <= HID_LAST_KEY) {
uint8_t bit = 1 << (k % 8);
keyReport.keys[k / 8] &= ~bit;
return 1;
} else { // It's a modifier key
if (k >= HID_KEYBOARD_FIRST_MODIFIER && k <= HID_KEYBOARD_LAST_MODIFIER) {
// Convert key into bitfield (0 - 7)
k = k - HID_KEYBOARD_FIRST_MODIFIER;
keyReport.modifiers &= ~(1 << k);
return 1;
}
}
// No empty/pressed key was found
return 0;
// No empty/pressed key was found
return 0;
}
void Keyboard_::releaseAll(void) {
// Release all keys
memset(&keyReport.allkeys, 0x00, sizeof(keyReport.allkeys));
// Release all keys
memset(&keyReport.allkeys, 0x00, sizeof(keyReport.allkeys));
}
Keyboard_ Keyboard;

54
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/Keyboard.h
Unescape View File

@ -36,39 +36,39 @@ THE SOFTWARE.
#define KEY_BYTES 28
typedef union {
// Modifiers + keymap
struct {
uint8_t modifiers;
uint8_t keys[KEY_BYTES ];
};
uint8_t allkeys[1 + KEY_BYTES];
// Modifiers + keymap
struct {
uint8_t modifiers;
uint8_t keys[KEY_BYTES ];
};
uint8_t allkeys[1 + KEY_BYTES];
} HID_KeyboardReport_Data_t;
class Keyboard_ {
public:
Keyboard_(void);
void begin(void);
void end(void);
public:
Keyboard_(void);
void begin(void);
void end(void);
size_t press(uint8_t k);
size_t release(uint8_t k);
void releaseAll(void);
int sendReport(void);
size_t press(uint8_t k);
size_t release(uint8_t k);
void releaseAll(void);
int sendReport(void);
boolean isKeyPressed(uint8_t k);
boolean wasKeyPressed(uint8_t k);
boolean isModifierActive(uint8_t k);
boolean wasModifierActive(uint8_t k);
boolean isAnyModifierActive();
boolean wasAnyModifierActive();
boolean isKeyPressed(uint8_t k);
boolean wasKeyPressed(uint8_t k);
boolean isModifierActive(uint8_t k);
boolean wasModifierActive(uint8_t k);
boolean isAnyModifierActive();
boolean wasAnyModifierActive();
uint8_t getLEDs() {
return HID().getLEDs();
}
uint8_t getLEDs() {
return HID().getLEDs();
}
HID_KeyboardReport_Data_t keyReport;
HID_KeyboardReport_Data_t lastKeyReport;
private:
int sendReportUnchecked(void);
HID_KeyboardReport_Data_t keyReport;
HID_KeyboardReport_Data_t lastKeyReport;
private:
int sendReportUnchecked(void);
};
extern Keyboard_ Keyboard;

140
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/Mouse.cpp
Unescape View File

@ -27,110 +27,110 @@ THE SOFTWARE.
#include "../DescriptorPrimitives.h"
static const uint8_t _hidMultiReportDescriptorMouse[] PROGMEM = {
/* Mouse relative */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, // USAGE_PAGE (Generic Desktop)
D_USAGE, D_USAGE_MOUSE, // USAGE (Mouse)
D_COLLECTION, D_APPLICATION, // COLLECTION (Application)
D_REPORT_ID, HID_REPORTID_MOUSE, // REPORT_ID (Mouse)
/* 8 Buttons */
D_USAGE_PAGE, D_PAGE_BUTTON, // USAGE_PAGE (Button)
D_USAGE_MINIMUM, 0x01, // USAGE_MINIMUM (Button 1)
D_USAGE_MAXIMUM, 0x08, // USAGE_MAXIMUM (Button 8)
D_LOGICAL_MINIMUM, 0x00, // LOGICAL_MINIMUM (0)
D_LOGICAL_MAXIMUM, 0x01, // LOGICAL_MAXIMUM (1)
D_REPORT_COUNT, 0x08, // REPORT_COUNT (8)
D_REPORT_SIZE, 0x01, // REPORT_SIZE (1)
D_INPUT, (D_DATA|D_VARIABLE|D_ABSOLUTE), // INPUT (Data,Var,Abs)
/* X, Y, Wheel */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, // USAGE_PAGE (Generic Desktop)
D_USAGE, 0x30, // USAGE (X)
D_USAGE, 0x31, // USAGE (Y)
D_USAGE, 0x38, // USAGE (Wheel)
D_LOGICAL_MINIMUM, 0x81, // LOGICAL_MINIMUM (-127)
D_LOGICAL_MAXIMUM, 0x7f, // LOGICAL_MAXIMUM (127)
D_REPORT_SIZE, 0x08, // REPORT_SIZE (8)
D_REPORT_COUNT, 0x03, // REPORT_COUNT (3)
D_INPUT, (D_DATA|D_VARIABLE|D_RELATIVE), // INPUT (Data,Var,Rel)
/* Horizontal wheel */
D_USAGE_PAGE, D_PAGE_CONSUMER, // USAGE_PAGE (Consumer)
D_PAGE_ORDINAL, 0x38, 0x02, // PAGE (AC Pan)
D_LOGICAL_MINIMUM, 0x81, // LOGICAL_MINIMUM (-127)
D_LOGICAL_MAXIMUM, 0x7f, // LOGICAL_MAXIMUM (127)
D_REPORT_SIZE, 0x08, // REPORT_SIZE (8)
D_REPORT_COUNT, 0x01, // REPORT_COUNT (1)
D_INPUT, (D_DATA|D_VARIABLE|D_RELATIVE), // INPUT (Data,Var,Rel)
/* End */
D_END_COLLECTION // END_COLLECTION
/* Mouse relative */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, // USAGE_PAGE (Generic Desktop)
D_USAGE, D_USAGE_MOUSE, // USAGE (Mouse)
D_COLLECTION, D_APPLICATION, // COLLECTION (Application)
D_REPORT_ID, HID_REPORTID_MOUSE, // REPORT_ID (Mouse)
/* 8 Buttons */
D_USAGE_PAGE, D_PAGE_BUTTON, // USAGE_PAGE (Button)
D_USAGE_MINIMUM, 0x01, // USAGE_MINIMUM (Button 1)
D_USAGE_MAXIMUM, 0x08, // USAGE_MAXIMUM (Button 8)
D_LOGICAL_MINIMUM, 0x00, // LOGICAL_MINIMUM (0)
D_LOGICAL_MAXIMUM, 0x01, // LOGICAL_MAXIMUM (1)
D_REPORT_COUNT, 0x08, // REPORT_COUNT (8)
D_REPORT_SIZE, 0x01, // REPORT_SIZE (1)
D_INPUT, (D_DATA | D_VARIABLE | D_ABSOLUTE), // INPUT (Data,Var,Abs)
/* X, Y, Wheel */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, // USAGE_PAGE (Generic Desktop)
D_USAGE, 0x30, // USAGE (X)
D_USAGE, 0x31, // USAGE (Y)
D_USAGE, 0x38, // USAGE (Wheel)
D_LOGICAL_MINIMUM, 0x81, // LOGICAL_MINIMUM (-127)
D_LOGICAL_MAXIMUM, 0x7f, // LOGICAL_MAXIMUM (127)
D_REPORT_SIZE, 0x08, // REPORT_SIZE (8)
D_REPORT_COUNT, 0x03, // REPORT_COUNT (3)
D_INPUT, (D_DATA | D_VARIABLE | D_RELATIVE), // INPUT (Data,Var,Rel)
/* Horizontal wheel */
D_USAGE_PAGE, D_PAGE_CONSUMER, // USAGE_PAGE (Consumer)
D_PAGE_ORDINAL, 0x38, 0x02, // PAGE (AC Pan)
D_LOGICAL_MINIMUM, 0x81, // LOGICAL_MINIMUM (-127)
D_LOGICAL_MAXIMUM, 0x7f, // LOGICAL_MAXIMUM (127)
D_REPORT_SIZE, 0x08, // REPORT_SIZE (8)
D_REPORT_COUNT, 0x01, // REPORT_COUNT (1)
D_INPUT, (D_DATA | D_VARIABLE | D_RELATIVE), // INPUT (Data,Var,Rel)
/* End */
D_END_COLLECTION // END_COLLECTION
};
Mouse_::Mouse_(void) {
}
void Mouse_::begin(void) {
static HIDSubDescriptor node(_hidMultiReportDescriptorMouse, sizeof(_hidMultiReportDescriptorMouse));
HID().AppendDescriptor(&node);
static HIDSubDescriptor node(_hidMultiReportDescriptorMouse, sizeof(_hidMultiReportDescriptorMouse));
HID().AppendDescriptor(&node);
end();
end();
}
void Mouse_::end(void) {
releaseAll();
sendReport();
releaseAll();
sendReport();
}
void Mouse_::click(uint8_t b) {
press(b);
sendReport();
release(b);
press(b);
sendReport();
release(b);
}
void Mouse_::move(signed char x, signed char y, signed char vWheel, signed char hWheel) {
report.xAxis = x;
report.yAxis = y;
report.vWheel = vWheel;
report.hWheel = hWheel;
report.xAxis = x;
report.yAxis = y;
report.vWheel = vWheel;
report.hWheel = hWheel;
}
void Mouse_::releaseAll(void) {
memset(&report, 0, sizeof(report));
memset(&report, 0, sizeof(report));
}
void Mouse_::press(uint8_t b) {
report.buttons |= b;
report.buttons |= b;
}
void Mouse_::release(uint8_t b) {
report.buttons &= ~b;
report.buttons &= ~b;
}
bool Mouse_::isPressed(uint8_t b) {
if ((b & report.buttons) > 0)
return true;
return false;
if ((b & report.buttons) > 0)
return true;
return false;
}
void Mouse_::sendReportUnchecked(void) {
HID().SendReport(HID_REPORTID_MOUSE, &report, sizeof(report));
HID().SendReport(HID_REPORTID_MOUSE, &report, sizeof(report));
}
void Mouse_::sendReport(void) {
// If the last report is different than the current report, then we need to send a report.
// We guard sendReport like this so that calling code doesn't end up spamming the host with empty reports
// if sendReport is called in a tight loop.
// if the two reports are the same, check if they're empty, and return early
// without a report if they are.
static HID_MouseReport_Data_t emptyReport;
if (memcmp(&lastReport, &report, sizeof(report)) == 0 &&
memcmp(&report, &emptyReport, sizeof(report)) == 0)
return;
sendReportUnchecked();
memcpy(&lastReport, &report, sizeof(report));
// If the last report is different than the current report, then we need to send a report.
// We guard sendReport like this so that calling code doesn't end up spamming the host with empty reports
// if sendReport is called in a tight loop.
// if the two reports are the same, check if they're empty, and return early
// without a report if they are.
static HID_MouseReport_Data_t emptyReport;
if (memcmp(&lastReport, &report, sizeof(report)) == 0 &&
memcmp(&report, &emptyReport, sizeof(report)) == 0)
return;
sendReportUnchecked();
memcpy(&lastReport, &report, sizeof(report));
}
Mouse_ Mouse;

66
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/Mouse.h
Unescape View File

@ -32,46 +32,46 @@ THE SOFTWARE.
#include "../MouseButtons.h"
typedef union {
// Mouse report: 8 buttons, position, wheel
struct {
uint8_t buttons;
int8_t xAxis;
int8_t yAxis;
int8_t vWheel;
int8_t hWheel;
};
// Mouse report: 8 buttons, position, wheel
struct {
uint8_t buttons;
int8_t xAxis;
int8_t yAxis;
int8_t vWheel;
int8_t hWheel;
};
} HID_MouseReport_Data_t;
class Mouse_ {
public:
Mouse_(void);
void begin(void);
void end(void);
void click(uint8_t b = MOUSE_LEFT);
void move(signed char x, signed char y, signed char vWheel = 0, signed char hWheel = 0);
void press(uint8_t b = MOUSE_LEFT); // press LEFT by default
void release(uint8_t b = MOUSE_LEFT); // release LEFT by default
bool isPressed(uint8_t b = MOUSE_LEFT); // check LEFT by default
public:
Mouse_(void);
void begin(void);
void end(void);
void click(uint8_t b = MOUSE_LEFT);
void move(signed char x, signed char y, signed char vWheel = 0, signed char hWheel = 0);
void press(uint8_t b = MOUSE_LEFT); // press LEFT by default
void release(uint8_t b = MOUSE_LEFT); // release LEFT by default
bool isPressed(uint8_t b = MOUSE_LEFT); // check LEFT by default
/** getReport returns the current report.
*
* The current report is the one to be send next time sendReport() is called.
*
* @returns A copy of the report.
*/
const HID_MouseReport_Data_t getReport() {
return report;
}
void sendReport(void);
/** getReport returns the current report.
*
* The current report is the one to be send next time sendReport() is called.
*
* @returns A copy of the report.
*/
const HID_MouseReport_Data_t getReport() {
return report;
}
void sendReport(void);
void releaseAll(void);
void releaseAll(void);
protected:
HID_MouseReport_Data_t report;
HID_MouseReport_Data_t lastReport;
protected:
HID_MouseReport_Data_t report;
HID_MouseReport_Data_t lastReport;
private:
void sendReportUnchecked(void);
private:
void sendReportUnchecked(void);
};
extern Mouse_ Mouse;

70
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/SystemControl.cpp
Unescape View File

@ -27,70 +27,70 @@ THE SOFTWARE.
#include "../DescriptorPrimitives.h"
static const uint8_t _hidMultiReportDescriptorSystem[] PROGMEM = {
//TODO(anyone): limit to system keys only?
/* System Control (Power Down, Sleep, Wakeup, ...) */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_USAGE, 0x80, /* USAGE (System Control) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
D_REPORT_ID, HID_REPORTID_SYSTEMCONTROL, /* REPORT_ID */
/* 1 system key */
D_LOGICAL_MINIMUM, 0x00, /* LOGICAL_MINIMUM (0) */
D_MULTIBYTE(D_LOGICAL_MAXIMUM), 0xff, 0x00, /* LOGICAL_MAXIMUM (255) */
D_USAGE_MINIMUM, 0x00, /* USAGE_MINIMUM (Undefined) */
D_USAGE_MAXIMUM, 0xff, /* USAGE_MAXIMUM (System Menu Down) */
D_REPORT_COUNT, 0x01, /* REPORT_COUNT (1) */
D_REPORT_SIZE, 0x08, /* REPORT_SIZE (8) */
D_INPUT, (D_DATA|D_ARRAY|D_ABSOLUTE), /* INPUT (Data,Ary,Abs) */
D_END_COLLECTION /* END_COLLECTION */
//TODO(anyone): limit to system keys only?
/* System Control (Power Down, Sleep, Wakeup, ...) */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) */
D_USAGE, 0x80, /* USAGE (System Control) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
D_REPORT_ID, HID_REPORTID_SYSTEMCONTROL, /* REPORT_ID */
/* 1 system key */
D_LOGICAL_MINIMUM, 0x00, /* LOGICAL_MINIMUM (0) */
D_MULTIBYTE(D_LOGICAL_MAXIMUM), 0xff, 0x00, /* LOGICAL_MAXIMUM (255) */
D_USAGE_MINIMUM, 0x00, /* USAGE_MINIMUM (Undefined) */
D_USAGE_MAXIMUM, 0xff, /* USAGE_MAXIMUM (System Menu Down) */
D_REPORT_COUNT, 0x01, /* REPORT_COUNT (1) */
D_REPORT_SIZE, 0x08, /* REPORT_SIZE (8) */
D_INPUT, (D_DATA | D_ARRAY | D_ABSOLUTE), /* INPUT (Data,Ary,Abs) */
D_END_COLLECTION /* END_COLLECTION */
};
SystemControl_::SystemControl_(void) {
static HIDSubDescriptor node(_hidMultiReportDescriptorSystem, sizeof(_hidMultiReportDescriptorSystem));
HID().AppendDescriptor(&node);
static HIDSubDescriptor node(_hidMultiReportDescriptorSystem, sizeof(_hidMultiReportDescriptorSystem));
HID().AppendDescriptor(&node);
}
void SystemControl_::begin(void) {
// release all buttons
end();
// release all buttons
end();
}
void SystemControl_::end(void) {
uint8_t _report = 0x00;
sendReport(&_report, sizeof(_report));
uint8_t _report = 0x00;
sendReport(&_report, sizeof(_report));
}
void SystemControl_::write(uint8_t s) {
press(s);
release();
press(s);
release();
}
void SystemControl_::release(void) {
begin();
begin();
}
void SystemControl_::releaseAll(void) {
begin();
begin();
}
void SystemControl_::press(uint8_t s) {
if (s == HID_SYSTEM_WAKE_UP) {
if (s == HID_SYSTEM_WAKE_UP) {
#ifdef __AVR__
USBDevice.wakeupHost();
USBDevice.wakeupHost();
#endif
#ifdef ARDUINO_ARCH_SAMD
// This is USBDevice_SAMD21G18x.wakeupHost(). But we can't include that
// header, because it redefines a few symbols, and causes linking
// errors. So we simply reimplement the same thing here.
USB->DEVICE.CTRLB.bit.UPRSM = 1;
// This is USBDevice_SAMD21G18x.wakeupHost(). But we can't include that
// header, because it redefines a few symbols, and causes linking
// errors. So we simply reimplement the same thing here.
USB->DEVICE.CTRLB.bit.UPRSM = 1;
#endif
} else {
sendReport(&s, sizeof(s));
}
} else {
sendReport(&s, sizeof(s));
}
}
void SystemControl_::sendReport(void* data, int length) {
HID().SendReport(HID_REPORTID_SYSTEMCONTROL, data, length);
HID().SendReport(HID_REPORTID_SYSTEMCONTROL, data, length);
}
SystemControl_ SystemControl;

28
src/kaleidoscope/driver/hid/keyboardio/HID/MultiReport/SystemControl.h
Unescape View File

@ -32,24 +32,24 @@ THE SOFTWARE.
#include "../HIDTables.h"
typedef union {
// Every usable system control key possible
uint8_t key;
// Every usable system control key possible
uint8_t key;
} HID_SystemControlReport_Data_t;
class SystemControl_ {
public:
void begin(void);
void end(void);
void write(uint8_t s);
void press(uint8_t s);
void release(void);
void releaseAll(void);
void sendReport(void* data, int length);
SystemControl_(void);
protected:
public:
void begin(void);
void end(void);
void write(uint8_t s);
void press(uint8_t s);
void release(void);
void releaseAll(void);
void sendReport(void* data, int length);
SystemControl_(void);
protected:
};

128
src/kaleidoscope/driver/hid/keyboardio/HID/SingleReport/SingleAbsoluteMouse.cpp
Unescape View File

@ -27,91 +27,91 @@ THE SOFTWARE.
#include "HIDReportObserver.h"
static const uint8_t _hidSingleReportDescriptorAbsoluteMouse[] PROGMEM = {
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) 54 */
D_USAGE, D_USAGE_MOUSE, /* USAGE (Mouse) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
DESCRIPTOR_ABS_MOUSE_BUTTONS
DESCRIPTOR_ABS_MOUSE_XY
DESCRIPTOR_ABS_MOUSE_WHEEL
D_END_COLLECTION /* End */
D_USAGE_PAGE, D_PAGE_GENERIC_DESKTOP, /* USAGE_PAGE (Generic Desktop) 54 */
D_USAGE, D_USAGE_MOUSE, /* USAGE (Mouse) */
D_COLLECTION, D_APPLICATION, /* COLLECTION (Application) */
DESCRIPTOR_ABS_MOUSE_BUTTONS
DESCRIPTOR_ABS_MOUSE_XY
DESCRIPTOR_ABS_MOUSE_WHEEL
D_END_COLLECTION /* End */
};
SingleAbsoluteMouse_::SingleAbsoluteMouse_(void) : PluggableUSBModule(1, 1, epType), protocol(HID_REPORT_PROTOCOL), idle(1) {
epType[0] = EP_TYPE_INTERRUPT_IN;
PluggableUSB().plug(this);
epType[0] = EP_TYPE_INTERRUPT_IN;
PluggableUSB().plug(this);
}
int SingleAbsoluteMouse_::getInterface(uint8_t* interfaceCount) {
*interfaceCount += 1; // uses 1
HIDDescriptor hidInterface = {
D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_NONE, HID_PROTOCOL_NONE),
D_HIDREPORT(sizeof(_hidSingleReportDescriptorAbsoluteMouse)),
D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01)
};
return USB_SendControl(0, &hidInterface, sizeof(hidInterface));
*interfaceCount += 1; // uses 1
HIDDescriptor hidInterface = {
D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_NONE, HID_PROTOCOL_NONE),
D_HIDREPORT(sizeof(_hidSingleReportDescriptorAbsoluteMouse)),
D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01)
};
return USB_SendControl(0, &hidInterface, sizeof(hidInterface));
}
int SingleAbsoluteMouse_::getDescriptor(USBSetup& setup) {
// Check if this is a HID Class Descriptor request
if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) {
return 0;
}
if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) {
return 0;
}
// In a HID Class Descriptor wIndex cointains the interface number
if (setup.wIndex != pluggedInterface) {
return 0;
}
// Reset the protocol on reenumeration. Normally the host should not assume the state of the protocol
// due to the USB specs, but Windows and Linux just assumes its in report mode.
protocol = HID_REPORT_PROTOCOL;
return USB_SendControl(TRANSFER_PGM, _hidSingleReportDescriptorAbsoluteMouse, sizeof(_hidSingleReportDescriptorAbsoluteMouse));
// Check if this is a HID Class Descriptor request
if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) {
return 0;
}
if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) {
return 0;
}
// In a HID Class Descriptor wIndex cointains the interface number
if (setup.wIndex != pluggedInterface) {
return 0;
}
// Reset the protocol on reenumeration. Normally the host should not assume the state of the protocol
// due to the USB specs, but Windows and Linux just assumes its in report mode.
protocol = HID_REPORT_PROTOCOL;
return USB_SendControl(TRANSFER_PGM, _hidSingleReportDescriptorAbsoluteMouse, sizeof(_hidSingleReportDescriptorAbsoluteMouse));
}
bool SingleAbsoluteMouse_::setup(USBSetup& setup) {
if (pluggedInterface != setup.wIndex) {
return false;
}
if (pluggedInterface != setup.wIndex) {
return false;
}
uint8_t request = setup.bRequest;
uint8_t requestType = setup.bmRequestType;
uint8_t request = setup.bRequest;
uint8_t requestType = setup.bmRequestType;
if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE) {
if (request == HID_GET_REPORT) {
// TODO(anyone): HID_GetReport();
return true;
}
if (request == HID_GET_PROTOCOL) {
// TODO(anyone): Send8(protocol);
return true;
}
if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE) {
if (request == HID_GET_REPORT) {
// TODO(anyone): HID_GetReport();
return true;
}
if (request == HID_GET_PROTOCOL) {
// TODO(anyone): Send8(protocol);
return true;
}
}
if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE) {
if (request == HID_SET_PROTOCOL) {
protocol = setup.wValueL;
return true;
}
if (request == HID_SET_IDLE) {
idle = setup.wValueL;
return true;
}
if (request == HID_SET_REPORT) {
}
if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE) {
if (request == HID_SET_PROTOCOL) {
protocol = setup.wValueL;
return true;
}
if (request == HID_SET_IDLE) {
idle = setup.wValueL;
return true;
}
if (request == HID_SET_REPORT) {
}
}
return false;
return false;
}
void SingleAbsoluteMouse_::sendReport(void* data, int length) {
auto result = USB_Send(pluggedEndpoint | TRANSFER_RELEASE, data, length);
HIDReportObserver::observeReport(HID_REPORTID_MOUSE_ABSOLUTE, data, length, result);
auto result = USB_Send(pluggedEndpoint | TRANSFER_RELEASE, data, length);
HIDReportObserver::observeReport(HID_REPORTID_MOUSE_ABSOLUTE, data, length, result);
}
SingleAbsoluteMouse_ SingleAbsoluteMouse;

32
src/kaleidoscope/driver/hid/keyboardio/HID/SingleReport/SingleAbsoluteMouse.h
Unescape View File

@ -33,21 +33,21 @@ THE SOFTWARE.
class SingleAbsoluteMouse_ : public PluggableUSBModule, public AbsoluteMouseAPI {
public:
SingleAbsoluteMouse_(void);
uint8_t getLeds(void);
uint8_t getProtocol(void);
protected:
// Implementation of the PUSBListNode
int getInterface(uint8_t* interfaceCount);
int getDescriptor(USBSetup& setup);
bool setup(USBSetup& setup);
EPTYPE_DESCRIPTOR_SIZE epType[1];
uint8_t protocol;
uint8_t idle;
inline void sendReport(void* data, int length) override;
public:
SingleAbsoluteMouse_(void);
uint8_t getLeds(void);
uint8_t getProtocol(void);
protected:
// Implementation of the PUSBListNode
int getInterface(uint8_t* interfaceCount);
int getDescriptor(USBSetup& setup);
bool setup(USBSetup& setup);
EPTYPE_DESCRIPTOR_SIZE epType[1];
uint8_t protocol;
uint8_t idle;
inline void sendReport(void* data, int length) override;
};
extern SingleAbsoluteMouse_ SingleAbsoluteMouse;

4
src/kaleidoscope/driver/hid/keyboardio/HID/arch/samd.cpp
Unescape View File

@ -3,11 +3,11 @@
#ifdef ARDUINO_ARCH_SAMD
int USB_SendControl(void* b, unsigned char c) {
USBDevice.sendControl(b, c);
USBDevice.sendControl(b, c);
}
int USB_SendControl(uint8_t a, const void* b, uint8_t c) {
USBDevice.sendControl(b, c);
USBDevice.sendControl(b, c);
}
void USB_PackMessages(bool pack) {

Write Preview
Loading…
Cancel
Save