Visual Studio Code development with gcc and openocd

RE: Visual Studio Code development with gcc and openocd

Koenigs — Wed, 01 Jan 2020 22:18:28 GMT

Wow thanks a lot Davide for this complete explanation.

I understand well how VsCode works now, the difficulty for me is mostly to understand all the embedded tools.

As I said, for the moment I'm working on another non-embedded project but I'll for sure come read again your comment when I'll be back on embedded stuffs in the future.

Thanks again

EDIT: I was at the same time trying to use Zephyr RTOS instead of the Nordic SDK but it's adding even more complexity to the task

RE: Visual Studio Code development with gcc and openocd

Davide — Tue, 17 Dec 2019 17:48:18 GMT

Dear Koenigs,

I don't have time to write a complete tutorial but I'll try to write here a brief description on how I managed to do it (I found 99% of the resources by searching with google, the remaining 1% is probably experience). This refers to a linux machine (I tested the same on macOs and it works, but I never tested this on windows).

First of all you need all the gcc toolchain set up. In other words you need arm-none-eabi-gcc working on your machine, make and all the components to build the .elf file (can be .out in some cases).

If you have arm-none-eabi-gcc probably you also have arm-none-eabi-gdb, but in order to debug you need also a version of openOCD that works for your target MCU (Nordic DKs are well supported in all the recent versions).

Then you need vscode and its cortex-debug extension.

With this in your hand, from vscode open the folder that contains the makefile or the folder you prefer as the "root" of the project and now you can create a debug configuration from vscode, it will create a launch.json. You must modify that file to make it similar to the one I posted above (of course you must fix the "executable" path, and maybe also the configFiles). Moreover, in order to compile the code automatically when you press the debug button you also need the task.json posted above ("command" is simply "make" on regular projects). If you also provide the SVD file for your MCU (I think it is somewhere in the sdk) vscode also have an handy view of the peripheral registers during debug.

Now, by pressing the debug button it should compile and then bring you to the debug interface where you can do step by step debugging.

Notes:

Keep in mind that making this work requires many components developed by a number of independent communities, and when something doesn't work it is not always easy to understand where the problem is and where to look for the solution. I suggest you to test one component at the time from the command line, for instance to test openocd on a nordic dk you should call:

openocd -f board/nordic_nrf52_dk.cfg

and look for some positive response, if you get some error you know that it is related to openocd and you won't bother vscode community for that.

In a similar way you can test arm-none-eabi-gdb. Please search in google a guide to run gdb from command line, in few words you must have the openocd instance running (without errors) and in another terminal you just execute arm-none-eabi-gdb. Once arm-none-eabi-gdb is launched, openocd should print some message informing that a client has connected.

Once you have all this working, it should work also in vscode, and if it doesn't you have to spend you engineering skills to debug it (this is actually what I do when I start a new project).

If you look online there are some tutorials, but I understand that they are not always clear in particular if you have never used vscode. However give it a try, the learning curve is not steep, it took a couple of days for me and I started from zero experience with vscode (but quite a lot of experience in embedded and linux command line).

RE: Visual Studio Code development with gcc and openocd

Koenigs — Fri, 13 Dec 2019 15:37:34 GMT

Hello,

I'm a beginner in embedded programming and I wanted to use the same setup as yours.
Sadly several months ago I didn't find enough resources and I was stuck trying to integrate GDB and OpenOCD altogether in my VS Code project.
I temporary gave up and switched to another non-embedded project.

Would you mind to share a sample project on Github to simply demonstrate how these tools integrate together?
That would be an interesting resource for the community in my opinion.

Thanks a lot

RE: Visual Studio Code development with gcc and openocd

Davide — Mon, 14 Oct 2019 13:06:10 GMT

So, now it works.

I don't know where the problem was because that launch.json was derived from a working one (it was working with third party ARM device). However, I fixed it by using the Cortex-Debug extension of vscode.

That extension was actually already installed, however it was not properly used. In fact, in order to use it, the configuration inside the launch.json is required to be "type":"cortex-debug".

Now the working launch.json is like this:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug Nordic",
            "type": "cortex-debug",
            "request": "launch",
            "servertype": "openocd",
            "executable": "${workspaceRoot}/pca10040/s132/armgcc/_build/nrf52832_xxaa.out",
            "cwd": "${workspaceRoot}",
            "preLaunchTask": "build",
            "runToMain": true, //does not look to work for now
            "debuggerArgs": [
                "--directory=/home/giova/workspaces/GIT/time_of_flight_ble/nRF5_SDK_14.0.0_3bcc1f7" //not sure it is required
            ],
            "searchDir": ["/usr/local/share/openocd/scripts"],
            "device":"nRF52832_xxAA", //required if "servertype":"jlink",
            //   "svdFile": //used for peripheral view
            //   "swoConfig":{ //see https://marcelball.ca/projects/cortex-debug/cortex-debug-swo-decoding-and-graphing/
            //       "enabled": false,
            //       "swoFrequency": 0,
            //       "cpuFrequency": 0,
            //       "ports":{ //to populate see https://marcelball.ca/projects/cortex-debug/cortex-debug-swo-decoding-and-graphing/
            //       }
            //   },

            "graphConfig": [],
            "showDevDebugOutput": true,
            "configFiles": [
                "board/nordic_nrf52_dk.cfg"
            ],
            "linux": {},
        },
    ]
  }

This file also requires task.json which defines how to build the project:

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "type": "shell",

            "args": [],
            "linux": {
                "command": "${workspaceRoot}/pca10040/s132/armgcc/build_script.sh" //substitute with "make" for regular builds
            },
        },

    ]
}

These configuration is just the first one working. Probably there are better ways to configure it (for instance by using only relative paths), nevertheless they can be used as reference.

RE: Visual Studio Code development with gcc and openocd

Nguyen Hoan Hoang — Fri, 11 Oct 2019 14:21:20 GMT

Of course young one ("Yoda style"), everyone has their own preferences. Some prefer tab some prefer spaces. Some like it blue some like it black. heheh!!

RE: Visual Studio Code development with gcc and openocd

Davide — Fri, 11 Oct 2019 14:20:00 GMT

Ok, thanks.

RE: Visual Studio Code development with gcc and openocd

Nguyen Hoan Hoang — Fri, 11 Oct 2019 14:15:42 GMT

CMSIS-DAP is ARM standard debug port access protocol. So it is supported by all IDE and OpenOCD as well. The IDAP-Link is a CMSIS-DAP based jtag probe. GDB is still required for debugging.

RE: Visual Studio Code development with gcc and openocd

Davide — Fri, 11 Oct 2019 13:31:28 GMT

Sorry, a quick related question. Is CMSIS-DAP and alternative to gdb? Or are they different stuff?

I still don't have a clear picture of the roles of all the components.

RE: Visual Studio Code development with gcc and openocd

Davide — Fri, 11 Oct 2019 13:27:58 GMT

Ah ok, so you stopped using makefiles when I was just born..eheh. Jokes apart, these are personal choices, they can be shared or not.

RE: Visual Studio Code development with gcc and openocd

Nguyen Hoan Hoang — Fri, 11 Oct 2019 13:12:37 GMT

Actually not, I only use relative path in native project. That is non issue for me. It also support all macro just like makefile. I stopped using makefile file 30 years ago and never come back to that. A colleague of mine even setup an auto build machine using native eclipse project directly.

RE: Visual Studio Code development with gcc and openocd

Davide — Fri, 11 Oct 2019 13:05:49 GMT

Yes probably with native project the symbols are much easier to get recognized, but then it is really hard to synchronize the project on git. You can just push all the .project files, but then absolute path might brake at every pull, and diff operation would work badly. With makefiles the synchronization of project is much cleaner and again, once you understood the makefile configuration for an ARM MCU model, it is almost the same on the others.

I have been really a fan of Eclipse in the past years, but for me it is time to try something else.

RE: Visual Studio Code development with gcc and openocd

Nguyen Hoan Hoang — Fri, 11 Oct 2019 12:41:46 GMT

I think the problem was that used makefile project. Eclipse native project works better. Probably due to the fact that it does not have the include path. While native project have all the paths to resolve the missing definition. I use only native Eclipse project. It works fine for me. Nonetheless, I am still interested to find a way to add support of VS code to this multiplatform multiarchitecture library github.com/.../IOsonata

RE: Visual Studio Code development with gcc and openocd

Davide — Fri, 11 Oct 2019 11:21:39 GMT

oh yes, I also tried index rebuild. When I read the tutorial I managed to make it work the first time, however after a while it stopped. I repeated all the steps several times but without luck.

For VSCode there is a jlink extension that should do the job for what concerns Nordic DKs (there are some related questions in this forum about it), however it can be applied only to jlink based boards. I would like a generic tool that can be configured also on other mcu, at least arm ones.

RE: Visual Studio Code development with gcc and openocd

Nguyen Hoan Hoang — Thu, 10 Oct 2019 15:20:46 GMT

Thanks for the insight. Yeah, I know the red thing is quite annoying. One way I found to reduce it is to go to project/C/C++ index/Rebuild.

I'll try VSCode when I get some free time. It would be great if there is some kind of plugins similar to the GNU ARM eclipse.

RE: Visual Studio Code development with gcc and openocd

Davide — Thu, 10 Oct 2019 14:32:16 GMT

Three reasons:

1) eclipse is heavy to run, I don't have any data but VScode seems lighter. This is important because everything runs on a virtual machine, host is windows and guest is ubuntu.

2) I've put a lot of efforts to make eclipse recognizing all the symbols/include/declaration used in the code, but my projects are still full of red signs/warning/errors, even if gcc compiles perfectly. It is really annoying that the editor doesn't follow the compiler (yes I took a look at the tutorial here on the nordic, and yes I edited the providers string).

3) VScode projects and configurations are much more portable and clean, in particular when the code is on git like repository.

These reasons made me think about trying something else, and VScode was used by most of developers here.

RE: Visual Studio Code development with gcc and openocd

Nguyen Hoan Hoang — Thu, 10 Oct 2019 13:47:44 GMT

May I ask any particular reason why you switch to VS code instead of continuing with Eclipse? Eclipse can work with OpenOCD and multiple MCU targets easily. See here http://embeddedsoftdev.blogspot.com/p/idap-link.html for debugging nRF5x MCU with CMSIS-DAP and OpenOCD with Eclipse.