Skip to content


The wESP32™ by default ships with MicroPython preloaded, but it can be made to work with pretty much all ESP32 compatible software development tools that exist. However, some work out-of-the-box while others would require quite a bit of hacking. This section lists software of which compatibility has been checked.

WARNING: GPIO pin configuration

By default, the wESP32 ships with MicroPython and a script that automatically configures the GPIO pins correctly to communicate with the Ethernet PHY and enables the Ethernet subsystem. Plugging in an Ethernet cable should automatically connect the board to the network with DHCP.

If the user wants to use a different software environment, it is the user's responsibility to ensure that the software loaded on the ESP32 configures the GPIO pins that are connected to the Ethernet PHY correctly. Many of the signals between the ESP32 and the LAN8720 Ethernet PHY are part of the high speed RMII bus, and they are directly connected together without any protection. Pins involved in connectivity between the ESP32 and PHY are IO0, IO16, IO17, IO19, IO21, IO22, IO25, IO26, IO27.

If the user loads software on the ESP32 that does not configure the RMII pins correctly, it is possible the software will configure the pins in such a way that physical damage may result, for instance connecting an output from the PHY to an output of the ESP32, resulting in a short circuit through the chip’s output drivers.

It is recommended the wESP32 is first tested with the default MicroPython software to confirm network functionality, before other software is loaded. Basic network functionality can be confirmed by running lan.ifconfig() and checking that the wESP32 received an IP address from DHCP. No defective units will be replaced once they have been flashed with different software.


ESP-IDF is the official Espressif development framework for the ESP32. Since the ESP-IDF provides the ultimate flexibility, it is out-of-the-box compatible with the wESP32. The only thing the user needs to do to make it work with the wESP32 is set the right configuration for how the PHY is connected and configured (either in the menuconfig if using example projects, or in code):

  • Ethernet PHY type is Microchip LAN8720
  • PHY interface is RMII
  • PHY address is 0
  • Clock mode is GPIO0 external input
  • PHY power/reset pin is disabled (set to -1)
  • SMI MDC pin is 16, SMI MDIO pin is 17

In code, this can be done with the following code snippet to configure and start Ethernet:

eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
mac_config.smi_mdc_gpio_num = 16;
mac_config.smi_mdio_gpio_num = 17;
esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&mac_config);

eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
phy_config.phy_addr = 0;
phy_config.reset_gpio_num = -1;
esp_eth_phy_t *phy = esp_eth_phy_new_lan8720(&phy_config);

esp_eth_handle_t eth_handle = NULL;
esp_eth_config_t config = ETH_DEFAULT_CONFIG(mac, phy);
ESP_ERROR_CHECK(esp_eth_driver_install(&config, &eth_handle));

ESP_ERROR_CHECK(esp_netif_attach(eth_netif, esp_eth_new_netif_glue(eth_handle)));

Full details can be found in the ESP-IDF Programming Guide.


The Arduino-ESP32 project allows you to program the wESP32 from the popular Arduino IDE. Installation instructions are in the repo's, support for the wESP32 is now fully integrated into the stable release so you can use the Adruino Boards Manager installation instructions.

Once the ESP32 support is installed, you can select the wESP32 from the Arduino IDE menu:

Tools → Board → Silicognition wESP32

To use the Ethernet connection in your sketch, you need to #include <ETH.h> and call ETH.begin() to start the Ethernet peripheral. This function takes optional parameters to set the configuration, but the board support package already takes care of setting these correctly for the wESP32.

Below is a minimal web server with mDNS example sketch:

#include <ETH.h>
#include <WebServer.h>
#include <ESPmDNS.h>

// Web server
WebServer server(80);

// HTTP handlers
void handleRoot() {
  server.send(200, "text/plain", "Hello from wESP32!\n");

void handleNotFound() {
  server.send(404, "text/plain", String("No ") + server.uri() + " here!\n");

void setup(){
  // Start the ethernet
  // You can browse to wesp32demo.local with this

  // Bind HTTP handler
  server.on("/", handleRoot);

  // Start the Ethernet web server
  // Add service to MDNS-SD
  MDNS.addService("http", "tcp", 80);

void loop(){


The MicroPython project provides a very rich Python 3 environment for small microcontrollers. The ESP32 and Ethernet are well supported, and due to its flexible nature, the wESP32 is supported out-of-the-box.

The following is the minimum code needed to get the wESP32 connected to Ethernet with MicroPython:

import machine
import network

lan = network.LAN(mdc = machine.Pin(16), mdio = machine.Pin(17),
                  power = None, phy_type = network.PHY_LAN8720, phy_addr=0)

Once connected, all networking functionality will occur over Ethernet.

The wESP32 by default ships with MicroPython and a pre-installed script that contains the code shown above. This means that out-of-the-box, the wESP32 will connect to the network when the Ethernet jack is connected without any code needing to be supplied by the user.


Lua-RTOS-ESP32 provides a rich Lua environment for the ESP32. Installation instructions are in the, when prompted to enter a board type choose the option for the "Silicognition wESP32" with or without OTA.

Once built and flashed, the minimum code to get connected over Ethernet is:


Once connected, all networking functionality will occur over Ethernet. Since this runtime has dropbear on board, you can even remotely log in to the Lua REPL over SSH!


Fans of Lua have a second option to run Lua on the wESP32. NodeMCU is one of the oldest projects for running a high-level interpreted language on microcontrollers. They were kind of late in providing Ethernet support in their ESP32 version, but this has been fixed now, and they provide quite a nice implementation with events that allow the user to respond to various states of the Ethernet connection such as cable connect / disconnect and acquiring an IP address.

NodeMCU does not seem to provide ready-made images, you have to check out the dev-esp32 branch from Github and follow the build instructions found in the project's documentation. To be able to use the Ethernet port, you have to ensure you turn on the Ethernet module when you run make menuconfig to configure your build options:

Component config → NodeMCU modules → Ethernet module

Once built and flashed, the minimum code to get connected over Ethernet is:

eth.init({phy  = eth.PHY_LAN8720,
          addr = 0,
          clock_mode = eth.CLOCK_GPIO0_IN,
          mdc   = 16,
          mdio  = 17})