Bump firmware version to 8.1.0 and update changelog, package.json, and versions.h

CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is loosely based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to the [UHK Versioning](VERSIONING.md) conventions.
 
+## [8.1.0] - 2018-01-15
+
+Device Protocol: 4.**2**.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0
+
+- Enable left-half watchdog in reinit mode which seems to prevent freezes.
+- Slow down main bus I2C baud rate to 30kHz when BusPal is on to make firmware transfer more robust.
+- Implement UsbCommandId_GetSlaveI2cErrors. `DEVICEPROTOCOL:MINOR`
+- Implement UsbCommandId_SetI2cBaudRate. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_CurrentKbootCommand. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_I2cMainBusBaudRate. `DEVICEPROTOCOL:MINOR`
+- Implement DevicePropertyId_Uptime. `DEVICEPROTOCOL:MINOR`
+
 ## [8.0.1] - 2017-12-25
 
 Device Protocol: 4.1.0 | Module Protocol: 4.0.0 | User Config: 4.0.0 | Hardware Config: 1.0.0

left/src/config.h

@@ -3,6 +3,11 @@
 
 // Macros:
 
+    #define I2C_WATCHDOG_VALUE_REINIT 1
+    #define I2C_WATCHDOG_VALUE_REBOOT 2
+
 //    #define DEBUG_OVER_SPI
+    #define I2C_WATCHDOG I2C_WATCHDOG_VALUE_REINIT
+//    #define I2C_WATCHDOG I2C_WATCHDOG_VALUE_REBOOT
 
 #endif

left/src/i2c_watchdog.c

@@ -3,42 +3,40 @@
 #include "i2c_watchdog.h"
 #include "test_led.h"
 #include "init_peripherals.h"
-#include "main.h"
+#include "config.h"
 
 /* NOTE: Because of a bug in the ROM bootloader of the KL03Z, the watchdog timer is disabled and cannot be re-enabled.
  * See https://community.nxp.com/thread/457893
  * Therefore the hardware watchdog timer cannot be used without an extra way to enter bootloader or application mode.
  */
-#if KEY_USE_I2C_WATCHDOG_TIMER
+#ifdef I2C_WATCHDOG
   static uint32_t prevWatchdogCounter = 0;
   static uint32_t I2cWatchdog_RecoveryCounter; /* counter for how many times we had to recover and restart */
-#endif
 
-void InitI2cWatchdog(void)
-{
-}
-
-#if KEY_USE_I2C_WATCHDOG_TIMER
 void RunWatchdog(void)
 {
-	static volatile uint32_t I2cWatchdog_WatchCounter = 0; /* counter for timer */
+    static volatile uint32_t I2cWatchdog_WatchCounter = 0; /* counter for timer */
-	static int cntr = 0;
+    static int cntr = 0;
 
-	cntr++;
+    cntr++;
-	if (cntr==100) { /* we get called from KEY_SCANNER_HANDLER() which runs at 1ms, thus scaling down by 100 here to get 100 ms period */
+    if (cntr==100) { /* we get called from KEY_SCANNER_HANDLER() which runs at 1ms, thus scaling down by 100 here to get 100 ms period */
-		cntr=0;
+        cntr=0;
-		TEST_LED_TOGGLE();
+        TEST_LED_TOGGLE();
-		I2cWatchdog_WatchCounter++;
+        I2cWatchdog_WatchCounter++;
 
-		if (I2cWatchdog_WatchCounter>10) { /* do not check within the first 1000 ms, as I2C might not be running yet */
+        if (I2cWatchdog_WatchCounter>10) { /* do not check within the first 1000 ms, as I2C might not be running yet */
-			if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there hasn't been any interrupt during 100 ms. I2C_Watchdog gets incremented for every I2C transaction
+            if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there hasn't been any interrupt during 100 ms. I2C_Watchdog gets incremented for every I2C transaction
-		//        NVIC_SystemReset();
+                I2cWatchdog_RecoveryCounter++;
-				I2cWatchdog_RecoveryCounter++;
+#if I2C_WATCHDOG == I2C_WATCHDOG_VALUE_REBOOT
-				I2C_SlaveDeinit(I2C_BUS_BASEADDR);
+                NVIC_SystemReset();
-				InitI2c();
+#endif
-			}
+#if I2C_WATCHDOG == I2C_WATCHDOG_VALUE_REINIT
-		}
+                I2C_SlaveDeinit(I2C_BUS_BASEADDR);
-		prevWatchdogCounter = I2C_Watchdog; /* remember previous counter */
+                initI2c();
-	}
+#endif
+            }
+        }
+        prevWatchdogCounter = I2C_Watchdog; /* remember previous counter */
+    }
 }
 #endif

left/src/i2c_watchdog.h

@@ -13,7 +13,6 @@
 
 // Functions:
 
-    void InitI2cWatchdog(void);
     void RunWatchdog(void);
 
 #endif

left/src/init_peripherals.c

@@ -45,14 +45,14 @@ static void i2cSlaveCallback(I2C_Type *base, i2c_slave_transfer_t *xfer, void *u
     }
 }
 
-void InitInterruptPriorities(void)
+void initInterruptPriorities(void)
 {
     NVIC_SetPriority(I2C0_IRQn, 1);
     NVIC_SetPriority(TPM1_IRQn, 1);
     NVIC_SetPriority(SPI0_IRQn, 1);
 }
 
-void InitI2c(void)
+void initI2c(void)
 {
     port_pin_config_t pinConfig = {
         .pullSelect = kPORT_PullUp,
@@ -82,13 +82,10 @@ void InitLedDriver(void)
 
 void InitPeripherals(void)
 {
-    InitInterruptPriorities();
+    initInterruptPriorities();
     InitLedDriver();
     InitTestLed();
     LedPwm_Init();
     DebugOverSpi_Init();
-    InitI2c();
+    initI2c();
-#if KEY_USE_I2C_WATCHDOG_TIMER
-    InitI2cWatchdog();
-#endif
 }

left/src/init_peripherals.h

@@ -11,6 +11,6 @@
 // Functions:
 
     void InitPeripherals(void);
-    void InitI2c(void);
+    void initI2c(void);
 
 #endif

left/src/key_scanner.c

@@ -1,14 +1,12 @@
 #include "fsl_lptmr.h"
 #include "key_scanner.h"
-#include "main.h"
+#include "config.h"
-#if KEY_USE_I2C_WATCHDOG_TIMER
+#include "i2c_watchdog.h"
-  #include "i2c_watchdog.h"
-#endif
 
 void KEY_SCANNER_HANDLER(void)
 {
     KeyMatrix_ScanRow(&keyMatrix);
-#if KEY_USE_I2C_WATCHDOG_TIMER
+#ifdef I2C_WATCHDOG
     RunWatchdog();
 #endif
     LPTMR_ClearStatusFlags(KEY_SCANNER_LPTMR_BASEADDR, kLPTMR_TimerCompareFlag);

left/src/main.h

@@ -14,6 +14,4 @@
 
     extern key_matrix_t keyMatrix;
 
-   #define KEY_USE_I2C_WATCHDOG_TIMER   (1) /* if set to 1, every 100 ms the I2C communication is checked */
-
 #endif

right/src/config.h

@@ -4,6 +4,7 @@
 // Macros:
 
     #define I2C_WATCHDOG
+    #define LED_DRIVERS_ENABLED
 //    #define LED_DRIVER_STRESS_TEST
 
 #endif

right/src/config_parser/parse_config.c

@@ -8,6 +8,7 @@
 #include "led_display.h"
 #include "slave_scheduler.h"
 #include "slave_drivers/is31fl3731_driver.h"
+#include "config.h"
 
 static parser_error_t parseModuleConfiguration(config_buffer_t *buffer)
 {
@@ -142,9 +143,10 @@ parser_error_t ParseConfig(config_buffer_t *buffer)
         IconsAndLayerTextsBrightness = iconsAndLayerTextsBrightness;
         AlphanumericSegmentsBrightness = alphanumericSegmentsBrightness;
         KeyBacklightBrightness = keyBacklightBrightness;
+#ifdef LED_DRIVERS_ENABLED
         Slaves[SlaveId_LeftLedDriver].isConnected = false;
         Slaves[SlaveId_RightLedDriver].isConnected = false;
-
+#endif
         // Update mouse key speeds
 
         MouseMoveState.initialSpeed = mouseMoveInitialSpeed;

right/src/i2c.h

@@ -10,11 +10,12 @@
 
     // Main bus
 
-    #define I2C_MAIN_BUS_BASEADDR  I2C0
+    #define I2C_MAIN_BUS_BASEADDR         I2C0
-    #define I2C_MAIN_BUS_IRQ_ID    I2C0_IRQn
+    #define I2C_MAIN_BUS_IRQ_ID           I2C0_IRQn
-    #define I2C_MAIN_BUS_CLK_SRC   I2C0_CLK_SRC
+    #define I2C_MAIN_BUS_CLK_SRC          I2C0_CLK_SRC
-    #define I2C_MAIN_BUS_BAUD_RATE 100000  // 100 kHz works even with a 20 meter long bridge cable.
+    #define I2C_MAIN_BUS_NORMAL_BAUD_RATE 100000
-    #define I2C_MAIN_BUS_MUX       kPORT_MuxAlt7
+    #define I2C_MAIN_BUS_BUSPAL_BAUD_RATE 30000
+    #define I2C_MAIN_BUS_MUX              kPORT_MuxAlt7
 
     #define I2C_MAIN_BUS_SDA_GPIO  GPIOD
     #define I2C_MAIN_BUS_SDA_PORT  PORTD

right/src/i2c_error_logger.c

@@ -0,0 +1,25 @@
+#include "fsl_i2c.h"
+#include "i2c_error_logger.h"
+
+i2c_slave_error_counter_t I2cSlaveErrorCounters[MAX_SLAVE_COUNT];
+
+void LogI2cError(uint8_t slaveId, status_t status)
+{
+    i2c_slave_error_counter_t *i2cSlaveErrorCounter = I2cSlaveErrorCounters + slaveId;
+    uint8_t errorIdx;
+
+    for (errorIdx=0; errorIdx<i2cSlaveErrorCounter->errorTypeCount; errorIdx++) {
+        i2c_error_count_t *currentI2cError = i2cSlaveErrorCounter->errors + errorIdx;
+        if (currentI2cError->status == status) {
+            currentI2cError->count++;
+            break;
+        }
+    }
+
+    if (errorIdx == i2cSlaveErrorCounter->errorTypeCount && errorIdx < MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE) {
+        i2cSlaveErrorCounter->errorTypeCount++;
+        i2c_error_count_t *currentI2cError = i2cSlaveErrorCounter->errors + errorIdx;
+        currentI2cError->status = status;
+        currentI2cError->count = 1;
+    }
+}

right/src/i2c_error_logger.h

@@ -0,0 +1,33 @@
+#ifndef __I2C_ERROR_LOGGER_H__
+#define __I2C_ERROR_LOGGER_H__
+
+// Includes:
+
+    #include "fsl_common.h"
+    #include "slave_scheduler.h"
+
+// Macros:
+
+    #define MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE 7
+
+// Typedefs:
+
+    typedef struct {
+        status_t status;
+        uint32_t count;
+    } i2c_error_count_t;
+
+    typedef struct {
+        uint8_t errorTypeCount;
+        i2c_error_count_t errors[MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE];
+    } i2c_slave_error_counter_t;
+
+// Variables:
+
+    extern i2c_slave_error_counter_t I2cSlaveErrorCounters[MAX_SLAVE_COUNT];
+
+// Functions:
+
+    void LogI2cError(uint8_t slaveId, status_t status);
+
+#endif

right/src/i2c_watchdog.c

@@ -5,7 +5,6 @@
 #include "fsl_gpio.h"
 #include "i2c.h"
 #include "i2c_watchdog.h"
-#include "slave_scheduler.h"
 #include "init_peripherals.h"
 
 uint32_t I2cWatchdog_WatchCounter;
@@ -19,17 +18,13 @@ static uint32_t prevWatchdogCounter;
 void PIT_I2C_WATCHDOG_HANDLER(void)
 {
     I2cWatchdog_WatchCounter++;
+
     if (I2C_Watchdog == prevWatchdogCounter) { // Restart I2C if there haven't been any interrupts recently
         I2cWatchdog_RecoveryCounter++;
-        i2c_master_config_t masterConfig;
+        ReinitI2cMainBus();
-        I2C_MasterGetDefaultConfig(&masterConfig);
-        I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
-        InitI2cMainBus();
-        InitSlaveScheduler();
     }
 
     prevWatchdogCounter = I2C_Watchdog;
-
     PIT_ClearStatusFlags(PIT, PIT_I2C_WATCHDOG_CHANNEL, PIT_TFLG_TIF_MASK);
 }
 

right/src/init_peripherals.c

@@ -14,8 +14,22 @@
 #include "timer.h"
 #include "key_debouncer.h"
 #include "usb_api.h"
+#include "slave_scheduler.h"
+#include "bootloader/wormhole.h"
 
-void InitInterruptPriorities(void)
+bool IsBusPalOn;
+uint32_t I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_NORMAL_BAUD_RATE;
+uint32_t I2cMainBusActualBaudRateBps;
+
+void initBusPalState(void) {
+    IsBusPalOn = Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal;
+    if (IsBusPalOn) {
+        Wormhole.magicNumber = 0;
+        I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_BUSPAL_BAUD_RATE;
+    }
+}
+
+void initInterruptPriorities(void)
 {
     NVIC_SetPriority(PIT_I2C_WATCHDOG_IRQ_ID,  1);
     NVIC_SetPriority(PIT_TIMER_IRQ_ID,         2);
@@ -60,7 +74,7 @@ void recoverI2c(void)
     delay();
 }
 
-void InitI2cMainBus(void)
+void initI2cMainBus(void)
 {
     CLOCK_EnableClock(I2C_MAIN_BUS_SDA_CLOCK);
     CLOCK_EnableClock(I2C_MAIN_BUS_SCL_CLOCK);
@@ -78,9 +92,17 @@ void InitI2cMainBus(void)
 
     i2c_master_config_t masterConfig;
     I2C_MasterGetDefaultConfig(&masterConfig);
-    masterConfig.baudRate_Bps = I2C_MAIN_BUS_BAUD_RATE;
+    masterConfig.baudRate_Bps = I2cMainBusRequestedBaudRateBps;
     uint32_t sourceClock = CLOCK_GetFreq(I2C_MAIN_BUS_CLK_SRC);
     I2C_MasterInit(I2C_MAIN_BUS_BASEADDR, &masterConfig, sourceClock);
+    I2cMainBusActualBaudRateBps = I2C_ActualBaudRate;
+}
+
+void ReinitI2cMainBus(void)
+{
+    I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
+    initI2cMainBus();
+    InitSlaveScheduler();
 }
 
 void initI2cEepromBus(void)
@@ -91,7 +113,6 @@ void initI2cEepromBus(void)
        .mux = I2C_EEPROM_BUS_MUX,
    };
 
-
    CLOCK_EnableClock(I2C_EEPROM_BUS_SDA_CLOCK);
    CLOCK_EnableClock(I2C_EEPROM_BUS_SCL_CLOCK);
 
@@ -105,21 +126,22 @@ void initI2cEepromBus(void)
    I2C_MasterInit(I2C_EEPROM_BUS_BASEADDR, &masterConfig, sourceClock);
 }
 
-void InitI2c(void)
+void initI2c(void)
 {
-    InitI2cMainBus();
+    initI2cMainBus();
     initI2cEepromBus();
 }
 
 void InitPeripherals(void)
 {
-    InitInterruptPriorities();
+    initBusPalState();
+    initInterruptPriorities();
     Timer_Init();
     InitLedDriver();
     InitResetButton();
     InitMergeSensor();
     ADC_Init();
-    InitI2c();
+    initI2c();
     InitTestLed();
     LedPwm_Init();
 #ifdef I2C_WATCHDOG

right/src/init_peripherals.h

@@ -5,9 +5,15 @@
 
     #include "fsl_common.h"
 
+// Variables:
+
+    extern bool IsBusPalOn;
+    extern uint32_t I2cMainBusRequestedBaudRateBps;
+    extern uint32_t I2cMainBusActualBaudRateBps;
+
 // Functions:
 
     void InitPeripherals(void);
-    void InitI2cMainBus(void);
+    void ReinitI2cMainBus(void);
 
 #endif

right/src/main.c

@@ -5,7 +5,6 @@
 #include "slave_scheduler.h"
 #include "bus_pal_hardware.h"
 #include "command.h"
-#include "bootloader/wormhole.h"
 #include "eeprom.h"
 #include "key_scanner.h"
 #include "usb_commands/usb_command_apply_config.h"
@@ -34,8 +33,7 @@ void main(void)
         EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_HardwareConfig, hardwareConfigurationReadFinished);
     }
 
-    if (Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal) {
+    if (IsBusPalOn) {
-        Wormhole.magicNumber = 0;
         init_hardware();
         handleUsbBusPalCommand();
     } else {

right/src/slave_drivers/kboot_driver.c

@@ -4,7 +4,7 @@
 
 kboot_driver_state_t KbootDriverState;
 
-static uint8_t rxBuffer[MAX_KBOOT_COMMAND_LENGTH];
+static uint8_t rxBuffer[KBOOT_PACKAGE_MAX_LENGTH];
 static uint8_t pingCommand[] = {0x5a, 0xa6};
 static uint8_t resetCommand[] = {0x5a, 0xa4, 0x04, 0x00, 0x6f, 0x46, 0x0b, 0x00, 0x00, 0x00};
 static uint8_t ackMessage[] = {0x5a, 0xa1};
@@ -27,50 +27,52 @@ status_t KbootSlaveDriver_Update(uint8_t kbootInstanceId)
 {
     status_t status = kStatus_Uhk_IdleSlave;
 
-    switch (KbootDriverState.commandType) {
+    switch (KbootDriverState.command) {
         case KbootCommand_Idle:
             break;
         case KbootCommand_Ping:
             switch (KbootDriverState.phase) {
-                case 0:
+                case KbootPhase_SendPing:
                     status = tx(pingCommand, sizeof(pingCommand));
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_CheckPingStatus;
                     break;
-                case 1:
+                case KbootPhase_CheckPingStatus:
                     KbootDriverState.status = Slaves[SlaveId_KbootDriver].previousStatus;
-                    KbootDriverState.phase = KbootDriverState.status == kStatus_Success ? 2 : 0;
+                    KbootDriverState.phase = KbootDriverState.status == kStatus_Success
-                    return kStatus_Uhk_NoTransfer;
+                        ? KbootPhase_ReceivePingResponse
-                case 2:
+                        : KbootPhase_SendPing;
-                    status = rx(10);
+                    return kStatus_Uhk_IdleCycle;
-                    KbootDriverState.phase++;
+                case KbootPhase_ReceivePingResponse:
+                    status = rx(KBOOT_PACKAGE_LENGTH_PING_RESPONSE);
+                    KbootDriverState.phase = KbootPhase_CheckPingResponseStatus;
                     break;
-                case 3:
+                case KbootPhase_CheckPingResponseStatus:
                     KbootDriverState.status = Slaves[SlaveId_KbootDriver].previousStatus;
                     if (KbootDriverState.status == kStatus_Success) {
-                        KbootDriverState.commandType = KbootCommand_Idle;
+                        KbootDriverState.command = KbootCommand_Idle;
                     } else {
-                        KbootDriverState.phase = 0;
+                        KbootDriverState.phase = KbootPhase_SendPing;
-                        return kStatus_Uhk_NoTransfer;
+                        return kStatus_Uhk_IdleCycle;
                     }
                 }
             break;
         case KbootCommand_Reset:
             switch (KbootDriverState.phase) {
-                case 0:
+                case KbootPhase_SendReset:
                     status = tx(resetCommand, sizeof(resetCommand));
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_ReceiveResetAck;
                     break;
-                case 1:
+                case KbootPhase_ReceiveResetAck:
-                    status = rx(2);
+                    status = rx(KBOOT_PACKAGE_LENGTH_ACK);
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_ReceiveResetGenericResponse;
                     break;
-                case 2:
+                case KbootPhase_ReceiveResetGenericResponse:
-                    status = rx(18);
+                    status = rx(KBOOT_PACKAGE_LENGTH_GENERIC_RESPONSE);
-                    KbootDriverState.phase++;
+                    KbootDriverState.phase = KbootPhase_CheckResetSendAck;
                     break;
-                case 3:
+                case KbootPhase_CheckResetSendAck:
                     status = tx(ackMessage, sizeof(ackMessage));
-                    KbootDriverState.commandType = KbootCommand_Idle;
+                    KbootDriverState.command = KbootCommand_Idle;
                     break;
             }
             break;

right/src/slave_drivers/kboot_driver.h

@@ -7,7 +7,10 @@
 
 // Macros:
 
-    #define MAX_KBOOT_COMMAND_LENGTH 32
+    #define KBOOT_PACKAGE_MAX_LENGTH 32
+    #define KBOOT_PACKAGE_LENGTH_PING_RESPONSE 10
+    #define KBOOT_PACKAGE_LENGTH_ACK 2
+    #define KBOOT_PACKAGE_LENGTH_GENERIC_RESPONSE 18
 
 // Typedefs:
 
@@ -21,8 +24,22 @@
         KbootCommand_Reset,
     } kboot_command_t;
 
+    typedef enum {
+        KbootPhase_SendPing,
+        KbootPhase_CheckPingStatus,
+        KbootPhase_ReceivePingResponse,
+        KbootPhase_CheckPingResponseStatus,
+    } kboot_ping_phase_t;
+
+    typedef enum {
+        KbootPhase_SendReset,
+        KbootPhase_ReceiveResetAck,
+        KbootPhase_ReceiveResetGenericResponse,
+        KbootPhase_CheckResetSendAck,
+    } kboot_reset_phase_t;
+
     typedef struct {
-        kboot_command_t commandType;
+        kboot_command_t command;
         uint8_t i2cAddress;
         uint8_t phase;
         uint32_t status;

right/src/slave_drivers/uhk_module_driver.c

@@ -91,7 +91,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
         case UhkModulePhase_ProcessSync: {
             bool isMessageValid = CRC16_IsMessageValid(rxMessage);
             bool isSyncValid = memcmp(rxMessage->data, SlaveSyncString, SLAVE_SYNC_STRING_LENGTH) == 0;
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = isSyncValid && isMessageValid
                 ? UhkModulePhase_RequestModuleProtocolVersion
                 : UhkModulePhase_RequestSync;
@@ -115,7 +115,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
             if (isMessageValid) {
                 memcpy(&uhkModuleState->moduleProtocolVersion, rxMessage->data, sizeof(version_t));
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestFirmwareVersion : UhkModulePhase_RequestModuleProtocolVersion;
             break;
         }
@@ -137,7 +137,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
             if (isMessageValid) {
                 memcpy(&uhkModuleState->firmwareVersion, rxMessage->data, sizeof(version_t));
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleId : UhkModulePhase_RequestFirmwareVersion;
             break;
         }
@@ -159,7 +159,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
             if (isMessageValid) {
                 uhkModuleState->moduleId = rxMessage->data[0];
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModuleKeyCount : UhkModulePhase_RequestModuleId;
             break;
         }
@@ -181,7 +181,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
             if (isMessageValid) {
                 uhkModuleState->keyCount = rxMessage->data[0];
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestModulePointerCount : UhkModulePhase_RequestModuleKeyCount;
             break;
         }
@@ -203,7 +203,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
             if (isMessageValid) {
                 uhkModuleState->pointerCount = rxMessage->data[0];
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = isMessageValid ? UhkModulePhase_RequestKeyStates : UhkModulePhase_RequestModulePointerCount;
             break;
         }
@@ -227,14 +227,14 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
                     KeyStates[slotId][keyId].current = keyStatesBuffer[keyId];
                 }
             }
-            status = kStatus_Uhk_NoTransfer;
+            status = kStatus_Uhk_IdleCycle;
             *uhkModulePhase = UhkModulePhase_SetTestLed;
             break;
 
         // Set test LED
         case UhkModulePhase_SetTestLed:
             if (uhkModuleSourceVars->isTestLedOn == uhkModuleTargetVars->isTestLedOn) {
-                status = kStatus_Uhk_NoTransfer;
+                status = kStatus_Uhk_IdleCycle;
             } else {
                 txMessage.data[0] = SlaveCommand_SetTestLed;
                 txMessage.data[1] = uhkModuleSourceVars->isTestLedOn;
@@ -248,7 +248,7 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
         // Set PWM brightness
         case UhkModulePhase_SetLedPwmBrightness:
             if (uhkModuleSourceVars->ledPwmBrightness == uhkModuleTargetVars->ledPwmBrightness) {
-                status = kStatus_Uhk_NoTransfer;
+                status = kStatus_Uhk_IdleCycle;
             } else {
                 txMessage.data[0] = SlaveCommand_SetLedPwmBrightness;
                 txMessage.data[1] = uhkModuleSourceVars->ledPwmBrightness;
@@ -265,8 +265,10 @@ status_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
 
 void UhkModuleSlaveDriver_Disconnect(uint8_t uhkModuleDriverId)
 {
+#ifdef LED_DRIVERS_ENABLED
     if (uhkModuleDriverId == SlaveId_LeftKeyboardHalf) {
         Slaves[SlaveId_LeftLedDriver].isConnected = false;
     }
     UhkModuleStates[uhkModuleDriverId].moduleId = 0;
+#endif
 }

right/src/slave_scheduler.c

@@ -6,6 +6,8 @@
 #include "slave_drivers/kboot_driver.h"
 #include "i2c.h"
 #include "i2c_addresses.h"
+#include "config.h"
+#include "i2c_error_logger.h"
 
 uint32_t I2cSlaveScheduler_Counter;
 
@@ -29,6 +31,7 @@ uhk_slave_t Slaves[] = {
         .update = UhkModuleSlaveDriver_Update,
         .perDriverId = UhkModuleDriverId_RightAddon,
     },
+#ifdef LED_DRIVERS_ENABLED
     {
         .init = LedSlaveDriver_Init,
         .update = LedSlaveDriver_Update,
@@ -39,6 +42,7 @@ uhk_slave_t Slaves[] = {
         .update = LedSlaveDriver_Update,
         .perDriverId = LedDriverId_Left,
     },
+#endif
     {
         .init = KbootSlaveDriver_Init,
         .update = KbootSlaveDriver_Update,
@@ -48,23 +52,27 @@ uhk_slave_t Slaves[] = {
 
 static void slaveSchedulerCallback(I2C_Type *base, i2c_master_handle_t *handle, status_t previousStatus, void *userData)
 {
-    bool isFirstIteration = true;
+    bool isFirstCycle = true;
     bool isTransferScheduled = false;
     I2cSlaveScheduler_Counter++;
 
     do {
-        uhk_slave_t *previousSlave = Slaves + previousSlaveId;
         uhk_slave_t *currentSlave = Slaves + currentSlaveId;
 
-        previousSlave->previousStatus = previousStatus;
+        if (isFirstCycle) {
+            uhk_slave_t *previousSlave = Slaves + previousSlaveId;
+            previousSlave->previousStatus = previousStatus;
+            if (IS_STATUS_I2C_ERROR(previousStatus)) {
+                LogI2cError(previousSlaveId, previousStatus);
+            }
 
-        if (isFirstIteration) {
             bool wasPreviousSlaveConnected = previousSlave->isConnected;
             previousSlave->isConnected = previousStatus == kStatus_Success;
             if (wasPreviousSlaveConnected && !previousSlave->isConnected && previousSlave->disconnect) {
                 previousSlave->disconnect(previousSlaveId);
             }
-            isFirstIteration = false;
+
+            isFirstCycle = false;
         }
 
         if (!currentSlave->isConnected) {
@@ -72,18 +80,21 @@ static void slaveSchedulerCallback(I2C_Type *base, i2c_master_handle_t *handle,
         }
 
         status_t currentStatus = currentSlave->update(currentSlave->perDriverId);
-        isTransferScheduled = currentStatus != kStatus_Uhk_IdleSlave && currentStatus != kStatus_Uhk_NoTransfer;
+        if (IS_STATUS_I2C_ERROR(currentStatus)) {
+            LogI2cError(currentSlaveId, currentStatus);
+        }
+        isTransferScheduled = currentStatus != kStatus_Uhk_IdleSlave && currentStatus != kStatus_Uhk_IdleCycle;
         if (isTransferScheduled) {
             currentSlave->isConnected = true;
         }
 
-        if (currentStatus != kStatus_Uhk_NoTransfer) {
+        if (currentStatus != kStatus_Uhk_IdleCycle) {
             previousSlaveId = currentSlaveId++;
+            if (currentSlaveId >= SLAVE_COUNT) {
+                currentSlaveId = 0;
+            }
         }
 
-        if (currentSlaveId >= (sizeof(Slaves) / sizeof(uhk_slave_t))) {
-            currentSlaveId = 0;
-        }
     } while (!isTransferScheduled);
 }
 
@@ -92,7 +103,7 @@ void InitSlaveScheduler(void)
     previousSlaveId = 0;
     currentSlaveId = 0;
 
-    for (uint8_t i=0; i<sizeof(Slaves) / sizeof(uhk_slave_t); i++) {
+    for (uint8_t i=0; i<SLAVE_COUNT; i++) {
         uhk_slave_t *currentSlave = Slaves + i;
         currentSlave->isConnected = false;
     }

right/src/slave_scheduler.h

@@ -4,6 +4,14 @@
 // Includes:
 
     #include "fsl_common.h"
+    #include "config.h"
+
+// Macros:
+
+    #define SLAVE_COUNT (sizeof(Slaves) / sizeof(uhk_slave_t))
+    #define MAX_SLAVE_COUNT 6
+    #define IS_VALID_SLAVE_ID(slaveId) (0 <= slaveId && slaveId <= MAX_SLAVE_COUNT)
+    #define IS_STATUS_I2C_ERROR(status) (kStatus_I2C_Busy <= status && status <= kStatus_I2C_Timeout)
 
 // Typedefs:
 
@@ -11,8 +19,10 @@
         SlaveId_LeftKeyboardHalf,
         SlaveId_LeftAddon,
         SlaveId_RightAddon,
+#ifdef LED_DRIVERS_ENABLED
         SlaveId_RightLedDriver,
         SlaveId_LeftLedDriver,
+#endif
         SlaveId_KbootDriver,
     } slave_id_t;
 
@@ -30,12 +40,12 @@
     } uhk_slave_t;
 
     typedef enum {
-        kStatusGroup_Uhk = -1,
+        kStatusGroup_Uhk = 200,
     } uhk_status_group_t;
 
     typedef enum {
-        kStatus_Uhk_IdleSlave  = MAKE_STATUS(kStatusGroup_Uhk, 0), // Another slave should be scheduled
+        kStatus_Uhk_IdleSlave = MAKE_STATUS(kStatusGroup_Uhk, 0), // Another slave should be scheduled
-        kStatus_Uhk_NoTransfer = MAKE_STATUS(kStatusGroup_Uhk, 1), // The same slave should be rescheduled
+        kStatus_Uhk_IdleCycle = MAKE_STATUS(kStatusGroup_Uhk, 1), // The same slave should be rescheduled
     } uhk_status_t;
 
 // Variables:

right/src/usb_commands/usb_command_get_device_property.c

@@ -3,6 +3,11 @@
 #include "usb_protocol_handler.h"
 #include "eeprom.h"
 #include "versions.h"
+#include "slave_drivers/kboot_driver.h"
+#include "i2c.h"
+#include "init_peripherals.h"
+#include "fsl_i2c.h"
+#include "timer.h"
 
 version_t deviceProtocolVersion = {
     DEVICE_PROTOCOL_MAJOR_VERSION,
@@ -55,6 +60,17 @@ void UsbCommand_GetDeviceProperty(void)
         case DevicePropertyId_ConfigSizes:
             memcpy(GenericHidOutBuffer+1, (uint8_t*)&configSizes, sizeof(configSizes));
             break;
+        case DevicePropertyId_CurrentKbootCommand:
+            GenericHidOutBuffer[1] = KbootDriverState.command;
+            break;
+        case DevicePropertyId_I2cMainBusBaudRate:
+            GenericHidOutBuffer[1] = I2C_MAIN_BUS_BASEADDR->F;
+            SetUsbTxBufferUint32(2, I2cMainBusRequestedBaudRateBps);
+            SetUsbTxBufferUint32(6, I2cMainBusActualBaudRateBps);
+            break;
+        case DevicePropertyId_Uptime:
+            SetUsbTxBufferUint32(1, CurrentTime);
+            break;
         default:
             SetUsbTxBufferUint8(0, UsbStatusCode_GetDeviceProperty_InvalidProperty);
             break;

right/src/usb_commands/usb_command_get_device_property.h

@@ -7,7 +7,10 @@
         DevicePropertyId_DeviceProtocolVersion = 0,
         DevicePropertyId_ProtocolVersions      = 1,
         DevicePropertyId_ConfigSizes           = 2,
-    } system_property_t;
+        DevicePropertyId_CurrentKbootCommand   = 3,
+        DevicePropertyId_I2cMainBusBaudRate    = 4,
+        DevicePropertyId_Uptime                = 5,
+    } device_property_t;
 
     typedef enum {
         UsbStatusCode_GetDeviceProperty_InvalidProperty = 2,

right/src/usb_commands/usb_command_get_module_property.c

@@ -12,10 +12,15 @@ void UsbCommand_GetModuleProperty()
         SetUsbTxBufferUint8(0, UsbStatusCode_GetModuleProperty_InvalidModuleSlotId);
     }
 
-    uint8_t moduleDriverId = SLOT_ID_TO_UHK_MODULE_DRIVER_ID(slotId);
+    module_property_id_t modulePropertyId = GetUsbRxBufferUint8(2);
-    uhk_module_state_t *moduleState = UhkModuleStates + moduleDriverId;
+    switch (modulePropertyId) {
-
+        case ModulePropertyId_VersionNumbers: {
-    GenericHidOutBuffer[1] = moduleState->moduleId;
+            uint8_t moduleDriverId = SLOT_ID_TO_UHK_MODULE_DRIVER_ID(slotId);
-    memcpy(GenericHidOutBuffer + 2, &moduleState->moduleProtocolVersion, sizeof(version_t));
+            uhk_module_state_t *moduleState = UhkModuleStates + moduleDriverId;
-    memcpy(GenericHidOutBuffer + 2 + sizeof(version_t), &moduleState->firmwareVersion, sizeof(version_t));
+            GenericHidOutBuffer[1] = moduleState->moduleId;
+            memcpy(GenericHidOutBuffer + 2, &moduleState->moduleProtocolVersion, sizeof(version_t));
+            memcpy(GenericHidOutBuffer + 8, &moduleState->firmwareVersion, sizeof(version_t));
+            break;
+        }
+    }
 }

right/src/usb_commands/usb_command_get_module_property.h

@@ -7,6 +7,10 @@
 
 // Typedefs:
 
+    typedef enum {
+        ModulePropertyId_VersionNumbers = 0,
+    } module_property_id_t;
+
     typedef enum {
         UsbStatusCode_GetModuleProperty_InvalidModuleSlotId = 2,
     } usb_status_code_get_module_property_t;

right/src/usb_commands/usb_command_get_slave_i2c_errors.c

@@ -0,0 +1,19 @@
+#include "fsl_common.h"
+#include "usb_commands/usb_command_get_slave_i2c_errors.h"
+#include "usb_protocol_handler.h"
+#include "slave_scheduler.h"
+#include "i2c_error_logger.h"
+
+void UsbCommand_GetSlaveI2cErrors()
+{
+    uint8_t slaveId = GetUsbRxBufferUint8(1);
+
+    if (!IS_VALID_SLAVE_ID(slaveId)) {
+        SetUsbTxBufferUint8(0, UsbStatusCode_GetModuleProperty_InvalidSlaveId);
+    }
+
+    i2c_slave_error_counter_t *i2cSlaveErrorCounter =  I2cSlaveErrorCounters + slaveId;
+
+    GenericHidOutBuffer[1] = i2cSlaveErrorCounter->errorTypeCount;
+    memcpy(GenericHidOutBuffer + 2, i2cSlaveErrorCounter->errors, sizeof(i2c_error_count_t) * MAX_LOGGED_I2C_ERROR_TYPES_PER_SLAVE);
+}

right/src/usb_commands/usb_command_get_slave_i2c_errors.h

@@ -0,0 +1,14 @@
+#ifndef __USB_COMMAND_GET_SLAVE_I2C_ERRORS_H__
+#define __USB_COMMAND_GET_SLAVE_I2C_ERRORS_H__
+
+// Functions:
+
+    void UsbCommand_GetSlaveI2cErrors();
+
+// Typedefs:
+
+    typedef enum {
+        UsbStatusCode_GetModuleProperty_InvalidSlaveId = 2,
+    } usb_status_code_get_slave_i2c_errors_t;
+
+#endif

right/src/usb_commands/usb_command_send_kboot_command_to_module.c

@@ -6,5 +6,5 @@ void UsbCommand_SendKbootCommandToModule(void)
 {
     KbootDriverState.phase = 0;
     KbootDriverState.i2cAddress  = GetUsbRxBufferUint8(2);
-    KbootDriverState.commandType = GetUsbRxBufferUint8(1); // Command should be set last.
+    KbootDriverState.command = GetUsbRxBufferUint8(1); // Command should be set last.
 }

right/src/usb_commands/usb_command_set_i2c_baud_rate.c

@@ -0,0 +1,11 @@
+#include "usb_protocol_handler.h"
+#include "usb_commands/usb_command_set_i2c_baud_rate.h"
+#include "init_peripherals.h"
+#include "fsl_i2c.h"
+
+void UsbCommand_SetI2cBaudRate(void)
+{
+    uint32_t i2cBaudRate = GetUsbRxBufferUint32(1);
+    I2cMainBusRequestedBaudRateBps = i2cBaudRate;
+    ReinitI2cMainBus();
+}

right/src/usb_commands/usb_command_set_i2c_baud_rate.h

@@ -0,0 +1,8 @@
+#ifndef __USB_COMMAND_SET_I2C_BAUD_RATE__
+#define __USB_COMMAND_SET_I2C_BAUD_RATE__
+
+// Functions:
+
+    void UsbCommand_SetI2cBaudRate(void);
+
+#endif

right/src/usb_protocol_handler.c

@@ -14,6 +14,8 @@
 #include "usb_commands/usb_command_get_debug_buffer.h"
 #include "usb_commands/usb_command_jump_to_module_bootloader.h"
 #include "usb_commands/usb_command_send_kboot_command_to_module.h"
+#include "usb_commands/usb_command_get_slave_i2c_errors.h"
+#include "usb_commands/usb_command_set_i2c_baud_rate.h"
 
 void UsbProtocolHandler(void)
 {
@@ -65,6 +67,12 @@ void UsbProtocolHandler(void)
         case UsbCommandId_GetModuleProperty:
             UsbCommand_GetModuleProperty();
             break;
+        case UsbCommandId_GetSlaveI2cErrors:
+            UsbCommand_GetSlaveI2cErrors();
+            break;
+        case UsbCommandId_SetI2cBaudRate:
+            UsbCommand_SetI2cBaudRate();
+            break;
         default:
             SetUsbTxBufferUint8(0, UsbStatusCode_InvalidCommand);
             break;

right/src/usb_protocol_handler.h

@@ -31,6 +31,8 @@
         UsbCommandId_GetAdcValue              = 0x0c,
         UsbCommandId_SetLedPwmBrightness      = 0x0d,
         UsbCommandId_GetModuleProperty        = 0x0e,
+        UsbCommandId_GetSlaveI2cErrors        = 0x0f,
+        UsbCommandId_SetI2cBaudRate           = 0x10,
     } usb_command_id_t;
 
     typedef enum {

scripts/package.json

@@ -15,8 +15,8 @@
     "commander": "^2.11.0",
     "shelljs": "^0.7.8"
   },
-  "firmwareVersion": "8.0.1",
+  "firmwareVersion": "8.1.0",
-  "deviceProtocolVersion": "4.1.0",
+  "deviceProtocolVersion": "4.2.0",
   "moduleProtocolVersion": "4.0.0",
   "userConfigVersion": "4.0.0",
   "hardwareConfigVersion": "1.0.0",

shared/versions.h

@@ -19,11 +19,11 @@
 // Variables:
 
     #define FIRMWARE_MAJOR_VERSION 8
-    #define FIRMWARE_MINOR_VERSION 0
+    #define FIRMWARE_MINOR_VERSION 1
-    #define FIRMWARE_PATCH_VERSION 1
+    #define FIRMWARE_PATCH_VERSION 0
 
     #define DEVICE_PROTOCOL_MAJOR_VERSION 4
-    #define DEVICE_PROTOCOL_MINOR_VERSION 1
+    #define DEVICE_PROTOCOL_MINOR_VERSION 2
     #define DEVICE_PROTOCOL_PATCH_VERSION 0
 
     #define MODULE_PROTOCOL_MAJOR_VERSION 4