Move loading of flashing algorithms to examples.

Author: arekzaluski

README.md

@@ -69,7 +69,9 @@ this.hid = new DAPjs.HID(device);
 // open hid device
 await this.hid.open();
 dapDevice = new DAPjs.DAP(this.hid);
-const flashAlgorithm = await DAPjs.FlashAlgorithm.load(deviceCode);
+// contains flash algorithms data and memory map
+let flashAlgorithmsData = {};
+let flashAlgorithm = new DAPjs.FlashAlgorithm(flashAlgorithmsData, this.deviceCode);
 this.target = new DAPjs.FlashTarget(dapDevice, flashAlgorithm);
 
 // init and halt target

examples/flash.js

@@ -46,14 +46,14 @@ function getFileName() {
     });
 }
 
-// Load a file, returning a buffer
-function loadFile(fileName) {
+// Load a file
+function loadFile(fileName, isJson=false) {
     var file = fs.readFileSync(fileName);
-    return new Uint8Array(file).buffer;
+    return isJson ? JSON.parse(file) : new Uint8Array(file).buffer;
 }
 
-// Download a file, returning a buffer
-function downloadFile(url) {
+// Download a file
+function downloadFile(url, isJson=false) {
     return new Promise((resolve, reject) => {
         console.log("Downloading file...");
         var scheme = (url.indexOf("https") === 0) ? https : http;
@@ -67,7 +67,12 @@ function downloadFile(url) {
                 if (response.statusCode !== 200) return reject(response.statusMessage);
 
                 var download = Buffer.concat(data);
-                resolve(new Uint8Array(download).buffer);
+                if (isJson) {
+                    resolve(JSON.parse(data));
+                }
+                else {
+                    resolve(new Uint8Array(download).buffer);
+                }
             });
         })
         .on("error", error => {
@@ -110,9 +115,16 @@ function getTarget(device) {
     return hid.open()
     .then(() => {
         console.log("Device opened");
-
+        // Load flashing algorithms
+        var flashAlgorithmsFile = "flash_targets/flash_targets.json";
+        if (flashAlgorithmsFile.indexOf("http") === 0) return downloadFile(flashAlgorithmsFile, true);
+        return loadFile(flashAlgorithmsFile, true);
+    })
+    .then((flashAlgorithms) => {
+        console.log("Flash algorithms loaded");
         var dapDevice = new DAPjs.DAP(hid);
-        var flashAlgorithm = DAPjs.FlashAlgorithm.load(deviceCode);
+        var flashAlgorithm = new DAPjs.FlashAlgorithm(flashAlgorithms, deviceCode);
+        if (!flashAlgorithm.flashAlgo) throw new Error("Flash algorithm not found for this board.");
         target = new DAPjs.FlashTarget(dapDevice, flashAlgorithm);
         return target.init();
     })
@@ -124,6 +136,10 @@ function getTarget(device) {
         console.log("Target halted");
         return target;
     })
+    .catch(error => {
+        console.log(error.message || error);
+        process.exit();
+    });
 }
 
 // Update device using image buffer

examples/web.html

@@ -218,30 +218,35 @@
                 log("Device opened.");
 
                 this.dapDevice = new DAPjs.DAP(this.hid);
-                const flashAlgorithm = await DAPjs.FlashAlgorithm.load(this.deviceCode).catch(error => log(error));
-                if (!flashAlgorithm) return log("No flashing algorithm can be found for this board.");
-                this.target = new DAPjs.FlashTarget(this.dapDevice, flashAlgorithm);
-
-                log("Initialising device.");
-
-                await this.target.init();
+                const xhr = new XMLHttpRequest();
+                xhr.responseType = "json";
+                xhr.open("GET", "../flash_targets/flash_targets.json", true);
+                xhr.onload = async (e) => {
+                    if (xhr.status !== 200) return log(xhr.statusText);
 
-                log("Halting target.");
+                    let flashAlgorithm = new DAPjs.FlashAlgorithm(xhr.response, this.deviceCode);
+                    if (!flashAlgorithm.flashAlgo) return log("No flashing algorithm can be found for this board.");
 
-                await this.target.halt();
+                    this.target = new DAPjs.FlashTarget(this.dapDevice, flashAlgorithm);
 
-                log("Target halted.");
+                    log("Initialising device.");
+                    await this.target.init();
 
-                const [imp, isa, type] = await this.target.readCoreType();
-                log(`Connected to an ARM ${DAPjs.CoreNames.get(type)} (${DAPjs.ISANames.get(isa)})`);
+                    log("Halting target.");
+                    await this.target.halt();
+                    log("Target halted.");
 
-                document.getElementById("connect").disabled = true;
+                    const [imp, isa, type] = await this.target.readCoreType();
+                    log(`Connected to an ARM ${DAPjs.CoreNames.get(type)} (${DAPjs.ISANames.get(isa)})`);
+                    document.getElementById("connect").disabled = true;
 
-                const elements = Array.from(document.querySelectorAll(".when-connected"));
+                    const elements = Array.from(document.querySelectorAll(".when-connected"));
 
-                for (const elem of elements) {
-                    elem.disabled = false;
-                }
+                    for (const elem of elements) {
+                        elem.disabled = false;
+                    }
+                };
+                xhr.send();
             }
 
             async function halt() {

src/documentation.md

@@ -31,7 +31,9 @@ this.hid = new DAPjs.HID(device);
 // open hid device
 await this.hid.open();
 dapDevice = new DAPjs.DAP(this.hid);
-const flashAlgorithm = await DAPjs.FlashAlgorithm.load(this.deviceCode);
+// contains flash algorithms data and memory map
+let flashAlgorithmsData = {};
+let flashAlgorithm = new DAPjs.FlashAlgorithm(flashAlgorithmsData, this.deviceCode);
 this.target = new DAPjs.FlashTarget(dapDevice, flashAlgorithm);
 
 // init and halt target

src/targets/FlashAlgorithm.ts

@@ -31,34 +31,21 @@ export class FlashAlgorithm {
     public flashAlgo: IFlashAlgo;
     public memoryMap: IMemoryRegion[];
 
-    public static async load(deviceCode: string) {
-        const xhr = new XMLHttpRequest();
-        xhr.open("get", "../../flash_targets/flash_targets.json", true);
-        xhr.responseType = "json";
-        return new Promise<FlashAlgorithm>((resolve, reject) => {
-            xhr.onload = (_e: any) => {
-                if (xhr.status !== 200) return reject(xhr.statusText);
-                let flashAlgorithm = null;
-                const algorithms = xhr.response;
-                if (deviceCode in algorithms) {
-                    flashAlgorithm = new FlashAlgorithm();
-                    flashAlgorithm.flashAlgo = FlashAlgorithm.setFlashingAlgo(algorithms[deviceCode]);
-                    flashAlgorithm.memoryMap = FlashAlgorithm.setMemoryMap(algorithms[deviceCode]);
-                }
-                resolve(flashAlgorithm);
-            };
-            xhr.send();
-        });
+    public constructor(flashAlgorithmsData: any, deviceCode: string) {
+        if (deviceCode in flashAlgorithmsData) {
+            this.setFlashingAlgo(flashAlgorithmsData[deviceCode]);
+            this.setMemoryMap(flashAlgorithmsData[deviceCode]);
+        }
     }
 
-    private static setFlashingAlgo(flashAlgorithm: any): IFlashAlgo {
+    private setFlashingAlgo(flashAlgorithm: any) {
         const instructions = flashAlgorithm.flash_algo.instructions.map((instruction: string) => {
             return parseInt(instruction, 16);
         });
         const pageBuffers = flashAlgorithm.flash_algo.page_buffers.map((pageBuffer: string) => {
             return parseInt(pageBuffer, 16);
         });
-        return {
+        this.flashAlgo = {
             analyzerAddress: parseInt(flashAlgorithm.flash_algo.analyzer_address, 16),
             analyzerSupported: flashAlgorithm.flash_algo.analyzer_supported,
             loadAddress: parseInt(flashAlgorithm.flash_algo.load_address, 16),
@@ -73,8 +60,8 @@ export class FlashAlgorithm {
         };
     }
 
-    private static setMemoryMap(flashAlgorithm: any): IMemoryRegion[] {
-        return flashAlgorithm.memory_map.map((region: any) => {
+    private setMemoryMap(flashAlgorithm: any) {
+        this.memoryMap = flashAlgorithm.memory_map.map((region: any) => {
             return {
                 blocksize: parseInt(region.blocksize, 16),
                 end: parseInt(region.end, 16),