Send micro:bit 1 device id to micro:bit 2 (#211)

This is used to determine the frequency and included in the radio packets to further disambiguate.
Updated hexes make the corresponding change.

Co-authored-by: Carlos Pereira Atencio <[email protected]>

Author: microbit-matt-hillsdon

public/firmware/local-sensors-v0.1.0.hex renamed to public/firmware/local-sensors-v0.2.0.hex

@@ -26,12 +26,6 @@ describe('Microbit USB connection tests', () => {
     });
   });
 
-  test('Can connect read serial', async () => {
-    const mockUsbDevice = new MockUSBDevice().withSerialNumber('123test').build();
-    const connection = new TestableMicrobitUSB(mockUsbDevice);
-    expect(connection.getSerialNumber()).toBe('123test');
-  });
-
   test('Serial number 9900 should be a version 1', async () => {
     const mockUsbDevice = new MockUSBDevice().withSerialNumber('9900serno').build();
     const connection = new TestableMicrobitUSB(mockUsbDevice);

public/firmware/radio-bridge-v0.1.0.hex

@@ -184,30 +184,22 @@ describe('processResponseMessage', () => {
   it('processes valid Handshake responses', () => {
     const message1 = 'R[0]HS[1]';
     const message2 = 'R[1122aabb]HS[255]';
-    const message3 = 'R[FFFFFFFF]HS[-1000]';
 
     const got1 = processResponseMessage(message1);
     const got2 = processResponseMessage(message2);
-    const got3 = processResponseMessage(message3);
 
     expect(got1).toEqual({
       message: message1,
       messageId: 0,
-      cmdType: 'HS',
+      type: 'HS',
       value: 1,
     });
     expect(got2).toEqual({
       message: message2,
       messageId: 0x1122aabb,
-      cmdType: 'HS',
+      type: 'HS',
       value: 255,
     });
-    expect(got3).toEqual({
-      message: message3,
-      messageId: 0xffffffff,
-      cmdType: 'HS',
-      value: -1000,
-    });
   });
 
   it('processes valid Radio Frequency response', () => {
@@ -218,11 +210,24 @@ describe('processResponseMessage', () => {
     expect(got).toEqual({
       message: message,
       messageId: 0x1234,
-      cmdType: 'RF',
+      type: 'RF',
       value: 42,
     });
   });
 
+  it('processes valid Remote micro:bit ID response', () => {
+    const message = 'R[1234]RMBID[4294967295]';
+
+    const got = processResponseMessage(message);
+
+    expect(got).toEqual({
+      message: message,
+      messageId: 0x1234,
+      type: 'RMBID',
+      value: 4294967295,
+    });
+  });
+
   it('processes valid Software Versions responses', () => {
     const message1 = 'R[1234]SWVER[0.0.0]';
     const message2 = 'R[1234]SWVER[99.99.99]';
@@ -235,19 +240,19 @@ describe('processResponseMessage', () => {
     expect(got1).toEqual({
       message: message1,
       messageId: 0x1234,
-      cmdType: 'SWVER',
+      type: 'SWVER',
       value: '0.0.0',
     });
     expect(got2).toEqual({
       message: message2,
       messageId: 0x1234,
-      cmdType: 'SWVER',
+      type: 'SWVER',
       value: '99.99.99',
     });
     expect(got3).toEqual({
       message: message3,
       messageId: 0x1234,
-      cmdType: 'SWVER',
+      type: 'SWVER',
       value: '1.2.3',
     });
   });
@@ -262,13 +267,13 @@ describe('processResponseMessage', () => {
     expect(got1).toEqual({
       message: message1,
       messageId: 0x1234,
-      cmdType: 'HWVER',
+      type: 'HWVER',
       value: 0,
     });
     expect(got2).toEqual({
       message: message2,
       messageId: 0x1234,
-      cmdType: 'HWVER',
+      type: 'HWVER',
       value: 9999,
     });
   });
@@ -281,7 +286,7 @@ describe('processResponseMessage', () => {
     expect(got).toEqual({
       message: message,
       messageId: 0x1234,
-      cmdType: 'ZSTART',
+      type: 'ZSTART',
       value: '',
     });
   });
@@ -294,11 +299,24 @@ describe('processResponseMessage', () => {
     expect(got).toEqual({
       message: message,
       messageId: 0x1234,
-      cmdType: 'STOP',
+      type: 'STOP',
       value: '',
     });
   });
 
+  it('processes valid Error response', () => {
+    const message = 'R[1234]ERROR[1]';
+
+    const got = processResponseMessage(message);
+
+    expect(got).toEqual({
+      message: message,
+      messageId: 0x1234,
+      type: 'ERROR',
+      value: 1,
+    });
+  });
+
   it('throws away messages that are not a response', () => {
     // First a valid response to stablish a baseline
     expect(processResponseMessage('R[0]STOP[]')).not.toBeUndefined();
@@ -326,8 +344,10 @@ describe('processResponseMessage', () => {
   it('throws away response messages with invalid number values', () => {
     // First valid messages to stablish a baseline
     expect(processResponseMessage('R[0]RF[10000]')).not.toBeUndefined();
-    expect(processResponseMessage('R[0]RF[-1]')).not.toBeUndefined();
+    expect(processResponseMessage('R[0]RMBID[4294967295]')).not.toBeUndefined();
     // Now invalid values
+    expect(processResponseMessage('R[0]RMBID[4294967296]')).toBeUndefined();
+    expect(processResponseMessage('R[0]RF[-1]')).toBeUndefined();
     expect(processResponseMessage('R[0]RF[1-2]')).toBeUndefined();
     expect(processResponseMessage('R[0]RF[1,2]')).toBeUndefined();
     expect(processResponseMessage('R[0]RF[1F]')).toBeUndefined();

public/firmware/radio-remote-v0.1.0-dev.hex renamed to public/firmware/radio-bridge-v0.2.0.hex

@@ -5,38 +5,41 @@
  -->
 
 <script lang="ts">
-  import StandardDialog from '../dialogs/StandardDialog.svelte';
-  import StartRadioDialog from './radio/StartRadioDialog.svelte';
-  import StartBluetoothDialog from './bluetooth/StartBluetoothDialog.svelte';
-  import ConnectCableDialog from './bluetooth/ConnectCableDialog.svelte';
-  import SelectMicrobitDialogUsb from './usb/SelectMicrobitDialogUsb.svelte';
-  import ConnectBatteryDialog from './bluetooth/ConnectBatteryDialog.svelte';
-  import BluetoothConnectDialog from './bluetooth/BluetoothConnectDialog.svelte';
-  import DownloadingDialog from './usb/DownloadingDialog.svelte';
-  import ManualInstallTutorial from './usb/manual/ManualInstallTutorial.svelte';
-  import {
-    ConnectDialogStates,
-    connectionDialogState,
-  } from '../../script/stores/connectDialogStore';
-  import { btPatternInput } from '../../script/stores/connectionStore';
-  import MBSpecs from '../../script/microbit-interfacing/MBSpecs';
-  import BrokenFirmwareDetected from './usb/BrokenFirmwareDetected.svelte';
-  import BluetoothConnectingDialog from './bluetooth/BluetoothConnectingDialog.svelte';
-  import SelectMicrobitDialogBluetooth from './bluetooth/SelectMicrobitDialogBluetooth.svelte';
-  import MicrobitWearingInstructionDialog from './MicrobitWearingInstructionDialog.svelte';
-  import WebUsbTryAgain, { USBTryAgainType } from './WebUsbTryAgain.svelte';
   import { onDestroy, onMount } from 'svelte';
-  import { get, Unsubscriber } from 'svelte/store';
-  import { compatibility, state } from '../../script/stores/uiStore';
+  import { Unsubscriber, get } from 'svelte/store';
   import { isDevMode } from '../../script/environment';
   import { flags } from '../../script/flags';
-  import ConnectingMicrobits from './radio/ConnectingMicrobits.svelte';
+  import MBSpecs from '../../script/microbit-interfacing/MBSpecs';
+  import MicrobitUSB from '../../script/microbit-interfacing/MicrobitUSB';
   import Microbits, {
     FlashStage,
     HexType,
   } from '../../script/microbit-interfacing/Microbits';
-  import MicrobitUSB from '../../script/microbit-interfacing/MicrobitUSB';
+  import {
+    ConnectDialogStates,
+    connectionDialogState,
+  } from '../../script/stores/connectDialogStore';
+  import {
+    btPatternInput,
+    radioBridgeRemoteDeviceId,
+  } from '../../script/stores/connectionStore';
+  import { compatibility, state } from '../../script/stores/uiStore';
+  import StandardDialog from '../dialogs/StandardDialog.svelte';
+  import MicrobitWearingInstructionDialog from './MicrobitWearingInstructionDialog.svelte';
   import WebBluetoothTryAgain from './WebBluetoothTryAgain.svelte';
+  import WebUsbTryAgain, { USBTryAgainType } from './WebUsbTryAgain.svelte';
+  import BluetoothConnectDialog from './bluetooth/BluetoothConnectDialog.svelte';
+  import BluetoothConnectingDialog from './bluetooth/BluetoothConnectingDialog.svelte';
+  import ConnectBatteryDialog from './bluetooth/ConnectBatteryDialog.svelte';
+  import ConnectCableDialog from './bluetooth/ConnectCableDialog.svelte';
+  import SelectMicrobitDialogBluetooth from './bluetooth/SelectMicrobitDialogBluetooth.svelte';
+  import StartBluetoothDialog from './bluetooth/StartBluetoothDialog.svelte';
+  import ConnectingMicrobits from './radio/ConnectingMicrobits.svelte';
+  import StartRadioDialog from './radio/StartRadioDialog.svelte';
+  import BrokenFirmwareDetected from './usb/BrokenFirmwareDetected.svelte';
+  import DownloadingDialog from './usb/DownloadingDialog.svelte';
+  import SelectMicrobitDialogUsb from './usb/SelectMicrobitDialogUsb.svelte';
+  import ManualInstallTutorial from './usb/manual/ManualInstallTutorial.svelte';
 
   const { bluetooth, usb } = get(compatibility);
   let endOfFlow = false;
@@ -113,7 +116,7 @@
 
   async function flashMicrobit(usb: MicrobitUSB): Promise<void> {
     try {
-      const name = await usb.getFriendlyName();
+      const deviceId = await usb.getDeviceId();
       const hexForStage = stageToHex(flashStage);
       await usb.flashHex(hexForStage, progress => {
         // Flash hex
@@ -125,11 +128,20 @@
         }
         flashProgress = progress;
       });
-      // Finished flashing successfully
+
+      // Store radio/bluetooth details. Radio is essential to pass to micro:bit 2.
+      // Bluetooth saves the user from entering the pattern.
+      if (flashStage === 'bluetooth') {
+        $btPatternInput = MBSpecs.Utility.nameToPattern(
+          MBSpecs.Utility.serialNumberToName(deviceId),
+        );
+      }
+      if (flashStage === 'radio-remote') {
+        $radioBridgeRemoteDeviceId = deviceId;
+      }
+
+      // Next UI state:
       if (flashStage === 'bluetooth' || flashStage === 'radio-remote') {
-        if (flashStage === 'bluetooth') {
-          $btPatternInput = MBSpecs.Utility.nameToPattern(name);
-        }
         $connectionDialogState.connectionState = ConnectDialogStates.CONNECT_BATTERY;
       } else if (flashStage === 'radio-bridge') {
         onConnectingSerial(usb);
@@ -157,7 +169,10 @@
 
   async function onConnectingSerial(usb: MicrobitUSB): Promise<void> {
     $connectionDialogState.connectionState = ConnectDialogStates.CONNECTING_MICROBITS;
-    await Microbits.assignSerialInput(usb);
+    if ($radioBridgeRemoteDeviceId === -1) {
+      throw new Error('Radio bridge device id not set');
+    }
+    await Microbits.assignSerialInput(usb, $radioBridgeRemoteDeviceId);
     endFlow();
   }
 

public/firmware/radio-remote-v0.1.0.hex renamed to public/firmware/radio-remote-v0.2.0-dev.hex

@@ -29,19 +29,14 @@ export class MicrobitSerial implements MicrobitConnection {
   // 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
-  //       reflashing we need to store and retrieve this value somehow.
-  // FIXME: Setting this to the hex files default value for now, as we need
-  //        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;
   private isReconnect: boolean = false;
 
-  constructor(private usb: MicrobitUSB) {}
+  constructor(
+    private usb: MicrobitUSB,
+    private remoteDeviceId: number,
+  ) {}
 
   async connect(...states: DeviceRequestStates[]): Promise<void> {
     logMessage('Serial connect', states);
@@ -55,7 +50,7 @@ export class MicrobitSerial implements MicrobitConnection {
     let onPeriodicMessageRecieved: (() => void) | undefined;
 
     const handleError = (e: unknown) => {
-      console.error(e);
+      logError('Serial error', e);
       void this.disconnectInternal(false, 'bridge');
     };
     const processMessage = (data: string) => {
@@ -122,14 +117,15 @@ export class MicrobitSerial implements MicrobitConnection {
         }, 1000);
       }
 
-      // Set the radio frequency to a value unique to this session
-      const radioFreqCommand = protocol.generateCmdRadioFrequency(
-        this.sessionRadioFrequency,
-      );
-      const radioFreqResponse = await this.sendCmdWaitResponse(radioFreqCommand);
-      if (radioFreqResponse.value !== this.sessionRadioFrequency) {
+      logMessage(`Serial: using remote device id ${this.remoteDeviceId}`);
+      const remoteMbIdCommand = protocol.generateCmdRemoteMbId(this.remoteDeviceId);
+      const remoteMbIdResponse = await this.sendCmdWaitResponse(remoteMbIdCommand);
+      if (
+        remoteMbIdResponse.type === protocol.ResponseTypes.Error ||
+        remoteMbIdResponse.value !== this.remoteDeviceId
+      ) {
         throw new Error(
-          `Failed to set radio frequency. Expected ${this.sessionRadioFrequency}, got ${radioFreqResponse.value}`,
+          `Failed to set remote micro:bit ID. Expected ${this.remoteDeviceId}, got ${remoteMbIdResponse.value}`,
         );
       }
 
@@ -140,15 +136,21 @@ export class MicrobitSerial implements MicrobitConnection {
           accelerometer: true,
           buttons: true,
         });
-        await this.usb.serialWrite(startCmd.message);
         const periodicMessagePromise = new Promise<void>((resolve, reject) => {
           onPeriodicMessageRecieved = resolve;
           setTimeout(() => {
             onPeriodicMessageRecieved = undefined;
             reject(new Error('Failed to receive data from remote micro:bit'));
           }, 500);
         });
-        await this.sendCmdWaitResponse(startCmd);
+
+        const startCmdResponse = await this.sendCmdWaitResponse(startCmd);
+        if (startCmdResponse.type === protocol.ResponseTypes.Error) {
+          throw new Error(
+            `Failed to start streaming sensors data. Error response received: ${startCmdResponse.message}`,
+          );
+        }
+
         if (this.isReconnect) {
           await periodicMessagePromise;
         } else {
@@ -246,6 +248,7 @@ export class MicrobitSerial implements MicrobitConnection {
     // As a workaround we can spam the micro:bit with handshake messages until
     // enough responses have been queued in the buffer to fill it and the data
     // starts to flow.
+    logMessage('Serial handshake');
     const handshakeResult = await new Promise<protocol.MessageResponse>(
       async (resolve, reject) => {
         const attempts = 20;
@@ -284,9 +287,10 @@ export class MicrobitSerial implements MicrobitConnection {
 export const startSerialConnection = async (
   usb: MicrobitUSB,
   requestState: DeviceRequestStates,
+  remoteDeviceId: number,
 ): Promise<MicrobitSerial | undefined> => {
   try {
-    const serial = new MicrobitSerial(usb);
+    const serial = new MicrobitSerial(usb, remoteDeviceId);
     await serial.connect(requestState);
     return serial;
   } catch (e) {