Issue in Ethernet and Uart in STM32n6570-DK

[MownishBugatha]

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);
 }
}