Refactor serial.

Add example binaries.

Author: arekzaluski

binaries/k64f-blinky-green.bin

@@ -261,6 +261,7 @@
                 log("Device opened.");
 
                 this.dapDevice = new DAPjs.DAP(this.hid);
+                this.serial = new DAPjs.Serial(dapDevice);
                 this.target = new DAPjs.FlashTarget(this.dapDevice, DAPjs.FlashTargets.get(this.deviceCode));
 
                 log("Initialising device.");
@@ -333,20 +334,20 @@
             async function startSerialMonitor() {
                 var elem = document.getElementById("baudRate");
                 var baudRate = elem.options[elem.selectedIndex].value;
-                await this.dapDevice.initializeSerialMonitor(baudRate);
-                this.dapDevice.startSerialMonitor((data) => {
+                await this.serial.initialize(baudRate);
+                this.serial.start((data) => {
                     logSerial(data);
                 });
             }
 
             function writeSerial() {
                 var elem = document.getElementById("serialMonitorInput");
-                this.dapDevice.writeSerialData(elem.value);
+                this.serial.write(elem.value);
                 elem.value = "";
             }
 
             function stopSerialMonitor() {
-                this.dapDevice.stopSerialMonitor();
+                this.serial.stop();
                 clearLogSerial();
             }
 

binaries/k64f-blinky-red.bin

@@ -10,7 +10,6 @@ export class DAP {
 
     private dpSelect: number;
     private csw: number;
-    private serialTimer: any;
     // private idcode: number;
 
     constructor(private device: IHID) {
@@ -23,48 +22,6 @@ export class DAP {
         await this.init();
     }
 
-    public async initializeSerialMonitor(baudRate: number) {
-        const serialConfig: number[] = [];
-        addInt32(serialConfig, baudRate);
-        // serialConfig.push("8".charCodeAt(0)); // data bits
-        // serialConfig.push("0".charCodeAt(0)); // parity
-        // serialConfig.push("1".charCodeAt(0)); // stop bits
-        // serialConfig.push("0".charCodeAt(0)); // flow control
-        // console.log(serialConfig);
-        await this.dap.initializeSerial(serialConfig);
-    }
-
-    public async startSerialMonitor(responseCallback?: (serialData: string) => void) {
-        this.serialTimer = setInterval(async () => {
-            let serialData = await this.dap.getSerialData();
-            if (serialData.byteLength > 0) {
-                serialData = serialData.subarray(1);
-                const emptyResponse = serialData.every((c: any) => {
-                    return c === 0;
-                });
-                if (!emptyResponse) {
-                    const data = Buffer.from(serialData.buffer).toString("utf8").substring(1);
-                    responseCallback(data);
-                }
-            }
-        }, 200);
-    }
-
-    public async writeSerialData(data: string) {
-        let arrayData = [];
-        if (data || data !== "") {
-            arrayData = data.split("").map((e: any) => e.charCodeAt());
-        }
-        return await this.dap.writeSerialData(arrayData);
-    }
-
-    public async stopSerialMonitor() {
-        if (this.serialTimer) {
-            clearInterval(this.serialTimer);
-            this.serialTimer = null;
-        }
-    }
-
     public async init() {
         await this.dap.connect();
         await this.readDp(Reg.IDCODE);
@@ -224,4 +181,16 @@ export class DAP {
 
         return buf;
     }
+
+    public async initializeSerial(data: number[]) {
+        return this.dap.cmdNums(DapCmd.DAP_VENDOR1, data);
+    }
+
+    public async readSerial() {
+        return this.dap.cmdNums(DapCmd.DAP_VENDOR2, []);
+    }
+
+    public async writeSerial(data: number[]) {
+        return this.dap.cmdNums(DapCmd.DAP_VENDOR3, data);
+    }
 }

binaries/microbit-say-green.hex

@@ -1,6 +1,7 @@
 export {CortexM} from "./cortex/cortex";
 export {CortexReg, CortexSpecialReg, CoreState, CoreNames, ISANames} from "./cortex/constants";
 export {DAP} from "./dap/dap";
+export {Serial} from "./serial/serial";
 
 export {FlashTargets, FlashTarget} from "./targets/FlashTarget";
 export {FlashProgram} from "./targets/FlashProgram";

binaries/microbit-say-red.hex

@@ -0,0 +1,50 @@
+import {DAP} from "../dap/dap";
+import {addInt32} from "../util";
+
+export class Serial {
+    private dap: DAP;
+    private timer: any;
+    private delay: number;
+
+    constructor(dap: DAP) {
+        this.dap = dap;
+    }
+
+    public async initialize(baudRate: number, delay = 200) {
+        this.delay = delay;
+        const serialConfig: number[] = [];
+        addInt32(serialConfig, baudRate);
+        await this.dap.initializeSerial(serialConfig);
+    }
+
+    public async start(responseCallback?: (serialData: string) => void) {
+        this.timer = setInterval(async () => {
+            let serialData = await this.dap.readSerial();
+            if (serialData.byteLength > 0) {
+                serialData = serialData.subarray(1);
+                const emptyResponse = serialData.every((c: any) => {
+                    return c === 0;
+                });
+                if (!emptyResponse) {
+                    const data = Buffer.from(serialData.buffer).toString("utf8").substring(1);
+                    responseCallback(data);
+                }
+            }
+        }, this.delay);
+    }
+
+    public async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+
+    public async write(data: string) {
+        let arrayData = [];
+        if (data || data !== "") {
+            arrayData = data.split("").map((e: any) => e.charCodeAt());
+        }
+        return await this.dap.writeSerial(arrayData);
+    }
+}