Check for serial connection lost (#213)

* Reconnect and reset micro:bit when connection is lost
* Stop checking for connection when USB is unplugged

Author: microbit-grace

src/script/microbit-interfacing/MicrobitSerial.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 
-import { logError } from '../utils/logging';
+import { logError, logMessage } from '../utils/logging';
 import MicrobitConnection, { DeviceRequestStates } from './MicrobitConnection';
 import MicrobitUSB from './MicrobitUSB';
 import { onAccelerometerChange, onButtonChange } from './change-listeners';
@@ -16,13 +16,17 @@ import {
   stateOnFailedToConnect,
   stateOnReady,
 } from './state-updaters';
+import StaticConfiguration from '../../StaticConfiguration';
 
 export class MicrobitSerial implements MicrobitConnection {
   private responseMap = new Map<
     number,
     (value: protocol.MessageResponse | PromiseLike<protocol.MessageResponse>) => void
   >();
 
+  // To avoid concurrent connect attempts
+  private isConnecting: boolean = false;
+
   // TODO: The radio frequency should be randomly generated once per session.
   //       If we want a session to be restored (e.g. from local storage) and
   //       the previously flashed micro:bits to continue working without
@@ -31,10 +35,18 @@ export class MicrobitSerial implements MicrobitConnection {
   //        to configure the radio frequency for both micro:bits after they
   //        are flashed, not just the radio bridge.
   private sessionRadioFrequency = 42;
+  private connectionCheckIntervalId: ReturnType<typeof setInterval> | undefined;
+  private lastReceivedMessageTimestamp: number | undefined;
 
   constructor(private usb: MicrobitUSB) {}
 
   async connect(...states: DeviceRequestStates[]): Promise<void> {
+    logMessage('Serial connect', states);
+    if (this.isConnecting) {
+      logMessage('Skipping connect attempt when one is already in progress');
+      return;
+    }
+    this.isConnecting = true;
     let unprocessedData = '';
     let previousButtonState = { A: 0, B: 0 };
 
@@ -46,6 +58,8 @@ export class MicrobitSerial implements MicrobitConnection {
       const messages = protocol.splitMessages(unprocessedData + data);
       unprocessedData = messages.remainingInput;
       messages.messages.forEach(async msg => {
+        this.lastReceivedMessageTimestamp = Date.now();
+
         // Messages are either periodic sensor data or command/response
         const sensorData = protocol.processPeriodicMessage(msg);
         if (sensorData) {
@@ -80,6 +94,26 @@ export class MicrobitSerial implements MicrobitConnection {
       await this.handshake();
       stateOnConnected(DeviceRequestStates.INPUT);
 
+      // Check for USB being unplugged
+      navigator.usb.addEventListener('disconnect', () => {
+        logMessage('USB disconnected');
+        this.stopConnectionCheck();
+      });
+
+      // Check for connection lost
+      if (this.connectionCheckIntervalId === undefined) {
+        this.connectionCheckIntervalId = setInterval(async () => {
+          const allowedTimeWithoutMessageInMs =
+            StaticConfiguration.connectTimeoutDuration;
+          if (
+            this.lastReceivedMessageTimestamp &&
+            Date.now() - this.lastReceivedMessageTimestamp > allowedTimeWithoutMessageInMs
+          ) {
+            await this.handleReconnect();
+          }
+        }, 1000);
+      }
+
       // Set the radio frequency to a value unique to this session
       const radioFreqCommand = protocol.generateCmdRadioFrequency(
         this.sessionRadioFrequency,
@@ -104,26 +138,55 @@ export class MicrobitSerial implements MicrobitConnection {
 
       stateOnAssigned(DeviceRequestStates.INPUT, this.usb.getModelNumber());
       stateOnReady(DeviceRequestStates.INPUT);
+      logMessage('Serial successfully connected');
     } catch (e) {
       logError('Failed to initialise serial protocol', e);
       stateOnFailedToConnect(DeviceRequestStates.INPUT);
       await this.usb.stopSerial();
       throw e;
+    } finally {
+      this.isConnecting = false;
     }
   }
 
   async disconnect(): Promise<void> {
+    this.stopConnectionCheck();
     return this.disconnectInternal(true);
   }
 
+  private stopConnectionCheck() {
+    clearInterval(this.connectionCheckIntervalId);
+    this.connectionCheckIntervalId = undefined;
+    this.lastReceivedMessageTimestamp = undefined;
+  }
+
   private async disconnectInternal(userDisconnect: boolean): Promise<void> {
     // We might want to send command to stop streaming here?
     this.responseMap.clear();
     await this.usb.stopSerial();
     stateOnDisconnected(DeviceRequestStates.INPUT, userDisconnect);
   }
 
+  async handleReconnect(): Promise<void> {
+    if (this.isConnecting) {
+      logMessage('Serial disconnect ignored... reconnect already in progress');
+      return;
+    }
+    try {
+      this.stopConnectionCheck();
+      logMessage('Serial disconnected... automatically trying to reconnect');
+      await this.usb.softwareReset();
+      await this.usb.stopSerial();
+      await this.reconnect();
+    } catch (e) {
+      logError('Serial connect triggered by disconnect listener failed', e);
+    } finally {
+      this.isConnecting = false;
+    }
+  }
+
   async reconnect(): Promise<void> {
+    logMessage('Serial reconnect');
     await this.connect(DeviceRequestStates.INPUT);
   }
 

src/script/microbit-interfacing/MicrobitUSB.ts

@@ -8,6 +8,7 @@ import { CortexM, DAPLink, WebUSB } from 'dapjs';
 import MBSpecs from './MBSpecs';
 import { HexType, getHexFileUrl } from './Microbits';
 import { logError } from '../utils/logging';
+import { CortexSpecialReg } from './constants';
 
 const baudRate = 115200;
 const serialDelay = 5;
@@ -98,6 +99,27 @@ class MicrobitUSB {
     }
   }
 
+  /**
+   * Resets the micro:bit in software by writing to NVIC_AIRCR.
+   * Drawn from https://github.com/mmoskal/dapjs/blob/a32f11f54e9e76a9c61896ddd425c1cb1a29c143/src/cortex/cortex.ts#L347
+   */
+  public async softwareReset(): Promise<void> {
+    const cortexM = new CortexM(this.transport);
+    await cortexM.connect();
+    await cortexM.writeMem32(
+      CortexSpecialReg.NVIC_AIRCR,
+      CortexSpecialReg.NVIC_AIRCR_VECTKEY | CortexSpecialReg.NVIC_AIRCR_SYSRESETREQ,
+    );
+
+    // wait for the system to come out of reset
+    let dhcsr = await cortexM.readMem32(CortexSpecialReg.DHCSR);
+
+    while ((dhcsr & CortexSpecialReg.S_RESET_ST) !== 0) {
+      dhcsr = await cortexM.readMem32(CortexSpecialReg.DHCSR);
+    }
+    await cortexM.disconnect();
+  }
+
   /**
    * Flashes a .hex file to the micro:bit.
    * @param {string} hex The hex file to flash. (As a link)

src/script/microbit-interfacing/constants.ts

@@ -0,0 +1,17 @@
+/**
+ * (c) 2023, Center for Computational Thinking and Design at Aarhus University and contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+export const CortexSpecialReg = {
+  // Debug Halting Control and Status Register
+  DHCSR: 0xe000edf0,
+  S_RESET_ST: 1 << 25,
+
+  NVIC_AIRCR: 0xe000ed0c,
+  NVIC_AIRCR_VECTKEY: 0x5fa << 16,
+  NVIC_AIRCR_SYSRESETREQ: 1 << 2,
+
+  // Many more.
+};