When Ethernet is enabled, the pins should **automatically** be configured according to the below schematic. This can be wrong, please **confirm it**!
Setup all the PINS like it is done in the [PIN schematic](https://www.st.com/en/evaluation-tools/nucleo-h753zi.html#cad-resources) (Download: [MB1364-H753ZI-C01 Board schematic](https://www.st.com/resource/en/schematic_pack/mb1364-h753zi-c01-schematic.pdf), pg. 6) \[2\]. [](https://bookstack.roboteamtwente.nl/uploads/images/gallery/2026-04/gxsafbeelding.png) [](https://bookstack.roboteamtwente.nl/uploads/images/gallery/2026-04/2G1afbeelding.png)If any of the pins are not as in the schematic, refer to the above information. You can click each pin in CubeMX and choose the correct function (e.g. ETH\_RXD0), the other (incorrect) pin will be automatically disabled.
**NOTE:** when you use FreeRTOS, you will have to select **another SYS Timebase Source**. Go to **SYS > Timebase Source** and select any of the free timers, just make sure it is **NOT** SysTick. Make sure you do not use that timer for any other activities.
Make sure you set your `TOTAL_HEAP_SIZE` to a sufficient number. When it is not big enough, the threads that you will create using FreeRTOS will suffocate and not work. This will also not give you any errors so watch out for it! [](https://bookstack.roboteamtwente.nl/uploads/images/gallery/2026-06/afbeelding.png) --- ## **The Code** After you generate the code for your board, you can look through networking component, in the `ethernet.h` file, to see all public Ethernet functions.For a full guide of how to use Ethernet, I refer you to [Driver usage](https://bookstack.roboteamtwente.nl/books/communication-system/page/sending-your-first-message "https://bookstack.roboteamtwente.nl/books/communication-system/page/driver-usage") \[3\].
--- ## **Resources** 1. [STM32 Ethernet (Part 1): How to configure Ethernet peripheral and perform successful ping test](https://www.youtube.com/watch?v=8r8w6mgSn1A&t=907s) 2. [PIN schematic](https://www.st.com/en/evaluation-tools/nucleo-h753zi.html#cad-resources) (Download: [MB1364-H753ZI-C01 Board schematic](https://www.st.com/resource/en/schematic_pack/mb1364-h753zi-c01-schematic.pdf), pg. 6) 3. [Driver usage](https://bookstack.roboteamtwente.nl/books/communication-system/page/sending-your-first-message "https://bookstack.roboteamtwente.nl/books/communication-system/page/driver-usage") # Sending your first message ***This page:** *how to initialize your Ethernet driver and send your first message. A lot of constants can be seen in the explanatory code. Those can be found in* `components/common/networking_constants`*. They are also added at the end of this file.**The functions that are used for Ethernet can be found in `components/common/networking/inc/ethernet.h`.
The headers in the folder `components/common/networking/stm/` are only to be used inside the Ethernet driver!
**NOTE:** The implementation only works with FreeRTOS, but it works fine with only 1 thread. **Before you implement anything, do an introductory tutorial on FreeRTOS!**
--- ## **Code Usage** ### 1) Linker file updating In the linker file, you need to say what memory addresses LWIP uses. You set these values in Cubemx and the sections are generated for you, but you have to add it to the linker file yourself.You can find your linker (`.ld`) file in `components/{env_name}/firmware/`
The codeblock added for the default values is: ```c .lwip_sec (NOLOAD) : { . = ABSOLUTE(0x30000000); *(.RxDecripSection) . = ABSOLUTE(0x30000080); *(.TxDecripSection) . = ABSOLUTE(0x30000100); *(.Rx_PoolSection) } >RAM_D2 ``` You can just use the generated linker file and append to it, because it never gets regenerated, but you can also create a new one. If you create a new one, you have to put in the platformio configuration file that you use the new linker file. An example of how to do it is shown below. The path is relative to where the platformio configuration file is located. ```c board_build.ldscript = components/network_board/firmware/STM32H753XX_FLASH.ld ``` --- ### 2) Code initialization When you first use the Ethernet driver, you have to initialize a few things. First make sure that HAL is initialized, the D and I cache are enabled, the system clock and the memory protection unit as well. These auto-generated functions start processes that Ethernet uses. ```c //Initialize HAL HAL_Init(); //Enable D&I cache (for ETH) SCB_EnableICache(); SCB_EnableDCache(); //Start the system clock SystemClock_config(); //Memory protection unit MPU_Config_wrapper(); ```**NOTE on multithreading:** make sure you set the stack size big enough (I use `.stack_size = 1024 * 8`) when setting the `task_attributes` for the thread Ethernet will be running in!
##### ETH\_udp\_init() ```c void ETH_udp_init(uint8_t sender_prio_buf, QueueHandle_t *send_queues, receive_callback_t receiver_callback) ``` - `sender_prio_buf` Defines the **number** of priority queues you use for queuing the send messages. The queues we use are freeRTOS queues. More information can be found [here](https://freertos.org/Documentation/02-Kernel/02-Kernel-features/02-Queues-mutexes-and-semaphores/01-Queues). - `send_queues` You need to pass freeRTOS queues as a pointer to an array. The queues need to be implemented before passing them to `ETH_udp_init(...)`, see below.More information about the packet dispatcher is in the [Packet Dispatcher documentation](https://bookstack.roboteamtwente.nl/books/embedded-infastructure/page/packet-dispatcher "https://bookstack.roboteamtwente.nl/books/embedded-infastructure/page/packet-dispatcher").
**WARNING:** Make sure you have initialized udp **before** using ETH\_add\_arp(...)!
##### ETH\_udp\_send(...) ```c void ETH_udp_send(uint8_t ip[4], uint8_t port, uint8_t *payload, uint16_t payload_len, uint8_t prio_num) ``` - `payload` The payload can be any byte array, where the size of that byte array is the 4th argument: `payload_len`. - `prio_num` Priority level for transmission. Must be less than `sender_prio_buf` specified in `ETH_udp_init(...)`. Now you can send messages!Import `"networking_constants.h"` and `"ip_mac_constants.h"` to use the predefined test constants
```c #include "ethernet.h" #include "networking_constants.h" #include "ip_mac_constants.h" /* Callback function that handles a specific packet*/ void HandlePacket(receive_frame_t *receive_frame) { printf("Wayoo, message received"); } int outgoing_counter = 0; int main(void) { /*Inits*/ HAL_Init(); SystemClock_Config(); MPU_Config_wrapper(); SCB_EnableICache(); SCB_EnableDCache(); MX_GPIO_Init(); /*Config + init sending side*/ uint8_t mac[6] = NETWORK_MAC; uint8_t ip[4] = NETWORK_IP; uint8_t netmask[4] = NETMASK; uint8_t gateway[4] = GATEWAY; ETH_init(NULL, ip, netmask, gateway, mac); /*Making queues*/ int SendQueueSize = 80; static StaticQueue_t xStaticQueue1; uint8_t ucQueueStorageArea1[SendQueueSize * ETHERNET_SQ_ITEM_SIZE]; QueueHandle_t udp_receiver_queue1 = xQueueCreateStatic(SendQueueSize, ETHERNET_SQ_ITEM_SIZE, ucQueueStorageArea1, &xStaticQueue1); static StaticQueue_t xStaticQueue2; uint8_t ucQueueStorageArea2[SendQueueSize * ETHERNET_SQ_ITEM_SIZE]; QueueHandle_t udp_receiver_queue2 = xQueueCreateStatic(SendQueueSize, ETHERNET_SQ_ITEM_SIZE, ucQueueStorageArea2, &xStaticQueue2); QueueHandle_t queues[2] = {udp_receiver_queue1, udp_receiver_queue2}; ETH_udp_init(2, queues, HandlePacket); /*Config + add ARP receiving side*/ uint8_t ip[4] = SAMPLE_BOARD_IP; uint8_t mac[6] = SAMPLE_BOARD_MAC; ETH_add_arp(ip, mac, 5); /*Sending a message*/ uint8_t packet1_payload[4] = {14,06,20,04}; /*Test sending*/ while (outgoing_counter < 100) { //NOTE: after 80 packages the queue will be full! ETH_udp_send(ip, 8, packet1_payload, 4, 1); osDelay(10); outgoing_counter += 1; LOGI(TAG, "%d", outgoing_counter); } } ``` # Ethernet Testing ## **Send Testing** #### Requirements - STM32 - Ethernet Cable - Wireshark #### Testing Send testing is easy. The only thing you have to do is upload the setup and sending code to your STM32 and connect it to your PC/laptop using an Ethernet cable. Then you can go into Wireshark, look at the activity on you ethernet periphial, to see if it sends something. It also logs to the terminal if you send, if you have turned logging on. --- ## **Receive Testing** ### Requirements - Linux laptop 🫠- STM32 - Ethernet Cable Connect the Ethernet cable between the STM and the laptop that is sending you packets. - Any pcap packet sender We recommend packeth, installation manual will be below. - Wireshark (optional) ### Installation of Packeth**NOTE:** you need a Linux laptop for this
#### Testing Receive testing is done by sending packets, saved in test/networking, to the STM32 using a pcap packet sender. If you want to use new packets, I advise to send the packet you want from the STM32. Then use wireshark to save the packet such that you can send it back. In wireshark you can see, when you send a package, to which IP and MAC it is being send, and it should match with your IP and MAC. To see if the messages are received, make sure you print messages in your receive function. Then check the serial #### # Extra Functions ### Introduction This documentation is about extra functions, that are not necessary to get it running, but can be used if need be. ### Non-deprecated functions #### ETH\_setup\_MAC\_address\_filtering This function is used for perfect mac address filtering. It is used by giving it MAC-addresses as arguments. If you receive packets with those addresses, they will also be processed. ### Deprecated Functions There are deprecated functions for raw sending (`ETH_raw_send`) and custom protocol receiving (`ETH_custom_protocol_receiver`). Those can be used if you don't want to use UDP, but I don't know if they still work. ##### Raw receiving If you want to receive messages, you need to have `#define LWIP_HOOK_UNKNOWN_ETH_PROTOCOL(pbuf, netif) eth_reader(netif, pbuf)` in the `cubemx_main.h` file. ### ### # Debugging ### Introduction This documentation gives some tips on how to debug the Ethernet Driver. ### Debug Flags By setting the flag " LWIP\_DEBUG" to 1 in the cubemx main file, you will get extra lwip debug messages in your terminal. ### Hard Faults While debugging, it is easy to use a debugger to go step by step through your code. However, the deeper you go into the code, the bigger the chance that your debugging will trigger an hard fault. So when that happens verify if the hard fault is your doing or not, by debugging less deep while you have a debug point set on the hard fault function, to check if it still hard faults. # Issues ## Introduction There are some issues with ethernet. Those are described here. ## The Issues ### Arp Table removement The ARP function will fail when Ethernet is not started properly yet. Current fix is `retry_count` that retries the arp x amount of times.