Ran first debugging session

Author: Christian Weichel

.vscode/arduino.json

@@ -0,0 +1,4 @@
+{
+    "board": "arduino:samd:arduino_zero_edbg",
+    "port": "/dev/cu.usbmodem141402"
+}

.vscode/c_cpp_properties.json

@@ -0,0 +1,14 @@
+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "/Users/csweichel/Library/Arduino15/packages/arduino/tools/**",
+                "/Users/csweichel/Library/Arduino15/packages/arduino/hardware/samd/1.8.4/**"
+            ],
+            "forcedInclude": [
+                "/Users/csweichel/Library/Arduino15/packages/arduino/hardware/samd/1.8.4/cores/arduino/Arduino.h"
+            ]
+        }
+    ]
+}

.vscode/launch.json

@@ -10,6 +10,13 @@
       "name": "Attach by Process ID",
       "processId": "${command:PickProcess}"
     },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch Electron Packager",
+      "program": "${workspaceRoot}/electron/packager/index.js",
+      "cwd": "${workspaceFolder}/electron/packager"
+    },
     {
       "type": "node",
       "request": "launch",
@@ -99,13 +106,6 @@
       "smartStep": true,
       "internalConsoleOptions": "openOnSessionStart",
       "outputCapture": "std"
-    },
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Packager",
-      "program": "${workspaceRoot}/electron/packager/index.js",
-      "cwd": "${workspaceFolder}/electron/packager"
     }
   ]
 }

arduino-debugger-extension/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "arduino-debugger-extension",
+  "version": "0.0.2",
+  "description": "An extension for debugging Arduino programs",
+  "license": "MIT",
+  "engines": {
+    "node": ">=10.10.0"
+  },
+  "dependencies": {
+    "@theia/core": "next",
+    "@theia/debug": "next",
+
+    "cdt-gdb-adapter": "^0.0.14-next.4783033.0",
+    "vscode-debugadapter": "^1.26.0",
+    "vscode-debugprotocol": "^1.26.0"
+  },
+  "scripts": {
+    "prepare": "yarn run clean && yarn run build",
+    "clean": "rimraf lib",
+    "lint": "tslint -c ./tslint.json --project ./tsconfig.json",
+    "build": "tsc && yarn lint",
+    "watch": "tsc -w"
+  },
+  "devDependencies": {
+    "rimraf": "^2.6.1",
+    "tslint": "^5.5.0",
+    "typescript": "3.5.1"
+  },
+  "files": [
+    "lib",
+    "src",
+    "build",
+    "data"
+  ],
+  "theiaExtensions": [
+    {
+      "backend": "lib/node/backend-module"
+    }
+  ]
+}

arduino-debugger-extension/src/common/index.ts

@@ -0,0 +1,2 @@
+gdb_port 50000
+telnet_port 44444

arduino-debugger-extension/src/common/openocd/gdb.cfg

@@ -0,0 +1,12 @@
+source [find interface/cmsis-dap.cfg]
+
+# chip name
+set CHIPNAME at91samd21g18
+set ENDIAN little
+
+# choose a port here
+set telnet_port 0
+
+source [find target/at91samdXX.cfg]
+
+echo "GDB server started"

arduino-debugger-extension/src/common/openocd/openocd.cfg

@@ -0,0 +1,109 @@
+import { injectable } from 'inversify';
+import { DebugAdapterContribution, DebugAdapterExecutable, DebugAdapterSessionFactory } from '@theia/debug/lib/common/debug-model';
+import { DebugConfiguration } from "@theia/debug/lib/common/debug-configuration";
+import { MaybePromise } from "@theia/core/lib/common/types";
+import { IJSONSchema, IJSONSchemaSnippet } from "@theia/core/lib/common/json-schema";
+import * as path from 'path';
+
+@injectable()
+export class ArduinoDebugAdapterContribution implements DebugAdapterContribution {
+    type = "arduino";
+
+    label = "Arduino";
+
+    languages = ["c", "cpp", "ino"];
+
+    debugAdapterSessionFactory?: DebugAdapterSessionFactory;
+
+    getSchemaAttributes?(): MaybePromise<IJSONSchema[]> {
+        return [
+            {
+                "required": [
+                    "program"
+                ],
+                "properties": {
+                    "program": {
+                        "type": "string",
+                        "description": "Path to the program to be launched",
+                        "default": "${workspaceFolder}/${command:askProgramPath}"
+                    },
+                    "arguments": {
+                        "type": "string",
+                        "description": "Arguments for the program"
+                    },
+                    "runToMain": {
+                        "description": "If enabled the debugger will run until the start of the main function.",
+                        "type": "boolean",
+                        "default": false
+                    },
+                    "gdb": {
+                        "type": "string",
+                        "description": "Path to gdb",
+                        "default": "arm-none-eabi-gdb"
+                    },
+                    "gdbArguments": {
+                        "description": "Additional arguments to pass to GDB command line",
+                        "type": "array",
+                        "default": []
+                    },
+                    "gdbServer": {
+                        "type": "string",
+                        "description": "Path to gdb server",
+                        "default": "pyocd"
+                    },
+                    "gdbServerArguments": {
+                        "description": "Additional arguments to pass to GDB server",
+                        "type": "array",
+                        "default": []
+                    },
+                    "objdump": {
+                        "type": "string",
+                        "description": "Path to objdump executable",
+                        "default": "arm-none-eabi-objdump"
+                    },
+                    "initCommands": {
+                        "description": "Extra gdb commands to run after initialisation",
+                        "type": "array",
+                        "default": []
+                    },
+                    "verbose": {
+                        "type": "boolean",
+                        "description": "Produce verbose log output",
+                        "default": "false"
+                    },
+                    "debugDebugAdapter": {
+                        "type": "boolean",
+                        "description": "Start the debug adapter in debug mode (with --inspect-brk)",
+                        "default": "false"
+                    }
+                }
+            }
+        ]
+    }
+
+    getConfigurationSnippets?(): MaybePromise<IJSONSchemaSnippet[]> {
+        return []
+    }
+
+    provideDebugAdapterExecutable?(config: DebugConfiguration): MaybePromise<DebugAdapterExecutable> {
+        let args: string[] = [];
+        if (!!config.debugDebugAdapter) {
+            args.push('--inspect-brk')
+        }
+        args = args.concat([path.join(__dirname, 'debug-adapter', 'index.js')]);
+
+        return {
+            command: "node",
+            args: args,
+        }
+    }
+
+    provideDebugConfigurations?(workspaceFolderUri?: string): MaybePromise<DebugConfiguration[]> {
+        return [];
+    }
+
+    resolveDebugConfiguration?(config: DebugConfiguration, workspaceFolderUri?: string): MaybePromise<DebugConfiguration> {
+        return config;
+    }
+
+}

arduino-debugger-extension/src/node/arduino-debug-adapter-contribution.ts

@@ -0,0 +1,7 @@
+import { ContainerModule } from 'inversify';
+import { DebugAdapterContribution } from '@theia/debug/lib/common/debug-model';
+import { ArduinoDebugAdapterContribution } from './arduino-debug-adapter-contribution';
+
+export default new ContainerModule((bind, unbind, isBound, rebind) => {
+    bind(DebugAdapterContribution).to(ArduinoDebugAdapterContribution).inSingletonScope();
+});

arduino-debugger-extension/src/node/backend-module.ts

@@ -0,0 +1,151 @@
+/*
+* CMSIS Debug Adapter
+* Copyright (c) 2017-2019 Marcel Ball
+* Copyright (c) 2019 Arm Limited
+*
+* The MIT License (MIT)
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all
+* copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*/
+
+import { EOL } from 'os';
+import { spawn, ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+import { dirname } from 'path';
+import { CmsisRequestArguments } from './cmsis-debug-session';
+
+const TIMEOUT = 1000 * 10; // 10 seconds
+
+export abstract class AbstractServer extends EventEmitter {
+
+    protected process?: ChildProcess;
+    protected outBuffer: string = '';
+    protected errBuffer: string = '';
+    protected launchResolve?: () => void;
+    protected launchReject?: (error: any) => void;
+    protected timer?: NodeJS.Timer;
+
+    public spawn(args: CmsisRequestArguments): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            this.launchResolve = resolve;
+            this.launchReject = reject;
+
+            try {
+                this.timer = setTimeout(() => this.onSpawnError(new Error('Timeout waiting for gdb server to start')), TIMEOUT);
+
+                const command = args.gdbServer || 'gdb-server';
+                const serverArguments = await this.resolveServerArguments(args.gdbServerArguments);
+                this.process = spawn(command, serverArguments, {
+                    cwd: dirname(command),
+                });
+
+                if (!this.process) {
+                    throw new Error('Unable to spawn gdb server');
+                }
+
+                this.process.on('exit', this.onExit.bind(this));
+                this.process.on('error', this.onSpawnError.bind(this));
+
+                if (this.process.stdout) {
+                    this.process.stdout.on('data', this.onStdout.bind(this));
+                }
+                if (this.process.stderr) {
+                    this.process.stderr.on('data', this.onStderr.bind(this));
+                }
+            } catch (error) {
+                this.onSpawnError(error);
+            }
+        });
+    }
+
+    public kill() {
+        if (this.process) {
+            this.process.kill('SIGINT');
+        }
+    }
+
+    protected async resolveServerArguments(serverArguments?: string[]): Promise<string[]> {
+        return serverArguments || [];
+    }
+
+    protected onExit(code: number, signal: string) {
+        this.emit('exit', code, signal);
+
+        // Code can be undefined, null or 0 and we want to ignore those values
+        if (!!code) {
+            this.emit('error', `GDB server stopped unexpectedly with exit code ${code}`);
+        }
+    }
+
+    protected onSpawnError(error: Error) {
+        if (this.launchReject) {
+            this.clearTimer();
+            this.launchReject(error);
+            this.clearPromises();
+        }
+    }
+
+    protected onStdout(chunk: string | Buffer) {
+        this.onData(chunk, this.outBuffer, 'stdout');
+    }
+
+    protected onStderr(chunk: string | Buffer) {
+        this.onData(chunk, this.errBuffer, 'stderr');
+    }
+
+    protected onData(chunk: string | Buffer, buffer: string, event: string) {
+        buffer += typeof chunk === 'string' ? chunk
+                : chunk.toString('utf8');
+
+        const end = buffer.lastIndexOf('\n');
+        if (end !== -1) {
+            const data = buffer.substring(0, end);
+            this.emit(event, data);
+            this.handleData(data);
+            buffer = buffer.substring(end + 1);
+        }
+    }
+
+    protected handleData(data: string) {
+        if (this.launchResolve && this.serverStarted(data)) {
+            this.clearTimer();
+            this.launchResolve();
+            this.clearPromises();
+        }
+
+        if (this.serverError(data)) {
+            this.emit('error', data.split(EOL)[0]);
+        }
+    }
+
+    protected clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+
+    protected clearPromises() {
+        this.launchResolve = undefined;
+        this.launchReject = undefined;
+    }
+
+    protected abstract serverStarted(data: string): boolean;
+    protected abstract serverError(data: string): boolean;
+}