Expected Log using UART :
[BOOT] UART initialized successfully
[BOOT] Starting ThreadX kernel
[NET] NetX Duo initialization started
[NET] IP stack and protocols enabled
[TX] ThreadX kernel running
[NET] NetX application thread running
[NET] Network stack ready
[NET] Static IP: 192.168.1.1
But the it breaks at [NET] NetX application thread running and i have found the following error using debugger and stucked at the error, so need guidance on bring up of Ethernet and perfect log using the UART
I want to send the data from the pc to the STM Board through the ethernet [using] TCP and store the data at some memory so initially i want to bring up the flow and stucked at the error.
main.c
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2026 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.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "app_threadx.h"
#include "main.h"
#include "string.h"
/* Private variables ---------------------------------------------------------*/
#if defined ( __ICCARM__ )
#pragma location=0x34100000
ETH_DMADescTypeDef DMARxDscrTab[ETH_DMA_RX_CH_CNT][ETH_RX_DESC_CNT];
#pragma location=0x341000C0
ETH_DMADescTypeDef DMATxDscrTab[ETH_DMA_TX_CH_CNT][ETH_TX_DESC_CNT];
#elif defined ( __CC_ARM )
__attribute__((at(0x34100000))) ETH_DMADescTypeDef DMARxDscrTab[ETH_DMA_RX_CH_CNT][ETH_RX_DESC_CNT];
__attribute__((at(0x341000C0))) ETH_DMADescTypeDef DMATxDscrTab[ETH_DMA_TX_CH_CNT][ETH_TX_DESC_CNT];
#elif defined ( __GNUC__ )
ETH_DMADescTypeDef DMARxDscrTab[ETH_DMA_RX_CH_CNT][ETH_RX_DESC_CNT]
__attribute__((section(".RxDecripSection")));
ETH_DMADescTypeDef DMATxDscrTab[ETH_DMA_TX_CH_CNT][ETH_TX_DESC_CNT]
__attribute__((section(".TxDecripSection")));
#endif
ETH_TxPacketConfig TxConfig;
ETH_HandleTypeDef heth1;
UART_HandleTypeDef huart1;
/* Private function prototypes -----------------------------------------------*/
static void MX_GPIO_Init(void);
static void MX_ETH1_Init(void);
static void MX_USART1_UART_Init(void);
void SystemClock_Config(void);
void Error_Handler(void);
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
int main(void)
{
/* ------------------------------------------------------------------
* 1. Enable caches FIRST (required for ETH / DMA)
* ------------------------------------------------------------------ */
SCB_EnableICache();
SCB_EnableDCache();
/* ------------------------------------------------------------------
* 2. HAL + clocks
* ------------------------------------------------------------------ */
HAL_Init();
SystemClock_Config();
/* ------------------------------------------------------------------
* 3. Low-level peripherals (NO RTOS here)
* ------------------------------------------------------------------ */
MX_GPIO_Init();
MX_ETH1_Init(); /* ETH HAL init only (NetX will handle runtime) */
MX_USART1_UART_Init();
/* ------------------------------------------------------------------
* 4. Pre-RTOS UART sanity logs (blocking, short, safe)
* ------------------------------------------------------------------ */
const char msg1[] = "[BOOT] UART initialized successfully\r\n";
const char msg2[] = "[BOOT] Starting ThreadX kernel\r\n";
HAL_UART_Transmit(&huart1, (uint8_t *)msg1, sizeof(msg1) - 1, 100);
HAL_UART_Transmit(&huart1, (uint8_t *)msg2, sizeof(msg2) - 1, 100);
/* ------------------------------------------------------------------
* 5. Start ThreadX (never returns)
* ------------------------------------------------------------------ */
MX_ThreadX_Init();
/* ------------------------------------------------------------------
* 6. Should never reach here
* ------------------------------------------------------------------ */
while (1)
{
}
}
/* ========================= Peripheral init code ========================== */
/* (UNCHANGED — CubeMX generated) */
/* ========================================================================= */
static void MX_ETH1_Init(void)
{
static uint8_t MACAddr[6];
memset(&TxConfig, 0 , sizeof(ETH_TxPacketConfig));
TxConfig.Attributes = ETH_TX_PACKETS_FEATURES_CSUM | ETH_TX_PACKETS_FEATURES_CRCPAD;
TxConfig.ChecksumCtrl = ETH_CHECKSUM_IPHDR_PAYLOAD_INSERT_PHDR_CALC;
TxConfig.CRCPadCtrl = ETH_CRC_PAD_INSERT;
heth1.Instance = ETH1;
MACAddr[0] = 0x00;
MACAddr[1] = 0x80;
MACAddr[2] = 0xE1;
MACAddr[3] = 0x00;
MACAddr[4] = 0x00;
MACAddr[5] = 0x00;
heth1.Init.MACAddr = &MACAddr[0];
heth1.Init.MediaInterface = HAL_ETH_RGMII_MODE;
for (int ch = 0; ch < ETH_DMA_CH_CNT; ch++)
{
heth1.Init.TxDesc[ch] = DMATxDscrTab[ch];
heth1.Init.RxDesc[ch] = DMARxDscrTab[ch];
}
heth1.Init.RxBuffLen = 1536;
if (HAL_ETH_Init(&heth1) != HAL_OK)
{
Error_Handler();
}
}
static void MX_USART1_UART_Init(void)
{
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8);
HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8);
HAL_UARTEx_DisableFifoMode(&huart1);
}
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_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}
/* USER CODE BEGIN 4 */
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
if (HAL_PWREx_ConfigSupply(PWR_EXTERNAL_SOURCE_SUPPLY) != HAL_OK)
{
Error_Handler();
}
if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
{
Error_Handler();
}
/* Enable HSI */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL1.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.PLL2.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.PLL3.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.PLL4.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
HAL_RCC_GetClockConfig(&RCC_ClkInitStruct);
if ((RCC_ClkInitStruct.CPUCLKSource == RCC_CPUCLKSOURCE_IC1) ||
(RCC_ClkInitStruct.SYSCLKSource == RCC_SYSCLKSOURCE_IC2_IC6_IC11))
{
RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_CPUCLK | RCC_CLOCKTYPE_SYSCLK);
RCC_ClkInitStruct.CPUCLKSource = RCC_CPUCLKSOURCE_HSI;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct) != HAL_OK)
{
Error_Handler();
}
}
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_NONE;
RCC_OscInitStruct.PLL1.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL1.PLLSource = RCC_PLLSOURCE_HSI;
RCC_OscInitStruct.PLL1.PLLM = 4;
RCC_OscInitStruct.PLL1.PLLN = 75;
RCC_OscInitStruct.PLL1.PLLFractional = 0;
RCC_OscInitStruct.PLL1.PLLP1 = 1;
RCC_OscInitStruct.PLL1.PLLP2 = 1;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
RCC_ClkInitStruct.ClockType =
RCC_CLOCKTYPE_CPUCLK | RCC_CLOCKTYPE_HCLK |
RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 |
RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_PCLK4 |
RCC_CLOCKTYPE_PCLK5;
RCC_ClkInitStruct.CPUCLKSource = RCC_CPUCLKSOURCE_IC1;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_IC2_IC6_IC11;
/* 🔑 IMPORTANT LINE */
RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV1;
RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV1;
RCC_ClkInitStruct.APB5CLKDivider = RCC_APB5_DIV1;
RCC_ClkInitStruct.IC1Selection.ClockSelection = RCC_ICCLKSOURCE_PLL1;
RCC_ClkInitStruct.IC1Selection.ClockDivider = 2;
RCC_ClkInitStruct.IC2Selection.ClockSelection = RCC_ICCLKSOURCE_PLL1;
RCC_ClkInitStruct.IC2Selection.ClockDivider = 3;
RCC_ClkInitStruct.IC6Selection.ClockSelection = RCC_ICCLKSOURCE_PLL1;
RCC_ClkInitStruct.IC6Selection.ClockDivider = 4;
RCC_ClkInitStruct.IC11Selection.ClockSelection = RCC_ICCLKSOURCE_PLL1;
RCC_ClkInitStruct.IC11Selection.ClockDivider = 3;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE END 4 */
/**
* @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 */
app_netxduo.c
#include "app_netxduo.h"
#include "stm32n6xx_hal.h"
#include "main.h"
#include <stdio.h>
#include <string.h>
/* NetX objects -------------------------------------------------------------*/
TX_THREAD NxAppThread;
NX_PACKET_POOL NxAppPool;
NX_IP NetXDuoEthIpInstance;
TX_MUTEX uart_mutex;
/* Private prototypes -------------------------------------------------------*/
static VOID App_Main_Thread_Entry(ULONG thread_input);
extern UART_HandleTypeDef huart1;
/**
* @brief NetXDuo Initialization
*/
UINT MX_NetXDuo_Init(VOID *memory_ptr)
{
TX_BYTE_POOL *byte_pool = (TX_BYTE_POOL *)memory_ptr;
UCHAR *pointer;
/* ---- UART mutex (MUST be created before any RTOS print) ---- */
tx_mutex_create(&uart_mutex, "UART Mutex", TX_INHERIT);
tx_mutex_get(&uart_mutex, TX_WAIT_FOREVER);
HAL_UART_Transmit(&huart1,
(uint8_t *)"[NET] NetX Duo initialization started\r\n",
sizeof("[NET] NetX Duo initialization started\r\n") - 1,
HAL_MAX_DELAY);
tx_mutex_put(&uart_mutex);
/* ---- NetX system ---- */
nx_system_initialize();
/* ---- Packet pool ---- */
tx_byte_allocate(byte_pool, (VOID **)&pointer,
NX_APP_PACKET_POOL_SIZE, TX_NO_WAIT);
nx_packet_pool_create(&NxAppPool,
"NetX Packet Pool",
DEFAULT_PAYLOAD_SIZE,
pointer,
NX_APP_PACKET_POOL_SIZE);
/* ---- IP instance ---- */
tx_byte_allocate(byte_pool, (VOID **)&pointer,
Nx_IP_INSTANCE_THREAD_SIZE, TX_NO_WAIT);
nx_ip_create(&NetXDuoEthIpInstance,
"NetX IP",
NX_APP_DEFAULT_IP_ADDRESS,
NX_APP_DEFAULT_NET_MASK,
&NxAppPool,
nx_stm32_eth_driver,
pointer,
Nx_IP_INSTANCE_THREAD_SIZE,
NX_APP_INSTANCE_PRIORITY);
/* ---- Enable protocols ---- */
static UCHAR arp_cache[DEFAULT_ARP_CACHE_SIZE];
nx_arp_enable(&NetXDuoEthIpInstance, arp_cache, DEFAULT_ARP_CACHE_SIZE);
nx_icmp_enable(&NetXDuoEthIpInstance);
nx_udp_enable(&NetXDuoEthIpInstance);
nx_tcp_enable(&NetXDuoEthIpInstance);
tx_mutex_get(&uart_mutex, TX_WAIT_FOREVER);
HAL_UART_Transmit(&huart1,
(uint8_t *)"[NET] IP stack and protocols enabled\r\n",
sizeof("[NET] IP stack and protocols enabled\r\n") - 1,
HAL_MAX_DELAY);
tx_mutex_put(&uart_mutex);
/* ---- Application thread ---- */
tx_byte_allocate(byte_pool, (VOID **)&pointer,
NX_APP_THREAD_STACK_SIZE, TX_NO_WAIT);
tx_thread_create(&NxAppThread,
"NetX App Thread",
App_Main_Thread_Entry,
0,
pointer,
NX_APP_THREAD_STACK_SIZE,
NX_APP_THREAD_PRIORITY,
NX_APP_THREAD_PRIORITY,
TX_NO_TIME_SLICE,
TX_AUTO_START);
return NX_SUCCESS;
}
/**
* @brief NetX application main thread
*/
static VOID App_Main_Thread_Entry(ULONG thread_input)
{
ULONG ip, mask, status;
char msg[64];
(void)thread_input;
tx_mutex_get(&uart_mutex, TX_WAIT_FOREVER);
HAL_UART_Transmit(&huart1,
(uint8_t *)"[NET] NetX application thread running\r\n",
sizeof("[NET] NetX application thread running\r\n") - 1,
HAL_MAX_DELAY);
tx_mutex_put(&uart_mutex);
/* ---- Wait for Ethernet link ---- */
do
{
nx_ip_status_check(&NetXDuoEthIpInstance,
NX_IP_LINK_ENABLED,
&status,
TX_NO_WAIT);
tx_thread_sleep(TX_TIMER_TICKS_PER_SECOND / 2);
} while (!(status & NX_IP_LINK_ENABLED));
tx_mutex_get(&uart_mutex, TX_WAIT_FOREVER);
HAL_UART_Transmit(&huart1,
(uint8_t *)"[NET] Ethernet link UP\r\n",
sizeof("[NET] Ethernet link UP\r\n") - 1,
HAL_MAX_DELAY);
tx_mutex_put(&uart_mutex);
/* ---- Static gateway ---- */
nx_ip_gateway_address_set(&NetXDuoEthIpInstance,
NX_APP_DEFAULT_GATEWAY_ADDRESS);
/* ---- Read assigned IP ---- */
nx_ip_address_get(&NetXDuoEthIpInstance, &ip, &mask);
sprintf(msg,
"[NET] Static IP: %lu.%lu.%lu.%lu\r\n",
(ip >> 24) & 0xFF,
(ip >> 16) & 0xFF,
(ip >> 8) & 0xFF,
ip & 0xFF);
tx_mutex_get(&uart_mutex, TX_WAIT_FOREVER);
HAL_UART_Transmit(&huart1,
(uint8_t *)msg,
strlen(msg),
HAL_MAX_DELAY);
tx_mutex_put(&uart_mutex);
/* ---- Idle ---- */
while (1)
{
tx_thread_sleep(TX_TIMER_TICKS_PER_SECOND);
}
}
app_thread.c
/* Includes ------------------------------------------------------------------*/
#include "app_threadx.h"
#include "stm32n6xx_hal.h"
#include "main.h"
#include "tx_api.h"
#include <string.h>
/* Private defines -----------------------------------------------------------*/
#define UART_THREAD_STACK_SIZE 1024
#define UART_THREAD_PRIORITY 15
/* Private variables ---------------------------------------------------------*/
static TX_THREAD uart_thread;
static ULONG uart_thread_stack[UART_THREAD_STACK_SIZE / sizeof(ULONG)];
/* External variables --------------------------------------------------------*/
extern UART_HandleTypeDef huart1;
extern TX_MUTEX uart_mutex;
/* Private function prototypes -----------------------------------------------*/
static void uart_thread_entry(ULONG thread_input);
/**
* @brief Application ThreadX Initialization.
*/
UINT App_ThreadX_Init(VOID *memory_ptr)
{
(void)memory_ptr;
/* Create UART debug thread */
if (tx_thread_create(&uart_thread,
"UART Debug Thread",
uart_thread_entry,
0,
uart_thread_stack,
sizeof(uart_thread_stack),
UART_THREAD_PRIORITY,
UART_THREAD_PRIORITY,
TX_NO_TIME_SLICE,
TX_AUTO_START) != TX_SUCCESS)
{
return TX_THREAD_ERROR;
}
return TX_SUCCESS;
}
/**
* @brief ThreadX Kernel Start
*/
void MX_ThreadX_Init(void)
{
tx_kernel_enter();
}
/**
* @brief UART debug / system status thread
*/
static void uart_thread_entry(ULONG thread_input)
{
(void)(thread_input);
/* ---- ONE-TIME RTOS START LOG ---- */
tx_mutex_get(&uart_mutex, TX_WAIT_FOREVER);
HAL_UART_Transmit(&huart1,
(uint8_t *)"[TX] ThreadX kernel running\r\n",
sizeof("[TX] ThreadX kernel running\r\n") - 1,
HAL_MAX_DELAY);
tx_mutex_put(&uart_mutex);
/* ---- Thread stays alive, but silent ---- */
while (1)
{
tx_thread_sleep(TX_TIMER_TICKS_PER_SECOND);
}
}
