Dongle fixes

device/src/keyboard/uart_bridge.c

@@ -144,11 +144,11 @@ static void receivePacket(void *state, uart_control_t messageKind, const uint8_t
     }
 }
 
-void UartBridge_SendMessage(message_t* msg) {
+int UartBridge_SendMessage(message_t* msg) {
     uart_state_t *uartState = &bridgeState;
 
     if (uartState == NULL || uartState->core.device == NULL) {
-        return;
+        return -1;
     }
 
     int err;
@@ -170,10 +170,12 @@ void UartBridge_SendMessage(message_t* msg) {
 
     UartParser_FinalizeMessage(&uartState->parser);
 
-    UartLink_Send(&uartState->core, uartState->parser.txBuffer, uartState->parser.txPosition);
+    err = UartLink_Send(&uartState->core, uartState->parser.txBuffer, uartState->parser.txPosition);
 
     uartState->lastMessageSentTime = k_uptime_get();
     uartState->txState = UartTxState_WaitingForAck;
+
+    return err;
 }
 
 static void sendControl(uart_state_t *uartState, uint8_t byte) {

device/src/keyboard/uart_bridge.h

@@ -20,7 +20,7 @@
 // Functions:
 
     int Uart_SendModuleMessage(i2c_message_t* msg);
-    void UartBridge_SendMessage(message_t* msg);
+    int UartBridge_SendMessage(message_t* msg);
     void UartBridge_Enable();
     void InitUartBridge(void);
 

device/src/keyboard/uart_link.c

@@ -2,6 +2,7 @@
 #include "event_scheduler.h"
 #include <zephyr/kernel.h>
 #include <zephyr/drivers/uart.h>
+#include "config_manager.h"
 
 #define UART_RESET_DELAY 10
 

device/src/messenger.c

@@ -470,55 +470,63 @@ void Messenger_ProcessQueue() {
     }
 }
 
-void Messenger_SendMessage(message_t* message) {
+int Messenger_SendMessage(message_t* message) {
     connection_id_t connectionId = message->connectionId;
     device_id_t dst = message->dst;
 
+    int err = 0;
 
     switch (connectionId) {
         case ConnectionId_UartLeft:
         case ConnectionId_UartRight:
 #if DEVICE_IS_KEYBOARD
-            UartBridge_SendMessage(message);
+            err = UartBridge_SendMessage(message);
 #endif
             break;
         case ConnectionId_NusClientRight:
 #if defined(CONFIG_BT_NUS) && defined(CONFIG_BT_PERIPHERAL)
-            NusServer_SendMessage(message);
+            err = NusServer_SendMessage(message);
 #endif
             break;
         case ConnectionId_HostConnectionFirst ... ConnectionId_HostConnectionLast:
             if (Connections_Type(connectionId) == ConnectionType_NusDongle) {
 #if defined(CONFIG_BT_NUS) && defined(CONFIG_BT_PERIPHERAL)
-                NusServer_SendMessageTo(message, Peers[Connections[connectionId].peerId].conn);
+                err = NusServer_SendMessageTo(message, Peers[Connections[connectionId].peerId].conn);
+                if (err) {
+                    printk("Failed to send message from %s to %s over NUS Server connection; err %d\n", Utils_DeviceIdToString(DEVICE_ID), Utils_DeviceIdToString(dst), err);
+                }
 #endif
             } else {
                 printk("Failed to send message from %s to %s; incompatible connection type\n", Utils_DeviceIdToString(DEVICE_ID), Utils_DeviceIdToString(dst));
+                err = -1;
             }
             break;
         case ConnectionId_NusServerRight:
         case ConnectionId_NusServerLeft:
 #ifdef CONFIG_BT_NUS_CLIENT
-            NusClient_SendMessage(message);
+            err = NusClient_SendMessage(message);
 #endif
             break;
         default:
             printk("Failed to send message from %s to %s\n", Utils_DeviceIdToString(DEVICE_ID), Utils_DeviceIdToString(dst));
+            err = -1;
             break;
     }
 
-    const char *desc1, *desc2;
-    getMessageDescription(message->messageId[0], message->messageId[1], &desc1, &desc2);
-    desc1 = desc1 == NULL ? "" : desc1;
-    desc2 = desc2 == NULL ? "" : desc2;
     if (DEBUG_LOG_MESSAGES) {
+        const char *desc1, *desc2;
+        getMessageDescription(message->messageId[0], message->messageId[1], &desc1, &desc2);
+        desc1 = desc1 == NULL ? "" : desc1;
+        desc2 = desc2 == NULL ? "" : desc2;
         LogU("Sen %d        %d %s %s\n", connectionId, message->wm, desc1, desc2);
     }
 
     Trace('O');
+
+    return err;
 }
 
-void Messenger_Send(device_id_t dst, uint8_t messageId, const uint8_t* data, uint16_t len) {
+int Messenger_Send(device_id_t dst, uint8_t messageId, const uint8_t* data, uint16_t len) {
     message_t msg = {
         .data = data,
         .len = len,
@@ -528,10 +536,10 @@ void Messenger_Send(device_id_t dst, uint8_t messageId, const uint8_t* data, uin
         .dst = dst,
         .connectionId = determineChannel(dst),
     };
-    Messenger_SendMessage(&msg);
+    return Messenger_SendMessage(&msg);
 }
 
-void Messenger_Send2(device_id_t dst, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len) {
+int Messenger_Send2(device_id_t dst, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len) {
     message_t msg = {
         .data = data,
         .len = len,
@@ -542,10 +550,10 @@ void Messenger_Send2(device_id_t dst, uint8_t messageId, uint8_t messageId2, con
         .dst = dst,
         .connectionId = determineChannel(dst),
     };
-    Messenger_SendMessage(&msg);
+    return Messenger_SendMessage(&msg);
 }
 
-void Messenger_Send2Via(device_id_t dst, connection_id_t connectionId, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len) {
+int Messenger_Send2Via(device_id_t dst, connection_id_t connectionId, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len) {
     message_t msg = {
         .data = data,
         .len = len,
@@ -556,7 +564,7 @@ void Messenger_Send2Via(device_id_t dst, connection_id_t connectionId, uint8_t m
         .dst = dst,
         .connectionId = connectionId,
     };
-    Messenger_SendMessage(&msg);
+    return Messenger_SendMessage(&msg);
 }
 
 void Messenger_Init() {

device/src/messenger.h

@@ -57,10 +57,10 @@
 
     uint16_t Messenger_GetMissedMessages(device_id_t dst);
 
-    void Messenger_SendMessage(message_t* message);
-    void Messenger_Send(device_id_t dst, uint8_t messageId, const uint8_t* data, uint16_t len);
-    void Messenger_Send2(device_id_t dst, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len);
-    void Messenger_Send2Via(device_id_t dst, connection_id_t connectionId, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len);
+    int Messenger_SendMessage(message_t* message);
+    int Messenger_Send(device_id_t dst, uint8_t messageId, const uint8_t* data, uint16_t len);
+    int Messenger_Send2(device_id_t dst, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len);
+    int Messenger_Send2Via(device_id_t dst, connection_id_t connectionId, uint8_t messageId, uint8_t messageId2, const uint8_t* data, uint16_t len);
 
     void Messenger_Enqueue(uint8_t srcConnectionId, uint8_t src, const uint8_t* data, uint16_t len, uint8_t offset);
     void Messenger_ProcessQueue();

device/src/nus_client.c

@@ -22,6 +22,7 @@
 #include "resend.h"
 #include "trace.h"
 #include <zephyr/logging/log.h>
+#include "config_manager.h"
 
 LOG_MODULE_REGISTER(NusClient, LOG_LEVEL_INF);
 
@@ -180,15 +181,17 @@ bool NusClient_Availability(messenger_availability_op_t operation) {
     }
 }
 
-static void send_raw_buffer(const uint8_t *data, uint16_t len) {
+static int send_raw_buffer(const uint8_t *data, uint16_t len) {
     int err = bt_nus_client_send(&nus_client, data, len);
     if (err) {
         k_sem_give(&nusBusy);
         LOG_WRN("Client failed to send data over BLE connection (err %d)", err);
     }
+    return err;
 }
 
-void NusClient_SendMessage(message_t* msg) {
+int NusClient_SendMessage(message_t* msg) {
+    int err = 0;
     Trace_Printc("s2");
     SEM_TAKE(&nusBusy);
 
@@ -210,13 +213,15 @@ void NusClient_SendMessage(message_t* msg) {
         LOG_WRN("Message is too long for NUS packets! [%i, %i, ...]", buffer[0], buffer[1]);
         Trace_Printc("E1");
         Trace_Printc("r2");
-        return;
+        return -1;
     }
 
     memcpy(&buffer[bufferIdx], msg->data, msg->len);
 
     bufferIdx += msg->len;
 
-    send_raw_buffer(buffer, bufferIdx);
+    err = send_raw_buffer(buffer, bufferIdx);
     Trace_Printc("r2");
+
+    return err;
 }

device/src/nus_client.h

@@ -11,7 +11,7 @@
     void NusClient_Init(void);
     void NusClient_Disconnected();
     void NusClient_Connect(struct bt_conn *conn);
-    void NusClient_SendMessage(message_t* msg);
+    int NusClient_SendMessage(message_t* msg);
     bool NusClient_Availability(messenger_availability_op_t operation);
 
 #endif // __NUS_CLIENT_H__

device/src/nus_server.c

@@ -13,6 +13,7 @@
 #include <zephyr/logging/log.h>
 #include "bt_manager.h"
 #include "hid/transport.h"
+#include "config_manager.h"
 
 LOG_MODULE_REGISTER(NusServer, LOG_LEVEL_INF);
 
@@ -85,12 +86,13 @@ void NusServer_Disconnected() {
     }
 }
 
-static void send_raw_buffer(const uint8_t *data, uint16_t len, struct bt_conn* conn) {
+static int send_raw_buffer(const uint8_t *data, uint16_t len, struct bt_conn* conn) {
     int err = bt_nus_send(conn, data, len);
     if (err) {
         k_sem_give(&nusBusy);
         LOG_WRN("Failed to send data over BLE connection (err: %d)", err);
     }
+    return err;
 }
 
 bool NusServer_Availability(messenger_availability_op_t operation) {
@@ -108,8 +110,12 @@ bool NusServer_Availability(messenger_availability_op_t operation) {
     }
 }
 
-void NusServer_SendMessageTo(message_t* msg, struct bt_conn* conn) {
+int NusServer_SendMessageTo(message_t* msg, struct bt_conn* conn) {
+    int err = 0;
+
+    Trace_Printc("c1");
     SEM_TAKE(&nusBusy);
+    Trace_Printc("c2");
 
     // Call this only after we have taken the semaphore.
     Resend_RegisterMessageAndUpdateWatermarks(msg);
@@ -127,15 +133,19 @@ void NusServer_SendMessageTo(message_t* msg, struct bt_conn* conn) {
 
     if (bufferIdx + msg->len > MAX_LINK_PACKET_LENGTH) {
         LOG_WRN("Message is too long for NUS packets! [%i, %i, ...]", buffer[0], buffer[1]);
-        return;
+        return -1;
     }
 
     memcpy(&buffer[bufferIdx], msg->data, msg->len);
     bufferIdx += msg->len;
 
-    send_raw_buffer(buffer, bufferIdx, conn);
+    Trace_Printc("c3");
+    err = send_raw_buffer(buffer, bufferIdx, conn);
+    Trace_Printc("c4");
+
+    return err;
 }
 
-void NusServer_SendMessage(message_t* msg) {
-    NusServer_SendMessageTo(msg, NULL);
+int NusServer_SendMessage(message_t* msg) {
+    return NusServer_SendMessageTo(msg, NULL);
 }

device/src/nus_server.h

@@ -10,8 +10,8 @@
 
     extern int NusServer_Init(void);
     extern void NusServer_Disconnected();
-    extern void NusServer_SendMessage(message_t* msg);
-    extern void NusServer_SendMessageTo(message_t* msg, struct bt_conn* conn);
+    extern int NusServer_SendMessage(message_t* msg);
+    extern int NusServer_SendMessageTo(message_t* msg, struct bt_conn* conn);
     extern bool NusServer_Availability(messenger_availability_op_t operation);
 
 #endif // __NUS_SERVER_H__

right/src/config_parser/parse_host_connection.c

@@ -61,6 +61,13 @@ static parser_error_t parseHostConnection(config_buffer_t* buffer, host_connecti
     return ParserError_Success;
 }
 
+/*
+ * For every unregistered hid, try to look up registered connection.
+ * If found, empty it.
+ *
+ * For every registered hid, look up a dongle with the same address.
+ * If found, empty it.
+ */
 static void deduplicateUnregisteredConnections(void) {
 #ifdef __ZEPHYR__
     if (ParserRunDry) {
@@ -70,7 +77,7 @@ static void deduplicateUnregisteredConnections(void) {
     for (uint8_t i = 0; i < SERIALIZED_HOST_CONNECTION_COUNT_MAX; i++) {
         host_connection_t* conn = &HostConnections[i];
 
-        if (conn->type != HostConnectionType_UnregisteredBtHid) {
+        if (conn->type != HostConnectionType_UnregisteredBtHid && conn->type != HostConnectionType_BtHid) {
             continue;
         }
 
@@ -87,6 +94,10 @@ static void deduplicateUnregisteredConnections(void) {
                 continue;
             }
 
+            if (conn->type != HostConnectionType_BtHid && other->type != HostConnectionType_Dongle) {
+                continue;
+            }
+
             if (BtAddrEq(&conn->bleAddress, &other->bleAddress)) {
                 conn->type = HostConnectionType_Empty;
                 memset(&conn->bleAddress, 0, sizeof(bt_addr_le_t));

right/src/debug.h

@@ -36,6 +36,7 @@
 #include <stdint.h>
 #include "key_states.h"
 #include "hid/keyboard_report.h"
+#include "trace_defs.h"
 
 #if WATCHES
 
@@ -149,7 +150,7 @@
 #define WATCH_SEMAPHORE_TAKE(SEM, FILENAME, N) if(CurrentWatch == N) { WatchSemaforeTake(SEM, FILENAME, N); } else { k_sem_take(SEM, K_FOREVER); }
 #define SEM_TAKE(SEM) WATCH_SEMAPHORE_TAKE(SEM, __FILE__, 0)
 #else
-#define SEM_TAKE(SEM) k_sem_take(SEM, K_FOREVER)
+#define SEM_TAKE(SEM) if (k_sem_take(SEM, K_MSEC(128)) != 0) { uint8_t tgt = Cfg.DevMode ? LogTarget_Uart | LogTarget_ErrorBuffer : LogTarget_Uart; LogTo(DEVICE_ID, tgt, "Failed to take semaphore " #SEM " in file %s. This shouldn't have happened. Please report it!\n", __FILE__); Trace_Print(tgt, "Failed semaphore");  }
 #define WATCH_SEMAPHORE_TAKE(SEM, LABEL, N) k_sem_take(SEM, K_FOREVER);
 #endif
 

right/src/hid/transport.cpp

@@ -175,10 +175,10 @@ extern "C" errno_t Hid_SendKeyboardReport(const hid_keyboard_report_t *report)
 #endif
 #if DEVICE_IS_UHK80
     case ReportSink_Dongle:
-        // TODO: propagate underlying error up the stack
-        Messenger_Send2(DeviceId_Uhk_Dongle, MessageId_SyncableProperty,
-            SyncablePropertyId_KeyboardReport, (const uint8_t *)report, sizeof(*report));
-        err = 0;
+        err = Messenger_Send2(DeviceId_Uhk_Dongle, MessageId_SyncableProperty, SyncablePropertyId_KeyboardReport, (const uint8_t *)report, sizeof(*report));
+        if (err != 0) {
+            printk("Failed to send keyboard report to dongle: %d\n", err);
+        }
         break;
 #endif
     default:
@@ -218,10 +218,10 @@ extern "C" errno_t Hid_SendMouseReport(const hid_mouse_report_t *report)
 #endif
 #if DEVICE_IS_UHK80
     case ReportSink_Dongle:
-        // TODO: propagate underlying error up the stack
-        Messenger_Send2(DeviceId_Uhk_Dongle, MessageId_SyncableProperty,
-            SyncablePropertyId_MouseReport, (const uint8_t *)report, sizeof(*report));
-        err = 0;
+        err = Messenger_Send2(DeviceId_Uhk_Dongle, MessageId_SyncableProperty, SyncablePropertyId_MouseReport, (const uint8_t *)report, sizeof(*report));
+        if (err != 0) {
+            printk("Failed to send mouse report to dongle: %d\n", err);
+        }
         break;
 #endif
     default:
@@ -261,10 +261,10 @@ extern "C" errno_t Hid_SendControlsReport(const hid_controls_report_t *report)
 #endif
 #if DEVICE_IS_UHK80
     case ReportSink_Dongle:
-        // TODO: propagate underlying error up the stack
-        Messenger_Send2(DeviceId_Uhk_Dongle, MessageId_SyncableProperty,
-            SyncablePropertyId_ControlsReport, (const uint8_t *)report, sizeof(*report));
-        err = 0;
+        err = Messenger_Send2(DeviceId_Uhk_Dongle, MessageId_SyncableProperty, SyncablePropertyId_ControlsReport, (const uint8_t *)report, sizeof(*report));
+        if (err != 0) {
+            printk("Failed to send controls report to dongle: %d\n", err);
+        }
         break;
 #endif
     default: