uhk/firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'dev' of https://github.com/Lauszus/firmware into Lauszus-dev

Browse Source
This commit is contained in:
Eric Tang
2018-06-27 13:44:17 -07:00
parent 5c3e2966c4 8c02f3db53
commit 5d621880ec
14 changed files with 244 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
right/src/main.c
View File

@@ -45,7 +45,6 @@ int main(void)
InitSlaveScheduler();
KeyMatrix_Init(&RightKeyMatrix);
InitKeyScanner();
UpdateUsbReports();
InitUsb();
while (1) {

46
right/src/timer.c
View File

@@ -1,12 +1,15 @@
#include "fsl_pit.h"
#include "timer.h"
#include "peripherals/test_led.h"
static volatile uint32_t CurrentTime;
static uint32_t timerClockFrequency;
void PIT_TIMER_HANDLER(void)
{
CurrentTime++;
PIT_ClearStatusFlags(PIT, PIT_TIMER_CHANNEL, PIT_TFLG_TIF_MASK);
//TEST_LED_TOGGLE();
PIT_ClearStatusFlags(PIT, PIT_TIMER_CHANNEL, kPIT_TimerFlag);
}
void Timer_Init(void)
@@ -15,9 +18,8 @@ void Timer_Init(void)
PIT_GetDefaultConfig(&pitConfig);
PIT_Init(PIT, &pitConfig);
// TODO: Why the interval needs to be multiplied by two to arrive to the correct timing?
// Figure it out and clean this up.
PIT_SetTimerPeriod(PIT, PIT_TIMER_CHANNEL, MSEC_TO_COUNT(TIMER_INTERVAL_MSEC*2, PIT_SOURCE_CLOCK));
timerClockFrequency = PIT_SOURCE_CLOCK;
PIT_SetTimerPeriod(PIT, PIT_TIMER_CHANNEL, MSEC_TO_COUNT(TIMER_INTERVAL_MSEC, timerClockFrequency));
PIT_EnableInterrupts(PIT, PIT_TIMER_CHANNEL, kPIT_TimerInterruptEnable);
EnableIRQ(PIT_TIMER_IRQ_ID);
@@ -28,20 +30,50 @@ uint32_t Timer_GetCurrentTime() {
return CurrentTime;
}
uint32_t Timer_GetCurrentTimeMicros() {
uint32_t primask, count, ms;
primask = DisableGlobalIRQ(); // Make sure the read is atomic
count = PIT_GetCurrentTimerCount(PIT, PIT_TIMER_CHANNEL); // Read the current timer count
ms = CurrentTime; // Read the overflow counter
EnableGlobalIRQ(primask); // Enable interrupts again if they where enabled before - this should make it interrupt safe
// Calculate the counter value in microseconds - note that the PIT timer is counting downward, so we need to subtract the count from the period value
uint32_t us = 1000U * TIMER_INTERVAL_MSEC - COUNT_TO_USEC(count, timerClockFrequency);
return ms * 1000U * TIMER_INTERVAL_MSEC + us;
}
void Timer_SetCurrentTime(uint32_t *time)
{
*time = CurrentTime;
*time = Timer_GetCurrentTime();
}
void Timer_SetCurrentTimeMicros(uint32_t *time)
{
*time = Timer_GetCurrentTimeMicros();
}
uint32_t Timer_GetElapsedTime(uint32_t *time)
{
uint32_t elapsedTime = CurrentTime - *time;
uint32_t elapsedTime = Timer_GetCurrentTime() - *time;
return elapsedTime;
}
uint32_t Timer_GetElapsedTimeMicros(uint32_t *time)
{
uint32_t elapsedTime = Timer_GetCurrentTimeMicros() - *time;
return elapsedTime;
}
uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time)
{
uint32_t elapsedTime = Timer_GetElapsedTime(time);
*time = CurrentTime;
*time = Timer_GetCurrentTime();
return elapsedTime;
}
uint32_t Timer_GetElapsedTimeAndSetCurrentMicros(uint32_t *time)
{
uint32_t elapsedTime = Timer_GetElapsedTimeMicros(time);
*time = Timer_GetCurrentTimeMicros();
return elapsedTime;
}

4
right/src/timer.h
View File

@@ -13,8 +13,12 @@
void Timer_Init(void);
uint32_t Timer_GetCurrentTime();
uint32_t Timer_GetCurrentTimeMicros();
void Timer_SetCurrentTime(uint32_t *time);
void Timer_SetCurrentTimeMicros(uint32_t *time);
uint32_t Timer_GetElapsedTime(uint32_t *time);
uint32_t Timer_GetElapsedTimeMicros(uint32_t *time);
uint32_t Timer_GetElapsedTimeAndSetCurrent(uint32_t *time);
uint32_t Timer_GetElapsedTimeAndSetCurrentMicros(uint32_t *time);
#endif

39
right/src/usb_interfaces/usb_interface_basic_keyboard.c
View File

@@ -4,17 +4,16 @@
static usb_basic_keyboard_report_t usbBasicKeyboardReports[2];
uint32_t UsbBasicKeyboardActionCounter;
usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
volatile bool IsUsbBasicKeyboardReportSent = false;
static uint8_t usbBasicKeyboardInBuffer[USB_BASIC_KEYBOARD_REPORT_LENGTH];
static usb_basic_keyboard_report_t* getInactiveUsbBasicKeyboardReport(void)
usb_basic_keyboard_report_t* GetInactiveUsbBasicKeyboardReport(void)
{
return ActiveUsbBasicKeyboardReport == usbBasicKeyboardReports ? usbBasicKeyboardReports+1 : usbBasicKeyboardReports;
}
void SwitchActiveUsbBasicKeyboardReport(void)
static void SwitchActiveUsbBasicKeyboardReport(void)
{
ActiveUsbBasicKeyboardReport = getInactiveUsbBasicKeyboardReport();
ActiveUsbBasicKeyboardReport = GetInactiveUsbBasicKeyboardReport();
}
void ResetActiveUsbBasicKeyboardReport(void)
@@ -22,14 +21,20 @@ void ResetActiveUsbBasicKeyboardReport(void)
bzero(ActiveUsbBasicKeyboardReport, USB_BASIC_KEYBOARD_REPORT_LENGTH);
}
static usb_status_t UsbBasicKeyboardAction(void)
usb_status_t UsbBasicKeyboardAction(void)
{
usb_status_t status = USB_DeviceHidSend(
UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
(uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
IsUsbBasicKeyboardReportSent = true;
if (((usb_device_hid_struct_t *)UsbCompositeDevice.basicKeyboardHandle)->interruptInPipeBusy)
return kStatus_USB_Busy; // The previous report has not been sent yet
UsbBasicKeyboardActionCounter++;
return status;
SwitchActiveUsbBasicKeyboardReport(); // Switch the active report
usb_status_t usb_status = USB_DeviceHidSend(
UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
(uint8_t*)GetInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
if (usb_status != kStatus_USB_Success) {
SwitchActiveUsbBasicKeyboardReport(); // Switch back, as the command failed
}
return usb_status;
}
usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -37,11 +42,11 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
usb_status_t error = kStatus_USB_Error;
switch (event) {
// This report is received when the report has been sent
case kUSB_DeviceHidEventSendResponse:
if (UsbCompositeDevice.attach) {
return UsbBasicKeyboardAction();
}
error = kStatus_USB_Success;
break;
case kUSB_DeviceHidEventRecvResponse:
case kUSB_DeviceHidEventGetReport:
error = kStatus_USB_InvalidRequest;
break;
@@ -61,7 +66,7 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
report->reportBuffer = usbBasicKeyboardInBuffer;
error = kStatus_USB_Success;
} else {
error = kStatus_USB_InvalidRequest;
error = kStatus_USB_AllocFail;
}
break;
}
@@ -79,16 +84,10 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
usb_status_t UsbBasicKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
{
if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
return UsbBasicKeyboardAction();
}
return kStatus_USB_Error;
}
usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
{
if (USB_BASIC_KEYBOARD_INTERFACE_INDEX == interface) {
return UsbBasicKeyboardAction();
}
return kStatus_USB_Error;
}

4
right/src/usb_interfaces/usb_interface_basic_keyboard.h
View File

@@ -31,7 +31,6 @@
// Variables:
extern volatile bool IsUsbBasicKeyboardReportSent;
extern uint32_t UsbBasicKeyboardActionCounter;
extern usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport;
@@ -42,6 +41,7 @@
usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
void ResetActiveUsbBasicKeyboardReport(void);
void SwitchActiveUsbBasicKeyboardReport(void);
usb_basic_keyboard_report_t* GetInactiveUsbBasicKeyboardReport(void);
usb_status_t UsbBasicKeyboardAction(void);
#endif

37
right/src/usb_interfaces/usb_interface_media_keyboard.c
View File

@@ -3,16 +3,15 @@
uint32_t UsbMediaKeyboardActionCounter;
static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
volatile bool IsUsbMediaKeyboardReportSent = false;
static usb_media_keyboard_report_t* getInactiveUsbMediaKeyboardReport(void)
usb_media_keyboard_report_t* GetInactiveUsbMediaKeyboardReport(void)
{
return ActiveUsbMediaKeyboardReport == usbMediaKeyboardReports ? usbMediaKeyboardReports+1 : usbMediaKeyboardReports;
}
void SwitchActiveUsbMediaKeyboardReport(void)
static void SwitchActiveUsbMediaKeyboardReport(void)
{
ActiveUsbMediaKeyboardReport = getInactiveUsbMediaKeyboardReport();
ActiveUsbMediaKeyboardReport = GetInactiveUsbMediaKeyboardReport();
}
void ResetActiveUsbMediaKeyboardReport(void)
@@ -20,14 +19,20 @@ void ResetActiveUsbMediaKeyboardReport(void)
bzero(ActiveUsbMediaKeyboardReport, USB_MEDIA_KEYBOARD_REPORT_LENGTH);
}
static usb_status_t UsbMediaKeyboardAction(void)
usb_status_t UsbMediaKeyboardAction(void)
{
usb_status_t status = USB_DeviceHidSend(
UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
(uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
IsUsbMediaKeyboardReportSent = true;
if (((usb_device_hid_struct_t *)UsbCompositeDevice.mediaKeyboardHandle)->interruptInPipeBusy)
return kStatus_USB_Busy; // The previous report has not been sent yet
UsbMediaKeyboardActionCounter++;
return status;
SwitchActiveUsbMediaKeyboardReport(); // Switch the active report
usb_status_t usb_status = USB_DeviceHidSend(
UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
(uint8_t*)GetInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
if (usb_status != kStatus_USB_Success) {
SwitchActiveUsbMediaKeyboardReport(); // Switch back, as the command failed
}
return usb_status;
}
usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -35,11 +40,11 @@ usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, voi
usb_status_t error = kStatus_USB_Error;
switch (event) {
// This report is received when the report has been sent
case kUSB_DeviceHidEventSendResponse:
if (UsbCompositeDevice.attach) {
return UsbMediaKeyboardAction();
}
error = kStatus_USB_Success;
break;
case kUSB_DeviceHidEventRecvResponse:
case kUSB_DeviceHidEventGetReport:
case kUSB_DeviceHidEventSetReport:
case kUSB_DeviceHidEventRequestReportBuffer:
@@ -59,16 +64,10 @@ usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, voi
usb_status_t UsbMediaKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
{
if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
return UsbMediaKeyboardAction();
}
return kStatus_USB_Error;
}
usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
{
if (USB_MEDIA_KEYBOARD_INTERFACE_INDEX == interface) {
return UsbMediaKeyboardAction();
}
return kStatus_USB_Error;
}

4
right/src/usb_interfaces/usb_interface_media_keyboard.h
View File

@@ -28,7 +28,6 @@
// Variables:
extern volatile bool IsUsbMediaKeyboardReportSent;
extern uint32_t UsbMediaKeyboardActionCounter;
extern usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport;
@@ -39,6 +38,7 @@
usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
void ResetActiveUsbMediaKeyboardReport(void);
void SwitchActiveUsbMediaKeyboardReport(void);
usb_media_keyboard_report_t* GetInactiveUsbMediaKeyboardReport(void);
usb_status_t UsbMediaKeyboardAction();
#endif

38
right/src/usb_interfaces/usb_interface_mouse.c
View File

@@ -3,16 +3,15 @@
uint32_t UsbMouseActionCounter;
static usb_mouse_report_t usbMouseReports[2];
usb_mouse_report_t* ActiveUsbMouseReport = usbMouseReports;
volatile bool IsUsbMouseReportSent = false;
static usb_mouse_report_t* getInactiveUsbMouseReport(void)
usb_mouse_report_t* GetInactiveUsbMouseReport(void)
{
return ActiveUsbMouseReport == usbMouseReports ? usbMouseReports+1 : usbMouseReports;
}
void SwitchActiveUsbMouseReport(void)
static void SwitchActiveUsbMouseReport(void)
{
ActiveUsbMouseReport = getInactiveUsbMouseReport();
ActiveUsbMouseReport = GetInactiveUsbMouseReport();
}
void ResetActiveUsbMouseReport(void)
@@ -20,25 +19,32 @@ void ResetActiveUsbMouseReport(void)
bzero(ActiveUsbMouseReport, USB_MOUSE_REPORT_LENGTH);
}
static volatile usb_status_t usbMouseAction(void)
usb_status_t usbMouseAction(void)
{
usb_mouse_report_t *mouseReport = getInactiveUsbMouseReport();
IsUsbMouseReportSent = true;
return USB_DeviceHidSend(UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
(uint8_t*)mouseReport, USB_MOUSE_REPORT_LENGTH);
if (((usb_device_hid_struct_t *)UsbCompositeDevice.mouseHandle)->interruptInPipeBusy)
return kStatus_USB_Busy; // The previous report has not been sent yet
UsbMouseActionCounter++;
SwitchActiveUsbMouseReport(); // Switch the active report
usb_status_t usb_status = USB_DeviceHidSend(
UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
(uint8_t*)GetInactiveUsbMouseReport(), USB_MOUSE_REPORT_LENGTH);
if (usb_status != kStatus_USB_Success) {
SwitchActiveUsbMouseReport(); // Switch back, as the command failed
}
return usb_status;
}
usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
{
UsbMouseActionCounter++;
usb_status_t error = kStatus_USB_Error;
switch (event) {
// This report is received when the report has been sent
case kUSB_DeviceHidEventSendResponse:
if (UsbCompositeDevice.attach) {
return usbMouseAction();
}
error = kStatus_USB_Success;
break;
case kUSB_DeviceHidEventRecvResponse:
case kUSB_DeviceHidEventGetReport:
case kUSB_DeviceHidEventSetReport:
case kUSB_DeviceHidEventRequestReportBuffer:
@@ -58,16 +64,10 @@ usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param
usb_status_t UsbMouseSetConfiguration(class_handle_t handle, uint8_t configuration)
{
if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
return usbMouseAction();
}
return kStatus_USB_Error;
}
usb_status_t UsbMouseSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
{
if (USB_MOUSE_INTERFACE_INDEX == interface) {
return usbMouseAction();
}
return kStatus_USB_Error;
}

4
right/src/usb_interfaces/usb_interface_mouse.h
View File

@@ -31,7 +31,6 @@
// Variables:
extern volatile bool IsUsbMouseReportSent;
extern uint32_t UsbMouseActionCounter;
extern usb_mouse_report_t* ActiveUsbMouseReport;
@@ -42,6 +41,7 @@
usb_status_t UsbMouseSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
void ResetActiveUsbMouseReport(void);
void SwitchActiveUsbMouseReport(void);
usb_mouse_report_t* GetInactiveUsbMouseReport(void);
usb_status_t usbMouseAction(void);
#endif

37
right/src/usb_interfaces/usb_interface_system_keyboard.c
View File

@@ -3,16 +3,15 @@
uint32_t UsbSystemKeyboardActionCounter;
static usb_system_keyboard_report_t usbSystemKeyboardReports[2];
usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport = usbSystemKeyboardReports;
volatile bool IsUsbSystemKeyboardReportSent = false;
static usb_system_keyboard_report_t* getInactiveUsbSystemKeyboardReport()
usb_system_keyboard_report_t* GetInactiveUsbSystemKeyboardReport()
{
return ActiveUsbSystemKeyboardReport == usbSystemKeyboardReports ? usbSystemKeyboardReports+1 : usbSystemKeyboardReports;
}
void SwitchActiveUsbSystemKeyboardReport(void)
static void SwitchActiveUsbSystemKeyboardReport(void)
{
ActiveUsbSystemKeyboardReport = getInactiveUsbSystemKeyboardReport();
ActiveUsbSystemKeyboardReport = GetInactiveUsbSystemKeyboardReport();
}
void ResetActiveUsbSystemKeyboardReport(void)
@@ -20,14 +19,20 @@ void ResetActiveUsbSystemKeyboardReport(void)
bzero(ActiveUsbSystemKeyboardReport, USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
}
static usb_status_t UsbSystemKeyboardAction(void)
usb_status_t UsbSystemKeyboardAction(void)
{
usb_status_t status = USB_DeviceHidSend(
UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
(uint8_t*)getInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
IsUsbSystemKeyboardReportSent = true;
if (((usb_device_hid_struct_t *)UsbCompositeDevice.systemKeyboardHandle)->interruptInPipeBusy)
return kStatus_USB_Busy; // The previous report has not been sent yet
UsbSystemKeyboardActionCounter++;
return status;
SwitchActiveUsbSystemKeyboardReport(); // Switch the active report
usb_status_t usb_status = USB_DeviceHidSend(
UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
(uint8_t*)GetInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
if (usb_status != kStatus_USB_Success) {
SwitchActiveUsbSystemKeyboardReport(); // Switch back, as the command failed
}
return usb_status;
}
usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -35,11 +40,11 @@ usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, vo
usb_status_t error = kStatus_USB_Error;
switch (event) {
// This report is received when the report has been sent
case kUSB_DeviceHidEventSendResponse:
if (UsbCompositeDevice.attach) {
return UsbSystemKeyboardAction();
}
error = kStatus_USB_Success;
break;
case kUSB_DeviceHidEventRecvResponse:
case kUSB_DeviceHidEventGetReport:
case kUSB_DeviceHidEventSetReport:
case kUSB_DeviceHidEventRequestReportBuffer:
@@ -59,16 +64,10 @@ usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, vo
usb_status_t UsbSystemKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
{
if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
return UsbSystemKeyboardAction();
}
return kStatus_USB_Error;
}
usb_status_t UsbSystemKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
{
if (USB_SYSTEM_KEYBOARD_INTERFACE_INDEX == interface) {
return UsbSystemKeyboardAction();
}
return kStatus_USB_Error;
}

4
right/src/usb_interfaces/usb_interface_system_keyboard.h
View File

@@ -29,7 +29,6 @@
// Variables:
extern volatile bool IsUsbSystemKeyboardReportSent;
extern uint32_t UsbSystemKeyboardActionCounter;
extern usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport;
@@ -40,6 +39,7 @@
usb_status_t UsbSystemKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
void ResetActiveUsbSystemKeyboardReport(void);
void SwitchActiveUsbSystemKeyboardReport(void);
usb_system_keyboard_report_t* GetInactiveUsbSystemKeyboardReport();
usb_status_t UsbSystemKeyboardAction(void);
#endif

71
right/src/usb_report_updater.c
View File

@@ -285,6 +285,8 @@ static uint8_t secondaryRoleState = SecondaryRoleState_Released;
static uint8_t secondaryRoleSlotId;
static uint8_t secondaryRoleKeyId;
static secondary_role_t secondaryRole;
static bool simulateKeypresses = false;
static bool sendChar = false;
static void updateActiveUsbReports(void)
{
@@ -319,6 +321,16 @@ static void updateActiveUsbReports(void)
return;
}
key_state_t *testKeyState = &KeyStates[SlotId_LeftKeyboardHalf][0];
if (!testKeyState->previous && testKeyState->current && activeLayer == LayerId_Fn) {
simulateKeypresses = !simulateKeypresses;
}
if (simulateKeypresses) {
sendChar = !sendChar;
ActiveUsbBasicKeyboardReport->scancodes[basicScancodeIndex++] = sendChar ? HID_KEYBOARD_SC_A : HID_KEYBOARD_SC_B;
}
for (uint8_t slotId=0; slotId<SLOT_COUNT; slotId++) {
for (uint8_t keyId=0; keyId<MAX_KEY_COUNT_PER_MODULE; keyId++) {
key_state_t *keyState = &KeyStates[slotId][keyId];
@@ -390,27 +402,20 @@ static void updateActiveUsbReports(void)
}
uint32_t UsbReportUpdateCounter;
static uint32_t lastMouseUpdateTime;
static uint32_t lastMouseUpdateTimeMicros;
void UpdateUsbReports(void)
{
UsbReportUpdateCounter++;
// Process the key inputs at a constant rate when moving the mouse, so the mouse speed is consistent.
bool hasActiveMouseState = false;
for (uint8_t i=0; i<ACTIVE_MOUSE_STATES_COUNT; i++) {
hasActiveMouseState = true;
break;
}
if (hasActiveMouseState) {
if (Timer_GetElapsedTime(&lastMouseUpdateTime) < USB_MOUSE_INTERRUPT_IN_INTERVAL) {
return;
}
Timer_SetCurrentTime(&lastMouseUpdateTime);
} else if (!IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) {
if (((usb_device_hid_struct_t *)UsbCompositeDevice.basicKeyboardHandle)->interruptInPipeBusy ||
((usb_device_hid_struct_t *)UsbCompositeDevice.mediaKeyboardHandle)->interruptInPipeBusy ||
((usb_device_hid_struct_t *)UsbCompositeDevice.systemKeyboardHandle)->interruptInPipeBusy ||
((usb_device_hid_struct_t *)UsbCompositeDevice.mouseHandle)->interruptInPipeBusy) {
return;
} else if (Timer_GetElapsedTimeMicros(&lastMouseUpdateTimeMicros) < 1000U * USB_BASIC_KEYBOARD_INTERRUPT_IN_INTERVAL) {
return;
}
Timer_SetCurrentTimeMicros(&lastMouseUpdateTimeMicros);
ResetActiveUsbBasicKeyboardReport();
ResetActiveUsbMediaKeyboardReport();
@@ -419,35 +424,29 @@ void UpdateUsbReports(void)
updateActiveUsbReports();
static usb_basic_keyboard_report_t last_basic_report = { .scancodes[0] = 0xFF };
if (memcmp(ActiveUsbBasicKeyboardReport, &last_basic_report, sizeof(usb_basic_keyboard_report_t)) != 0) {
last_basic_report = *ActiveUsbBasicKeyboardReport;
SwitchActiveUsbBasicKeyboardReport();
IsUsbBasicKeyboardReportSent = false;
bool HasUsbBasicKeyboardReportChanged = memcmp(ActiveUsbBasicKeyboardReport, GetInactiveUsbBasicKeyboardReport(), sizeof(usb_basic_keyboard_report_t)) != 0;
if (HasUsbBasicKeyboardReportChanged) {
UsbBasicKeyboardAction();
}
static usb_media_keyboard_report_t last_media_report = { .scancodes[0] = 0xFF };
if (memcmp(ActiveUsbMediaKeyboardReport, &last_media_report, sizeof(usb_media_keyboard_report_t)) != 0) {
last_media_report = *ActiveUsbMediaKeyboardReport;
SwitchActiveUsbMediaKeyboardReport();
IsUsbMediaKeyboardReportSent = false;
bool HasUsbMediaKeyboardReportChanged = memcmp(ActiveUsbMediaKeyboardReport, GetInactiveUsbMediaKeyboardReport(), sizeof(usb_media_keyboard_report_t)) != 0;
if (HasUsbMediaKeyboardReportChanged) {
UsbMediaKeyboardAction();
}
static usb_system_keyboard_report_t last_system_report = { .scancodes[0] = 0xFF };
if (memcmp(ActiveUsbSystemKeyboardReport, &last_system_report, sizeof(usb_system_keyboard_report_t)) != 0) {
last_system_report = *ActiveUsbSystemKeyboardReport;
SwitchActiveUsbSystemKeyboardReport();
IsUsbSystemKeyboardReportSent = false;
bool HasUsbSystemKeyboardReportChanged = memcmp(ActiveUsbSystemKeyboardReport, GetInactiveUsbSystemKeyboardReport(), sizeof(usb_system_keyboard_report_t)) != 0;
if (HasUsbSystemKeyboardReportChanged) {
UsbSystemKeyboardAction();
}
static usb_mouse_report_t last_mouse_report = { .buttons = 0xFF };
if (memcmp(ActiveUsbMouseReport, &last_mouse_report, sizeof(usb_mouse_report_t)) != 0) {
last_mouse_report = *ActiveUsbMouseReport;
SwitchActiveUsbMouseReport();
IsUsbMouseReportSent = false;
// Send out the mouse position and wheel values continuously if the report is not zeros, but only send the mouse button states when they change.
bool HasUsbMouseReportChanged = memcmp(ActiveUsbMouseReport, GetInactiveUsbMouseReport(), sizeof(usb_mouse_report_t)) != 0;
if (HasUsbMouseReportChanged || ActiveUsbMouseReport->x || ActiveUsbMouseReport->y ||
ActiveUsbMouseReport->wheelX || ActiveUsbMouseReport->wheelY) {
usbMouseAction();
}
if ((previousLayer != LayerId_Base || !IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) && IsHostSleeping) {
if (IsHostSleeping && (previousLayer != LayerId_Base || HasUsbBasicKeyboardReportChanged || HasUsbMediaKeyboardReportChanged || HasUsbSystemKeyboardReportChanged || HasUsbMouseReportChanged)) {
WakeUpHost(true); // Wake up the host if any key is pressed and the computer is sleeping.
}
}