ev3: Fix issues with flashing (some?) EV3s.

src/firmware/sagas.ts

@@ -351,7 +351,20 @@ function* loadFirmware(
         'Expected metadata to be v2.x',
     );
 
-    const firmware = new Uint8Array(firmwareBase.length + 4);
+    const [checksumFunc, checksumSize] = (function () {
+        switch (metadata['checksum-type']) {
+            case 'sum':
+                return [sumComplement32, 4];
+            case 'crc32':
+                return [crc32, 4];
+            case 'none':
+                return [null, 0];
+            default:
+                return [undefined, 0];
+        }
+    })();
+
+    const firmware = new Uint8Array(firmwareBase.length + checksumSize);
     const firmwareView = new DataView(firmware.buffer);
 
     firmware.set(firmwareBase);
@@ -361,22 +374,7 @@ function* loadFirmware(
         firmware.set(encodeHubName(hubName, metadata), metadata['hub-name-offset']);
     }
 
-    const checksum = (function () {
-        switch (metadata['checksum-type']) {
-            case 'sum':
-                return sumComplement32(
-                    firmwareIterator(firmwareView, metadata['checksum-size']),
-                );
-            case 'crc32':
-                return crc32(firmwareIterator(firmwareView, metadata['checksum-size']));
-            case 'none':
-                return null;
-            default:
-                return undefined;
-        }
-    })();
-
-    if (checksum === undefined) {
+    if (checksumFunc === undefined) {
         // FIXME: we should return error/throw instead
         yield* put(
             didFailToFinish(
@@ -391,8 +389,12 @@ function* loadFirmware(
         throw new Error('unreachable');
     }
 
-    if (checksum !== null) {
-        firmwareView.setUint32(firmwareBase.length, checksum, true);
+    if (checksumFunc !== null) {
+        firmwareView.setUint32(
+            firmwareBase.length,
+            checksumFunc(firmwareIterator(firmwareView, metadata['checksum-size'])),
+            true,
+        );
     }
 
     return { firmware, deviceId: metadata['device-id'] };
@@ -1219,73 +1221,114 @@ function* handleFlashEV3(action: ReturnType<typeof firmwareFlashEV3>): Generator
 
     defined(version);
 
-    console.debug(
-        `EV3 bootloader version: ${version.getUint32(
-            0,
-            true,
-        )}, HW version: ${version.getUint32(4, true)}`,
-    );
+    // For reasons that we do not currently understand, some EV3s do not return
+    // anything to our GetVersion command. We don't actually use the version
+    // for anything so we will just ignore this error.
+    try {
+        console.debug(
+            `EV3 bootloader version: ${version.getUint32(
+                0,
+                true,
+            )}, HW version: ${version.getUint32(4, true)}`,
+        );
+    } catch (err) {
+        console.error(`Failed to parse ev3 version response: ${ensureError(err)}`);
+    }
 
     // FIXME: should be called much earlier.
     yield* put(didStart());
 
     const sectorSize = 64 * 1024; // flash memory sector size
     const maxPayloadSize = 1018; // maximum payload size for EV3 commands
 
-    for (let i = 0; i < action.firmware.byteLength; i += sectorSize) {
-        const sectorData = action.firmware.slice(i, i + sectorSize);
-        assert(sectorData.byteLength <= sectorSize, 'sector data too large');
+    console.info(`Firmware size: ${action.firmware.byteLength} bytes`);
+
+    // Apparently, erasing a span of the flash creates some sort of record in
+    // the EV3, and we can only write within a given erase span. Writes that
+    // cross the boundary will hang. To avoid this, we erase the whole firmware
+    // range at once.
+    const numSectors = Math.floor(action.firmware.byteLength / sectorSize);
+    assert(
+        action.firmware.byteLength === numSectors * sectorSize,
+        'Firmware size is required to be a round multiple of sector size.',
+    );
+
+    const erasePayload = new DataView(new ArrayBuffer(8));
+    erasePayload.setUint32(0, 0, true); // start address
+    erasePayload.setUint32(4, numSectors * sectorSize, true); // size
+    console.debug(
+        `Erasing bytes [0x${(0).toString(16)}, 0x${(numSectors * sectorSize).toString(
+            16,
+        )})`,
+    );
+
+    yield* put(
+        alertsShowAlert(
+            'firmware',
+            'flashProgress',
+            {
+                action: 'erase',
+                progress: undefined,
+            },
+            firmwareBleProgressToastId,
+            true,
+        ),
+    );
+
+    const [, eraseError] = yield* sendCommand(
+        0xf0,
+        new Uint8Array(erasePayload.buffer),
+    );
+
+    if (eraseError) {
+        yield* put(
+            alertsShowAlert('alerts', 'unexpectedError', {
+                error: eraseError,
+            }),
+        );
+        // FIXME: should have a better error reason
+        yield* put(didFailToFinish(FailToFinishReasonType.Unknown, eraseError));
+        yield* put(firmwareDidFailToFlashEV3());
+        yield* cleanup();
+        return;
+    }
 
-        const erasePayload = new DataView(new ArrayBuffer(8));
-        erasePayload.setUint32(0, i, true);
-        erasePayload.setUint32(4, sectorData.byteLength, true);
-        const [, eraseError] = yield* sendCommand(
-            0xf0,
-            new Uint8Array(erasePayload.buffer),
+    // If we don't write an exact multiple of the sector size, the flash process
+    // will hang on the last write we send.
+    const firmware = action.firmware;
+    for (let i = 0; i < firmware.byteLength; i += maxPayloadSize) {
+        const writeLength = Math.min(maxPayloadSize, firmware.byteLength - i);
+        const payload = firmware.slice(i, i + writeLength);
+        console.debug(
+            `Programming bytes [0x${i.toString(16)}, 0x${(i + writeLength).toString(
+                16,
+            )})`,
         );
 
-        if (eraseError) {
+        const [, sendError] = yield* sendCommand(0xf2, new Uint8Array(payload));
+        if (sendError) {
             yield* put(
                 alertsShowAlert('alerts', 'unexpectedError', {
-                    error: eraseError,
+                    error: sendError,
                 }),
             );
             // FIXME: should have a better error reason
-            yield* put(didFailToFinish(FailToFinishReasonType.Unknown, eraseError));
+            yield* put(didFailToFinish(FailToFinishReasonType.Unknown, sendError));
             yield* put(firmwareDidFailToFlashEV3());
             yield* cleanup();
             return;
         }
 
-        for (let j = 0; j < sectorData.byteLength; j += maxPayloadSize) {
-            const payload = sectorData.slice(j, j + maxPayloadSize);
-
-            const [, sendError] = yield* sendCommand(0xf2, new Uint8Array(payload));
-            if (sendError) {
-                yield* put(
-                    alertsShowAlert('alerts', 'unexpectedError', {
-                        error: sendError,
-                    }),
-                );
-                // FIXME: should have a better error reason
-                yield* put(didFailToFinish(FailToFinishReasonType.Unknown, sendError));
-                yield* put(firmwareDidFailToFlashEV3());
-                yield* cleanup();
-                return;
-            }
-        }
-
-        yield* put(
-            didProgress((i + sectorData.byteLength) / action.firmware.byteLength),
-        );
+        const progress = (i + writeLength) / firmware.byteLength;
+        yield* put(didProgress(progress));
 
         yield* put(
             alertsShowAlert(
                 'firmware',
                 'flashProgress',
                 {
                     action: 'flash',
-                    progress: (i + sectorData.byteLength) / action.firmware.byteLength,
+                    progress: progress,
                 },
                 firmwareBleProgressToastId,
                 true,