ESP32-P4-NANO
Overview
Introduction
ESP32-P4-NANO is a dual-core RISC-V high-performance development board based on ESP32-P4 chip designed by Waveshare. It supports a wide range of human-computer interfaces, including MIPI-CSI (Integrated Image Signal Processor, ISP) and MIPI-DSI interfaces, as well as common peripherals such as SPI, I2S, I2C, LED PWM, MCPWM, RMT, ADC, UART, and TWAI™. It also supports USB OTG 2.0 HS, Ethernet, and SDIO Host 3.0 for high-speed connectivity. The chip integrates a digital signature peripheral and a dedicated key management unit to ensure its security. ESP32-P4-NANO is specifically designed for high-performance and high-security applications, fully meeting the higher demands of embedded applications in areas such as support for human-machine interfaces, edge computing capabilities, and IO connectivity characteristics.
Features
- Processor
- Equipped with RISC-V 32-bit dual-core processor (HP system), it features DSP and instruction set expansions, along with floating point units (FPU), and the main frequency is up to 400MHz
- Equipped with a RISC-V 32-bit single-core processor (LP system) , the main frequency is up to 40MHz
- Equipped with ESP32-C6 WIFI/BT co-processor, expand WIFI 6/Bluetooth 5 and other functions through SDIO
- Memory
- 128 KB of high-performance (HP) system read-only memory (ROM)
- 16 KB of low-power (LP) system read-only memory (ROM)
- 768 KB of high-performance (HP) L2 memory (L2MEM)
- 32 KB of low-power (LP) SRAM
- 8 KB of system tightly coupled memory (TCM)
- 32 MB PSRAM is stacked in the package, and the QSPI interface is connected to 16MB Nor Flash
- Peripheral interfaces
- Onboard two-way 2*13 pin headers lead to 28 programmable GPIOs to support a wide range of peripherals
- Onboard Type-A USB 2.0 OTG interface, 100Mbps Ethernet interface, SDIO3.0 TF card slot, Type-C UART flashing port, for convenient use in different scenarios
- On-board speaker interface, microphone, Codec chip and power amplifier chip can be used to achieve the ideal audio function requirements
- Onboard MIPI-CSI high-definition camera interface, support full HD 1080P picture acquisition and encoding, integrated image signal processor (ISP) and H264 video encoder, support H.264 & JPEG video encoding (1080P @30fps), easy to apply to computer vision, machine vision and other fields
- On-board MIPI-DSI high-definition screen display interface, integrated pixel processing accelerator (PPA), 2D graphics acceleration controller (2D DMA), supporting JPEG image decoding (1080P @30fps), providing strong support for high-definition screen display and smooth HMI experience, convenient for application to smart home central control screen, industrial central control screen, vending machine and other scenarios
- Reserved PoE module interface makes the power supply mode of the development board more flexible, and only one network cable can be connected to the PoE device to enable the ESP32-S3-NANO series to network and power supply
Hardware description
1. ESP32-P4NRW32 2. ESP32-C6-MINI-1 3. Display screen interface 4. Camera interface 5. Type-C interface 6. USER-LED 7. BOOT button |
8. RESET button 9. PoE module power supply interface/external power supply interface 10. RTC holder 11. SMD microphone 14. 100MB RJ45 network port 15. Speaker interface |
Pinout Definition
Dimensions
Instructions for Use
This tutorial is designed to guide users to set up a software environment for ESP32-P4 hardware development, and show how to use the ESP-IDF configuration menu and compile and download the firmware to the ESP32-P4 development board through simple examples.
- Preparation
- Hardware
- ESP32-P4-NANO development board
- USB cable (Type-A to Type-C, prepared as needed)
- Computer (Windows, Linux or macOS)
- Software (it is recommended to use the integrated development environment to install ESP-IDF, if you are familiar with ESP-IDF, you can directly start from the ESP-IDF terminal, you can choose one of the following development methods)
- VSCode + ESP-IDF plug-in (Recommended)
- Eclipse + ESP-IDF plug-in (Espressif-IDE)
- Arduino IDE ( Since arduino-esp32 does not support ESP32-P4 at present, developers who are only familiar with Arduino IDE can only switch to other environments)
- Hardware
ESP-IDF
Introduction to ESP-IDF and Environment Setup (VSCode Column)
ESP-IDF (Espressif IoT Development Framework) is an open-source IoT development framework launched by Espressif specifically for the development of its ESP32 series chips. ESP-IDF provides the necessary tools and libraries to build IoT applications, including Wi-Fi, Bluetooth, peripheral drivers, file systems, network protocol stacks, encryption, security, and real-time operating systems (FreeRTOS).
The following description only applies to the VSCode + ESP-IDF environment
- PS:
- If you wish to use the Eclipse editor as your primary development environment, please click the link to download Espressif-IDE and install it, replacing the ESP-IDF version to be ≥v5.3.1.
- If you encounter errors such as TSL Error, Network Error, etc., during the installation of ESP-IDF, please re-clear the directory folders, ensure a stable network environment without any proxy contamination, and then try the installation again. It will take a long time, so please be patient.
Prerequisites
- If you are using a Mac or Linux, install the following ESP-IDF prerequisites. If you're using Windows, ignore this step.
Install VSCode
- Open the download page of the official VSCode website, and select the corresponding system and system bit to download
- After running the installation package, the rest can be installed by default, but here for the subsequent experience, it is recommended to check boxes 1, 2, and 3
- After the first and second items are enabled, you can open VSCode directly by right-clicking files or directories, which can improve the subsequent user experience
- After the third item is enabled, you can select VSCode directly when you choose how to open it
Install the ESP-IDF plug-in
- Open VSCode, click on Plugin Manager, and search for ESP-IDF to download and install, as shown in the figure:
- After installation, there is an Espressif logo on the left toolbar is a plug-in, click into the plug-in (there will be a short period of time for loading the program), select EXPRESS, for quick installation, as shown in the figure:
Install the ESP-IDF development environment
- Enter the EXPRESS installation interface, confirm the ESP-IDF version ≥v5.3.1 release version, ESP-IDF directory and ESP-IDF tool directory, click Install, and wait patiently for the installation steps to be completed, as shown in the figure:
- If you are a domestic user in China, you can choose to download the server as Espressif, the installation process is slow, make sure the network is in good condition, you can wait patiently for the installation to complete,
- The installation process is as follows:
- After the installation is complete, the interface is as follows:
Getting Start
The best way to learn a language or development environment is to start from the basics. This section will provide a detailed guide on how to create projects, develop from existing projects, and include embedded classic tutorials such as HelloWorld and the usage of common interface I2C
Introduction to basic structure of an ESP-IDF project
- Open the ESP-IDF plug-in, click New project, select the ESP-IDF demo -- >sample_project -- > click Create
- Create a new VSCode and open it in the window, you can see the structure of VSCode as follows
├── CMakeLists.txt ├── main │ ├── CMakeLists.txt │ └── main.c └── README.md
ESP-IDF Project Details
- Component: The components in ESP-IDF are the basic modules for building applications, each component is usually a relatively independent code base or library, which can implement specific functions or services, and can be reused by applications or other components, similar to the definition of libraries in Python development.
- Component reference: The import of libraries in the Python development environment only requires to "import library name or path", while ESP-IDF is based on the C language, and the importing of libraries is configured and defined through
CMakeLists.txt
. - When we use online components, we usually use
idf.py add-dependency <componetsName>
to add online components to the project, which generates aidf_component.yml
file for managing components. - The purpose of CmakeLists.txt: When compiling ESP-IDF, the build tool
CMake
first reads the content of the top-levelCMakeLists.txt
in the project directory to read the build rules and identify the content to be compiled. When the required components and demos are imported into theCMakeLists.txt
, the compilation toolCMake
will import each content that needs to be compiled according to the index. The compilation process is as follows:
- Component reference: The import of libraries in the Python development environment only requires to "import library name or path", while ESP-IDF is based on the C language, and the importing of libraries is configured and defined through
Description of bottom toolbar of VSCode user interface
When we open an ESP-IDF project, the environment is automatically loaded at the bottom. For the development of ESP32-P4-NANO, the bottom toolbar is also very important, as shown in the figure:
- ESP-IDF Development Environment Version Manager, when our project requires differentiation of development environment versions, it can be managed by installing different versions of ESP-IDF. When the project uses a specific version, it can be switched to by utilizing it
- Device flashing COM port, select to flash the compiled program into the chip
- Select set-target chip model, select the corresponding chip model, for example, ESP32-P4-NANO needs to choose
esp32p4
as the target chip - menuconfig, click it to Modify sdkconfig configuration file
- Fullclean button', when the project compilation error or other operations pollute the compiled content, you can clean up all the compiled content by clicking it
- Build project, when a project satisfies the build, click this button to compile
- Flash button, when a project build is completed, select the COM port of the corresponding development board, and click this button to flash the compiled firmware to the chip
- Monitor enable flashing port monitoring, when a project passes through Build --> Flash, click this button to view the log of output from flashing port and debugging port, so as to observe whether the application works normally
- Build Flash Monitor one-click button, which is used to continuously execute Build->Flash->Monitor, often referred to as "little flame”
HelloWorld demo
After understanding Description of bottom toolbar of VSCode user interface, the HelloWorld project allows you to quickly get started and understand the basic projects of the ESP32 development environment. It demonstrates how to use ESP-IDF to create a basic application, and covers the ESP32 development process, including compilation, flashing, and monitor debugging steps.
- After opening the sample project
HelloWorld
, set the target port and chip type (Note: There is a loading action in the lower right corner when the chip type is selected, indicating that ESP-IDF is executing the commandidf.py set-target esp32p4
. It needs to pull the architecture package environment corresponding to the chip from the package manager, which may take some time. Please wait patiently. If you perform build or other operations at this time, there will be errors!!!) - Through the bottom tool
🔥
with one click, you can build, flash, and monitor, allowing you to view the terminal output of "Hello World"! - Code content analysis
- There is only one
app_main
main function in the code, which determines the print content output through conditional judgment, and adds a loop at the end to achieve 10s restart of the chip. app_main
function is the entry point for user applications in the ESP-IDF (Espressif IoT Development Framework) development framework. It is the core function of the ESP-IDF project and is equivalent to the main function in the standard program of the C language. In ESP32 development,app_main
function is the first task scheduled by the real-time operating system (FreeRTOS), which is the starting point for the execution of the user's code.
- There is only one
I2C
I2C is a commonly used serial communication bus, which can communicate through two lines, one data cable (SDA, Serial Data) and one clock cable (SCL, Serial Clock), and supports multi-master and multi-slave mode. On the ESP32-P4, there are two I2C bus interfaces. The chip internally uses a GPIO exchange matrix to configure the use of any GPIO pins. This feature allows us to freely use any GPIO as an I2C pin control. Of course, the ESP32-P4 I2C supports both Slave and Master modes. Below, we primarily use the I2C host (Master) mode for ESP32-P4 to start communication, control, send data requests or receive data from the slave devices (which can be sensors with any I2C interface).
The I2C pins of ESP32-P4-NANO use SCL(GPIO8)
and SDA(GPIO7)
by default
In ESP-IDF, the I2C bus requires the configuration specified by i2c_master_bus_config_t
:
i2c_master_bus_config_t::clk_source
selects the source clock for the I2C bus, using the default I2C clock source (usually the default clock source) is simply set toI2C_CLK_SRC_DEFAULT
i2c_master_bus_config_t::i2c_port
sets the I2C port used by the controller, as explained above, the ESP32-P4 has two I2C ports. When two different I2C interfaces need to be enabled simultaneously, this needs to be utilized to distinguish between themi2c_master_bus_config_t::scl_io_num
sets the GPIO number of the serial clock bus (SCL), which is 8 on ESP32-P4-NANOi2c_master_bus_config_t::sda_io_num
sets the GPIO number for the serial data bus (SDA), which is 7 on the ESP32-P4-NANOi2c_master_bus_config_t::glitch_ignore_cnt
sets the Glitch Period for the Master Bus, and if the Glitch Period on the line is smaller than this value, it can be filtered out. Typically, this value is set to 7i2c_master_bus_config_t::enable_internal_pullup
enables internal pullups, on the ESP32-P4-NANO, there is already an additional I2C pullup, no need to enable internal pullups
As described above, the I2C configuration is:
i2c_master_bus_config_t i2c_bus_config = { .clk_source = I2C_CLK_SRC_DEFAULT, .i2c_port = I2C_NUM_0, .scl_io_num = 8, .sda_io_num = 7, .glitch_ignore_cnt = 7, .flags.enable_internal_pullup = false, };
- Open the
i2c_tools
the project, select the COM port and chip model, click⚙️
to enter the settings. This will open a new tab: SDK Configuration editor, also known as menuconfig. Directly search for I2C in the search bar. The content has already been retrieved, and the SCL GPIO Num and SDA GPIO Num in the demo are already corresponding toSCL(GPIO8)
andSDA(GPIO7)
- Next, you can directly compile, flash, and monitor by clicking
🔥
. Upon after completion, you will see the command menu in the terminal. When you execute i2cdetect, all I2C addresses will be printed. If there is a device, a number will be displayed (I2C address 18 device corresponds to the onboard ES8311 Codec audio chip, this chip will be detailed in the I2S section), as shown in the figure: - The above steps have realized the basics of I2C device communication. In devices that use the I2C communication protocol, it is often necessary to write register configurations to the corresponding address device via the I2C bus to achieve the functionality of the I2C device. In this case, we need to write the initialization program for the I2C device in the program to drive the I2C device. Different I2C devices have different I2C addresses. In development, we can use the i2ctools tool to query the attached I2C address, nd then read the chip manual to query the registers, configuration and other contents to achieve I2C bus communication.
Intermediate
Ethernet demo
Basic concepts of Ethernet
- Ethernet is an asynchronous Carrier Sense Multiple Access with Collision Detection (CSMA/CD) protocol or interface. Generally speaking, Ethernet is not suitable for low-power applications. However, thanks to its wide range of deployments, efficient network connectivity, high data rates, and unlimited scalability, almost all wired communication can be carried over Ethernet. Currently, Ethernet is classified based on speed tiers as follows: standard Ethernet (10Mbit/s), fast Ethernet (100Mbit/s), gigabit Ethernet (1000Mbit/s), and faster ten-gigabit Ethernet (10Gbit/s).
- Ethernet interface types include RJ45 interface, RJ11 interface (telephone line interface), etc. The RJ45 interface is the most commonly used Ethernet interface (computer interface), and it is also the ESP32-P4-NANO onboard network port type.
- ESP32-P4-NANO can be explained by citing the network model:
- ESP32-P4-NANO network interface layer: ESP32-P4 is connected to the IP101GRI through the RMII interface, and the RJ45 interface network port is drawn through the network transformer, while the development board is managed by the MAC layer integrated into the ESP32-P4 chip to manage the encapsulation, checksum and MAC address of the data frame.
- ESP32-P4-NANO network layer and transport layer: Implemented by the ESP32-P4 driving the IP101GRI
- ESP32-P4-NANO application layer: When a connection is successfully established with the network, ESP32-P4 can implement HTTP requests and use communication servers such as MQTT.
Example demonstration
This example demonstrates the basic usage of Ethernet driver and esp_netif. The initialization of the Ethernet driver is included in a separate subcomponent of the project to clearly distinguish between the initialization of the driver and the initialization of the esp_netif. The workflow for this example is as follows:
- RMII definition:
As mentioned above, The ESP32-P4 chip of ESP32-P4-NANO is connected with the IP101 GRI chip through RMII interface, and the interface is defined as follows:TXD[1:0]
: Sending data cable, controlled by GPIO34 and GPIO35RXD[1:0]
: Receiving data cable, controlled by GPIO30 and GPIO29TX_EN
: Sends an enable signal, controlled by GPIO49CRS_DV
: Carrier detection and data valid signals, controlled by GPIO28REF_CLK
: Reference clock, controlled by GPIO50, 50MHz generated by a 25 MHz passive crystal oscillator connected outside the PHY through frequency doublingMDIO
andMDC
: Manage data interface for Ethernet (control and configuration of the PHY) is controlled by GPIO52 and GPIO31RESET
: Control IP101GRI reset, controlled by GPIO51
- Open the
ethernetbasic
project, select the appropriate COM port and chip model, click on the⚙️
to enter the settings. This will open a new tab: SDK Configuration editor, also known as menuconfig. Directly search for ETH in the search bar, you will find that the content has already been retrieved, and correspond to the parameters in the following figure: - Next, you can directly compile, flash, and monitor by clicking
🔥
. Upon completion, you will see the program start in the terminal. After inserting an Ethernet cable, you can obtain an IP address. Removing the cable will disconnect the action, as shown in the figure: - You can see from the router that a device named
espressif
is connected, and the ESP32-P4-NANO is connected to the network.
SDMMC demo
The ESP32-P4-NANO features a 4-Wire SDIO3.0 card slot for off-chip memory expansion
- Supported rate modes
- Default rate (20 MHz)
- High-speed mode (40 MHz)
- Configure bus width and frequency
In ESP-IDF, use sdmmc_host_t
and sdmmc_slot_config_t
settings to configure the default 20MHz communication frequency and 4-wire width communication, as follows:
sdmmc_host_t host = SDMMC_HOST_DEFAULT(); sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
In designs that support 40 MHz communication, you can adjust the max_freq_khz field in the sdmmc_host_t structure to increase the bus frequency:
sdmmc_host_t host = SDMMC_HOST_DEFAULT(); host.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
The SDMMC 4-wire connection on the ESP32-P4-NANO should be defined as:
sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT(); slot_config.width = 4; slot_config.clk = 43; slot_config.cmd = 44; slot_config.d0 = 39; slot_config.d1 = 40; slot_config.d2 = 41; slot_config.d3 = 42; slot_config.flags |= SDMMC_SLOT_FLAG_INTERNAL_PULLUP;
- Open the
sdmmc
project, select the COM port and chip model, because the demo project defines the pin as a macro, so you need to configure it, of course, you can also directly fill in the pin value. Click⚙️
to enter the settings, here a new tab will open: SDK Configuration editor, which is also known as menuconfig. We directly search for sd in the search bar, see that the content has been retrieved at this time, and the demo configuration has been configured, check the default initialization and create the demo file by default: - Next, insert the prepared TF card, click
🔥
to compile, flash and monitor. After completion, you will see the output of the command menu in the terminal showing the contents of the files in the directory:
WIFI Networking demo
The ESP32-P4 does not come with WIFI/BT capabilities by itself, whereas the ESP32-P4-NANO extends its WIFI functionality by connecting to an ESP32-C6 module via SDIO. The ESP32-C6 acts as a Slave, supporting the ESP32-P4 as the Host utilizing the WIFI 6/BT 5 features through SDIO via a series of instruction sets. By adding two components, seamless use of esp_wifi
is achieved.
// In a WIFI project, add the following two components through the ESP-IDF component management tool idf.py add-dependency "espressif/esp_wifi_remote" idf.py add-dependency "espressif/esp_hosted"
- Open the
wifistation
project to add components - As shown in the above figure, these are the specific steps to add components
- Open the ESP-IDF terminal
- Add the required components in Terminal
- After successful addition, there will be an additional
idf_component.yml
in the main folder of the project, which is used to manage project components, as explained in the ESP-IDF Project Catalog section - After opening, it can be seen that two poments
espressif/esp_hosted: "*"
andespressif/esp_wifi_remote: "*"
have been added. They are added to the project as you build it
- Next, you can open the settings by clicking on
⚙️
. Input "Example" for the search, here you set the ssid and password for the WiFi you want to connect to. Note that ESP32-C6 supports 2.4GHz WiFi-6, so when choosing your target WiFi, make sure the frequency is 2.4GHz. After making the changes, you need to save them, otherwise, there will be an error! - Next, you can directly compile, flash, and monitor by clicking
🔥
. After completion, you will see the following results on the terminal, at this point the ESP32-P4-NANO has already connected to WIFI and is online:
I2S audio demo
I2S (Inter-IC Sound) is a digital communication protocol for transmitting audio data. I2S is a serial bus interface that is primarily used for digital audio data transmission between audio devices, such as digital audio processors (DSPs), digital-to-analog converters (DACs), analog-to-digital converters (ADCs), and audio codecs.
The ESP32-P4 includes 1 I2S peripheral. By configuring these peripherals, the sample data can be input and output with the help of an I2S driver. ESP32-P4-NANO board integrates the es8311 Codec chip and the NS4150B power amplifier chip combination. The I2S bus and pin distribution are as follows:
- MCLK (Master Clock): Master clock signal. The clock is typically provided to the ES8311 by an external device (such as an MCU or DSP), which serves as the clock source for its internal digital audio processing module.
- SCLK (Serial Clock): Serial clock signal. This signal is typically used for clock synchronization for I2S data transmission and is generated by the master device to indicate the rate at which the data is transferred. The transmission of each bit of each audio sample requires a clock cycle.
- ASDOUT (Audio Serial Data Output) or DOUT: Audio data output pin. The ES8311 outputs decoded digital audio data to this pin, which is then transmitted to an amplifier chip or other audio device.
- LRCK (Left/Right Clock) or WS (Word Select): Left and right channel selection signals to indicate whether the current data sample belongs to the left or right channel. Typically in the I2S protocol, one clock cycle represents the left channel data and the other clock cycle represents the right channel data.
- DSDIN (Digital Serial Data Input) or DIN: Digital audio data input pin. This pin receives audio data from an external audio device or a master. The ES8311 decodes this data and processes the audio signals through an internal digital signal processing module.
Function pin | ESP32-P4-NANO pin |
---|---|
MCLK | GPIO13 |
SCLK | GPIO12 |
ASDOUT | GPIO11 |
LRCK | GPIO10 |
DSDIN | GPIO9 |
PA_Ctrl (Power amplifier chip enable pin, active high) | GPIO53 |
The ESP32-P4-NANO es8311 driver uses ES8311 components. It can be added during usage through the IDF Component Manager.
idf.py add-dependency "espressif/es8311"
- Open the
i2scodec
project to add components - As shown in the above figure, these are the specific steps to add components
- Open the ESP-IDF terminal
- Add the required components in Terminal
- After successful addition, there will be an additional
idf_component.yml
in the main folder of the project, which is used to manage project components, as explained in the ESP-IDF Project Catalog section - Once opened, you can see that
the espressif/es8311
component has been added, and it will be added to the project when you build it
- Next, you can open the settings by clicking on
⚙️
, search for Example, and adjust the appropriate volume - When connected to the speaker, you can directly compile, flash, and monitor by clicking
🔥
on it, and the following result will be viewed in the terminal after completion, at this time, ESP32-P4-NANO is already playing audio - When the
echo
mode is set in the settings, the audio will be recorded by the microphone and output by the speakers
MIPI-DSI display driver demo
ESP32-P4-NANO uses the ESP32-P4NRW32 chip with the following new features:
- MIPI-DSI compliant, using D-PHY v1.1 version, up to 2-lane x 1.5Gbps (total 3Gbps)
- Supports RGB888, RGB565, YUV422 input
- Supports RGB888, RGB666, RGB565 output
- Uses video mode to output video streams, and supports output of fixed image patterns
MIPI-DSI image processing can also be processed using a 2D-DMA controller, which supports PPA and JPEG encoding/decoding peripherals
MIPI-DSI LCD driving principle
Hardware required
- Equipped with 10.1-inch display and accessories
- ESP32-P4-NANO [Host]
Steps for display driver
- The 10.1-inch screen driver has been packaged as a component, with the component located at ESP Component Registry
Useidf.py add-dependency "waveshare/esp_lcd_jd9365_10_1"
to add components to your project. - After opening the project, select
esp32p4
core, and you can directly click🔥
to compile, flash, monitor. Upon completion, you can see that the screen has lit up to refresh the color bar:
Advanced
MIPI-CSI To MIPI-DSI (Real-time screen display)
This example shows how to use the esp_driver_cam component to capture the camera sensor signal and display it through the DSI interface. This example utilizes the ESP camera sensor driver esp_cam_sensor
to capture camera sensor signals through the CSI interface and display them via the DSI interface.
Hardware required
- OV5647 camera
- Equipped with 10.1-inch display and accessories
- ESP32-P4-NANO [Host]
Running steps
- Connect the hardware, connect the screen power supply cable to the 5V GND of ESP32-P4-NANO, connect the camera, and the screen cable
- Use Type-C TO USB to connect the ESP32-P4-NANO to the host
- After opening the project, select the
esp32p4
core. Next, you can directly compile, flash, and monitor through clicking 🔥. Upon completion, you can view the screen lighting up and refreshing the camera's captured images. Here is a demonstration of the ESP32-S3-Touch-AMOLED-1.8
ETH To WIFI
This example demonstrates how to use the ESP32-C6 on the ESP32-P4-NANO board as a slave, enabling the ESP32-P4 to drive the IP101 network registration and then realizing the WiFi AP function through the ESP32-C6. The working principle is as follows in the diagram
Hardware required
- ESP32-P4-NANO [Host]
- Switches and network cables with POE function
- Luckfox PoE Module (Optional)
Running steps
- After opening the project, select
esp32p4
core, and you can directly click 🔥 to compile, flash, monitor. When you're done, you can connect the internet cable and check the WiFi to surf the Internet. If there is an optional Luckfox POE Module, it can be connected to a PoE switch to get power directly to the Internet.
LVGL HMI Human Machine Interaction
This example shows that the ESP32-P4 displays LVGL images through the MIPI DSI interface, which fully demonstrates the powerful image processing capabilities of the ESP32-P4
Hardware required
- Equipped with 10.1-inch display and accessories
- ESP32-P4-NANO [Host]
Steps for display driver
- The 10.1-inch screen driver has been packaged as a component, with the component located at ESP Component Registry
Useidf.py add-dependency "waveshare/esp_lcd_jd9365_10_1"
to add components to your project. - After opening the project, select
esp32p4
core, and you can directly click 🔥 to compile, flash, monitor. Upon completion, you can view the screen:
Expert Techniques
ESP-Phone
This example is based on ESP_Brookesia and shows an Android-like interface with many different applications. This example uses the board's MIPI-DSI interface, MIPI-CSI interface, ESP32-C6, TF card, and audio interface. Based on this example, you can create a use case based on ESP_Brookesia to efficiently develop multimedia applications.
Hardware required
- Equipped with 10.1-inch display and accessories
- OV5647 or SC2336 camera and cable
- 8Ω 2W speaker
- ESP32-P4-NANO [Host]
Steps for display driver
- The 10.1-inch screen driver has been packaged as a component, with the component located at ESP Component Registry
Useidf.py add-dependency "waveshare/esp_lcd_jd9365_10_1"
to add components to your project. - After opening the project, select
esp32p4
core, and you can directly click 🔥 to compile, flash, monitor. Upon completion, you can view the screen:
Resources
Schematic diagram
Demos
Datasheets
FAQ
1. In the mipi_dsi_bus.c driver file of the ESP-IDF, the signal escape clock frequency for MIPI_DSI_DEFAULT_ESCAPE_CLOCK_FREQ_MHZ is set to 10MHz. However, in practical testing, this escape speed clock frequency is too low. Since the MIPI communication quality varies for different screens, in this scenario, it can lead to blocking during high-speed MIPI-DSI communication on the ESP32-P4, causing the screen to fail to function properly. There are two solutions:
- Modify the underlying driver of ESP-IDF SDK
- Modify the Mbps value of the screen to reduce the risk of packet loss
- Modify the initialization configuration through the Displaycolorbar demo (the default value is recommended, and the actual modification will affect the screen display effect). The default parameter of lane_bit_rate_mbps in JD9365_PANEL_BUS_DSI_2CH_CONFIG is 1500, and the parameters that can usually be lit are 840, 933, 960, 1000, 1200, and 1500. This confirms that the mbps value of the screen can be lit up normally, and if the BSP is used in other examples where the screen works, this can also be modified or replaced to solve the issue.
1. This issue occurs when using the VS Code plugin. In some cases, the ESP-IDF installed by the VS Code plugin may have a bug. The current solution is to use the IDF tool directly for compilation and flashing.
1. The current chip is version EC01. This version has not undergone ADC calibration, so the use of ADC functionality is not recommended.
2. The USB Serial JTAG function is not yet supported but will be available in a future version.
1. The current chip is version EC01. Some aspects of this version differ from the production version, so we cannot provide the ESP32-P4 ECO1 chip manual and PCB package at this time. Once the production version is available, we will update the [Resources] section. Thank you for your attention.
1. The current SDK does not yet fully support the 400MHz frequency for the ESP32-P4 HP core. It will be updated in the ESP-IDF once the SDK is fully developed.
1. During functionality testing, we have validated several features. Some applications, like using a Cat-4 module for network access or using P4’s MIPI-DSI to expand the host, are progressing but not yet stable enough to release. Once these functionalities are refined, we will add examples to the wiki.
2. If you have ideas or partially validated application scenarios, feel free to share them with us for feasibility assessment.
1. For stability, PlatformIO support for the ESP32-P4 will require the PlatformIO community to support Arduino-esp32 SDK V3.1x.
2. During development, we tested MPY firmware for ESP32-P4, which can run some basic commands. However, this is just a preliminary verification; actual interface and peripheral applications are not yet adapted. Once fully adapted and stable, we will release ESP32-P4 usage examples in MicroPython.
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)