WIP: Stuck keys logging

device/src/messenger.c

@@ -17,6 +17,7 @@
 #include "legacy/str_utils.h"
 #include "legacy/event_scheduler.h"
 #include "legacy/slave_drivers/uhk_module_driver.h"
+#include "macros/status_buffer.h"
 
 #if DEVICE_IS_KEYBOARD
 #include "keyboard/uart.h"
@@ -143,11 +144,22 @@ static void processSyncablePropertyRight(device_id_t src, const uint8_t* data, u
     const uint8_t* message = data;
     switch (propertyId) {
         case SyncablePropertyId_LeftHalfKeyStates:
-            for (uint8_t keyId = 0; keyId < MAX_KEY_COUNT_PER_MODULE; keyId++) {
-                KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState = !!(message[keyId/8] & (1 << (keyId % 8)));
-            }
-            EventVector_Set(EventVector_StateMatrix);
-            break;
+            {
+                bool somethingChanged = false;
+                for (uint8_t keyId = 0; keyId < MAX_KEY_COUNT_PER_MODULE; keyId++) {
+                    bool state = !!(message[keyId/8] & (1 << (keyId % 8)));
+                    if (KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState != state) {
+                        KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState = state;
+                        somethingChanged = true;
+
+                        Macros_ReportPrintf(NULL, "M+%s", MacroKeyIdParser_KeyIdToAbbreviation(SlotId_LeftKeyboardHalf*64 + keyId));
+                    }
+                    KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState = !!(message[keyId/8] & (1 << (keyId % 8)));
+                }
+                if (somethingChanged) {
+                    EventVector_Set(EventVector_StateMatrix);
+                }
+            } break;
         case SyncablePropertyId_LeftModuleKeyStates:
             {
                 uint8_t driverId = UhkModuleDriverId_LeftModule;

right/src/debug.h

@@ -10,6 +10,8 @@
 #define DEBUG_POSTPONER false
 #define WATCH_INTERVAL 500
 
+#define DEBUG_ROLL_STATUS_BUFFER true
+
 #ifdef __ZEPHYR__
     #include "logger.h"
     #include <zephyr/kernel.h>

right/src/event_scheduler.c

@@ -221,7 +221,7 @@ void EventVector_ReportMask(const char* prefix, uint32_t mask) {
     REPORT_MASK(MouseKeysReportsUsed);
     REPORT_MASK(MouseControllerMouseReportsUsed);
     REPORT_MASK(MouseControllerKeyboardReportsUsed);
-    REPORT_MASK(ReportsChanged);
+    REPORT_MASK(SendUsbReports);
     REPORT_MASK(NativeActionsPostponing);
     REPORT_MASK(MacroEnginePostponing);
 

right/src/event_scheduler.h

@@ -49,8 +49,8 @@
        EventVector_MouseController =                       1 << 4,
        EventVector_Postponer =                             1 << 5,
        EventVector_LayerHolds =                            1 << 6,
-       EventVector_ZeroScan =                              1 << 7,
-       EventVector_EventScheduler =                        1 << 8,
+       EventVector_EventScheduler =                        1 << 7,
+       EventVector_MainTriggers =                          ((EventVector_EventScheduler << 1) - 1),
 
 
        // some other minor triggers
@@ -63,24 +63,23 @@
        EventVector_LedMapUpdateNeeded =                    1 << 15,
        EventVector_ApplyConfig =                           1 << 16,
        EventVector_NewMessage =                            1 << 17,
-
-       EventVector_ReportUpdateMask = ((1 << 9) - 1) & ~EventVector_EventScheduler,
-       EventVector_UserLogicUpdateMask = ((1 << 18) - 1) & ~EventVector_EventScheduler,
+       EventVector_AuxiliaryTriggers =                     ((EventVector_NewMessage << 1) - 1),
 
        // events that are informational only
        EventVector_NativeActionReportsUsed =               1 << 18,
        EventVector_MacroReportsUsed =                      1 << 19,
        EventVector_MouseKeysReportsUsed =                  1 << 20,
        EventVector_MouseControllerMouseReportsUsed =       1 << 21,
        EventVector_MouseControllerKeyboardReportsUsed =    1 << 22,
-       EventVector_ReportsChanged =                        1 << 23,
+       EventVector_SendUsbReports =                        1 << 23,
        EventVector_NativeActionsPostponing =               1 << 24,
        EventVector_MacroEnginePostponing =                 1 << 25,
        EventVector_MouseControllerPostponing =             1 << 26,
 
-       // helpers
+       // helper masks
+       EventVector_ReportUpdateMask = EventVector_MainTriggers & ~EventVector_EventScheduler,
+       EventVector_UserLogicUpdateMask = EventVector_AuxiliaryTriggers & ~EventVector_EventScheduler,
        EventVector_SomeonePostponing = EventVector_NativeActionsPostponing | EventVector_MacroEnginePostponing | EventVector_MouseControllerPostponing,
-
     } event_vector_event_t;
 
 /**

right/src/macros/core.c

@@ -624,7 +624,7 @@ static void executePreemptive(void)
 
             if (res & MacroResult_BlockingFlag) {
                 SchedulerPostponing = true;
-                EventVector_Set(EventVector_ReportsChanged);
+                EventVector_Set(EventVector_SendUsbReports);
             }
 
             if (S->ms.macroInterrupted) {
@@ -784,7 +784,7 @@ static void executeBlocking(void)
 
         if ((someoneBlocking = (res & MacroResult_BlockingFlag))) {
             SchedulerPostponing = true;
-            EventVector_Set(EventVector_ReportsChanged);
+            EventVector_Set(EventVector_SendUsbReports);
             break;
         }
 

right/src/macros/status_buffer.c

@@ -1,6 +1,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
+#include "debug.h"
 #include "macros/core.h"
 #include "macros/scancode_commands.h"
 #include "macros/status_buffer.h"
@@ -9,6 +10,7 @@
 #include "segment_display.h"
 #include "config_parser/parse_macro.h"
 #include "config_parser/config_globals.h"
+#include "timer.h"
 #include <math.h>
 #include <stdarg.h>
 
@@ -112,9 +114,11 @@ static void setStatusChar(char n)
         return;
     }
 
-    if (n && statusBufferLen == STATUS_BUFFER_MAX_LENGTH) {
+    if (n && statusBufferLen == STATUS_BUFFER_MAX_LENGTH && DEBUG_ROLL_STATUS_BUFFER) {
         memcpy(statusBuffer, &statusBuffer[STATUS_BUFFER_MAX_LENGTH/2], STATUS_BUFFER_MAX_LENGTH/2);
+        int16_t shiftBy = STATUS_BUFFER_MAX_LENGTH - STATUS_BUFFER_MAX_LENGTH/2;
         statusBufferLen = STATUS_BUFFER_MAX_LENGTH/2;
+        consumeStatusCharReadingPos = consumeStatusCharReadingPos > shiftBy ? consumeStatusCharReadingPos - shiftBy : 0;
     }
 
     if (n && statusBufferLen < STATUS_BUFFER_MAX_LENGTH) {
@@ -304,14 +308,20 @@ void Macros_ReportPrintf(const char* pos, const char *fmt, ...)
     char buffer[256];
     vsprintf(buffer, fmt, myargs);
 
+    static uint32_t lastUpdate = 0;
+
     indicateOut();
     if (pos != NULL) {
         reportErrorHeader("Out", findPosition(pos));
         reportError(buffer, pos, pos);
     } else {
+        Macros_SetStatusChar('+');
+        Macros_SetStatusNumSpaced(CurrentTime-lastUpdate, false);
+        Macros_SetStatusChar(' ');
         Macros_SetStatusString(buffer, NULL);
         Macros_SetStatusString("\n", NULL);
     }
+    lastUpdate = CurrentTime;
 }
 
 void Macros_ReportErrorPrintf(const char* pos, const char *fmt, ...)

right/src/macros/status_buffer.h

@@ -13,6 +13,7 @@
 
 // Typedefs:
 
+
 // Variables:
 //
     extern bool Macros_ConsumeStatusCharDirtyFlag;

right/src/mouse_controller.c

@@ -777,7 +777,7 @@ void MouseController_ProcessMouseActions()
     EventVector_SetValue(EventVector_MouseControllerMouseReportsUsed, mouseReportsUsed);
 
     if (keyboardReportsUsed || mouseReportsUsed || caretModeActionWasRunningSomewhere || modsChanged) {
-        EventVector_Set(EventVector_ReportsChanged);
+        EventVector_Set(EventVector_SendUsbReports);
     }
     if (!caretModeActionIsRunningSomewhere) {
         EventVector_Unset(EventVector_MouseControllerPostponing);

right/src/mouse_keys.c

@@ -210,13 +210,13 @@ void MouseKeys_ProcessMouseActions()
         EventVector_Set(EventVector_MouseKeysReportsUsed);
     }
     if (wasMoving) {
-        EventVector_Set(EventVector_MouseKeys | EventVector_ReportsChanged);
+        EventVector_Set(EventVector_MouseKeys | EventVector_SendUsbReports);
     }
 }
 
 void MouseKeys_SetState(serialized_mouse_action_t action, bool lock, bool activate)
 {
-    EventVector_Set(EventVector_MouseKeys | EventVector_ReportsChanged);
+    EventVector_Set(EventVector_MouseKeys | EventVector_SendUsbReports);
     if (activate) {
         if (lock) {
             EventVector_Set(EventVector_NativeActions);

right/src/postponer.c

@@ -91,6 +91,7 @@ static void applyEventAndConsume(postponer_buffer_record_type_t* rec) {
             Postponer_LastKeyMods = rec->event.key.modifiers;
             // This gives the key two ticks (this and next) to get properly processed before execution of next queued event.
             // PostponerCore_PostponeNCycles(1);
+            Macros_ReportPrintf(NULL, "P%c%s", rec->event.key.active ? '+' : '-', Utils_KeyStateToKeyAbbreviation(rec->event.key.keyState));
             EventVector_Set(EventVector_NativeActions);
             Macros_WakeBecauseOfKeystateChange();
             consumeEvent(1);

right/src/slave_drivers/touchpad_driver.c

@@ -164,25 +164,46 @@ slave_result_t TouchpadDriver_Update(uint8_t uhkModuleDriverId)
 
             ModuleConnectionStates[UhkModuleDriverId_RightModule].lastTimeConnected = CurrentTime;
 
-            TouchpadEvents.singleTap = gestureEvents.events0.singleTap;
-            TouchpadEvents.twoFingerTap = gestureEvents.events1.twoFingerTap;
-            TouchpadEvents.tapAndHold = gestureEvents.events0.tapAndHold;
-            TouchpadEvents.noFingers = noFingers;
-
-            if (gestureEvents.events1.scroll) {
-                TouchpadEvents.wheelX -= deltaX;
-                TouchpadEvents.wheelY += deltaY;
-            } else if (gestureEvents.events1.zoom) {
-                TouchpadEvents.zoomLevel -= deltaY;
-            } else {
-                TouchpadEvents.x -= deltaX;
-                TouchpadEvents.y += deltaY;
+            if (deltaX || deltaY || *(uint16_t*)&gestureEvents) {
+                bool somethingChanged = false;
+
+                if (
+                        TouchpadEvents.singleTap != gestureEvents.events0.singleTap
+                        || TouchpadEvents.twoFingerTap != gestureEvents.events1.twoFingerTap
+                        || TouchpadEvents.tapAndHold != gestureEvents.events0.tapAndHold
+                        || TouchpadEvents.noFingers != noFingers
+                   ) {
+                    TouchpadEvents.singleTap = gestureEvents.events0.singleTap;
+                    TouchpadEvents.twoFingerTap = gestureEvents.events1.twoFingerTap;
+                    TouchpadEvents.tapAndHold = gestureEvents.events0.tapAndHold;
+                    TouchpadEvents.noFingers = noFingers;
+                    somethingChanged = true;
+                }
+
+                if (deltaX != 0 || deltaY != 0) {
+                    if (gestureEvents.events1.scroll) {
+                        TouchpadEvents.wheelX -= deltaX;
+                        TouchpadEvents.wheelY += deltaY;
+                        somethingChanged = true;
+                    } else if (gestureEvents.events1.zoom) {
+                        TouchpadEvents.zoomLevel -= deltaY;
+                        somethingChanged = true;
+                    } else {
+                        TouchpadEvents.x -= deltaX;
+                        TouchpadEvents.y += deltaY;
+                        somethingChanged = true;
+                    }
+                }
+
+                if (somethingChanged) {
+                    EventVector_Set(EventVector_MouseController);
+                    EventVector_WakeMain();
+                }
             }
 
             res.status = I2cAsyncWrite(address, closeCommunicationWindow, sizeof(closeCommunicationWindow));
             res.hold = false;
-            EventVector_Set(EventVector_MouseController);
-            EventVector_WakeMain();
+
             phase = 3;
             break;
         }

right/src/slave_drivers/uhk_module_driver.c

@@ -2,6 +2,7 @@
 #include "config_parser/parse_config.h"
 #include "i2c_addresses.h"
 #include "i2c.h"
+#include "macros/keyid_parser.h"
 
 #ifdef __ZEPHYR__
 #include "messenger.h"
@@ -145,6 +146,11 @@ void UhkModuleSlaveDriver_ProcessKeystates(uint8_t uhkModuleDriverId, uhk_module
         }
 
         if (KeyStates[slotId][targetKeyId].hardwareSwitchState != keyStatesBuffer[keyId]) {
+            if (keyStatesBuffer[keyId]) {
+                Macros_ReportPrintf(NULL, "S+%s", MacroKeyIdParser_KeyIdToAbbreviation(targetKeyId+slotId*64));
+            } else {
+                Macros_ReportPrintf(NULL, "S-%s", MacroKeyIdParser_KeyIdToAbbreviation(targetKeyId+slotId*64));
+            }
             KeyStates[slotId][targetKeyId].hardwareSwitchState = keyStatesBuffer[keyId];
             stateChanged = true;
         }
@@ -446,6 +452,7 @@ slave_result_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
         case UhkModulePhase_ProcessKeystates:
             if (CRC16_IsMessageValid(rxMessage)) {
                 if (DEVICE_ID == DeviceId_Uhk80_Left) {
+                    // this handles forwarding left module states in uhk80 left half
                     forwardKeystates(uhkModuleDriverId, uhkModuleState, rxMessage);
                 } else {
                     UhkModuleSlaveDriver_ProcessKeystates(uhkModuleDriverId, uhkModuleState, rxMessage->data);

right/src/usb_interfaces/usb_interface_basic_keyboard.c

@@ -1,10 +1,12 @@
 #include <string.h>
+#include "event_scheduler.h"
 #include "led_display.h"
 #include "lufa/HIDClassCommon.h"
 #include "macros/core.h"
 #include "macro_events.h"
 #include "usb_composite_device.h"
 #include "usb_report_updater.h"
+#include "macros/status_buffer.h"
 
 #ifdef __ZEPHYR__
 #include "usb/usb_compatibility.h"
@@ -206,6 +208,7 @@ void UsbBasicKeyboardSendActiveReport(void)
         //This is *not* asynchronously safe as long as multiple reports of different type can be sent at the same time.
         //TODO: consider either making it atomic, or lowering semaphore reset delay
         UsbReportUpdateSemaphore &= ~(1 << USB_BASIC_KEYBOARD_INTERFACE_INDEX);
+        EventVector_Set(EventVector_SendUsbReports);
     }
 #endif
 }

right/src/usb_interfaces/usb_interface_mouse.c

@@ -1,6 +1,7 @@
 #include "usb_composite_device.h"
 #include "usb_report_updater.h"
 #include <string.h>
+#include "event_scheduler.h"
 
 #ifdef __ZEPHYR__
 #include "usb/usb_compatibility.h"
@@ -167,6 +168,7 @@ void UsbMouseSendActiveReport(void)
     usb_status_t status = UsbMouseAction();
     if (status != kStatus_USB_Success) {
         UsbReportUpdateSemaphore &= ~(1 << USB_MOUSE_INTERFACE_INDEX);
+        EventVector_Set(EventVector_SendUsbReports);
     }
 #endif
 }