This tutorial aims to create a new micro-ROS application on **[Olimex STM32-E407](https://www.olimex.com/Products/ARM/ST/STM32-E407/open-source-hardware)** evaluation board with **[FreeRTOS RTOS](https://www.freertos.org/)**

<div>

<img width="400" style="padding-right: 25px;" src="imgs/3.jpg">

<img width="300" style="padding-right: 25px;" src="imgs/4.png">

</div>

This tutorial uses the following hardware:

| Item | |

|---------------|----------------------------------------------------------|

| Olimex STM32-E407 | [Link](https://www.olimex.com/Products/ARM/ST/STM32-E407/open-source-hardware) |

| Olimex ARM-USB-TINY-H | [Link](https://www.olimex.com/Products/ARM/JTAG/ARM-USB-TINY-H/) |

| USB-Serial Cable Female | [Link](https://www.olimex.com/Products/Components/Cables/USB-Serial-Cable/USB-Serial-Cable-F/) |

First of all make sure that you have a **ROS 2** installation.

***TIP:** if you are familiar with Docker containers, this image may be useful: [ros:dashing](https://hub.docker.com/layers/ros/library/ros/dashing/images/sha256-b796c14ea663537129897769aa6c715a851ca08dffd4875ef2ecaa31a4dbd431?context=explore)*

On the **ROS 2** installation open a command line and follow these steps:

source /opt/ros/$ROS_DISTRO/setup.bash

mkdir microros_ws

cd microros_ws

git clone -b $ROS_DISTRO https://github.com/micro-ROS/micro-ros-build.git src/micro-ros-build

rosdep update

rosdep install --from-path src --ignore-src -y

colcon build

source install/local_setup.bash

Now, let's create a firmware workspace that targets all the required code and tools for Olimex development board and FreeRTOS:

ros2 run micro_ros_setup create_firmware_ws.sh freertos olimex-stm32-e407

Now you have all the required tools to crosscompile micro-ROS and FreeRTOS for Olimex STM32-E407 development board. At this point, you must know that the micro-ROS build system is a four-step workflow:

1. **Create**: retrieves all the required packages for a specific RTOS and hardware platform.

2. **Configure**: configures the downloaded packages with options such as the micro-ROS application, the selected transport layer or the micro-ROS agent IP address (in network transports).

3. **Build**: generates a binary file ready for being loaded in the hardware.

4. **Flash**: load the micro-ROS software in the hardware.

micro-ROS apps for Olimex + FreeRTOS are located at `firmware/freertos_apps/apps`. In order to create a new application, create a new folder containing two files: the app code and the RMW configuration.

cd firmware/freertos_apps/apps

mkdir my_brand_new_app

cd my_brand_new_app

touch app.c app-colcon.meta

For this example we are going to create a ping pong app where a node sends a ping package with a unique identifier using a publisher and the same package is received by a pong subscriber. The node will also answer to:


To start creating this app, lets configure the RMW with the required static memory. You can read more about RMW and Micro XRCE-DDS Configuration [here](/docs/tutorials/basic/microxrcedds_rmw_configuration/) The `app-colcon.meta` should look like:

Meanwhile `app.c` should look like the following code:

#include <allocators.h>

#include <rcl/rcl.h>

#include <rcl_action/rcl_action.h>

#include <rcl/error_handling.h>

#include "rosidl_generator_c/string_functions.h"

#include <std_msgs/msg/header.h>

#include <rmw_uros/options.h>

#include <stdio.h>

#include <unistd.h>

#include <pthread.h>

#define STRING_BUFFER_LEN 100

void * trigger_guard_condition(void *args){

rcl_guard_condition_t * guard_condition = (rcl_guard_condition_t *)args;

while(true){

rcl_trigger_guard_condition(guard_condition);

sleep(5);

}

}

// App main function

void appMain(void *argument)

{

//Init RCL options

rcl_init_options_t options = rcl_get_zero_initialized_init_options();

rcl_init_options_init(&options, rcl_get_default_allocator());

// Init RCL context

rcl_context_t context = rcl_get_zero_initialized_context();

rcl_init(0, NULL, &options, &context);

// Create a node

rcl_node_options_t node_ops = rcl_node_get_default_options();

rcl_node_t node = rcl_get_zero_initialized_node();

rcl_node_init(&node, "pingpong_node", "", &context, &node_ops);

// Create a reliable ping publisher

rcl_publisher_options_t ping_publisher_ops = rcl_publisher_get_default_options();

rcl_publisher_t ping_publisher = rcl_get_zero_initialized_publisher();

rcl_publisher_init(&ping_publisher, &node, ROSIDL_GET_MSG_TYPE_SUPPORT(std_msgs, msg, Header), "/microROS/ping", &ping_publisher_ops);

// Create a best effort pong publisher

rcl_publisher_options_t pong_publisher_ops = rcl_publisher_get_default_options();

pong_publisher_ops.qos.reliability = RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT;

rcl_publisher_t pong_publisher = rcl_get_zero_initialized_publisher();

rcl_publisher_init(&pong_publisher, &node, ROSIDL_GET_MSG_TYPE_SUPPORT(std_msgs, msg, Header), "/microROS/pong", &pong_publisher_ops);

// Create a reliable pong subscriber

rcl_subscription_options_t pong_subscription_ops = rcl_subscription_get_default_options();

rcl_subscription_t pong_subscription = rcl_get_zero_initialized_subscription();

rcl_subscription_init(&pong_subscription, &node, ROSIDL_GET_MSG_TYPE_SUPPORT(std_msgs, msg, Header), "/microROS/pong", &pong_subscription_ops);

// Create a best effort ping subscriber

rcl_subscription_options_t ping_subscription_ops = rcl_subscription_get_default_options();

ping_subscription_ops.qos.reliability = RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT;

rcl_subscription_t ping_subscription = rcl_get_zero_initialized_subscription();

rcl_subscription_init(&ping_subscription, &node, ROSIDL_GET_MSG_TYPE_SUPPORT(std_msgs, msg, Header), "/microROS/ping", &ping_subscription_ops);

// Create a guard condition

rcl_guard_condition_t guard_condition = rcl_get_zero_initialized_guard_condition();

rcl_guard_condition_options_t guard_condition_options = rcl_guard_condition_get_default_options();

rcl_guard_condition_init(&guard_condition, &context, guard_condition_options);

// Create a thread that triggers the guard condition

pthread_t guard_condition_thread;

pthread_create(&guard_condition_thread, NULL, trigger_guard_condition, &guard_condition);

// Create a wait set

rcl_wait_set_t wait_set = rcl_get_zero_initialized_wait_set();

rcl_wait_set_init(&wait_set, 2, 1, 0, 0, 0, 0, &context, rcl_get_default_allocator());

// Create and allocate the pingpong publication message

std_msgs__msg__Header msg;

char msg_buffer[STRING_BUFFER_LEN];

msg.frame_id.data = msg_buffer;

msg.frame_id.capacity = STRING_BUFFER_LEN;

// Create and allocate the pingpong subscription message

std_msgs__msg__Header rcv_msg;

char rcv_buffer[STRING_BUFFER_LEN];

rcv_msg.frame_id.data = rcv_buffer;

rcv_msg.frame_id.capacity = STRING_BUFFER_LEN;

// Set device id and sequence number;

int device_id = rand();

int seq_no;

int pong_count = 0;

struct timespec ts;

rcl_ret_t rc;

do {

// Clear and set the waitset

rcl_wait_set_clear(&wait_set);

size_t index_pong_subscription;

rcl_wait_set_add_subscription(&wait_set, &pong_subscription, &index_pong_subscription);

size_t index_ping_subscription;

rcl_wait_set_add_subscription(&wait_set, &ping_subscription, &index_ping_subscription);

size_t index_guardcondition;

rcl_wait_set_add_guard_condition(&wait_set, &guard_condition, &index_guardcondition);

// Run session for 100 ms

rcl_wait(&wait_set, RCL_MS_TO_NS(100));

// Check if it is time to send a ping

if (wait_set.guard_conditions[index_guardcondition]) {

// Generate a new random sequence number

seq_no = rand();

sprintf(msg.frame_id.data, "%d_%d", seq_no, device_id);

msg.frame_id.size = strlen(msg.frame_id.data);

// Fill the message timestamp

clock_gettime(CLOCK_REALTIME, &ts);

msg.stamp.sec = ts.tv_sec;

msg.stamp.nanosec = ts.tv_nsec;

// Reset the pong count and publish the ping message

pong_count = 0;

rcl_publish(&ping_publisher, (const void*)&msg, NULL);

// printf("Ping send seq 0x%x\n", seq_no);

}

// Check if some pong message is received

if (wait_set.subscriptions[index_pong_subscription]) {

rc = rcl_take(wait_set.subscriptions[index_pong_subscription], &rcv_msg, NULL, NULL);

if(rc == RCL_RET_OK && strcmp(msg.frame_id.data,rcv_msg.frame_id.data) == 0) {

pong_count++;

// printf("Pong for seq 0x%x (%d)\n", seq_no, pong_count);

}

}

// Check if some ping message is received and pong it

if (wait_set.subscriptions[index_ping_subscription]) {

rc = rcl_take(wait_set.subscriptions[index_ping_subscription], &rcv_msg, NULL, NULL);

// Dont pong my own pings

if(rc == RCL_RET_OK && strcmp(msg.frame_id.data,rcv_msg.frame_id.data) != 0){

// printf("Ping received with seq 0x%x (%d). Answering.\n", seq_no);

rcl_publish(&pong_publisher, (const void*)&rcv_msg, NULL);

}

}

usleep(10000);

} while (true);

}

When the configuring step ends, just build the firmware:

ros2 run micro_ros_setup build_firmware.sh

Once the build has successfully ended, let's power and connect the board. First, connect Olimex ARM-USB-TINY-H JTAG programmer to the board's JTAG port:

<img width="400" style="padding-right: 25px;" src="imgs/2.jpg">

Make sure that the board power supply jumper (PWR_SEL) is in the 3-4 position in order to power the board from the JTAG connector:

<img width="400" style="padding-right: 25px;" src="imgs/1.jpg">

You should see the red LED lighting. It is time to flash the board:

ros2 run micro_ros_setup flash_firmware.sh

The micro-ROS app is ready to connect to a micro-ROS-Agent and start talking with the rest of the ROS 2 world.

First of all, create and build a micro-ROS agent:

ros2 run micro_ros_setup create_agent_ws.sh

colcon build

Then connect the Olimex development board to the computer using the usb to serial cable:

<img width="400" style="padding-right: 25px;" src="imgs/5.jpg">

***TIP:** Color codes are applicable to [this cable](https://www.olimex.com/Products/Components/Cables/USB-Serial-Cable/USB-Serial-Cable-F/). Make sure to match Olimex Rx with Cable Tx and vice-versa. Remember GND!*

Then run the agent:

ros2 run micro_ros_agent micro_ros_agent serial --dev [device]

***TIP:** you can use this command to find your serial device name: `ls /dev/serial/by-id/*`*

And finally, let's check that everything is working. We are going to listen to ping topic to check whether the Ping Pong node is publishing its own pings

ros2 topic echo /microROS/ping

You should see the topic messages published by the Ping Pong node every 5 seconds:

On another command line, let's subscribe to the pong topic

ros2 topic echo /microROS/pong

At this point, we know that our app is publishing pings. Let's check if it also answers to someone else pings:

ros2 topic pub --once /microROS/ping std_msgs/msg/Header '{frame_id: "fake_ping"}'

Now, we should see on the ping subscriber our fake ping along with the board pings:

And in the pong subscriber, we should see the board's answer to our fake ping: