STM32 Ethernet Setup: Configure LWIP and Run a Ping Test

Getting Ethernet running on STM32 for the first time involves more moving parts than most peripherals — PHY address, RMII pin mapping, LWIP heap placement, and on Cortex-M7 devices, MPU cache coherency that will HardFault your board if skipped. This tutorial walks through every step so you end up with a working, ping-verified connection.

You will configure the MAC/PHY hardware in CubeMX, enable LWIP with a static IP, modify the linker script for DMA descriptor placement, and run a ping test to confirm everything is working. The tutorial covers multiple boards (Nucleo F207ZG, F7508 Discovery, H745 Discovery) and calls out where the setup differs between Cortex-M4 and Cortex-M7 devices.

This is Part 1 of the STM32 Ethernet series. You can browse the other tutorials below:

• UDP Server on STM32
• STM32 as UDP Client
• TCP Server on STM32
• STM32 as TCP Client
• Simple HTTP Server

STM32 Ethernet: MAC, PHY, and How It Works

MAC and PHY Overview

The STM32 Ethernet peripheral is split into two parts that must work together. The MAC (Media Access Controller) lives inside the STM32 itself — it handles framing, addressing, and packet management. The PHY (Physical Layer) is an external chip, typically connected over RMII or MII, that handles the actual electrical signaling on the cable, link detection, and speed negotiation.

CubeMX configures the MAC side. The PHY chip (e.g. LAN8742, DP83848, LAN8720) handles the physical side. Getting the PHY address and pin mapping right in CubeMX is the single most common failure point — the connection simply won’t establish if either is wrong.

RMII vs MII

Most modern STM32 Ethernet boards use RMII (Reduced Media Independent Interface), which requires fewer pins than full MII. Check your board’s schematic to confirm which interface the PHY is wired for — configuring the wrong one in CubeMX will result in no link, even if all other settings are correct.

Why Ethernet over UART, SPI, or I2C?

Ethernet is the right choice when your STM32 project needs high data throughput, long cable runs, or connection to a LAN/router. It supports running a full TCP/IP stack (via LWIP), acting as a UDP server, hosting an HTTP interface, or connecting to MQTT brokers — none of which are practical over UART or SPI.

Ethernet is one of the most reliable and widely used communication methods in embedded systems. With STM32 microcontrollers, you can enable high-speed networking by combining the Ethernet peripheral, CubeMX configuration, and the LWIP stack. This tutorial explains how to set up Ethernet on STM32 step by step, starting from the basics of MAC and PHY to testing the connection with a ping.

STM32 Ethernet CubeMX Setup: LWIP, MPU & Flash Script

After enabling the Ethernet, you must cross check the pins configured by the CubeMX with the schematic of the board. Most of the times, the pins are configured incorrectly and it becomes one of the most popular error for the ethernet to not work.

Ethernet Peripheral Configuration

There are many types of configurations available with different MCUs. Some MCUs let you configure the memory in the CubeMX, while others don’t. Some of the Boards have the MII Type Hardware, while other have RMII Type.

Below is the picture showing different configuration available in different ST Boards.

• The First board (Nucleo F207ZG) and second board (Disco F7508) uses the RMII pinout, while the third board (Disco H745) uses the MII pinout.
  
• On the first board we have the option to choose the PHY Address. This should be set to 0, if you are using the on board LAN Port, and it should be 1 in case of the external module.
  
• The 2nd and 3rd boards allow us to configure the memory addresses while the first one does not. If your board does not allow the memory configuration, you can simply skip those steps.
  
• The H745 discovery board is letting us configure the addresses for Tx and Rx DMA descriptors, and for the Rx Buffer as well. But the F7508 Discovery board does not let us configure the address for the Rx Buffer.
  
• Assuming that each DMA Descriptor takes 32 bits (MAXIMUM Possible), the RX Descriptor and Tx Descriptor have a maximum size of 128 Bytes (32×4) each.
  
• The Memory between them is spaced keeping this 128 bytes in mind.
  
• The Rx Buffer length is set to 1524 Bytes (1536 Bytes in H745 Discovery), but the number of RX buffers to be used can be defined later in the LWIP configuration. By default the cubeMX sets the number to 12 buffers. This would make the total length of Rx Buffer around 18KB.
  
• The memories are allocated in the SRAM region, whose properties can be modified later in the MPU.

LWIP Setup (Static IP, Heap, PHY Settings)

The LightWeight IP can be enabled in the middleware section. If the MCU does not let you enable it, make sure the cache (DCache and ICache) are enabled.

The most of the Configuration in the LWIP remains same. Except, some MCUs let us choose the address for the Heap.

• Here we are going to disable the DHCP, and configure a static IP for our ethernet module. I have set the IP 192.168.0.123 for the board.
• In the Key Option tab, I am using 5KB memory for the Heap. The location for this heap is defined as 0x30004900.
• In the Platform Settings tab, set the PHY as LAN8742.

MPU Configuration for Cortex-M7 (Cache Coherency Fix)

We have the DMA Descriptors in the SRAM Region. This is why we need to configure the MPU.

If your MCU didn’t let you choose the memory region, then probably you don’t need to do it. But for the cortex M7 devices, this is a must, or else you will get hardfault.

Remember that during the configuration, we set up everything in the SRAM (0x30000000). The complete memory structure is shown in the image below.

Below is the image showing the MPU configuration for the above Region.

• Here I have selected the 32 KB region so that it will cover our total RAM region, which is around 24KB.
• The rest of the configuration is to set the region as non-cacheable region.
• This would prevent the cache coherency issue between the CPU and the DMA.
• This is explained in the cortex M7 playlist, so do check that out.

Once the project is generated, open the LWIP -> Target -> ethernetif.c file. Here you will some memory locations that needs to be defined in the flash script file.

We need to define these memory locations in the flash script file, as per the configuration done in the cubeMX.

Flash script Modification

Below is the code is for the H745 Discovery board according to the configuration done in the CubeMX.

    .lwip_sec (NOLOAD) : {
    . = ABSOLUTE(0x30000000);
    *(.RxDescripSection)
    
    . = ABSOLUTE(0x30000080);
    *(.TxDescripSection)
    
    . = ABSOLUTE(0x30000100);
    *(.Rx_PoolSection) 
  } >RAM_D2

    .lwip_sec (NOLOAD) : {
    . = ABSOLUTE(0x30000000);
    *(.RxDescripSection)
    
    . = ABSOLUTE(0x30000080);
    *(.TxDescripSection)
    
    . = ABSOLUTE(0x30000100);
    *(.Rx_PoolSection) 
  } >RAM_D2

Below is the code is for the F7508 Discovery board according to the configuration done in the cubeMX.

    .lwip_sec (NOLOAD) : 
  {    
    . = ABSOLUTE(0x2004C000);
    *(.RxDecripSection) 
    
    . = ABSOLUTE(0x2004C0A0);
    *(.TxDecripSection)
  } >RAM

    .lwip_sec (NOLOAD) : 
  {    
    . = ABSOLUTE(0x2004C000);
    *(.RxDecripSection) 
    
    . = ABSOLUTE(0x2004C0A0);
    *(.TxDecripSection)
  } >RAM

PC Network Configuration (Direct Connection)

If you are connecting the STM32 board to the Router, there is nothing you need to do at the computer end. But if you are connecting the ethernet cable directly to the computer, you need to configure your computer’s ethernet as per the images shown below.

Below is the configuration for a Windows computer.

Below is the configuration for Mac.

STM32 Ethernet Example: Code, Ping Test & Results

HAL Code for LWIP Ping

Since this tutorial is more focused on connection part, there is not much in the code. We will just test the ping to our IP Address, and the code for the same is shown below.

int main()
{
  int wait = 10000000;
  while (wait-- >0);  // Wait for sometime before initializing the system
  
  MPU_Config();
  SCB_EnableICache();
  SCB_EnableDCache();
  HAL_Init();
  
  HAL_Delay (1000);  // wait for some time here
  
  SystemClock_Config();
  MX_GPIO_Init();
  MX_LWIP_Init();
  while (1)
  {
    MX_LWIP_Process();
  }
}

int main()
{
  int wait = 10000000;
  while (wait-- >0);  // Wait for sometime before initializing the system
  
  MPU_Config();
  SCB_EnableICache();
  SCB_EnableDCache();
  HAL_Init();
  
  HAL_Delay (1000);  // wait for some time here
  
  SystemClock_Config();
  MX_GPIO_Init();
  MX_LWIP_Init();
  while (1)
  {
    MX_LWIP_Process();
  }
}

Just call the function MX_LWIP_Process() inside the infinite loop. This function will handle all the processing required for the LWIP to run.

Running the Ping Test

Once the hardware and LWIP stack are configured, you can verify Ethernet functionality with a basic ping test.

• Connect STM32 to your PC/router via Ethernet.
  
• Assign a static IP on your PC (e.g., 192.168.0.100).
  
• Ping STM32’s static IP (e.g., 192.168.0.123) from your PC’s terminal or CMD:
  

ping 192.168.0.123

ping 192.168.0.123

You will get the response as shown in the image below.

You can see the ping is working on the IP Address that we set during the configuration. This confirms that the configuration is successful and we can proceed with the protocol implementation.

STM32 Ethernet: Troubleshooting & FAQs

Troubleshooting

No link detected / PHY not detected Check the PHY address in CubeMX first (0 for onboard, 1 for external module). Then verify every RMII/MII pin against your board schematic — CubeMX default pin mapping is frequently incorrect and is the #1 cause of Ethernet not working. Also confirm the PHY is receiving its required reference clock (25MHz for MII, 50MHz for RMII).

Ping request timed out Confirm the STM32’s static IP and your PC’s IP are in the same subnet. If connecting directly (no router), make sure the PC’s Ethernet adapter is manually configured with a compatible static IP. Also verify LWIP_ICMP is enabled in CubeMX LWIP options — without it, the STM32 won’t respond to ping at all.

HardFault on Cortex-M7 devices Almost always an MPU configuration issue. The Ethernet DMA region must be marked non-cacheable. Confirm the MPU region covers the full SRAM Ethernet area and that MPU_Config() is called before SCB_EnableDCache() in main().

Code only works in debug mode, not standalone Usually caused by timing. The while(wait-- > 0) startup delay in the code example allows the PHY to initialize before the STM32 starts communicating with it. If it works in debug (which runs slower) but not standalone, this delay is likely too short — increase it.

Ethernet works via router but not direct PC connection Your PC’s Ethernet adapter needs a manually assigned static IP in the same subnet as the STM32. DHCP won’t assign one automatically on a direct link without a router.

Frequently Asked Questions

In this tutorial, you set up STM32 Ethernet from scratch — configuring the MAC and PHY in CubeMX, enabling LWIP with a static IP, placing DMA descriptors correctly in SRAM, fixing the MPU for cache coherency on Cortex-M7, and verifying the connection with a ping test.

The key points to carry forward: always cross-check CubeMX pin assignments against your schematic, get the MPU non-cacheable region right before enabling DCache, and confirm the heap base address doesn't overlap with the Rx buffer region. These three things account for the vast majority of failures reported in the comments.

In the next part, we will build on this foundation to create a UDP Server on STM32 using the LWIP Raw API — sending and receiving UDP packets from a PC with minimal code overhead.

STM32 Ethernet Tutorial (PART 2): UDP Server with lwIP (Raw API)

STM32 Ethernet Tutorial (PART 3): UDP Client Tutorial with lwIP (Raw API)

STM32 Ethernet Tutorial (PART 4): TCP Server with lwIP Raw API

STM32 Ethernet Tutorial (PART 5): TCP Client with lwIP Raw API

STM32 Ethernet PART 6 – How to Configure Simple HTTP Webserver

STM32 Ethernet PART 6.1 – Configure HTTP Webserver using SSI

1 2 3 Next »

About the Author

Arun Rawat

Embedded Systems Engineer · Founder, ControllersTech

Arun is an embedded systems engineer with 10+ years of experience in STM32, ESP32, and AVR microcontrollers. He created ControllersTech to share practical tutorials on embedded software, HAL drivers, RTOS, and hardware design — grounded in real industrial automation experience.

About YouTube GitHub Facebook Instagram Shop