ESP32-S3-ETH
| ||
| ||
| ||
| ||
Overview
Introduction
ESP32-S3-GEEK is an Ethernet development board designed based on ESP32-S3R8. It has excellent Wi-Fi and Bluetooth wireless connection functions, has a more reliable and efficient wired Ethernet connection, and supports PoE power supply (PoE version only). The onboard camera interface is compatible with mainstream cameras such as OV5640, which is convenient for image and video capture. The development board also reserves a Pico-compatible interface, supporting some Raspberry Pi Pico expansion boards. Relying on its rich ecosystem and open-source resources, users can quickly and flexibly perform secondary development. It is widely applicable to Internet of Things, image acquisition, smart home, and artificial intelligence projects.
Features
- Based on the high-performance ESP32-S3R8 chip, equipped with an Xtensa 32-bit LX7 dual-core processor, with a main frequency up to 240MHz
- Integrated 512KB SRAM and 384KB ROM, with built-in 8MB PSRAM and 16MB Flash
- Supports 2.4GHz Wi-Fi and Bluetooth 5 (LE), built-in antenna, supports external antenna
- Onboard W5500 Ethernet chip, extending 10/100Mbps network connectivity via SPI interface
- Supports external PoE module for Power over Ethernet (IEEE 802.3af compliant)
- On-board camera interface, compatible with mainstream cameras such as OV5640, suitable for image and video capture
- Onboard USB Type-C port, supporting power supply, debugging and firmware downloading, making development more convenient
- Onboard TF card slot, supporting external TF card storage for pictures and files
- Onboard Pico-compatible interface, providing rich peripheral expansion, with strong compatibility
Onboard Resources
|
1. ESP32-S3R8 2. W25Q128 3. W5500 4. H1102NLT 5. JW5060 6. USB Type-C port 7. Ethernet interface |
8. PoE port 9. Camera interface 10. IPEX Gen 1 antenna interface 11. Ceramic antenna 12. TF card slot |
Interfaces
Dimensions
Usage Instructions
Components Preparation
- ESP32-S3-ETH x1
- PoE Module (B) x1
- OV5640 camera x1
- 32GB TF card x 1
- USB cable (Type-A male to Type-C male) x1
Working with Arduino
This chapter introduces setting up the Arduino environment, including the Arduino IDE, management of ESP32 boards, installation of related libraries, program compilation and downloading, as well as testing demos. It aims to help users master the development board and facilitate secondary development.
Environment Setup
Download and Install Arduino IDE
- Click to visit the Arduino official website, select the corresponding system and system bit to download.
- Run the installer and install all by default.
Install ESP32 Development Board
- To use ESP32 boards in Arduino IDE, first install the ESP32 Development Board package.
- In some areas, it may not be able to Install online due to network reason, and Install offline is generally recommended.
- For the tutorial on installing ESP32 Development Board package, please refer to Arduino board manager tutorial
| Board name | Board installation requirement | Version number requirement |
|---|---|---|
| ESP32-S3-ETH | "Install Offline" / "Install Online" | 2.0.12 and above |
Install Libraries
- When installing Arduino libraries, there are usually two ways to choose from: Install online and Install offline.
For most libraries, users can easily search and install them through the online library manager of the Arduino software. However, some open-source libraries or custom libraries are not synchronized to the Arduino Library Manager, so they cannot be acquired through online searches. In this case, users can only manually install these libraries offline. - For library installation tutorial, please refer to Arduino library manager tutorial
| Library Name | Description | Library Installation Requirement |
|---|---|---|
| Adafruit_NeoPixel | NeoPixel Light Bar Control Library | "Install Online" or "Install Offline" |
| ESP32-BLE-Keyboard | ESP32 Bluetooth Keyboard Library | "Install Online" or "Install Offline" |
| ETHClass | ESP32 Ethernet Library | Install Offline |
Run the First Arduino Demo
New Project
- Run the Arduino IDE and select
File->New Sketch
- Enter the code:
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
}
void loop() {
// put your main code here, to run repeatedly:
Serial.println("Hello, World!");
delay(2000);
}
- Save the project and select
File->Save As.... In the pop-up menu, select the path to save the project, and enter a project name, such as Hello_World, clickSave
Compile and Flash Demos
- Select the corresponding development board, take the ESP32S3 motherboard as an example:
Tools->Board->esp32->ESP32S3 Dev Module
- Select the corresponding port. In addition, if ESP32 S3 motherboard only has a USB port, USB CDC must be enabled, as shown in the following figure:
- Compile and upload the demo:
- Open the serial port monitoring window, and the demo will print "Hello World!" every 2 seconds, and the operation is as follows:
Demo
| No. | Demo | Description | Dependency Library |
|---|---|---|---|
| 1 | IO_Test | Basic demo: GPIO pin high and low level control | - |
| 2 | RGB_LED | Basic demo: GPIO pin controls WS2812 LED | Adafruit NeoPixel |
| 3 | SD_Card | Basic demo: TF card loading, read and write operations | - |
| 4 | BLE_Keyboard | Basic demo: Bluetooth keyboard function demonstration | ESP32-BLE-Keyboard |
| 5 | WiFi_AP | Basic demo: Set as an AP hotspot to allow other WiFi devices to connect to the Internet | |
| 6 | WiFi_STA | Basic demo: Set to STA mode to access WiFi routing network for networking, and can control the level output of the GPIO port in real time | |
| 7 | WiFi_DHCP | Basic demo: Connect via WiFi, assign IP address via DHCP | |
| 8 | WiFi_staticIP | Basic demo: Connect via WiFi, statically assign IP address | |
| 9 | ETH_DHCP | Basic demo: Connect via Ethernet, assign IP address via DHCP | |
| 10 | ETH_staticIP | Basic demo: Connect via Ethernet, statically assign IP address | |
| 11 | ETH_MAC_DHCP_StaticIP | Basic demo: Connect via Ethernet, customize the MAC address, use DHCP to automatically obtain IP by default, if the acquisition fails, use the default static IP address directly | |
| 12 | WIFI_Web_CAM | Comprehensive demo: Connect via WiFi, implement network camera function | |
| 13 | ETH_Web_CAM | Comprehensive demo: Connect via Ethernet, implement network camera function |
- Arduino project configuration:
IO_Test
Demo description
- This demo demonstrates how to use multiple GPIO pins of the ESP32-S3-ETH module as output control ports. The demo sequentially sets each GPIO pin to high (open) and low (closed) in order, with an interval of 300 milliseconds for each state change. In this way, the sequential switching operation of the GPIO pins can be observed.
Hardware connection
- Connect the board to the computer using a USB cable
Code analysis
1. GPIO pin configuration: The demo first defines the 25 GPIO pins and initializes them into output mode in the setup() function. All pins are set to low level (off state) at the beginning.
#define NUM_GPIO 25
// Define GPIO pins
const int gpio_pin[NUM_GPIO] = {21, 17, 16, 18, 15, 3, 2, 1, 0, 44, 43, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 46, 47, 48};
2. GPIO control loop:
- In the
loop()function, the demo will turn on each GPIO pin in turn (set to high) for a delay of 300 milliseconds, and then turn off the pin (set to low). - This process will be repeated constantly.
3. Print Output: The demo outputs the status information of each GPIO pin through the USB port, indicating whether the pin is in a high voltage level (on) or a low voltage level (off) state.
void loop() {
// Turn on each GPIO one by one
for (current_gpio = 0; current_gpio < NUM_GPIO; current_gpio++) {
digitalWrite(gpio_pin[current_gpio], HIGH); // Set GPIO pin to HIGH (turn on)
printf("GPIO %d set to HIGH.\n", gpio_pin[current_gpio]); // Print GPIO state
delay(300); // Delay for 300ms
}
// Turn off each GPIO one by one
for (current_gpio = 0; current_gpio < NUM_GPIO; current_gpio++) {
digitalWrite(gpio_pin[current_gpio], LOW); // Set GPIO pin to LOW (turn off)
printf("GPIO %d set to LOW.\n", gpio_pin[current_gpio]); // Print GPIO state
delay(300); // Delay for 300ms
}
Result demonstration
After the demo is flashed, the running result of the device is as follows:
- ESP32-S3-ETH will control 25 GPIO pins in turn. The demo switches the HIGH and LOW states on each GPIO pin and outputs the state changes to the monitoring window via USB.
The low level of the output is 0V, and the high level is the operating voltage of the current board. Since the operating voltage of ESP32-S3 is 3.3V, the high level is 3.3V. - Open the serial port monitoring window of the Arduino IDE, and you can observe the state switching of each GPIO pin, as shown in the following figure:
RGB_LED
【Demo description】
The demo uses the GPIO21 pin to control a WS2812 RGB LED to display a variety of lighting effects, including Color Wipe, Rainbow, and Theater Chase.
【Hardware connection】
Connect the board to the computer using a USB cable
【Code analysis】
1. GPIO pin configuration: The demo first defines the RGB LED control pin as a GPIO pin and performs the following steps in the **`setup` function**:
- Initialize the NeoPixel RGB LED:
- Use `strip.begin()` to enable LED control functionality.
- Set the LED brightness to 50% using `strip.setBrightness(50)`.
- Call `strip.show()` to initialize the LED to an off state.
- Configure an additional indicator LED (LED1) as an output and turn it on using `digitalWrite(LED1, HIGH)`.
#define PIN 21 // Pin connected to WS2812 RGB LED
#define LED1 -1 // GPIO for an additional LED (optional)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
#if defined (__AVR_ATtiny85__)
if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
#endif
strip.begin();
strip.setBrightness(50);
strip.show();
pinMode(LED1, OUTPUT);
digitalWrite(LED1, HIGH); // Turn on the additional LED
}
【Result demonstration】
- Color Wipe: The RGB LED sequentially displays red, green, and blue colors, with each color lasting for a certain period
- Theater Chase: Dynamic chasing effects in white, red, and blue, with LEDs displaying colors in a periodic flashing manner
SD_Card
Demo description
- This demo demonstrates how to operate a TF card on the ESP32-S3-ETH module, including initializing the TF card, creating and writing files, listing files in the directory, and reading file content. The demo will create a file named "waveshare.txt", write the text "Hello world from Waveshare", list all the file information in the root directory of the TF card, and finally read the contents of the "waveshare.txt" file and print it to the serial monitor.
Hardware connection
| SPI interface | ESP32-S3-ETH |
|---|---|
| CS (SS) | GPIO4 |
| DI (MOSI) | GPIO6 |
| DO (MISO) | GPIO5 |
| SCK (SCLK) | GPIO7 |
- Install a TF card on the board (a TF card below 16GB is recommended) and connect the board to the computer using a USB cable
Code analysis
1. setup()
- Initialize serial port communication and the TF card.
- Initialize the SPI bus of ESP32 via
SPI.begin()and specify the pins used for TF card communication. - Call
SD.begin()to try to mount the TF card, and output card size upon successful connection. - Call three core functions:
writeFileToSD(): Create and write to a file.listFilesOnSD(): Scan and print all files in the root directory of the TF card.readFileFromSD(): Opens and reads the contents of thewaveshare.txtfile.
2. writeFileToSD()
- The main function is to create or open
waveshare.txtfiles and write the text"Hello world from Waveshare". - After the file write is completed, the file is closed to ensure that the write operation completes correctly.
3. listFilesOnSD()
- Scan all files in the root directory of the TF card and output the file names through the serial port.
- Use
the openNextFile()function to open each file in the directory in turn and print their names, and finally close the root directory file.
4. readFileFromSD(const char *filePath)
- Open and read the file with the specified path, here is
waveshare.txt. - If the file exists, use
file.read()to read the content byte by byte, output the content of the file through the serial port, and finally close the file.
Result demonstration
After the demo is flashed, the running result of the device is as follows:
- Mount the TF card first, then create and write files, scan and list the root directory files of the TF card, and finally open and read the content of a specific file.
BLE_Keyboard
WIFI_AP
Demo description
- This demo configures the ESP32-S3-ETH as a WiFi access point (AP mode), allowing other devices to connect to this WiFi network. The MAC addresses of the connected devices and their assigned IP addresses will be printed on the serial port monitor. This demo allows you to learn how to use the ESP32 as an access point and dynamically monitor the information of the devices connected to the access point.
Hardware connection
- Connect the board to the computer using a USB cable
Code analysis
1. setup()
- Initialize serial communication and configure ESP32 as a WiFi access point (AP).
- Set up the AP using
WiFi.softAP()and specify the network name (SSID) as "ESP32-S3-ETH"and the password as "88888888". - Use
WiFi.onEvent()to register a WiFi event handler that handles client connections and disconnections. - Print a confirmation message on the serial port to indicate that the AP initialization was successful.
2. formatMacAddress()
- Convert the MAC address from a byte array format to a readable string format (such as
XX:XX:XX:XX:XX:XX:XX). - Used to display the MAC address of the connected device on the serial port.
3. WiFiEvent()
- Handle WiFi events, such as client connections and disconnections.
- When the device is connected:
- Print the MAC address of the device.
- Add a short delay (500 ms) to ensure DHCP has time to assign IP addresses.
- Call
printDeviceIP()to get and display the assigned IP address.
- When the device is disconnected, print the disconnection information.
4. printDeviceIP(const uint8_t* mac)
- Retrieves and prints the IP address of the connected device based on the MAC address.
- Use the ESP-IDF functions
esp_wifi_ap_get_sta_list()andtcpip_adapter_get_sta_list()to get a list of connected devices. - Traverse through the list of devices, compare MAC addresses to identify target devices.
- If the IP address is valid (not
0.0.0.0), the IP address is printed. Otherwise, it means that DHCP has not assigned an IP address.
5. loop()
- A small delay is included to keep the CPU idle and prevent unnecessary load.
- There are no other operations in the main loop.
Result demonstration
After the demo is flashed, the running result of the device is as follows:
- The ESP32-S3-ETH module will start a WiFi access point with the network name "ESP32-S3-ETH".
- When the device is connected to the access point, its MAC address and assigned IP address are printed to the serial monitor.
- When the device is disconnected, a disconnection message is also output on the serial port.
WIFI_STA
Demo description
- The demo configures the ESP32-S3 module as a WiFi workstation (STA mode) and sets up a web server to control the LEDs connected to the GPIO18 via a web page. The user can check the current LED status (LED ON or LED OFF) on the web page and toggle the switching status of the LED. Each time the LED status changes, the status information is displayed on the web page and on the serial monitor.
Hardware connection
- Connect the board to the computer using a USB cable
Code analysis
1. setup()
- Function: Initializes system settings, including serial communication, GPIO configuration, WiFi connection, and web server startup.
- Main steps:
- Initialize serial port communication (for debugging output).
- Set GPIO18 as the output and make sure the LED is initially off.
- Connect to a WiFi network and print the IP address on the serial monitor.
- Start the web server and wait for the client to connect.
2. loop()
- Function: Handles client connections and HTTP requests, switches the LED status based on the request content, and generates an HTML page to display the current LED status.
- Main steps:
- Check whether a new client is connected and read the HTTP request.
- Control the high or low level of GPIO18 based on the request path "/H" or "/L" to switch the LED status.
- Generate an HTML page containing the current LED status and switch links, then return it to the client.
- Close the connection with the client, wait for the next connection request.
Result demonstration
After the demo is flashed, the running result of the device is as follows:
- After the module is connected to the network, the IP address of the module is printed out in the monitoring window
- Open a web browser and enter the corresponding IP, you can control the high and low level status of the GPIO18 pin in real time, and the corresponding serial port monitoring window will also print out the return status value of H or L in real time.
GPIO18 is set high
Return: /H
GPIO18 is set low
Return: /L
WIFI_DHCP
Demo description
The demo connects via WIFI using the ESP32-S3-ETH module and assigns an IP address through DHCP.
Code analysis
1. WIFI network configuration: You need to change the WIFI and password in the code to the name and password in the WIFI router in your environment. If there is none, you can create a hotspot with the same name using your phone for module connection testing.
const char *ssid = "Waveshare"; const char *password = "88888888";
2. setup()
- Function: Initialize system settings
- Main steps:
- Initialize serial port communication (for debugging output).
- Print the WIFI connection status and connect to the WIFI network according to the network configuration.
- After connecting to WIFI successfully, print the connection success information and IP address.
Result demonstration
After startup, the serial port prints the status of the WIFI connection and the assigned IP.
WIFI_StaticIP
Demo description
The demo connects via WIFI using the ESP32-S3-ETH module and statically assigns an IP address.
Code analysis
1. WIFI network configuration: You need to change the WIFI and password in the code to the name and password in the WIFI router in your environment. If there is none, you can create a hotspot with the same name using your phone for module connection testing.
const char *ssid = "Waveshare"; const char *password = "88888888";
2. Fixed IP configuration
IPAddress local_ip(192, 168, 1, 100); // Fixed IP address IPAddress gateway(192, 168, 1, 1); // Gateway address IPAddress subnet(255, 255, 255, 0); // Subnet mask IPAddress dns(192, 168, 1, 1); // DNS server address
3. setup()
- Function: Initialize system settings
- Main steps:
- Initialize serial port communication (for debugging output).
- Set to LAN mode and configure a static IP address
- Connect to the WIFI network according to the network configuration.
- Print successful connection information and IP address.
Result demonstration
After startup, the serial port prints the status of the WIFI connection and the assigned IP.
WIFI_Web_CAM
Demo description
| Camera interface | ESP32-S3-ETH GPIO |
|---|---|
| VSYNC | GPIO1 |
| HREF | GPIO2 |
| XCLK | GPIO3 |
| PCLK | GPIO39 |
| SIOD (SDA) | GPIO48 |
| SIOC (SCL) | GPIO47 |
| D7 | GPIO18 |
| D6 | GPIO15 |
| D5 | GPIO38 |
| D4 | GPIO40 |
| D3 | GPIO42 |
| D2 | GPIO46 |
| D1 | GPIO45 |
| D0 | GPIO41 |
The demo uses the ESP32-S3-ETH module to connect via WIFI and combines with the camera module to achieve image acquisition and streaming transmission. The demo will configure the camera pins and start the camera server, allowing users to access the camera's content in real time through the WIFI LAN. During initialization process, the demo will set various parameters of the camera, including resolution, pixel format, etc.
Hardware connection
- Refer to the figure below to connect the hardware. The camera is connected using the DVP interface, and the pin definitions are shown in the diagram on the right.
Code analysis
1. WIFI network configuration: You need to change the WIFI and password in the code to the name and password in the WIFI router in your environment. If there is none, you can create a hotspot with the same name using your phone for module connection testing.
const char *ssid = "Waveshare"; const char *password = "88888888";
2. startCameraServer()
- It is used to start a web-based camera video streaming server. This function creates an HTTP server that receives client requests and returns images or video streams captured by the camera, allowing the user to access the camera data over the network.
Result demonstration
- After startup, ESP32-S3 will initialize WIFI and output the connection status.
- After the camera is successfully initialized, the server will start to provide real-time image transmission services, and users can connect to the camera server via WIFI to view real-time video.
- If the connection is disconnected or the camera initialization fails, the demo will output an error message on the serial monitor.
ETH_DHCP
Demo description
| Network port interface | ESP32-S3-ETH GPIO |
|---|---|
| MISO | GPIO12 |
| MOSI | GPIO11 |
| SCLK | GPIO13 |
| CS | GPIO14 |
| RST | GPIO9 |
| INT | GPIO10 |
The demo connects via Ethernet using the ESP32-S3-ETH module and assigns an IP address through DHCP.
Hardware connection
- Connect the hardware according to the following diagram, as shown in the figure below
Code analysis
1. setup()
- Function: Initialize system settings
- Main steps:
- Initialize serial port communication (for debugging output).
- Initialize the SPI bus and configure the pins of the Ethernet communication module.
- Initialize the Ethernet module and use DHCP to obtain an IP address. If it fails, stop the demo and continue if it succeeds.
- Print the obtained IP address.
Result demonstration
After startup, ESP32-S3 will initialize Ethernet and print the IP address assigned by DHCP.
ETH_StaticIP
Demo description
The demo connects via Ethernet using the ESP32-S3-ETH module and statically assigns an IP address.
Hardware connection
- Connect the hardware according to the following diagram, as shown in the figure below
Code analysis
1. setup()
- Function: Initialize system settings
- Main steps:
- Initialize serial port communication (for debugging output).
- Initialize the SPI bus and configure the pins of the Ethernet communication module.
- Initialize the Ethernet module and perform static IP configuration. If the IP address configuration fails, stop the demo, and continue if it succeeds
- Print the obtained IP address.
Result demonstration
After startup, ESP32-S3 will initialize Ethernet and print the statically assigned IP address.
ETH_MAC_DHCP_StaticIP
Demo description
The demo automatically obtains the IP address via DHCP using the ESP32-S3-ETH module; If the DHCP acquisition fails, it falls back to using a preset static IP address. Subsequently, the final assigned IP address is printed to the serial console for debugging and network verification.
Hardware connection
- Connect the hardware according to the following diagram, as shown in the figure below
Code analysis
1. setup()
- Function: Initialize system settings
- Main steps:
- Initialize serial port communication (for debugging output).
- Initialize the SPI bus and configure the pins of the Ethernet communication module.
- Initialize the Ethernet module, first attempt to obtain an IP address via DHCP; if it fails, use the user-preset static IP address (e.g., 192.168.1.177) for initialization.
- Print the obtained IP address.
Result demonstration
After startup, ESP32-S3 will initialize Ethernet and print the statically assigned IP address.
ETH_Web_CAM
Demo description
| Camera interface | ESP32-S3-ETH GPIO |
|---|---|
| VSYNC | GPIO1 |
| HREF | GPIO2 |
| XCLK | GPIO3 |
| PCLK | GPIO39 |
| SIOD (SDA) | GPIO48 |
| SIOC (SCL) | GPIO47 |
| D7 | GPIO18 |
| D6 | GPIO15 |
| D5 | GPIO38 |
| D4 | GPIO40 |
| D3 | GPIO42 |
| D2 | GPIO46 |
| D1 | GPIO45 |
| D0 | GPIO41 |
| Network port interface | ESP32-S3-ETH GPIO |
|---|---|
| MISO | GPIO12 |
| MOSI | GPIO11 |
| SCLK | GPIO13 |
| CS | GPIO14 |
| RST | GPIO9 |
| INT | GPIO10 |
The demo utilizes the ESP32-S3-ETH module for Ethernet connectivity and, in conjunction with a camera module, implements image acquisition and streaming. The demo will configure the camera pins and start the camera server, so that the user can access the camera content in real time via Ethernet. During initialization, the demo sets various parameters of the camera, including resolution, pixel format, etc., and monitors the status of the Ethernet connection through network events.
Hardware connection
- Refer to the figure below to connect the hardware (if you don't need PoE power supply, there is no need to connect the PoE module)
Code analysis
1. setup()
- Function: Configure serial port debugging and initialize the Ethernet connection, and set the camera control pins.
- Start Ethernet according to different ESP32 configurations through conditional compilation:
- SPI mode: On non-ESP32 devices, use "ETH.beginSPI()" to start Ethernet.
- After waiting for the Ethernet connection to be successful, configure the camera parameters and start the camera server for external access.
- Camera configuration: Configure various parameters of the camera through the "camera_config_t" structure, including:
- Image resolution, format (JPEG or RGB565), XCLK frequency, frame buffer, etc.
- If PSRAM is detected, higher JPEG quality and frame buffer settings will be used to improve image quality.
2. startCameraServer()
- Start the camera server so that the user can access the camera content through the network.
3. Event handling function WiFiEvent(WiFiEvent_t event)
- Function: Used to monitor the status of the Ethernet connection and output debugging information when an event occurs.
- Connection event : When Ethernet is started, connected, or disconnected, status information is output.
- Get IP address event: When an IP address is successfully obtained, the MAC address, IPv4 address, full-duplex status, link speed, and gateway IP address of the device are printed.
Result demonstration
- After startup, the ESP32-S3 initializes the Ethernet and outputs the connection status.
- After the camera is successfully initialized, the server will start to provide real-time image transmission services, and users can connect to the camera server through Ethernet to view real-time video.
- If the connection is disconnected or the camera initialization fails, the demo will output an error message on the serial monitor.
Flash Firmware Flashing and Erasing
- The current demo provides test firmware, which can be used to test whether the onboard device functions properly by directly flashing the test firmware
Resources
Schematic Diagram
Demo
Datasheets
ESP32-S3
Other Components
Software Tools
Arduino
Debugging Tools
Other Resource Links
Project Resources
This section features third - party project resources. We merely provide links and bear no responsibility for content updates or maintenance. Thank you for your understanding.
DroneBot Workshop-Ethernet & Power-over-Ethernet with ESP32 - Build a PoE Camera and a Web Server
- Youtube: https://www.youtube.com/watch?v=JgwjGeAqW8E
- Guide: https://dronebotworkshop.com/esp32-ethernet/
FAQ
Long press the BOOT button, press RESET at the same time, then release RESET, then release the BOOT button, at this time the module can enter the download mode, which can solve most of the problems that can not be downloaded.
GPIO33~GPIO37 are internally occupied and cannot be used.
Yes, but only in 1-line SD mode. Pins need to be configured in menuconfig, as shown below:
As shown in the figure below, the default weld is a vertical 0R resistor. If you want to switch to an external antenna, you need to re-solder the 0R resistor to a horizontal position: 
Support
Technical Support
If you need technical support or have any feedback/review, please click the Submit Now button to submit a ticket, Our support team will check and reply to you within 1 to 2 working days. Please be patient as we make every effort to help you to resolve the issue.
Working Time: 9 AM - 6 PM GMT+8 (Monday to Friday)