Running Code

Once your environment has been set up and you have some code to run, you need to compile it and push it to the device. As with nearly everything else, this is more complicated for embedded development than other types of software development, so this page aims to explain the process. Although there are a couple of different methods of accomplishing this, each method has the same three goals: compiling a binary, flashing the microcontroller (uC), and handling I/O.

MacOS/Linux

Building Code

Build instructions can be found in 'EVT-core/README.md'. Instructions are mostly duplicated here

Navigate to EVT-core directory
Run the following commands
1. mkdir build/
  cd build/
  cmake -DEVT_CORE_LOG_ENABLE=1 -DTARGET_DEV=STM32F302x8 ../
  make -j8
2. Above commands create build directory, set up cmake build project, then actually compile the code
3. When building EVT-core in this manner all samples code is compiled.
4. EVT_CORE_LOG_ENABLE is used to toggle logger functionality.
5. TARGET_DEV is used to specify what STM32 chip is being compiled for.

Programming STM Nucleo Board

Example is for an EVT-core sample, but the procedure is the same for any compiled EVT code

Connect the STM Nucleo board via Mini-USB to your PC
1. Device should be visible as a removable media device. On my PC the mount path is '/media/<username>/NODE_F302R8'
2. If it's not, you can manually mount with sudo mount /dev/<device name> <wherever you want to mount it>
  1. To find the device name, use lsblk , it's typically sda and does not contain any partitions
  2. MAKE SURE YOU SELECT THE CORRECT ONE OR YOU COULD CORRUPT A DRIVE
Copy compiled bin file to nucleo board
1. Example for blink sample
  1. cp <EVT-core dirctory>/build/samples/blink/blink.bin /media/<username>/NODE_F302R8
    1. may need sudo

Note: If debugging with UART I would recommend using gtkterm.

Building and Programming in Clion

In the top right there should be a drop down menu with build configurations
1. Click the drop-down
2. Select Edit Configurations
3. In the opened window click the '+' in the top left to add a new configuration
4. Select 'OpenOCD Download & Run' for the template
  1. Set the Desired Name
  2. Select the sample target and executable (example: 'blink')
  3. Click 'Assist...' button next to board config file
  4. Select st_nucleo_f3.cfg from list
  5. Other settings should work as default
5. Click OK
Select the new config from the dropdown menu
Click the Play button to build and program the connected ST Nucleo board.

Debugging in Clion

Complete the Steps outlined above in 'Building and Programming in Clion'
Add a breakpoint in the code
1. Click to the left of a line of code
Click the Bug Icon next to the desired build configuration
1. Clion will automatically connect GDB to the server run on the nucleo device and pause on your breakpoints
2. If you get a timeout waiting for target to reset issue editing the 'reset_config' line in the board configuration file to
  1. reset_config none separate
  2. See https://github.com/vsergeev/arm-bmw-sw/issues/1
Navigate the debugger as desired. See tutorial here: https://www.jetbrains.com/help/clion/debugging-code.html
1. View variables in right menu with access to full memory view
2. Click arrows in top row to navigate code execution (Step Over, Step Into, ...)
3. (Optional) Load SVD file to view peripheral status of STM board.
  1. Download svd files by cloning repo at https://github.com/posborne/cmsis-svd
  2. While debugging within Clion select the peripherals tab
  3. Choose SVD file at <path to cmsis-svd repo>/data/STMicro/STM32F446.svd (for example. actual file may differ)

Windows

Building in CLion

Specify compilation flags in File -> Settings -> Build, Execution, Deployment -> CMake -> CMake options
1. EVT_CORE_LOG_ENABLE is used to toggle logger functionality (1 for on, 0 for off).
  1. 1. Ex: -DEVT_CORE_LOG_ENABLE=1 to enable
2. TARGET_DEV is used to specify what STM32 chip is being compiled for.
  1. Ex: -DTARGET_DEV=STM32F302x8 for F302s
Select the executable you would like to build from the dropdown in the top right
Click the green hammer next to the dropdown to run the build
If the build is successful, there should now be a bin file in your build folder
1. The location of the bin file should mirror the folder structure of the project you're in
2. For example, in EVT-core, if you build the adc executable, which is in samples/adc, the bin file is found in {build-folder-name}/samples/adc
3. This location is based on the structure generated by the CMakeLists.txt files, not the actual file structure, so this may not always be true, although it should be if proper organizational standards are followed

Programming

Because the Nucleo has an onboard uC for programming the main chip, you can just plug it into your computer via USB and program it directly. Flashing it can be done with the following steps:

Plug the Nucleo into the computer, and open file explorer
Find and select the Nucleo from the list of devices under This PC → Devices and Drives
Copy and paste the .bin file into the Nucleo's files
If the Nucleo is programming correctly, the LED on it should be flashing between green and red
Once this flashing stops, the Nucleo should be running the code given to it

All of EVT's custom PCBs expose a JTAG header, which can be used for a number of different things, including programming the board and communicating via UART. To interface with this header, you will need an ST-LINK and the STM32CubeProgammer, which can be downloaded here. You do unfortunately need to make an account to download the software, but the process is fairly straightforward. Flashing one of these boards can be done with the following steps:

Plug the ST-LINK into the JTAG header and the computer
1. If the plastic surrounding the JTAG header is damaged, it is easy to misplace the JTAG connector by a single column of pins, so be sure to check this if there are problems connecting to the board
Open the STM32CubeProgrammer
Select the second option from the options at the top of the left side bar, titled "Erasing and Programming"
On the right side, under ST-LINK configuration, select the serial number of the board you are trying to program, refreshing as necessary
In the top right corner, click Connect
1. At this point, if the connection is successful, it should say "Connected" in the top right corner
Set the file bath to the .bin file you would like to program the board with
Click "Start Programming"
If the ST-LINK is programming correctly, the LED on it should be flashing between green and red
Once this flashing stops, the board should be running the code given to it

Debugging

Debugging with PuTTY is often the fastest and easiest way to get output from a board. PuTTY interfaces with the COM ports on your computer, which allows it to send and receive data over UART. PuTTY can be set up with the following steps:

Setup.
1. Install PuTTY
  1. https://www.putty.org/
2. Determine COM number for STM device
  1. Open Windows Device Manager
    1. Right Click Start Icon
    2. Click 'Device Manager'
  2. Expand 'Ports (COM & LPT)' menu
  3. Device should appear as 'USB Serial Device' or something similar
    1. Take a note of the COMx number (ex. COM5)
3. Launch PuTTY
4. Select Connection Type 'Serial'
5. Enter the COMx value in the Serial Line box
6. Enter Baud Rate in Speed Box (usually 9600)
Testing
1. Once PuTTY is open, it can be used to send text to and receive text from the board via UART
2. Any code that calls uart.printf() will write its text here
3. Any code that calls uart.getc() will read text you input here

While PuTTY is very simple and easy, it has its limitations because it requires the uC to be able to use UART properly, which, depending on the severity of the error, may not be the case. In these cases, we need software that uses SWD instead of UART to communicate. The software we use as a team to do this is called OpenOCD. This can be set up to work in CLion with the following steps:

Setup
1. Install OpenOCD
  1. Download windows zip from https://github.com/xpack-dev-tools/openocd-xpack/releases
    1. Select the option that is a .zip file. You may need to select "More options" at the bottom.
  2. Extract Contents to desired install location.
    1. Take note of path and try to avoid spaces
  3. Open the extracted folder and move all of the files in the 'openocd' subdirectory up a level.
  4. Setup Path to OpenOCD in Clion IDE
    1. Within Clion Select File → Settings → Build, Execution, Deployment → Embedded Development
    2. Set OpenOCD Location to the path to the openocd.exe located at <OpenOCD install location>\bin\openocd.exe
2. In the top right there should be a drop down menu with build configurations
  1. Click the drop-down
  2. Select Edit Configurations
  3. In the opened window click the '+' in the top left to add a new configuration
  4. Select 'OpenOCD Download & Run' for the template
    1. Set the Desired Name
    2. Select the sample target and executable (example: 'blink')
    3. Click 'Assist...' button next to board config file
    4. Select st_nucleo_f3.cfg from list
    5. Other settings should work as default
  5. Click OK
Running
1. Select the new config from the dropdown menu
2. Click the Play button to build and program the connected ST Nucleo board.
3. If you have an issue with libusb errors, follow the following steps
  1. Download USB Driver Tool: https://visualgdb.com/UsbDriverTool/
  2. Launch Tool via .exe
  3. Right Click on ST-Link Device
  4. Select Install LibUSB
Debugging
1. Add a breakpoint in the code
  1. Click to the left of a line of code
2. Click the Bug Icon next to the desired build configuration
  1. CLion will automatically connect GDB to the server run on the nucleo device and pause on your breakpoints
3. Navigate the debugger as desired. See tutorial here: https://www.jetbrains.com/help/clion/debugging-code.html
  1. View variables in right menu with access to full memory view
  2. Click arrows in top row to navigate code execution (Step Over, Step Into, ...)
  3. (Optional) Load SVD file to view peripheral status of STM board.
    1. Download svd files by cloning repo at https://github.com/posborne/cmsis-svd
    2. While debugging within CLion select the peripherals tab
    3. Choose SVD file at <path to cmsis-svd repo>/data/STMicro/STM32F446.svd (for example. actual file may differ)

Page updated

Report abuse