Fix pyocd launch and other small improvements (#23)

* refactor and logging
* prepend 'gdbserver' option for pyocd
* removed auto-filled 'target' and 'pack' options
* comment in cbuild run file support
* resolve args as late as possible
* remove reset before load
* change pyOCD to pyocd for Unix
* pyocd debug setup docs

---------

Signed-off-by: Jens Reinecke <[email protected]>

Author: jreineckearm

README.md

@@ -20,7 +20,22 @@ The following extensions are included in this extension pack:
 - [Memory Inspector](https://marketplace.visualstudio.com/items?itemName=eclipse-cdt.memory-inspector), an Eclipse CDT Cloud extension that provides a powerful and configurable memory viewer that works with debug adapters.
 - [Peripheral Inspector](https://marketplace.visualstudio.com/items?itemName=eclipse-cdt.peripheral-inspector), an Eclipse CDT Cloud extension that provides a CMSIS SVD viewer and works with debug adapters.
 
-## Additional Functionality
+## pyOCD Debug Setup
+
+- Install `GCC compiler for ARM CPUs` with the `Arm Tools Environment Manager` to get access to a GDB (`arm-none-eabi-gdb`).
+
+- (Temporary, should become obsolete with full `*.cbuild-run.yml` support in pyOCD)<br> 
+  Make sure to set up your CMSIS Pack installation root folder by one of the following methods:
+  - Set your system environment variable `CMSIS_PACK_ROOT`.
+  - Add the following to your debug launch configuration
+    ```
+    "environment": {
+      "CMSIS_PACK_ROOT": "</path/to/your/pack/cache>"
+    }
+
+    ```
+
+## Additional Extension Functionality
 
 This extension contributes additional functionality to more seamlessly integrate the included extensions:
 - The pseudo debugger types `cmsis-debug-pyocd` and `cmsis-debug-jlink`. These types allow a more seamless integration into the VS Code IDE. However, these are not full debug adapters but generate debug configurations of type `gdbtarget` which comes with the [CDT GDB Debug Adapter Extension](https://marketplace.visualstudio.com/items?itemName=eclipse-cdt.cdt-gdb-vscode).

package.json

@@ -57,13 +57,12 @@
             "program": "${command:cmsis-csolution.getBinaryFile}",
             "gdb": "arm-none-eabi-gdb",
             "initCommands": [
-              "monitor reset halt",
               "load",
               "break main",
               "continue"
             ],
             "target": {
-              "server": "pyOCD",
+              "server": "pyocd",
               "port": "3333"
             },
             "cmsis": {
@@ -83,13 +82,12 @@
               "program": "^\"\\${command:cmsis-csolution.getBinaryFile}\"",
               "gdb": "arm-none-eabi-gdb",
               "initCommands": [
-                "monitor reset halt",
                 "load",
                 "break main",
                 "continue"
               ],
               "target": {
-                "server": "pyOCD",
+                "server": "pyocd",
                 "port": "3333"
               },
               "cmsis": {

src/debug-configuration/gdbtarget-configuration-provider.ts

@@ -51,6 +51,17 @@ export class GDBTargetConfigurationProvider implements vscode.DebugConfiguration
         );
     }
 
+    private logDebugConfiguration(resolverType: ResolverType, config: vscode.DebugConfiguration, message = '') {
+        logger.debug(`${resolverType}: ${message}`);
+        logger.debug(JSON.stringify(config));
+    }
+
+    private logGdbServerCommandLine(resolverType: ResolverType, config: vscode.DebugConfiguration) {
+        logger.debug(`${resolverType}: GDB server command line`);
+        const resolvedGDBConfig = config as GDBTargetConfiguration;
+        logger.debug(`\t${resolvedGDBConfig.target?.server} ${resolvedGDBConfig.target?.serverParameters?.join(' ')}`);
+    }
+
     private isRelevantSubprovider(resolverType: ResolverType, serverType: string, subProvider: GDBTargetConfigurationSubProvider): boolean {
         const serverTypeMatch = subProvider.serverRegExp.test(serverType);
         const hasResolverFunction = !!subProvider.provider[resolverType];
@@ -65,6 +76,7 @@ export class GDBTargetConfigurationProvider implements vscode.DebugConfiguration
     }
 
     private getRelevantSubprovider(resolverType: ResolverType, serverType?: string): GDBTargetConfigurationSubProvider | undefined {
+        logger.debug(`${resolverType}: Check for relevant configuration subproviders`);
         const subproviders = this.getRelevantSubproviders(resolverType, serverType);
         if (!subproviders.length) {
             logger.debug('No relevant configuration subproviders found');
@@ -74,7 +86,12 @@ export class GDBTargetConfigurationProvider implements vscode.DebugConfiguration
             logger.warn('Multiple configuration subproviders detected. Using first in list:');
             subproviders.forEach((subprovider, index) => logger.warn(`#${index}: '${subprovider.serverRegExp}'`));
         }
-        return subproviders[0];
+        const relevantProvider = subproviders[0];
+        if (!relevantProvider.provider[resolverType]) {
+            logger.debug(`${resolverType}: Subprovider '${relevantProvider.serverRegExp}' does not implement '${resolverType}'.`);
+            return undefined;
+        }
+        return relevantProvider;
     }
 
     private async resolveDebugConfigurationByResolverType(
@@ -83,29 +100,22 @@ export class GDBTargetConfigurationProvider implements vscode.DebugConfiguration
         debugConfiguration: vscode.DebugConfiguration,
         token?: vscode.CancellationToken
     ): Promise<vscode.DebugConfiguration | null | undefined> {
-        logger.debug(`${resolverType}: Check for relevant configuration subproviders`);
+        this.logDebugConfiguration(resolverType, debugConfiguration, 'original config');
         const gdbTargetConfig: GDBTargetConfiguration = debugConfiguration;
         const gdbServerType = gdbTargetConfig.target?.server;
         const subprovider = this.getRelevantSubprovider(resolverType, gdbServerType);
         if (!subprovider) {
-            return debugConfiguration;
-        }
-        if (!subprovider.provider[resolverType]) {
-            logger.debug(`${resolverType}: Subprovider '${subprovider.serverRegExp}' does not implement '${resolverType}'.`);
+            this.logGdbServerCommandLine(resolverType, debugConfiguration);
             return debugConfiguration;
         }
         logger.debug(`${resolverType}: Resolve config with subprovider '${subprovider.serverRegExp}'`);
-        logger.debug(`${resolverType}: original config:`);
-        logger.debug(JSON.stringify(debugConfiguration));
-        const resolvedConfig = await subprovider.provider[resolverType](folder, debugConfiguration, token);
+        const resolvedConfig = await subprovider.provider[resolverType]!(folder, debugConfiguration, token);
         if (!resolvedConfig) {
             logger.error(`${resolverType}: Resolving config failed with subprovider '${subprovider.serverRegExp}'`);
+            return undefined;
         }
-        logger.debug(`${resolverType}: resolved config:`);
-        logger.debug(JSON.stringify(resolvedConfig));
-        logger.debug(`${resolverType}: expected server command line:`);
-        const resolvedGDBConfig = resolvedConfig as GDBTargetConfiguration;
-        logger.debug(`${resolvedGDBConfig.target?.server} ${resolvedGDBConfig.target?.serverParameters?.join(' ')}`);
+        this.logDebugConfiguration(resolverType, resolvedConfig, 'resolved config');
+        this.logGdbServerCommandLine(resolverType, resolvedConfig);
         return resolvedConfig;
     }
 

src/debug-configuration/subproviders/pyocd-configuration-provider.ts

@@ -42,36 +42,25 @@ export class PyocdConfigurationProvider implements vscode.DebugConfigurationProv
         const parameters = debugConfiguration.target.serverParameters ??= [];
         // gdbserver
         if (await this.shouldAppendParam(parameters, 'gdbserver')) {
-            parameters.push('gdbserver');
-        }
-        // target
-        if (await this.shouldAppendParam(parameters, '--target')) {
-            parameters.push('--target');
-            parameters.push('${command:cmsis-csolution.getDeviceName}');
-        }
-        // pack
-        if (await this.shouldAppendParam(parameters, '--pack')) {
-            parameters.push('--pack');
-            parameters.push('${command:cmsis-csolution.getDfpPath}');
+            // Prepend, it must be the first argument
+            parameters.unshift('gdbserver');
         }
         // port (use value defined in 'port' outside 'serverParamters')
         const port = debugConfiguration.target?.port;
-        if (await this.shouldAppendParam(parameters, '--port') && port) {
+        if (port && await this.shouldAppendParam(parameters, '--port')) {
             parameters.push('--port');
             parameters.push(`${port}`);
         }
-        // cbuild-run (ToDo: comment in the code when pyOCD supports it)
-        /*
+        // cbuild-run
         const cbuildRunFile = debugConfiguration.cmsis?.cbuildRunFile;
-        if (await this.shouldAppendParam(parameters, '--cbuild-run') && cbuildRunFile) {
+        if (cbuildRunFile && await this.shouldAppendParam(parameters, '--cbuild-run')) {
             parameters.push('--cbuild-run');
             parameters.push(`${cbuildRunFile}`);
         }
-        */
         return debugConfiguration;
     }
 
-    public async resolveDebugConfiguration(
+    public async resolveDebugConfigurationWithSubstitutedVariables(
         _folder: vscode.WorkspaceFolder | undefined,
         debugConfiguration: vscode.DebugConfiguration,
         _token?: vscode.CancellationToken