STM32H573: Ethernet - HAL_ETH_Init returns error.

[jowakar122]

I am using STM32H573 and trying to enable ethernet. I have used the below article for it:
https://community.st.com/t5/stm32-mcus/how-to-use-the-lwip-ethernet-middleware-on-the-stm32h5-series/ta-p/691100

But ethernet is not being initialized. The HAL_ETH_Init is returning error which is resulting in error handler.

This is the condition being checked in MX_ETH_Init function. As even after using the steps mentioned in the article mentioned above the ethernet is not working. 
- Do we have to add RX and TX descriptors specific addresses in the linker file?

[mbarg.1]

Of course, you need to point to correct area reachable ny DMA and with correct cache setting.

Best thing, download an example for your processor and compare .ld and .ioc - you will learn a lot - or go to other post in this community - or look to youtube.

Many solutions!

[jowakar122]

@mbarg.1 I have tried that but still it is not working.

This where it is getting error inside the HAL_ETH_Init function. Moreover, there are no LWIP examples on STM32H573. 

[mbarg.1]

Look at examples for H563 - H573 is the same with minor differences on encryption hw that does not impact Ethernet, it is due to export limitation on some crypto hw - select ETH and ...

some examples where to learn how to setup your micro.

 

Kudos and solution ok mark are appreciated.

mike

[jowakar122]

As I have mentioned above the issue lies due to wrong configuration of clock. Due to which the ETH_DMAMR_SWR is always SET. 

Does anybody have any idea regarding this issue.

[mbarg.1]

I see only 2 options:

• you attach your code and we can compare with working example;
• you already know where is the problem (you mention clock setup) and you can fix it.

My glass ball is out of duty ..

[jowakar122]

/**
 ******************************************************************************
 * @file LwIP/LwIP_TCP_Echo_Client/LWIP/Target/ethernetif.c
 * @author MCD Application Team
 * @brief This file implements Ethernet network interface drivers for lwIP
 ******************************************************************************
 * @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.
 *
 ******************************************************************************
 */

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32h5xx_hal.h"
#include "lwip/opt.h"
#include "lwip/timeouts.h"
#include "lwip/netif.h"
#include "netif/etharp.h"
#include "ethernetif.h"
#include "BSP/lan8742.h"
#include <string.h>

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Network interface name */
#define IFNAME0 's'
#define IFNAME1 't'

#define ETH_DMA_TRANSMIT_TIMEOUT (20U)

#define ETH_RX_BUFFER_SIZE 1000U
#define ETH_RX_BUFFER_CNT 12U
#define ETH_TX_BUFFER_MAX ((ETH_TX_DESC_CNT) * 2U)

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/*
@Note: This interface is implemented to operate in zero-copy mode only:
 - Rx Buffers will be allocated from LwIP stack memory heap,
 then passed to ETH HAL driver.
 - Tx Buffers will be allocated from LwIP stack memory heap,
 then passed to ETH HAL driver.

@Notes:
 1.a. ETH DMA Rx descriptors must be contiguous, the default count is 4,
 to customize it please redefine ETH_RX_DESC_CNT in ETH GUI (Rx Descriptor Length)
 so that updated value will be generated in stm32xxxx_hal_conf.h
 1.b. ETH DMA Tx descriptors must be contiguous, the default count is 4,
 to customize it please redefine ETH_TX_DESC_CNT in ETH GUI (Tx Descriptor Length)
 so that updated value will be generated in stm32xxxx_hal_conf.h

 2.a. Rx Buffers number: ETH_RX_BUFFER_CNT must be greater than ETH_RX_DESC_CNT.
 2.b. Rx Buffers must have the same size: ETH_RX_BUFFER_SIZE, this value must
 passed to ETH DMA in the init field (heth.Init.RxBuffLen)
*/
typedef enum
{
 RX_ALLOC_OK = 0x00,
 RX_ALLOC_ERROR = 0x01
} RxAllocStatusTypeDef;

typedef struct
{
 struct pbuf_custom pbuf_custom;
 uint8_t buff[(ETH_RX_BUFFER_SIZE + 31) & ~31] __ALIGNED(32);
} RxBuff_t;

extern ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
extern ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */
extern u8_t memp_memory_RX_POOL_base[];

/* Memory Pool Declaration */
LWIP_MEMPOOL_DECLARE(RX_POOL, ETH_RX_BUFFER_CNT, sizeof(RxBuff_t), "Zero-copy RX PBUF pool");



/* Variable Definitions */
static uint8_t RxAllocStatus;

/* Global Ethernet handle*/
//extern ETH_HandleTypeDef EthHandle;
extern ETH_HandleTypeDef heth;
extern ETH_TxPacketConfig TxConfig;


/* Private function prototypes -----------------------------------------------*/
u32_t sys_now(void);

int32_t ETH_PHY_IO_Init(void);
int32_t ETH_PHY_IO_DeInit (void);
int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal);
int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal);
int32_t ETH_PHY_IO_GetTick(void);

lan8742_Object_t LAN8742;
lan8742_IOCtx_t LAN8742_IOCtx = {ETH_PHY_IO_Init,
 ETH_PHY_IO_DeInit,
 ETH_PHY_IO_WriteReg,
 ETH_PHY_IO_ReadReg,
 ETH_PHY_IO_GetTick};


/* Private functions ---------------------------------------------------------*/
void pbuf_free_custom(struct pbuf *p);
/*******************************************************************************
 LL Driver Interface ( LwIP stack --> ETH)
*******************************************************************************/
/**
 * @brief In this function, the hardware should be initialized.
 * Called from ethernetif_init().
 *
 * @PAram netif the already initialized lwip network interface structure
 * for this ethernetif
 */
static void low_level_init(struct netif *netif)
{
	MX_ETH_Init();

	heth.Instance = ETH;

	/* set MAC hardware address length */
	netif->hwaddr_len = ETH_HWADDR_LEN;

	/* set MAC hardware address */
	netif->hwaddr[0] = heth.Init.MACAddr[0];
	netif->hwaddr[1] = heth.Init.MACAddr[1];
	netif->hwaddr[2] = heth.Init.MACAddr[2];
	netif->hwaddr[3] = heth.Init.MACAddr[3];
	netif->hwaddr[4] = heth.Init.MACAddr[4];
	netif->hwaddr[5] = heth.Init.MACAddr[5];

	/* maximum transfer unit */
	netif->mtu = ETH_MAX_PAYLOAD;

	/* device capabilities */
	/* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
	netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;

	/* Initialize the RX POOL */
	LWIP_MEMPOOL_INIT(RX_POOL);

	/* Set PHY IO functions */
	LAN8742_RegisterBusIO(&LAN8742, &LAN8742_IOCtx);

	/* Initialize the LAN8742 ETH PHY */
	LAN8742_Init(&LAN8742);

	ethernet_link_check_state(netif);
}

/**
 * @brief This function should do the actual transmission of the packet. The packet is
 * contained in the pbuf that is passed to the function. This pbuf
 * might be chained.
 *
 * @PAram netif the lwip network interface structure for this ethernetif
 * @PAram p the MAC packet to send (e.g. IP packet including MAC addresses and type)
 * @return ERR_OK if the packet could be sent
 * an err_t value if the packet couldn't be sent
 *
 * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
 * strange results. You might consider waiting for space in the DMA queue
 * to become available since the stack doesn't retry to send a packet
 * dropped because of memory failure (except for the TCP timers).
 */
static err_t low_level_output(struct netif *netif, struct pbuf *p)
{
 uint32_t i = 0U;
 struct pbuf *q = NULL;
 err_t errval = ERR_OK;
 ETH_BufferTypeDef Txbuffer[ETH_TX_DESC_CNT] = {0};

 memset(Txbuffer, 0 , ETH_TX_DESC_CNT*sizeof(ETH_BufferTypeDef));

 for(q = p; q != NULL; q = q->next)
 {
 if(i >= ETH_TX_DESC_CNT)
 return ERR_IF;

 Txbuffer[i].buffer = q->payload;
 Txbuffer[i].len = q->len;

 if(i>0)
 {
 Txbuffer[i-1].next = &Txbuffer[i];
 }

 if(q->next == NULL)
 {
 Txbuffer[i].next = NULL;
 }

 i++;
 }

 TxConfig.Length = p->tot_len;
 TxConfig.TxBuffer = Txbuffer;
 TxConfig.pData = p;

 HAL_ETH_Transmit(&heth, &TxConfig, ETH_DMA_TRANSMIT_TIMEOUT);

 return errval;
}


/**
 * @brief Should allocate a pbuf and transfer the bytes of the incoming
 * packet from the interface into the pbuf.
 *
 * @PAram netif the lwip network interface structure for this ethernetif
 * @return a pbuf filled with the received packet (including MAC header)
 * NULL on memory error
 */
static struct pbuf * low_level_input(struct netif *netif)
{
 struct pbuf *p = NULL;

 if(RxAllocStatus == RX_ALLOC_OK)
 {
 HAL_ETH_ReadData(&heth, (void **)&p);
 }
 return p;

}

/**
 * @brief This function is the ethernetif_input task, it is processed when a packet
 * is ready to be read from the interface. It uses the function low_level_input()
 * that should handle the actual reception of bytes from the network
 * interface. Then the type of the received packet is determined and
 * the appropriate input function is called.
 *
 * @PAram netif the lwip network interface structure for this ethernetif
 */
void ethernetif_input(struct netif *netif)
{
 struct pbuf *p = NULL;

 do
 {
 p = low_level_input( netif );
 if (p != NULL)
 {
 if (netif->input( p, netif) != ERR_OK )
 {
 pbuf_free(p);
 }
 }

 } while(p!=NULL);

}

/**
 * @brief Should be called at the beginning of the program to set up the
 * network interface. It calls the function low_level_init() to do the
 * actual setup of the hardware.
 *
 * This function should be passed as a parameter to netif_add().
 *
 * @PAram netif the lwip network interface structure for this ethernetif
 * @return ERR_OK if the loopif is initialized
 * ERR_MEM if private data couldn't be allocated
 * any other err_t on error
 */
err_t ethernetif_init(struct netif *netif)
{
 LWIP_ASSERT("netif != NULL", (netif != NULL));

#if LWIP_NETIF_HOSTNAME
 /* Initialize interface hostname */
 netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */

 netif->name[0] = IFNAME0;
 netif->name[1] = IFNAME1;
 /* We directly use etharp_output() here to save a function call.
 * You can instead declare your own function an call etharp_output()
 * from it if you have to do some checks before sending (e.g. if link
 * is available...) */
 netif->output = etharp_output;
 netif->linkoutput = low_level_output;

 /* initialize the hardware */
 low_level_init(netif);

 return ERR_OK;
}

/**
 * @brief Custom Rx pbuf free callback
 * @PAram pbuf: pbuf to be freed
 * @retval None
 */
void pbuf_free_custom(struct pbuf *p)
{
 struct pbuf_custom* custom_pbuf = (struct pbuf_custom*)p;
 LWIP_MEMPOOL_FREE(RX_POOL, custom_pbuf);
 /* If the Rx Buffer Pool was exhausted, signal the ethernetif_input task to
 * call HAL_ETH_GetRxDataBuffer to rebuild the Rx descriptors. */
 if (RxAllocStatus == RX_ALLOC_ERROR)
 {
 RxAllocStatus = RX_ALLOC_OK;
 }
}

/**
 * @brief Returns the current time in milliseconds
 * when LWIP_TIMERS == 1 and NO_SYS == 1
 * @PAram None
 * @retval Current Time value
 */
u32_t sys_now(void)
{
 return HAL_GetTick();
}
/*******************************************************************************
 Ethernet MSP Routines
*******************************************************************************/
/**
 * @brief Initializes the ETH MSP.
 * @PAram heth: ETH handle
 * @retval None
 */
//void HAL_ETH_MspInit(ETH_HandleTypeDef *heth)
//{
// GPIO_InitTypeDef GPIO_InitStruct = {0};
// if(heth->Instance==ETH)
// {
// /* USER CODE BEGIN ETH_MspInit 0 */
//
// /* USER CODE END ETH_MspInit 0 */
// /* Peripheral clock enable */
// __HAL_RCC_ETH_CLK_ENABLE();
// __HAL_RCC_ETHTX_CLK_ENABLE();
// __HAL_RCC_ETHRX_CLK_ENABLE();
//
// __HAL_RCC_GPIOC_CLK_ENABLE();
// __HAL_RCC_GPIOA_CLK_ENABLE();
// __HAL_RCC_GPIOB_CLK_ENABLE();
// __HAL_RCC_GPIOG_CLK_ENABLE();
// /**ETH GPIO Configuration
// PC1 ------> ETH_MDC
// PA1 ------> ETH_REF_CLK
// PA2 ------> ETH_MDIO
// PA7 ------> ETH_CRS_DV
// PC4 ------> ETH_RXD0
// PC5 ------> ETH_RXD1
// PB15 ------> ETH_TXD1
// PG11 ------> ETH_TX_EN
// PG13 ------> ETH_TXD0
// */
// GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_4|GPIO_PIN_5;
// GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
// GPIO_InitStruct.Pull = GPIO_NOPULL;
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
// GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
// HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
//
// GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_7;
// GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
// GPIO_InitStruct.Pull = GPIO_NOPULL;
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
// GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
// HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
//
// GPIO_InitStruct.Pin = GPIO_PIN_15;
// GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
// GPIO_InitStruct.Pull = GPIO_NOPULL;
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
// GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
// HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
//
// GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_13;
// GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
// GPIO_InitStruct.Pull = GPIO_NOPULL;
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
// GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
// HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
//
// /* ETH interrupt Init */
// HAL_NVIC_SetPriority(ETH_IRQn, 7, 0);
// HAL_NVIC_EnableIRQ(ETH_IRQn);
// /* USER CODE BEGIN ETH_MspInit 1 */
//
// /* USER CODE END ETH_MspInit 1 */
// }
//}

/*******************************************************************************
 PHI IO Functions
*******************************************************************************/
/**
 * @brief Initializes the MDIO interface GPIO and clocks.
 * @PAram None
 * @retval 0 if OK, -1 if ERROR
 */
int32_t ETH_PHY_IO_Init(void)
{
 /* We assume that MDIO GPIO configuration is already done
 in the ETH_MspInit() else it should be done here
 */

 /* Configure the MDIO Clock */
 HAL_ETH_SetMDIOClockRange(&heth);

 return 0;
}

/**
 * @brief De-Initializes the MDIO interface .
 * @PAram None
 * @retval 0 if OK, -1 if ERROR
 */
int32_t ETH_PHY_IO_DeInit (void)
{
 return 0;
}

/**
 * @brief Read a PHY register through the MDIO interface.
 * @PAram DevAddr: PHY port address
 * @PAram RegAddr: PHY register address
 * @PAram pRegVal: pointer to hold the register value
 * @retval 0 if OK -1 if Error
 */
int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal)
{
 if(HAL_ETH_ReadPHYRegister(&heth, DevAddr, RegAddr, pRegVal) != HAL_OK)
 {
 return -1;
 }

 return 0;
}

/**
 * @brief Write a value to a PHY register through the MDIO interface.
 * @PAram DevAddr: PHY port address
 * @PAram RegAddr: PHY register address
 * @PAram RegVal: Value to be written
 * @retval 0 if OK -1 if Error
 */
int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal)
{
 if(HAL_ETH_WritePHYRegister(&heth, DevAddr, RegAddr, RegVal) != HAL_OK)
 {
 return -1;
 }

 return 0;
}

/**
 * @brief Get the time in millisecons used for internal PHY driver process.
 * @retval Time value
 */
int32_t ETH_PHY_IO_GetTick(void)
{
 return HAL_GetTick();
}

/**
 * @brief
 * @retval None
 */
void ethernet_link_check_state(struct netif *netif)
{
 ETH_MACConfigTypeDef MACConf = {0};
 int32_t PHYLinkState = 0U;
 uint32_t linkchanged = 0U, speed = 0U, duplex =0U;

 PHYLinkState = LAN8742_GetLinkState(&LAN8742);

 if(netif_is_link_up(netif) && (PHYLinkState <= LAN8742_STATUS_LINK_DOWN))
 {
 HAL_ETH_Stop(&heth);
 netif_set_down(netif);
 netif_set_link_down(netif);
 }
 else if(!netif_is_link_up(netif) && (PHYLinkState > LAN8742_STATUS_LINK_DOWN))
 {
 switch (PHYLinkState)
 {
 case LAN8742_STATUS_100MBITS_FULLDUPLEX:
 duplex = ETH_FULLDUPLEX_MODE;
 speed = ETH_SPEED_100M;
 linkchanged = 1;
 break;
 case LAN8742_STATUS_100MBITS_HALFDUPLEX:
 duplex = ETH_HALFDUPLEX_MODE;
 speed = ETH_SPEED_100M;
 linkchanged = 1;
 break;
 case LAN8742_STATUS_10MBITS_FULLDUPLEX:
 duplex = ETH_FULLDUPLEX_MODE;
 speed = ETH_SPEED_10M;
 linkchanged = 1;
 break;
 case LAN8742_STATUS_10MBITS_HALFDUPLEX:
 duplex = ETH_HALFDUPLEX_MODE;
 speed = ETH_SPEED_10M;
 linkchanged = 1;
 break;
 default:
 break;
 }

 if(linkchanged)
 {
 /* Get MAC Config MAC */
 HAL_ETH_GetMACConfig(&heth, &MACConf);
 MACConf.DuplexMode = duplex;
 MACConf.Speed = speed;
 HAL_ETH_SetMACConfig(&heth, &MACConf);
 HAL_ETH_Start(&heth);
 netif_set_up(netif);
 netif_set_link_up(netif);
 }
 }

}
void HAL_ETH_RxAllocateCallback(uint8_t **buff)
{
 struct pbuf_custom *p = LWIP_MEMPOOL_ALLOC(RX_POOL);
 if (p)
 {
 /* Get the buff from the struct pbuf address. */
 *buff = (uint8_t *)p + offsetof(RxBuff_t, buff);
 p->custom_free_function = pbuf_free_custom;
 /* Initialize the struct pbuf.
 * This must be performed whenever a buffer's allocated because it may be
 * changed by lwIP or the app, e.g., pbuf_free decrements ref. */
 pbuf_alloced_custom(PBUF_RAW, 0, PBUF_REF, p, *buff, ETH_RX_BUFFER_SIZE);
 }
 else
 {
 RxAllocStatus = RX_ALLOC_ERROR;
 *buff = NULL;
 }
}

void HAL_ETH_RxLinkCallback(void **pStart, void **pEnd, uint8_t *buff, uint16_t Length)
{
 struct pbuf **ppStart = (struct pbuf **)pStart;
 struct pbuf **ppEnd = (struct pbuf **)pEnd;
 struct pbuf *p = NULL;

 /* Get the struct pbuf from the buff address. */
 p = (struct pbuf *)(buff - offsetof(RxBuff_t, buff));
 p->next = NULL;
 p->tot_len = 0;
 p->len = Length;

 /* Chain the buffer. */
 if (!*ppStart)
 {
 /* The first buffer of the packet. */
 *ppStart = p;
 }
 else
 {
 /* Chain the buffer to the end of the packet. */
 (*ppEnd)->next = p;
 }
 *ppEnd = p;

 /* Update the total length of all the buffers of the chain. Each pbuf in the chain should have its tot_len
 * set to its own length, plus the length of all the following pbufs in the chain. */
 for (p = *ppStart; p != NULL; p = p->next)
 {
 p->tot_len += Length;
 }
}

void HAL_ETH_TxFreeCallback(uint32_t * buff)
{
 pbuf_free((struct pbuf *)buff);
}

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file : main.c
 * @brief : Main program body
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2025 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 "string.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "lwip.h"
#include "ethernetif.h"
#include "lwip/opt.h"
#include "lwip/init.h"
#include "netif/etharp.h"
#include "lwip/netif.h"
#include "lwip/timeouts.h"
#include "tcp_echoclient.h"
#if LWIP_DHCP
#include "lwip/dhcp.h"
#endif

#include <string.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 ---------------------------------------------------------*/

ETH_TxPacketConfigTypeDef TxConfig;
ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */

ETH_HandleTypeDef heth;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */
extern struct netif gnetif;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ICACHE_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */
static void Netif_Config(void);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
PUTCHAR_PROTOTYPE
{
 /* Place your implementation of fputc here */
 /* e.g. write a character to the USART1 and Loop until the end of transmission */
 HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
 return ch;
}
/* USER CODE END 0 */

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

 /* USER CODE BEGIN 1 */

 /* USER CODE END 1 */

 /* 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_ICACHE_Init();
 MX_USART1_UART_Init();
 /* USER CODE BEGIN 2 */
 lwip_init();
 Netif_Config();

 printf("\rALTEEM TECH. - H573 - IoT Touch\n\n");
// char str[50] = "ALTEEM TECH. - H573 - IoT Touch\n";
// HAL_UART_Transmit(&huart1, (uint8_t*)str, strlen(str), 1000);

 /* USER CODE END 2 */

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

 /* USER CODE END WHILE */

 /* USER CODE BEGIN 3 */
	 ethernetif_input(&gnetif);
 sys_check_timeouts();

#if LWIP_NETIF_LINK_CALLBACK
 Ethernet_Link_Periodic_Handle(&gnetif);
#endif
#if LWIP_DHCP
 DHCP_Periodic_Handle(&gnetif);
#endif
 }
 /* USER CODE END 3 */
}

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

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

 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_HSI;
 RCC_OscInitStruct.HSIState = RCC_HSI_ON;
 RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;
 RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
 RCC_OscInitStruct.PLL.PLLSource = RCC_PLL1_SOURCE_HSI;
 RCC_OscInitStruct.PLL.PLLM = 16;
 RCC_OscInitStruct.PLL.PLLN = 125;
 RCC_OscInitStruct.PLL.PLLP = 2;
 RCC_OscInitStruct.PLL.PLLQ = 10;
 RCC_OscInitStruct.PLL.PLLR = 2;
 RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1_VCIRANGE_2;
 RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1_VCORANGE_WIDE;
 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_PCLK3;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 RCC_ClkInitStruct.APB3CLKDivider = RCC_HCLK_DIV1;

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

 /** Configure the programming delay
 */
 __HAL_FLASH_SET_PROGRAM_DELAY(FLASH_PROGRAMMING_DELAY_2);
}

/**
 * @brief ETH Initialization Function
 * None
 * @retval None
 */
void MX_ETH_Init(void)
{

 /* USER CODE BEGIN ETH_Init 0 */

 /* USER CODE END ETH_Init 0 */

 static uint8_t MACAddr[6];

 /* USER CODE BEGIN ETH_Init 1 */

 /* USER CODE END ETH_Init 1 */
 heth.Instance = ETH;
 MACAddr[0] = 0x00;
 MACAddr[1] = 0x80;
 MACAddr[2] = 0xE1;
 MACAddr[3] = 0x00;
 MACAddr[4] = 0x00;
 MACAddr[5] = 0x00;
 heth.Init.MACAddr = &MACAddr[0];
 heth.Init.MediaInterface = HAL_ETH_RMII_MODE;
 heth.Init.TxDesc = DMATxDscrTab;
 heth.Init.RxDesc = DMARxDscrTab;
 heth.Init.RxBuffLen = 1524;

 /* USER CODE BEGIN MACADDRESS */

 /* USER CODE END MACADDRESS */

 if (HAL_ETH_Init(&heth) != HAL_OK)
 {
 Error_Handler();
 }

 memset(&TxConfig, 0 , sizeof(ETH_TxPacketConfigTypeDef));
 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;
 /* USER CODE BEGIN ETH_Init 2 */

 /* USER CODE END ETH_Init 2 */

}

/**
 * @brief ICACHE Initialization Function
 * None
 * @retval None
 */
static void MX_ICACHE_Init(void)
{

 /* USER CODE BEGIN ICACHE_Init 0 */

 /* USER CODE END ICACHE_Init 0 */

 /* USER CODE BEGIN ICACHE_Init 1 */

 /* USER CODE END ICACHE_Init 1 */

 /** Enable instruction cache in 1-way (direct mapped cache)
 */
 if (HAL_ICACHE_ConfigAssociativityMode(ICACHE_1WAY) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_ICACHE_Enable() != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN ICACHE_Init 2 */

 /* USER CODE END ICACHE_Init 2 */

}

/**
 * @brief USART1 Initialization Function
 * None
 * @retval None
 */
static void MX_USART1_UART_Init(void)
{

 /* USER CODE BEGIN USART1_Init 0 */

 /* USER CODE END USART1_Init 0 */

 /* USER CODE BEGIN USART1_Init 1 */

 /* USER CODE END USART1_Init 1 */
 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();
 }
 if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN USART1_Init 2 */

 /* USER CODE END USART1_Init 2 */

}

/**
 * @brief GPIO Initialization Function
 * None
 * @retval None
 */
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 /* 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_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOC, LED_1_Pin|LED_2_Pin, GPIO_PIN_RESET);

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(LED_3_GPIO_Port, LED_3_Pin, GPIO_PIN_RESET);

 /*Configure GPIO pins : LED_1_Pin LED_2_Pin */
 GPIO_InitStruct.Pin = LED_1_Pin|LED_2_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

 /*Configure GPIO pin : LED_3_Pin */
 GPIO_InitStruct.Pin = LED_3_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(LED_3_GPIO_Port, &GPIO_InitStruct);

 /* USER CODE BEGIN MX_GPIO_Init_2 */

 /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */
/**
 * @brief Setup the network interface
 * None
 * @retval None
 */
static void Netif_Config(void)
{
	ip_addr_t ipaddr;
	ip_addr_t netmask;
	ip_addr_t gw;

#if LWIP_DHCP
 ip_addr_set_zero_ip4(&ipaddr);
 ip_addr_set_zero_ip4(&netmask);
 ip_addr_set_zero_ip4(&gw);
#else
	IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
	IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
	IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
#endif
	/* add the network interface */
	netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &ethernet_input);

	/* Registers the default network interface */
	netif_set_default(&gnetif);

	if(netif_is_link_up(&gnetif))
	{
	 /* When the netif is fully configured this function must be called */
		netif_set_up(&gnetif);
		HAL_GPIO_WritePin(LED_3_GPIO_Port, LED_3_Pin, GPIO_PIN_SET);
	}
	else
	{
		/* When the netif link is down this function must be called */
		netif_set_down(&gnetif);
		HAL_GPIO_WritePin(LED_3_GPIO_Port, LED_3_Pin, GPIO_PIN_RESET);
	}

	ethernet_link_status_updated(&gnetif);

#if LWIP_NETIF_LINK_CALLBACK
	netif_set_link_callback(&gnetif, ethernet_link_status_updated);
//	dhcp_start(&gnetif);
#endif
}

/* 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.
 * file: pointer to the source file name
 * 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 */

[Guillaume K]

Are you using STMicroelectronics board STM32H573-DK or your own board design ?

[jowakar122]

@Guillaume K  I am using my own board design in which I have used STM32H573RIT6.

 

 

[Andrew Neil]

---

@jowakar122 wrote:

The HAL_ETH_Init is returning error

---

So what error, exactly, is it returning ?

Have you stepped into HAL_ETH_Init to see where and why it is failing ?

 

---

@jowakar122 wrote:

I am using my own board design

---

Then please post schematics:

How to write your question to maximize your chances to find a solution.

Have you tried on an ST board?

[jowakar122]

@Andrew Neil In HAL_ETH_Init: From here HAL_ERROR is returned.

The ETH_DMAMR_SWR is always set.

[mbarg.1]

To look at the problem, I need the .ioc file and eventually also the main. c and Middleware directory.

[jowakar122]

@mbarg.1 I tried after changing the Ethernet clock frequency as per the example and also initialized ethernet before calling Network_config. Yet same result

[mbarg.1]

First: something MUST be the problem, never forget this; many people run this device without problems.

Next step is to see differences between your code and exampe I did attach to previous post.

Or add code of lwip_init() and let me try to understand what happens.

[jowakar122]

@mbarg.1 here are the lwip source file

[LCE]

Are you using "pure HAL ETH", or did you modify it?

As you are using your own hardware, have you checked that all external clocks are available? 

See NOTE in code:

/* SoftWare Reset */
	/* set SWR bit: resets all MAC subsystem internal registers and logic
	 * 	NOTE: the SWR is not performed if the ETH_RX_CLK or the ETH_TX_CLK are
	 *			not available -> check external PHY or IO configuration
	 */
	ETH->DMAMR |= ETH_DMAMR_SWR;
	/* wait for software reset to reset... */
	u32TickStart = HAL_GetTick();
	while( ETH->DMAMR & ETH_DMAMR_SWR )
	{
		/* timeout ? */
		if( (HAL_GetTick() - u32TickStart ) > ETH_TIMEOUT_SWRESET_MS )
		{
			#if DEBUG_ETHNETIF
				uart_printf(SZC_TEXT_ERR "ETH_DMAMR_SWR software reset TO\n\r");
			#endif 	/* DEBUG_ETHNETIF */
			return HAL_TIMEOUT;
		}
	}

 

[Andrew Neil]

---

@LCE wrote:

As you are using your own hardware, have you checked that all external clocks are available? 

---

Indeed.

@jowakar122 and, in fact, have you verified all your external hardware?

Again, please post your schematics.

Have you got this working on an ST board (known-good hardware) before moving on to unknown hardware?

[LCE]

---

@Andrew Neil wrote:

---

Have you got this working on an ST board (known-good hardware) before moving on to unknown hardware?

---

THIS is so important - and easy to do. The Nucleo-boards are easily available and don't cost much.

I started every STM32 project with a Nucleo or a DK, and it helped me a lot to avoid mistakes with my own following circuits, PCBs, and surely source code.

The STM32 firmware always starts with a pre-processor define to differentiate between Nucleo and my own board, mostly for GPIO settings, but also for other stuff.

This define might by in the STM32CubeIDE project, or at the start of main.c.

Like so:

#define NUCLEO_EVK 1
...

#if NUCLEO_EVK
 #include gpio_Nuc.h
#else /* not NUCLEO_EVK */
 #include gpio.h
#endif

or:

#if NUCLEO_EVK
 GpioInitNuc();
#else /* not NUCLEO_EVK */
 GpioInit();
#endif

 

[jowakar122]

After multiple tries I check on the hardware side and the problem was there. After proper connections on the hardware the problem was solved.

I appreciate all for helping me out 

[Guillaume K]

Hi,

If possible, could you give some details about what was wrong on the hardware side ? Maybe it can help other people if they do similar mistake.