upload using programmer (#553)

czgtest · Sneezry · commit 1af89caaa646 · 2018-05-09T16:17:37.000+08:00
diff --git a/README.md b/README.md
@@ -47,6 +47,7 @@ This extension provides several commands in the Command Palette (`F1` or `Ctrl +
 - **Arduino: Select Serial Port**: Change the current serial port.
 - **Arduino: Send Text to Serial Port**: Send a line of text via the current serial port.
 - **Arduino: Upload**: Build sketch and upload to Arduino board.
+- **Arduino: Upload Using Programmer**: Upload using an external programmer.
 - **Arduino: Verify**: Build sketch.
 
 ## Options
diff --git a/package.json b/package.json
@@ -36,6 +36,8 @@
     "*",
     "onCommand:arduino.verify",
     "onCommand:arduino.upload",
+    "onCommand:arduino.uploadUsingProgrammer",
+    "onCommand:arduino.selectProgrammer",
     "onCommand:arduino.selectSerialPort",
     "onCommand:arduino.changeBaudRate",
     "onCommand:arduino.addLibPath",
@@ -75,6 +77,14 @@
         "command": "arduino.upload",
         "title": "Arduino: Upload"
       },
+      {
+        "command": "arduino.uploadUsingProgrammer",
+        "title": "Arduino: Upload Using Programmer"
+      },
+      {
+        "command": "arduino.selectProgrammer",
+        "title": "Arduino: Select Programmer"
+      },
       {
         "command": "arduino.selectSerialPort",
         "title": "Arduino: Select Serial Port"
diff --git a/src/arduino/arduino.ts b/src/arduino/arduino.ts
@@ -22,6 +22,7 @@ import { arduinoChannel } from "../common/outputChannel";
 import { ArduinoWorkspace } from "../common/workspace";
 import { SerialMonitor } from "../serialmonitor/serialMonitor";
 import { UsbDetector } from "../serialmonitor/usbDetector";
+import { ProgrammerManager } from "./programmerManager";
 
 /**
  * Represent an Arduino application based on the official Arduino IDE.
@@ -34,6 +35,8 @@ export class ArduinoApp {
 
     private _exampleManager: ExampleManager;
 
+    private _programmerManager: ProgrammerManager;
+
     /**
      * @param {IArduinoSettings} _settings ArduinoSetting object.
      */
@@ -154,6 +157,64 @@ export class ArduinoApp {
         });
     }
 
+    public async uploadUsingProgrammer() {
+        const dc = DeviceContext.getInstance();
+        const boardDescriptor = this.getBoardBuildString();
+        if (!boardDescriptor) {
+            return;
+        }
+
+        const selectProgrammer = this.getProgrammerString();
+        if (!selectProgrammer) {
+            return;
+        }
+
+        if (!ArduinoWorkspace.rootPath) {
+            vscode.window.showWarningMessage("Cannot find the sketch file.");
+            return;
+        }
+
+        if (!dc.sketch || !util.fileExistsSync(path.join(ArduinoWorkspace.rootPath, dc.sketch))) {
+            await this.getMainSketch(dc);
+        }
+        if (!dc.port) {
+            vscode.window.showErrorMessage("Please specify the upload serial port.");
+            return;
+        }
+
+        arduinoChannel.show();
+        arduinoChannel.start(`Upload sketch - ${dc.sketch}`);
+
+        const serialMonitor = SerialMonitor.getInstance();
+
+        const needRestore = await serialMonitor.closeSerialMonitor(dc.port);
+        UsbDetector.getInstance().pauseListening();
+        await vscode.workspace.saveAll(false);
+
+        const appPath = path.join(ArduinoWorkspace.rootPath, dc.sketch);
+        const args = ["--upload", "--board", boardDescriptor, "--port", dc.port, "--useprogrammer",
+                "--pref", "programmer=" + selectProgrammer, appPath];
+        if (VscodeSettings.getInstance().logLevel === "verbose") {
+            args.push("--verbose");
+        }
+        if (dc.output) {
+            const outputPath = path.resolve(ArduinoWorkspace.rootPath, dc.output);
+            args.push("--pref", `build.path=${outputPath}`);
+        } else {
+            const msg = "Output path is not specified. Unable to reuse previously compiled files. Upload could be slow. See README.";
+            arduinoChannel.warning(msg);
+        }
+        await util.spawn(this._settings.commandPath, arduinoChannel.channel, args).then(async () => {
+            UsbDetector.getInstance().resumeListening();
+            if (needRestore) {
+                await serialMonitor.openSerialMonitor();
+            }
+            arduinoChannel.end(`Uploaded the sketch: ${dc.sketch}${os.EOL}`);
+        }, (reason) => {
+            arduinoChannel.error(`Exit with code=${reason.code}${os.EOL}`);
+        });
+    }
+
     public async verify(output: string = "") {
         const dc = DeviceContext.getInstance();
         const boardDescriptor = this.getBoardBuildString();
@@ -528,6 +589,23 @@ export class ArduinoApp {
         this._exampleManager = value;
     }
 
+    public get programmerManager() {
+        return this._programmerManager;
+    }
+
+    public set programmerManager(value: ProgrammerManager) {
+        this._programmerManager = value;
+    }
+
+    private getProgrammerString(): string {
+        const selectProgrammer = this.programmerManager.currentProgrammer;
+        if (!selectProgrammer) {
+            Logger.notifyUserError("getProgrammerString", new Error(constants.messages.NO_PROGRAMMMER_SELECTED));
+            return;
+        }
+        return selectProgrammer;
+    }
+
     private getBoardBuildString(): string {
         const selectedBoard = this.boardManager.currentBoard;
         if (!selectedBoard) {
diff --git a/src/arduino/programmerManager.ts b/src/arduino/programmerManager.ts
@@ -0,0 +1,104 @@
+import * as vscode from "vscode";
+import * as constants from "../common/constants";
+import { ArduinoApp } from "./arduino";
+import { IArduinoSettings } from "./arduinoSettings";
+import { ArduinoSettings } from "./arduinoSettings";
+
+export enum ProgrammerList {
+    "AVR ISP",
+    "AVRISP mkII",
+    "USBtinyISP",
+    "ArduinoISP",
+    "ArduinoISP.org",
+    "USBasp",
+    "Parallel Programmer",
+    "Arduino as ISP",
+    "Arduino Gemma",
+    "BusPirate as ISP",
+    "Atmel STK500 development board",
+    "Atmel JTAGICE3 (ISP mode)",
+    "Atmel JTAGICE3 (JTAG mode)",
+    "Atmel-ICE (AVR)",
+}
+
+export class ProgrammerManager {
+
+    private static _programmerManager: ProgrammerManager = null;
+
+    private _currentprogrammer: ProgrammerList;
+
+    private _programmervalue: string;
+
+    private _programmerStatusBar: vscode.StatusBarItem;
+
+    constructor(private _settings: IArduinoSettings, private _arduinoApp: ArduinoApp) {
+        this._programmerStatusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, constants.statusBarPriority.PROGRAMMER);
+        this._programmerStatusBar.command = "arduino.selectProgrammer";
+        this._programmerStatusBar.tooltip = "Select Programmer";
+        this._programmerStatusBar.text = "<Select Programmer>";
+        this._programmerStatusBar.show();
+    }
+
+    public get currentProgrammer(): string {
+        return this._programmervalue;
+    }
+
+    public async selectProgrammer() {
+        const chosen: string | undefined = await vscode.window.showQuickPick(Object.keys(ProgrammerList)
+            .filter((key) => {
+                return !isNaN(Number(ProgrammerList[key]));
+            }), { placeHolder: "Select programmer" });
+        if (!chosen) {
+            return;
+        }
+        this._currentprogrammer = ProgrammerList[chosen];
+        this.getProgrammer(this._currentprogrammer);
+        this._programmerStatusBar.text = chosen;
+    }
+
+    public getProgrammer(newProgrammer: ProgrammerList) {
+        switch (newProgrammer) {
+            case ProgrammerList["AVR ISP"]:
+                this._programmervalue = "arduino:avrisp";
+                break;
+            case ProgrammerList["AVRISP mkII"]:
+                this._programmervalue = "arduino:avrispmkii";
+                break;
+            case ProgrammerList.USBtinyISP:
+                this._programmervalue = "arduino:usbtinyisp";
+                break;
+            case ProgrammerList.ArduinoISP:
+                this._programmervalue = "arduino:arduinoisp";
+                break;
+            case ProgrammerList.USBasp:
+                this._programmervalue = "arduino:usbasp";
+                break;
+            case ProgrammerList["Parallel Programmer"]:
+                this._programmervalue = "arduino:parallel";
+                break;
+            case ProgrammerList["Arduino as ISP"]:
+                this._programmervalue = "arduino:arduinoasisp";
+                break;
+            case ProgrammerList["Arduino Gemma"]:
+                this._programmervalue = "arduino:usbGemma";
+                break;
+            case ProgrammerList["BusPirate as ISP"]:
+                this._programmervalue = "arduino:buspirate";
+                break;
+            case ProgrammerList["Atmel STK500 development board"]:
+                this._programmervalue = "arduino:stk500";
+                break;
+            case ProgrammerList["Atmel JTAGICE3 (ISP mode)"]:
+                this._programmervalue = "arduino:jtag3isp";
+                break;
+            case ProgrammerList["Atmel JTAGICE3 (JTAG mode)"]:
+                this._programmervalue = "arduino:jtag3";
+                break;
+            case ProgrammerList["Atmel-ICE (AVR)"]:
+                this._programmervalue = "arduino:atmel_ice";
+                break;
+            default:
+                break;
+        }
+    }
+}
diff --git a/src/arduinoActivator.ts b/src/arduinoActivator.ts
@@ -9,6 +9,7 @@ import { BoardManager } from "./arduino/boardManager";
 import { ExampleManager } from "./arduino/exampleManager";
 import { ExampleProvider } from "./arduino/exampleProvider";
 import { LibraryManager } from "./arduino/libraryManager";
+import { ProgrammerManager } from "./arduino/programmerManager";
 import ArduinoContext from "./arduinoContext";
 import { DeviceContext } from "./deviceContext";
 
@@ -37,6 +38,7 @@ class ArduinoActivator {
             await arduinoApp.boardManager.loadPackages();
             arduinoApp.libraryManager = new LibraryManager(arduinoSettings, arduinoApp);
             arduinoApp.exampleManager = new ExampleManager(arduinoSettings, arduinoApp);
+            arduinoApp.programmerManager = new ProgrammerManager(arduinoSettings, arduinoApp);
             ArduinoContext.arduinoApp = arduinoApp;
 
             const exampleProvider = new ExampleProvider(arduinoApp.exampleManager, arduinoApp.boardManager);
diff --git a/src/common/constants.ts b/src/common/constants.ts
@@ -26,6 +26,7 @@ export const messages = {
     FAILED_SEND_SERIALPORT: "Failed to send message to serial port.",
     SERIAL_PORT_NOT_STARTED: "Serial Monitor has not been started.",
     SEND_BEFORE_OPEN_SERIALPORT: "Please open a serial port first.",
+    NO_PROGRAMMMER_SELECTED: "Please select the programmer first.",
 };
 
 export const statusBarPriority = {
@@ -35,4 +36,5 @@ export const statusBarPriority = {
     BOARD: 60,
     ENDING: 70,
     SKETCH: 80,
+    PROGRAMMER: 90,
 };
diff --git a/src/extension.ts b/src/extension.ts
@@ -193,6 +193,32 @@ export async function activate(context: vscode.ExtensionContext) {
         deviceContext.showStatusBar();
     });
 
+    registerArduinoCommand("arduino.uploadUsingProgrammer", async () => {
+        if (!status.compile) {
+            status.compile = "upload";
+            try {
+                await ArduinoContext.arduinoApp.uploadUsingProgrammer();
+            } catch (ex) {
+            }
+            delete status.compile;
+        }
+    }, () => {
+        return { board: ArduinoContext.boardManager.currentBoard.name };
+    });
+
+    registerArduinoCommand("arduino.selectProgrammer", async () => {
+        if (!status.compile) {
+            status.compile = "upload";
+            try {
+                await ArduinoContext.arduinoApp.programmerManager.selectProgrammer();
+            } catch (ex) {
+            }
+            delete status.compile;
+        }
+    }, () => {
+        return { board: ArduinoContext.boardManager.currentBoard.name };
+    });
+
     registerArduinoCommand("arduino.addLibPath", (path) => ArduinoContext.arduinoApp.addLibPath(path));
     registerArduinoCommand("arduino.openExample", (path) => ArduinoContext.arduinoApp.openExample(path));
     registerArduinoCommand("arduino.loadPackages", async () => await ArduinoContext.boardManager.loadPackages(true));
diff --git a/test/extension.test.ts b/test/extension.test.ts
@@ -34,6 +34,8 @@ suite("Arduino: Extension Tests", () => {
                 const ARDUINO_COMMANDS = [
                     "arduino.verify",
                     "arduino.upload",
+                    "arduino.uploadUsingProgrammer",
+                    "arduino.selectProgrammer",
                     "arduino.showBoardManager",
                     "arduino.showLibraryManager",
                     "arduino.showBoardConfig",
