In firmware development debugging the code is essential to make sure everything works. The Zephyr project provides all the necessary tools to build, flash and debug our applications, but configuring everything to work from an IDE is not straight forward. I spent days figuring it out. Below I will show the steps required for debugging a Zephyr project on Eclipse IDE using OpenOCD.

Example

To demonstrate we will use the hello_world sample from Zephyr available at zephyr/tree/main/samples/hello_world and step debug it on STM32F3DISCOVERY board. While the Zephyr documentation for this board provides information on how to flash and debug, it does not tells us how to configure the Eclipse IDE and step debug applications.

Required tools

Before proceeding, please make sure you have the following tools installed:

1. Eclipse CDT IDE

2. Zephyr RTOS and its dependencies

Prepare the project

First, copy the hello_world project to your preferred directory and create a directory called source and move the contents of hello_world into source. Then move the source directory into hello_world. The source directory is needed because Zephyr’s build tool west uses CMake and the CMake generator expects the files along with the main CMakeLists.txt file inside of a folder (source in our case) when generating for Eclipse IDE.

$ cp -r ~/zephyrproject/zephyr/samples/hello_world/ ~/my_workspace/
$ cd ~/my_workspace/
$ mkdir -p source
$ mv hello_world/* source/
$ mv source/ hello_world/
$ cd hello_world/

At this point the contents of the hello_world directory should look like this:

$ ls -lR
.:
total 4
drwxrwxr-x 3 user user 4096 Mar 28 12:29 source

./source:
total 20
-rw-rw-r-- 1 user user  194 Mar 28 12:21 CMakeLists.txt
-rw-rw-r-- 1 user user   15 Mar 28 12:21 prj.conf
-rw-rw-r-- 1 user user  610 Mar 28 12:21 README.rst
-rw-rw-r-- 1 user user  324 Mar 28 12:21 sample.yaml
drwxrwxr-x 2 user user 4096 Mar 28 12:21 src

./source/src:
total 4
-rw-rw-r-- 1 user user 196 Mar 28 12:21 main.c

Generate the Eclipse Project

Now, we must build the Zephyr project and use CMake’s generator to generate an Eclipse project for us. So, source the zephyr environment and build the project for STM32F3DISCOVERY board with the following commands:

$ source ~/zephyrproject/.venv/bin/activate
$ source ~/zephyrproject/zephyr/zephyr-env.sh
$ west build -p always -d build/ source/ -b stm32f3_disco -G"Eclipse CDT4 - Ninja"

Now, import the project into Eclipse from File -> Import -> General -> Existing Projects into Workspace -> Next -> Browse for the hello_world project -> Finish

Set the Debug Configurations

Select the project on the Project Explorer and go to Run -> Debug Configurations.

Then right click on GDB Open OCD Debugging and create a new configuration.

Now, set the following options are per below points and screenshots

1. Open the “Main” tab of Debug Configurations

2. Type the C/C++ Application name as zephyr/zephyr.elf

3. Open the “Debugger tab”

4. Browse for the OpenOCD executable file inside the zephyr SDK installation directory.

5. Verify the path of the selected OpenOCD executable.

6. Enter TCL port 6333

7. Enter the following OpenOCD config options. Please verify the paths according to your system.

-s /home/<username>/zephyrproject/zephyr/boards/arm/stm32f3_disco/support

-s /home/<username>/zephyr-sdk-0.16.3/sysroots/x86_64-pokysdk-linux/usr/share/openocd/scripts

-f /home/<username>/zephyrproject/zephyr/boards/arm/stm32f3_disco/support/openocd.cfg

8. Browse for the GDB executable file inside the zephyr SDK installation directory.

9. Click Debug to start debugging.

Debug the project

All settings are done, now you can step debug the project.

Thanks for reading!

The Zephyr RTOS supports a wide range of boards and devices and the list is growing every day. But, like myself, you might face a situation where your application requires a peripheral or a sensor which is not supported by Zephyr yet. One way to tackle the situation is to write an application-level driver and call its functions directly, but the proper way would be if the driver can be put into Zephyr’s device driver model and use Zephyr’s Sensing Subsystem APIs to communicate with the driver. Luckily, Zephyr supports out-of-tree builds where you can add a device driver for a new peripheral to your project without modifying Zephyr’s source code. This device driver will follow Zephyr’s device driver model although not being part of the Zephyr RTOS’s source code.

zephyr_custom_driver
 |- source
     |- boards
	 |    |- native_posix.conf
	 |    |- native_posix.overlay
	 |
	 |- dts
	 |    |- bindings
	 |        |- sensor
	 |            |- rdt,sensor_sim.yaml
	 |
	 |- modules
	 |    |- sensor_sim
	 |    |   |- CMakeLists.txt
	 |    |   |- Kconfig
	 |    |   |- sensor_sim.c
	 |    |   |- sensor_sim.h
	 |    |
	 |    |- zephyr
	 |    |    |- module.yml
	 |    |
	 |    |- CMakeLists.txt
	 |    |- Kconfig
	 |
	 |- src
	 |    |- CMakeLists.txt
	 |    |- Kconfig
	 |    |- main.c
	 |
	 |- CMakeLists.txt
	 |- prj.conf
	 |- sample.yaml

description: |
  Sensor simulation driver with dummy data

  Example usage:
  sensor_sim {
    compatible = "rdt,sensor_sim";
    sim-attr = <5>;
  };

compatible: "rdt,sensor_sim"

properties:
  sim-attr:
    type: int
    description: |
      A random integer.

/ {
	sensor_sim1: sensor_sim1 {
		status = "okay";
		compatible = "rdt,sensor_sim";
		sim-attr = <5>;
	};

	sensor_sim2: sensor_sim2 {
		status = "okay";
		compatible = "rdt,sensor_sim";
		sim-attr = <3>;
	};
};

cmake_minimum_required(VERSION 3.20.0)

# Add our modules directory to Zephyr Modules
list(APPEND ZEPHYR_EXTRA_MODULES ${CMAKE_CURRENT_SOURCE_DIR}/modules)

# Set project, dts and board directories
set(PROJ_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/)
set(DTS_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/dts)
set(BOARD_ROOT ${CMAKE_CURRENT_LIST_DIR})


find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(zephyr_custom_driver)

add_subdirectory(src)

#define DT_DRV_COMPAT rdt_sensor_sim

struct sensor_sim_config {

};

struct sensor_sim_data {
	int sensor_attr;
	uint32_t sensor_val;
};

static int sensor_sim_init(const struct device *dev)
{
	ARG_UNUSED(dev);
	int ret = 0;

	LOG_INF("sensor_sim_init");

	return ret;
}

static const struct sensor_driver_api sensor_sim_driver_api = {
	.sample_fetch = sensor_sim_sample_fetch,
	.channel_get = sensor_sim_channel_get,
};

#define DEVICE_INSTANCE(inst) \
\
const static struct sensor_sim_config sensor_sim_##inst##_cfg;\
\
static struct sensor_sim_data sensor_sim_##inst##_drvdata = { \
		.sensor_attr = DT_PROP(DT_DRV_INST(inst),sim_attr), \
}; \
\
DEVICE_DT_INST_DEFINE(inst,						\
		sensor_sim_init,								\
		device_pm_control_nop,							\
		&sensor_sim_##inst##_drvdata,					\
		&sensor_sim_##inst##_cfg,						\
		POST_KERNEL, CONFIG_SENSOR_SIM_INIT_PRIORITY,	\
		&sensor_sim_driver_api);

DT_INST_FOREACH_STATUS_OKAY(DEVICE_INSTANCE);

const struct device* sim_dev1 = DEVICE_DT_GET(DT_NODELABEL(sensor_sim1));
	if (sim_dev1 == NULL) {
		LOG_ERR("device sensor_sim1 not found");
		return -1;
	}

	const struct device* sim_dev2 = DEVICE_DT_GET(DT_NODELABEL(sensor_sim2));
	if (sim_dev2 == NULL) {
		LOG_ERR("device sensor_sim2 not found");
		return -1;
	}

	struct sensor_value val;

	while (1) {
		sensor_sample_fetch_chan(sim_dev1, SENSOR_CHAN_AMBIENT_TEMP);
		sensor_channel_get(sim_dev1, SENSOR_CHAN_AMBIENT_TEMP, &val);
		LOG_INF("sim1 val = %d\n", val.val1);

		sensor_sample_fetch_chan(sim_dev2, SENSOR_CHAN_AMBIENT_TEMP);
		sensor_channel_get(sim_dev2, SENSOR_CHAN_AMBIENT_TEMP, &val);
		LOG_INF("sim2 val = %d\n", val.val1);

		k_sleep(K_MSEC(1000));
	}

Thanks for reading! Please send your comments or questions.

In this article I will show how to use CMake in a simple C++ project to generate the required makefiles and build the project on Linux and Windows host machines. Let’s get started.

CMake Installation

$ cmake --version

$ sudo apt install cmake

Other tools to install

To build a C/C++ project you must install a compiler and a make utility. Here I will show how to install and use the gcc, g++ and make utilities.

$ gcc --version
$ g++ --version
$ make --version

$ sudo apt install make gcc gcc-multilib g++-multilib

$ pacman -S mingw-w64-ucrt-x86_64-gcc
$ pacman -S cmake
$ pacman -S make

Verify each installation by running the below commands:

$ gcc --version
$ g++ --version
$ cmake --version
$ make --version

If all is good you can generate and build your program using CMake

Configure a C/C++ project with CMake

Consider the below C++ project having multiple sub-directories. Each of the directories contains a “CMakeLists.txt” file. These CMakeLists.txt files contains the necessary cmake configurations to generate the relevant makefiles and compile the program:

cmake_cpp
    |- source
            |- CMakeLists.txt
            |- src
                 |- CMakeLists.txt
                 |- main.cpp
                 |
                 |- module1
                 |      |- CMakeLists.txt
                 |      |- module1.cpp
                 |      |- module1_priv.h
                 |
                 |- module2
                 |      |- CMakeLists.txt
                 |      |- module2.cpp
                 |      |- module2_priv.h
                 |
                 |- include
                         |- main.h
                         |- module1.h
                         |- module2.h

Below are the content and explanation of each CMakeLists.txt file.

cmake_cpp/source/CMakeLists.txt`

# set the minimum cmake version requirement
cmake_minimum_required(VERSION 3.20)

# set the project name and version number
project (cmake_cpp
	VERSION 0.1
	DESCRIPTION "CMake demo")

# This project will output an executable file called app
add_executable(app "")

# add the next lower level directory
add_subdirectory(src)

cmake_cpp/source/src/CMakeLists.txt

# add the next lower level directories
add_subdirectory(module1)
add_subdirectory(module2)

# make a list of source files to be compiled
list(APPEND app_sources 
			main.cpp
# 			add more source files here
	)

# this function adds the list of source files to the executable app
target_sources(app PUBLIC ${app_sources})

# add paths to include directories
target_include_directories(app PUBLIC . include)

cmake_cpp/source/src/module1/ CMakeLists.txt (same for cmake_cpp/source/src/module2/ CMakeLists.txt)

# make a list of source files to be compiled
list(APPEND app_sources 
			module1.cpp
# 			add more source files here
	)

# this function adds the list of source files to the executable app
target_sources(app PUBLIC ${app_sources})

# if there is a need to add module specific include directories, uncomment the following line
#target_include_directories(app PUBLIC .)

Generate and Build

The next step is to generate the relevant makefiles and then call the make utility to compile and link and build the executable. Below are the set of commands to do so. Please note these commands will run on Ubuntu and Windows (tested in MSYS2)

Change to the `cmake_cpp` directory (the below command is considering the directory is at /home/user)

$ cd /home/user/cmake_cpp

The next command is to tell the cmake program to use the files under the source directory and generate the necessary makefiles inside a build directory. Note that the build directory may or may not be present. If not present the cmake program will create the build directory.

$ cmake -Ssource -Bbuild

Next is to compile the code. This command tells the cmake program to compile the files present inside `build` directory.

$ cmake --build build

Use the below commands if the above build fails. If cmake cannot find the compiler, the path can be set from the command line. A known issue with MSYS2 is, it may use the gcc compiler in place of g++ compiler. If you get linker errors of undefined references to C++ standard library objects, then set the g++ compiler as shown below.

$ cmake -DCMAKE_CXX_COMPILER=/ucrt64/bin/g++.exe -Ssource -Bbuild
$ cmake --build build

Use the command whereis g++ to get the path to the g++ executable

CMake can also generate configuration files for IDEs. Below is a list of Generators available. Use cmake –help to see the list.

Generators

The following generators are available on this platform (* marks default):
  Green Hills MULTI            = Generates Green Hills MULTI files
                                 (experimental, work-in-progress).
* Unix Makefiles               = Generates standard UNIX makefiles.
  Ninja                        = Generates build.ninja files.
  Ninja Multi-Config           = Generates build-<Config>.ninja files.
  Watcom WMake                 = Generates Watcom WMake makefiles.
  CodeBlocks - Ninja           = Generates CodeBlocks project files.
  CodeBlocks - Unix Makefiles  = Generates CodeBlocks project files.
  CodeLite - Ninja             = Generates CodeLite project files.
  CodeLite - Unix Makefiles    = Generates CodeLite project files.
  Eclipse CDT4 - Ninja         = Generates Eclipse CDT 4.0 project files.
  Eclipse CDT4 - Unix Makefiles= Generates Eclipse CDT 4.0 project files.
  Kate - Ninja                 = Generates Kate project files.
  Kate - Unix Makefiles        = Generates Kate project files.
  Sublime Text 2 - Ninja       = Generates Sublime Text 2 project files.
  Sublime Text 2 - Unix Makefiles
                               = Generates Sublime Text 2 project files.

For instance, if you want to generate the cmake_cpp program for Eclipse IDE use the below command.

$ cmake -Ssource -Bbuild -G"Eclipse CDT4 - Unix Makefiles"
$ cmake --build build

To enable debugging in Eclipse IDE use.

$ cmake -Ssource -Bbuild -DCMAKE_BUILD_TYPE=Debug -G"Eclipse CDT4 - Unix Makefiles"
$ cmake --build build

The Eclipse project is generated inside the build directory. To open the project in eclipse go to File -> Import -> Existing Projects into Workspace and browse for the cmake_cpp/build directory

Source files

Complete source can be found in the following github link:

https://github.com/deyro/cmake_cpp

I hope the information provided here is useful and will help others to get started with using CMake in C/C++ projects.

For any questions please comment.

Do check out my other posts https://rodeytech.com/blog/