Use control transfer to write/read from HID (#17)

* Add support for NRF51-DK board.
Add support for sending data using control transfer.
Allow to override hid interface class.

* Use control transfer to write/read data from the device.

* Read data from the device after 1 ms delay.

* Update webusb version

* Use control transfer to interface.

* Remove delay between sending write and read commands.

* Tidy variables.
Move isBufferBinary to utils.

Author: arekzaluski

binaries/nrf51dk-led-green.hex

@@ -256,6 +256,9 @@
                     case "9900":
                         binary = binariesPath + "microbit-say-" + color + ".hex";
                         break;
+                    case "1100":
+                        binary = binariesPath + "nrf51dk-led-" + color + ".hex";
+                        break;
                     default:
                         log("No binary found for this target");
                         return;

binaries/nrf51dk-led-red.hex

@@ -1,5 +1,5 @@
 import * as MemoryMap from "nrf-intel-hex";
-import {Utils} from "../dap/utils";
+import {isBufferBinary} from "../util";
 
 export class FlashSection {
     constructor(public address: number, public data: Uint32Array) {
@@ -40,7 +40,7 @@ export class FlashProgram {
     constructor(public sections: FlashSection[]) {}
 
     public static fromArrayBuffer(buffer: ArrayBuffer): FlashProgram {
-        if (Utils.isBufferBinary(buffer)) {
+        if (isBufferBinary(buffer)) {
             return FlashProgram.fromBinary(0, new Uint32Array(buffer));
         }
         const bufferString = Buffer.from(buffer).toString("utf8");

examples/web.html

@@ -223,3 +223,4 @@ export class FlashTarget extends CortexM {
 export let FlashTargets = new Map<string, IPlatform>();
 FlashTargets.set("0240", new K64F());
 FlashTargets.set("9900", new NRF51());
+FlashTargets.set("1100", new NRF51());

src/dap/utils.ts

@@ -24,17 +24,23 @@ export class HID {
     private endpoints: USBEndpoint[];
     private epIn: USBEndpoint;
     private epOut: USBEndpoint;
+    private useControlTransfer: boolean;
+    private packetSize = 64;
+    private controlTransferGetReport = 0x01;
+    private controlTransferSetReport = 0x09;
+    private controlTransferOutReport = 0x200;
+    private controlTransferInReport = 0x100;
 
     constructor(device: USBDevice) {
         this.device = device;
     }
 
-    public async open() {
+    public async open(hidInterfaceClass = 0xFF, useControlTransfer = true) {
+        this.useControlTransfer = useControlTransfer;
         await this.device.open();
         await this.device.selectConfiguration(1);
-
         const hids = this.device.configuration.interfaces.filter(
-            intf => intf.alternates[0].interfaceClass === 0xFF);
+            intf => intf.alternates[0].interfaceClass === hidInterfaceClass);
 
         if (hids.length === 0) {
             throw new Error("No HID interfaces found.");
@@ -45,9 +51,7 @@ export class HID {
         if (this.interfaces.length === 1) {
             this.interface = this.interfaces[0];
         }
-
         await this.device.claimInterface(this.interface.interfaceNumber);
-
         this.endpoints = this.interface.alternates[0].endpoints;
 
         this.epIn = null;
@@ -60,28 +64,49 @@ export class HID {
                 this.epOut = endpoint;
             }
         }
-
-        if (this.epIn === null || this.epOut === null) {
-            // tslint:disable-next-line:no-console
-            console.log("Unable to find an in and an out endpoint.");
-        }
     }
 
     public async close() {
         return this.device.close();
     }
 
     public async write(data: ArrayBuffer): Promise<USBOutTransferResult> {
-        const reportSize = this.epOut.packetSize;
-        const buffer = bufferExtend(data, reportSize);
-
-        return this.device.transferOut(this.epOut.endpointNumber, buffer);
+        if (this.epOut && !this.useControlTransfer) {
+            const reportSize = this.epOut.packetSize;
+            const buffer = bufferExtend(data, reportSize);
+            return this.device.transferOut(this.epOut.endpointNumber, buffer);
+        } else {
+            // Device does not have out endpoint. Send data using control transfer
+            const buffer = bufferExtend(data, this.packetSize);
+            return this.device.controlTransferOut(
+                {
+                    requestType: "class",
+                    recipient: "interface",
+                    request: this.controlTransferSetReport,
+                    value: this.controlTransferOutReport,
+                    index: this.interface.interfaceNumber
+                },
+                buffer
+            );
+        }
     }
 
     public async read(): Promise<DataView> {
-        const reportSize = this.epIn.packetSize;
-
-        return this.device.transferIn(this.epIn.endpointNumber, reportSize)
-            .then(res => res.data);
+        if (this.epIn && !this.useControlTransfer) {
+            const reportSize = this.epIn.packetSize;
+            return this.device.transferIn(this.epIn.endpointNumber, reportSize)
+                .then(res => res.data);
+        } else {
+            return this.device.controlTransferIn(
+                {
+                    requestType: "class",
+                    recipient: "interface",
+                    request: this.controlTransferGetReport,
+                    value: this.controlTransferInReport,
+                    index: this.interface.interfaceNumber
+                },
+                this.packetSize
+            ).then(res => res.data);
+        }
     }
 }

src/targets/FlashProgram.ts

@@ -113,3 +113,18 @@ export const hexBytes = (bytes: number[]) => {
 
     return r.toUpperCase();
 };
+
+export const isBufferBinary = (buffer: ArrayBuffer): boolean => {
+    // detect if buffer contains text or binary data
+    const lengthToCheck = buffer.byteLength > 50 ? 50 : buffer.byteLength;
+    const bufferString = Buffer.from(buffer).toString("utf8");
+    for (let i = 0; i < lengthToCheck; i++) {
+        const charCode = bufferString.charCodeAt(i);
+        // 65533 is a code for unknown character
+        // 0-8 are codes for control characters
+        if (charCode === 65533 || charCode <= 8) {
+            return true;
+        }
+    }
+    return false;
+};