• 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
  }

Running Result

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 program 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:
  
  

  GPIO waterfull light experiment diagram
  
  
  

• This program 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 program 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.

• 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 the waveshare.txt file.

2. writeFileToSD()

• The main function is to create or open waveshare.txt files 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.

Running Result

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.
  
  

• 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 program 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() and tcpip_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.

Running Result

After the demo is flashed, the running result of the device is as follows:

1. The ESP32-S3-ETH module will start a WiFi access point with the network name "ESP32-S3-ETH".
2. When the device is connected to the access point, its MAC address and assigned IP address are printed to the serial monitor.
3. When the device is disconnected, a disconnect message is also output on the serial port.
   
   

• 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

WIFI controls GPIO18 output high and low levels

• 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.

Running Result

After the demo is flashed, the running result of the device is as follows:

1. After the module is connected to the network, the IP address of the module is printed out in the monitoring window
   
   
2. 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.
   
   

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.

Running Result

1. After startup, the ESP32-S3 initializes the Ethernet and outputs the connection status.
2. 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.
3. If the connection is disconnected or the camera initialization fails, the demo will output an error message on the serial monitor.