STM32H753 microros (humble) publisher does not publish anything

[ugurxun]

Hello,
I am trying to work with microros on STM32H753ZIT6U .

System: WSL Ubuntu22.04
Ros Distro: Humble
Microcontroller: STM32H753ZIT6U
Transport: USART with DMA
USART baudrate: 115200

What I have done

I followed the instrunctions on microros tutorials and I created microros workspace, cloned micro_ros_setup, updated dependencies, installed python3-pip, builded, sourced. Then, I created firmware, builded it and crated microros agent.

I created a stm32cubeide project and arranged peripherals as HSE to crystal/seramic, SYS to TIM1. I enabled the USART3 (PD8, PD9) which is directly connected STLINKs microusb. I adjusted usart3_rx and usart3_tx for DMA with very high priority. I selected circular buffer for RX, I enabled the global interrupt for that. Finally, I enabled the FreeRTOS and I gave 12kb storage for stack of default task.

I cloned the micro_ros_stm32cubemx_utils and moved the files in extra_sources to /Core/Src . I deleted the files except dma_transport.c in microros_transports. Then, I added prebuid steps, micro-ROS include directory and Add the micro-ROS precompiled library as described. I sourced ros2 humble, micro ros workspace and gave the permissions via "sudo chmod 666 /var/run/docker.sock ". I found a basic projects ,compiled it and flashed succesfully. I runned the microros agent with "ros2 run micro_ros_agent micro_ros_agent serial --dev /dev/ttyACM0". I also tried the run it with "ros2 run micro_ros_agent micro_ros_agent udp4 --port 8888". However the publisher does not publish anything.

I tried to see the publisher with "ros2 topic list" but it is not seen.

Code

/* USER CODE BEGIN Header /
/*

---

• @file : main.c
• @brief : Main program body

---

• @attention
• Copyright (c) 2024 STMicroelectronics.
• All rights reserved.
• This software is licensed under terms that can be found in the LICENSE file
• in the root directory of this software component.
• If no LICENSE file comes with this software, it is provided AS-IS.

---

/
/ USER CODE END Header /
/ Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------/
/ USER CODE BEGIN Includes */
#include <rcl/rcl.h>
#include <rcl/error_handling.h>
#include <rclc/rclc.h>
#include <rclc/executor.h>
#include <uxr/client/transport.h>
#include <rmw_microxrcedds_c/config.h>
#include <rmw_microros/rmw_microros.h>

#include <std_msgs/msg/int32.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------/
/ USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------/
/ USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------/
/ USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

UART_HandleTypeDef huart3;
DMA_HandleTypeDef hdma_usart3_rx;
DMA_HandleTypeDef hdma_usart3_tx;

/* Definitions for defaultTask /
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
.name = "defaultTask",
.stack_size = 3000 * 4,
.priority = (osPriority_t) osPriorityNormal,
};
/ USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MPU_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART3_UART_Init(void);
void StartDefaultTask(void *argument);

/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------/
/ USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**

• @brief The application entry point.
• @RetVal int
  */
  int main(void)
  {

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/* MPU Configuration--------------------------------------------------------*/
MPU_Config();

/* MCU Configuration--------------------------------------------------------*/

/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();

/* USER CODE BEGIN Init */

/* USER CODE END Init */

/* Configure the system clock */
SystemClock_Config();

/* USER CODE BEGIN SysInit */

/* USER CODE END SysInit */

/* Initialize all configured peripherals /
MX_GPIO_Init();
MX_DMA_Init();
MX_USART3_UART_Init();
/ USER CODE BEGIN 2 */

/* USER CODE END 2 */

/* Init scheduler */
osKernelInitialize();

/* USER CODE BEGIN RTOS_MUTEX /
/ add mutexes, ... /
/ USER CODE END RTOS_MUTEX */

/* USER CODE BEGIN RTOS_SEMAPHORES /
/ add semaphores, ... /
/ USER CODE END RTOS_SEMAPHORES */

/* USER CODE BEGIN RTOS_TIMERS /
/ start timers, add new ones, ... /
/ USER CODE END RTOS_TIMERS */

/* USER CODE BEGIN RTOS_QUEUES /
/ add queues, ... /
/ USER CODE END RTOS_QUEUES */

/* Create the thread(s) /
/ creation of defaultTask */
defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

/* USER CODE BEGIN RTOS_THREADS /
/ add threads, ... /
/ USER CODE END RTOS_THREADS */

/* USER CODE BEGIN RTOS_EVENTS /
/ add events, ... /
/ USER CODE END RTOS_EVENTS */

/* Start scheduler */
osKernelStart();

/* We should never get here as control is now taken by the scheduler */

/* Infinite loop /
/ USER CODE BEGIN WHILE /
while (1)
{
/ USER CODE END WHILE */

/* USER CODE BEGIN 3 */

}
/* USER CODE END 3 */
}

/**

• @brief System Clock Configuration
• @RetVal None
  */
  void SystemClock_Config(void)
  {
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

/** Supply configuration update enable
*/
HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);

/** Configure the main internal regulator output voltage
*/
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}

/** Initializes the RCC Oscillators according to the specified parameters

• in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 2;
  RCC_OscInitStruct.PLL.PLLN = 64;
  RCC_OscInitStruct.PLL.PLLP = 2;
  RCC_OscInitStruct.PLL.PLLQ = 2;
  RCC_OscInitStruct.PLL.PLLR = 2;
  RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3;
  RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
  RCC_OscInitStruct.PLL.PLLFRACN = 0;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
  Error_Handler();
  }

/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
|RCC_CLOCKTYPE_D3PCLK1|RCC_CLOCKTYPE_D1PCLK1;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}

/**

• @brief USART3 Initialization Function
• @param None
• @RetVal None
  */
  static void MX_USART3_UART_Init(void)
  {

/* USER CODE BEGIN USART3_Init 0 */

/* USER CODE END USART3_Init 0 */

/* USER CODE BEGIN USART3_Init 1 */

/* USER CODE END USART3_Init 1 /
huart3.Instance = USART3;
huart3.Init.BaudRate = 115200;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold(&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold(&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode(&huart3) != HAL_OK)
{
Error_Handler();
}
/ USER CODE BEGIN USART3_Init 2 */

/* USER CODE END USART3_Init 2 */

}

/**

• Enable DMA controller clock
  */
  static void MX_DMA_Init(void)
  {

/* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE();

/* DMA interrupt init /
/ DMA1_Stream0_IRQn interrupt configuration /
HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
/ DMA1_Stream1_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);

}

/**

• @brief GPIO Initialization Function
• @param None
• @RetVal None
  /
  static void MX_GPIO_Init(void)
  {
  / USER CODE BEGIN MX_GPIO_Init_1 /
  / USER CODE END MX_GPIO_Init_1 */

/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();

/* USER CODE BEGIN MX_GPIO_Init_2 /
/ USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 /
bool cubemx_transport_open(struct uxrCustomTransport * transport);
bool cubemx_transport_close(struct uxrCustomTransport * transport);
size_t cubemx_transport_write(struct uxrCustomTransport transport, const uint8_t * buf, size_t len, uint8_t * err);
size_t cubemx_transport_read(struct uxrCustomTransport* transport, uint8_t* buf, size_t len, int timeout, uint8_t* err);

void * microros_allocate(size_t size, void * state);
void microros_deallocate(void * pointer, void * state);
void * microros_reallocate(void * pointer, size_t size, void * state);
void * microros_zero_allocate(size_t number_of_elements, size_t size_of_element, void * state);

/* USER CODE END 4 */

/* USER CODE BEGIN Header_StartDefaultTask /
/*

• @brief Function implementing the defaultTask thread.

• @param argument: Not used

• @RetVal None
  /
  / USER CODE END Header_StartDefaultTask */
  void StartDefaultTask(void argument)
  {
  / USER CODE BEGIN 5 */

  // micro-ROS configuration

  rmw_uros_set_custom_transport(
  true,
  (void *) &huart3,
  cubemx_transport_open,
  cubemx_transport_close,
  cubemx_transport_write,
  cubemx_transport_read);

  rcl_allocator_t freeRTOS_allocator = rcutils_get_zero_initialized_allocator();
  freeRTOS_allocator.allocate = microros_allocate;
  freeRTOS_allocator.deallocate = microros_deallocate;
  freeRTOS_allocator.reallocate = microros_reallocate;
  freeRTOS_allocator.zero_allocate = microros_zero_allocate;

  if (!rcutils_set_default_allocator(&freeRTOS_allocator)) {
  printf("Error on default allocators (line %d)\n", LINE);
  }

  // micro-ROS app

  rcl_publisher_t publisher;
  std_msgs__msg__Int32 msg;
  rclc_support_t support;
  rcl_allocator_t allocator;
  rcl_node_t node;

  allocator = rcl_get_default_allocator();

  //create init_options
  rclc_support_init(&support, 0, NULL, &allocator);

  // create node
  rclc_node_init_default(&node, "cubemx_node", "", &support);

  // create publisher
  rclc_publisher_init_default(
  &publisher,
  &node,
  ROSIDL_GET_MSG_TYPE_SUPPORT(std_msgs, msg, Int32),
  "cubemx_publisher");

  msg.data = 0;

  for(;;)
  {
  rcl_ret_t ret = rcl_publish(&publisher, &msg, NULL);
  if (ret != RCL_RET_OK)
  {
  printf("Error publishing (line %d)\n", LINE);
  }

  msg.data++;
  osDelay(10);
  

  }
  /* USER CODE END 5 */
  }

/* MPU Configuration */

void MPU_Config(void)
{
MPU_Region_InitTypeDef MPU_InitStruct = {0};

/* Disables the MPU */
HAL_MPU_Disable();

/** Initializes and configures the Region and the memory to be protected
*/
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
MPU_InitStruct.Number = MPU_REGION_NUMBER0;
MPU_InitStruct.BaseAddress = 0x0;
MPU_InitStruct.Size = MPU_REGION_SIZE_4GB;
MPU_InitStruct.SubRegionDisable = 0x87;
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
MPU_InitStruct.AccessPermission = MPU_REGION_NO_ACCESS;
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE;
MPU_InitStruct.IsShareable = MPU_ACCESS_SHAREABLE;
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;

HAL_MPU_ConfigRegion(&MPU_InitStruct);
/* Enables the MPU */
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);

}

/**

• @brief Period elapsed callback in non blocking mode
• @note This function is called when TIM1 interrupt took place, inside
• HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
• a global variable "uwTick" used as application time base.
• @param htim : TIM handle
• @RetVal None
  */
  void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef htim)
  {
  / USER CODE BEGIN Callback 0 */

/* USER CODE END Callback 0 /
if (htim->Instance == TIM1) {
HAL_IncTick();
}
/ USER CODE BEGIN Callback 1 */

/* USER CODE END Callback 1 */
}

/**

• @brief This function is executed in case of error occurrence.
• @RetVal None
  /
  void Error_Handler(void)
  {
  / USER CODE BEGIN Error_Handler_Debug /
  / User can add his own implementation to report the HAL error return state /
  __disable_irq();
  while (1)
  {
  }
  / USER CODE END Error_Handler_Debug */
  }

#ifdef USE_FULL_ASSERT
/**

• @brief Reports the name of the source file and the source line number

•     where the assert_param error has occurred.
  

• @param file: pointer to the source file name
• @param line: assert_param error line source number
• @RetVal None
  */
  void assert_failed(uint8_t file, uint32_t line)
  {
  / USER CODE BEGIN 6 /
  / User can add his own implementation to report the file name and line number,
  ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) /
  / USER CODE END 6 /
  }
  #endif / USE_FULL_ASSERT */

---

What I expect to see

Then, I need to see my topic in ros2 topic list. The publisher must publish increasing counter data.

Do you have any idea to solve my problem? Thank you all.