STM32F4 – In-circuit Debugging [Revisited]

In this tutorial I update my previous post on configuring in-circuit debugger for STM32F4 using the following open source tools:

• Eclipse Luna (4.4.1);
• GNU ARM Eclipse Plug-ins;
• GCC ARM Embedded Toolchain;
• My project wizard.

1. Prerequisites

• Ubuntu 14.04 LTS (x86 architecture).
• Eclipse C/C++ IDE for Luna SR1 (requires manual installation; direct link).
• STM32F4 Discovery Board (ARM architecture, costs less than 20 EUR).
• Complete the Template Project with Generic Makefile.
  • Or at least go through chapter 2. Below is a quick-and-dirty instruction summary if you decide to stay on this page.

cd ~
# Remove the official package
sudo apt-get purge binutils-arm-none-eabi \
                   gcc-arm-none-eabi \
                   gdb-arm-none-eabi \
                   libnewlib-arm-none-eabi

# Add 3rd party repository
sudo add-apt-repository ppa:terry.guo/gcc-arm-embedded
sudo apt-get update
# Check the GCC package version in the PPA repository
sudo apt-cache policy gcc-arm-none-eabi

# Install
sudo apt-get install build-essential git openocd \
             gcc-arm-none-eabi

# Clone my git repository and init submodules
git clone https://github.com/istarc/stm32.git
cd ~/stm32
git submodule update --init

 2. Install Software Dependencies

2.1 Install Eclipse

Install Eclipse Luna (4.4.1) release for Linux 64-bit for C/C++ developers. Assuming you downloaded the file to the Download folder, execute the following commands to install Eclipse.

cd ~/Downloads
# Untar and move to home folder
sudo tar xzf eclipse-cpp-luna-SR1-linux-gtk-x86_64.tar.gz
mv eclipse ../
# Start the Eclipse from the command-line
~/eclipse/eclipse &

Be sure to start the Eclipse from the command-line, import the old workspace and install GNU ARM Eclipse plug-ins as follows.

1. Help → Install New Software… → Add…
2. Add the GNU ARM Eclipse plug-ins repository.
3. Install the plug-ins.

2.2 Check the OpenOCD version

Check the OpenOCD version and build from scratch, if necessary.

openocd --version

If it is less than 0.9.0, then I recommend you to build the program the from the source in 7 very simple steps as follows (due to some issues with STM32F4). You may find the OpenOCD at /opt/openocd.

# Install build dependencies
sudo apt-get install eclipse-cdt libtool libftdi-dev \
                     libusb-1.0-0-dev \
                     automake pkg-config texinfo
# Clone OpenOCD project
git clone \
 git://openocd.git.sourceforge.net/gitroot/openocd/openocd

# Configure OpenOCD
cd ~/openocd
./bootstrap
./configure --enable-maintainer-mode \
 --disable-option-checking \
 --disable-werror \
 --prefix=/opt/openocd \
 --enable-dummy \
 --enable-usb_blaster_libftdi \
 --enable-ep93xx \
 --enable-at91rm9200 \
 --enable-presto_libftdi \
 --enable-usbprog \
 --enable-jlink \
 --enable-vsllink \
 --enable-rlink \
 --enable-stlink \
 --enable-arm-jtag-ew

# Build and Deploy the OpenOCD project (/opt/openocd)
make # Build
sudo make install # Install

3.  Create a New Project

Create a new project using my project wizard with the mbed-none argument that creates a bare-metal project with mbed SDK support.

mkdir -p ~/stm32/examples/icd-test
cd ~/stm32/examples/icd-test
../../mbed-project-wizard/gen-stm32f407-GCC-project.sh \
                                                    mbed-none

4. Import the Project

Switch back to Eclipse and import the newly created project.

1. File → Import… → C/C++ → Existing Code as Makefile Project
2. Browse… → Navigate to ~/stm32/examples/icd-test and select Cross ARM GCC toolchain.
3. Manually import make targets.
   1. Navigate to Window → Show View → Make Targets.
   2. Expand the project directory.
   3. Right click on the project directory and add a new target by filling in the target name.
   4. Repeat the previous step for the remaining targets: release, release-memopt, release-memopt-blame, debug, clean, deploy.
      1. You may check the project’s Makefile for additional targets.
4. Import the GNU ARM toolchain environment settings.
   1. Navigate to File → Properties → C/C++ Build → Settings.
   2. Deselect “Use global toolchain path” option.
   3. Then reselect it again! This is a hotfix for GNU ARM Eclipse Plug-ins to import environmental variables correctly.
   4. Verify the hotfix (optionally).
      1. Navigate to File → Properties → C/C++ Build → Build Variables.
      2. Enable show system variables.
      3. Check cross_make value.

4. Configure In-Circuit Debugger

1. Build the debug target.
   1. Navigate to Project → Make Target → Build… → clean (or [Shift + F9] → clean).
   2. [Shift + F9] → debug.
2. Create a new debug configuration by navigating to Run → Debug Configurations… → Right click on the GDB OpenOCD Debugging option.
3. Configure the debug configuration
   1. Provide the path to the binary file and select the “Disable auto-build” option — you can optimize that later. 😉
   2. Provide the path to the OpenOCD executable and to the STM32F4-Discovery script.

5. Start Debugging

1.  Edit the main.cpp file in the src folder.
   1. Add a counter variable (see the figure below, line 19).
   2. Increment it before turning on/off LED (see the figure below, line 22 and 26).
2. Build the debug target.
   1. [Shift + F9] → clean.
   2. [Shift + F9] → debug.
3. Run → Debug Configurations… → Double click on the new debug configuration.
4. Wait a few seconds and then step through the code (F5).