Getting Started with ESP32-S3 Wi-Fi & Bluetooth SoC using ESP32-S3-DEV-KIT-NxR8
Learn how to use Espressif ESP32-S3 SoC for Wi-Fi and Bluetooth development using the Waveshare ESP32-S3-DEV-KIT-NxR8 development board. Use Arduino, ESP-IDF, PlatformIO and VS Code for software development.
If you have ever used the ESP32 microcontroller from Espressif, you must have noticed a few of the limitations it had, mainly with the GPIOs. This is despite the fact that the ESP32 packs a lot of features for its size and price. What if you could improve the ESP32 and overcome those limitations? The ESP32-S3 is the natural evolution of the ESP32 (now called the classic or legacy ESP32) microcontroller series. It overcomes the limitations of the classic ESP32 by adding more features and improvements. This is not the first time we cover the ESP32-S3 though. The Arduino Nano ESP32 Wi-Fi & IoT development board is based on the ESP32-S3 microcontroller. In this post, we will introduce you to the ESP32-S3-DEV-KIT-NxR8 development board from Waveshare. This board is by far the best ESP32-S3 development board we could find, and for good reasons. As usual, we will walk through the features, pinout diagram, schematic and sample codes that you can try out. If you are looking for the ESP32 instead, check out our following tutorial.
Getting Started with Espressif ESP32 Wi-Fi & Bluetooth SoC using DOIT-ESP32-DevKit-V1 Development Board
Learn how to use Espressif ESP32 SoC for Wi-Fi and Bluetooth development using DOIT ESP32 DevKit V1 development board. Use Arduino, ESP-IDF, PlatformIO and VS Code for software development.
ESP32-S3-DEV-KIT-NxR8
The ESP32-S3-DEV-KIT-NxR8 is a development board from Waveshare, a Chinese manufacturer of electronic boards and modules. The board comes in two variants and 4 SKUs.
- ESP32-S3-DEV-KIT-N8R8 – Uses ESP32-S3-WROOM-1 module with 8 MB Flash memory and 8 MB PSRAM.
- ESP32-S3-DEV-KIT-N16R8 – Uses ESP32-S3-WROOM-1 module with 16 MB Flash memory and 8 MB PSRAM.
- Both of the above with and without soldered pin headers.
In this tutorials we are using the variant with 16 MB Flash memory and 8 MB PSRAM. Following are the remaining features of the board.
Features
- Uses ESP32-S3-WROOM-1-NxR8 with either 16 MB or 8 MB Flash memory.
- ESP32 integrates 512 KB SRAM, 384 KB ROM, 8 MB PSRAM, 8 MB / 16 MB Flash memory.
- USB-C connector for power, programming and data. Supports multiple peripherals interfaces simultaneously.
- Onboard CH343 acts as UART-USB converter allowing serial programming and communication.
- Onboard CH334 4-port USB hub chip combines two USB interfaces to one USB-C connector.
- Serial auto-programming support.
- 5V to 3.3V Low Dropout (LDO) voltage regulator with 1 A max current.
- Breaks out all of the ESP32 pins. Pinout is compatible with official ESP32-S3-DevKitC-1 development board.
- Castellated pins allows soldering directly to carrier boards.
- Reset and Boot buttons.
- WS2812B serial RGB LED.
- Power LED on the 3.3V line.
- Breadboard-friendly form-factor.
Block Diagram
Topology
Dimensions
Schematic
Pinout
We have designed a beautiful pinout diagram for the Waveshare ESP32-S3-DEV-KIT-NXR8 development board. This vector pinout diagram is much better than the official one, and allows high quality printing.
For the latest pinout diagram and more details, check our the following page.
Waveshare ESP32-S3-DEV-KIT-NxR8 Wi-Fi Development Board – Pinout Diagram & Arduino Reference
Complete pinout reference for the Waveshare ESP32-S3-DEV-KIT-NXR8 ESP32-S3 Wi-Fi development board including Arduino pin and interface references.
ESP32-S3 SoC
ESP32 is a family of SoCs (System-on-Chip) from Espressif. But when it was first introduced, there was only one SoC called simply “ESP32”. As the company added more products to the line-up, it became a family. The first ESP32 was simply called “ESP32” without any prefix or suffix to the family name. But the term ESP32 is also used for talking about the ESP32 family of SoCs and modules. So if you see the term ESP32, it could mean the ESP32 family, or the first version of the chip.
ESP32 is precisely a System-on-Chip. This is because the chip die integrates more than a typical microcontroller does. The ESP32 integrates entire RF front-ends and MAC for Bluetooth and Wi-Fi into a single chip. The CPU used in ESP32 is a dual-core Xtensa LX6 from Tensilica (now Cadence). The Xtensa is a 32-bit RISC core IP that is different from ARM, AVR, 8051, and others. The Xtensa cores are supported by GCC-based Xtensa toolchain for development. ESP32-S3 is a more recent variant from the ESP32 family. Below is a list of the currently available SoC variants in the ESP family from Espressif.
| SoC Family | CPU | Core Count | Frequency | Bluetooth | WiFi |
|---|---|---|---|---|---|
| ESP8266EX | Xtensa 32-bit L106 | 1 | 160 MHz | N/A | IEEE 802.11 b/g/n; 2.4 GHz; HT20; up to 75 Mbps |
| ESP8285 | Xtensa 32-bit L106 | 1 | 160 MHz | N/A | IEEE 802.11 b/g/n; 2.4 GHz; HT20; up to 75 Mbps |
| ESP32 | Xtensa 32-bit LX6 CPU | 2 | 240 MHz | BR/EDR + Bluetooth LE v4.2 | IEEE 802.11 b/g/n; 2.4 GHz; HT20/40; up to 150 Mbps |
| ESP32-S2 | Xtensa 32-bit LX7 | 1 | 240 MHz | N/A | IEEE 802.11 b/g/n; 2.4 GHz; HT20/40; up to 150 Mbps |
| ESP32-C3/ESP8685 | 32-bit RISC-V | 1 | 160 MHz | Bluetooth LE v5.0 | IEEE 802.11 b/g/n; 2.4 GHz; HT20/40; up to 150 Mbps |
| ESP32-S3 | Xtensa 32-bit LX7 | 2 | 240 MHz | Bluetooth LE v5.0 | IEEE 802.11 b/g/n; 2.4 GHz; HT20/40; up to 150 Mbps |
| ESP32-C2/ESP8684 | 32-bit RISC-V | 1 | 120 MHz | Bluetooth LE v5.0 | IEEE 802.11 b/g/n; 2.4 GHz; HT20; up to 150 Mbps |
| ESP32-C6 | 32-bit RISC-V | 1 | 160 MHz | Bluetooth LE v5.3 | IEEE 802.11 b/g/n; 2.4 GHz; HT20/40; up to 150 Mbps |
| ESP32-H2 | 32-bit RISC-V | 1 | 96 MHz | Bluetooth LE v5.0 | N/A |
You can check out the ESP Product Selector to learn more about the different types of ESP32 SoCs and their features. In addition to different subfamilies of SoCs, each SoC also has different variants based on some feature variations. For example, the ESP32-S3 has 6 variants.
| Ordering Code | In-Package Flash | In-Package PSRAM | Ambient Temp (°C) | VDD_SPI Voltage |
|---|---|---|---|---|
| ESP32-S3 | – | – | -40 ~ 105 | 3.3 V/1.8 V |
| ESP32-S3FN8 | 8 MB (Quad SPI)4 | – | -40 ~ 85 | 3.3 V |
| ESP32-S3R2 | – | 2 MB (Quad SPI) | -40 ~ 85 | 3.3 V |
| ESP32-S3R8 | – | 8 MB (Octal SPI) | -40 ~ 65 | 3.3 V |
| ESP32-S3R8V | – | 8 MB (Octal SPI) | -40 ~ 65 | 1.8 V |
| ESP32-S3FH4R2 | 4 MB (Quad SPI) | 2 MB (Quad SPI) | -40 ~ 85 | 3.3 V |
ESP32-S3-WROOM-1 is available in the following variants. The ESP32-S3-DEV-KIT-NXR8 either uses ESP32-S3-WROOM-1-N8R8 or ESP32-S3-WROOM-1-N16R8.
| Ordering Code | Flash | PSRAM | Ambient Temp. (°C) |
|---|---|---|---|
| ESP32-S3-WROOM-1-N4 | 4 MB (Quad SPI) | – | -40 ~ 85 |
| ESP32-S3-WROOM-1-N8 | 8 MB (Quad SPI) | – | -40 ~ 85 |
| ESP32-S3-WROOM-1-N16 | 16 MB (Quad SPI) | – | -40 ~ 85 |
| ESP32-S3-WROOM-1-H4 | 4 MB (Quad SPI) | – | -40 ~ 105 |
| ESP32-S3-WROOM-1-N4R2 | 4 MB (Quad SPI) | 2 MB (Quad SPI) | -40 ~ 85 |
| ESP32-S3-WROOM-1-N8R2 | 8 MB (Quad SPI) | 2 MB (Quad SPI) | -40 ~ 85 |
| ESP32-S3-WROOM-1-N16R2 | 16 MB (Quad SPI) | 2 MB (Quad SPI) | -40 ~ 85 |
| ESP32-S3-WROOM-1-N4R8 | 4 MB (Quad SPI) | 8 MB (Octal SPI) | -40 ~ 65 |
| ESP32-S3-WROOM-1-N8R8 | 8 MB (Quad SPI) | 8 MB (Octal SPI) | -40 ~ 65 |
| ESP32-S3-WROOM-1-N16R8 | 16 MB (Quad SPI) | 8 MB (Octal SPI) | -40 ~ 65 |
| ESP32-S3-WROOM-1-N16R16VA | 16 MB (Quad SPI) | 16 MB (Octal SPI) | -40 ~ 65 |
ESP32-S3 is a dual-core 32-bit Xtensa LX7 CPU with an additional low-power core (ULP). The main improvements to the ESP32-S3 over the ESP32 are the more number of GPIOs and the USB interface. But this comes with removal of the Ethernet interface and the Bluetooth Classic.
To give you a familiar context, the Arduino Uno uses an ATmega328P AVR microcontroller with a single core inside. Compared to an Arduino Uno, ESP32-S3 is much more powerful as shown in the comparison table below.
| Property | ESP32-S3 | ATmega328P (Uno) |
|---|---|---|
| Core Type | Xtensa LX6 | AVR |
| Instruction Type | RISC | RISC |
| Instruction Size | 32-bit | 8-bit |
| Core Count | 2 | 1 |
| Maximum Clockspeed | 240 MHz | 20 MHz |
| SRAM | 512 KB | 2 KB |
| Flash Size | Up to 16 MB | 32 KB |
| GPIO Count | 45 | 23 |
| ADC Resolution | 12 bit | 10 bit |
| PWM | All GPIO pins | Limited GPIO pins |
| Interrupt | All GPIO pins | 2 GPIO pins |
| UART | 3 | 1 |
| SPI | 4 | 1 |
| I2C | 2 | 1 |
| I2S | 2 | 0 |
| CAN (TWAI) | 1 | 0 |
| DAC | 0 | 0 |
| Touch Input | 14 | 0 |
| LCD | 1 | 0 |
| SDIO | 1 | 0 |
| Ethernet | 0 | 0 |
| USB | 1 | No |
| Price | ~$2.3 | ~$2.7 |
| Firmware Lock Protection | Yes | Yes |
| Working Voltage | 2.3 to 3.6V | 1.8 to 5.5V |
The more the CPU frequency the faster it can execute your code. Similarly, large memory width and instruction size make accessing memory and executing instructions faster. Therefore the computing throughput of an ESP32-S3 SoC is much higher than an average 8-bit microcontroller. This is what allows ESP to run web servers or drive large LCD displays. ESP32 also integrates a large 520 KB of SRAM (Static RAM), 448 KB ROM (not usable), and optionally up to 16 MB flash memory and 8 MB PSRAM (Pseudo Static RAM). Some variants come with internal flash and PSRAM capacities so that you can reduce the BoM cost and PCB area.
In terms of peripherals, ESP32-S3 comes with all modern hardware peripherals such as multiple UART, SPI, I2C, I2S, CAN, SDIO, USB, and ADC. Most of the peripheral functions can be mapped to any GPIO pins of the ESP32, thanks to the IO multiplexer.
Features & Specifications
- Wi-Fi
- IEEE 802.11b/g/n-compliant
- Supports 20 MHz, 40 MHz bandwidth in 2.4 GHz band
- 1T1R mode with data rate up to 150 Mbps
- Wi-Fi Multimedia (WMM)
- TX/RX A-MPDU, TX/RX A-MSDU
- Immediate Block ACK
- Fragmentation and defragmentation
- Automatic Beacon monitoring (hardware TSF)
- 4 × virtual Wi-Fi interfaces
- Simultaneous support for Infrastructure BSS in Station, SoftAP, or Station + SoftAP modes Note that when ESP32-S3 scans in Station mode, the SoftAP channel will change along with the Station channel
- Antenna diversity
- 802.11mc FTM
- Bluetooth
- Bluetooth LE: Bluetooth 5, Bluetooth mesh
- High power mode (20 dBm)
- Speed: 125 Kbps, 500 Kbps, 1 Mbps, 2 Mbps
- Advertising extensions
- Multiple advertisement sets
- Channel selection algorithm #2
- Internal co-existence mechanism between Wi-Fi and Bluetooth to share the same antenna
- CPU and Memory
- Xtensa® dual-core 32-bit LX7 microprocessor, up to 240 MHz
- 128-bit data bus and SIMD commands
- 384 KB ROM
- 512 KB SRAM
- 16 KB SRAM in RTC
- SPI, Dual SPI, Quad SPI, Octal SPI, QPI and OPI interfaces that allow connection to multiple flash and external RAM
- Flash controller with cache is supported
- Flash In-Circuit Programming (ICP) is supported
- CoreMark® scores:
- 1 core at 240 MHz: 613.86 CoreMark; 2.56 CoreMark/MHz
- 2 cores at 240 MHz: 1181.60 CoreMark; 4.92 CoreMark/MHz
- Advanced Peripheral Interfaces
- 45 × programmable GPIOs
- Digital interfaces:
- 4 × SPI
- 1 × LCD interface (8-bit ~16-bit parallel RGB, I8080 and MOTO6800), supporting conversion between RGB565, YUV422, YUV420 and YUV411
- 1 × DVP 8-bit ~16-bit camera interface
- 3 × UART
- 2 × I2C
- 2 × I2S
- 1 × RMT (TX/RX)
- 1 × pulse counter
- LED PWM controller, up to 8 channels
- 1 × full-speed USB OTG
- 1 × USB Serial/JTAG controller
- 2 × MCPWM
- 1 × SD/MMC host controller with 2 slots
- General DMA controller (GDMA), with 5 transmit channels and 5 receive channels
- 1 × TWAI controller, compatible with ISO
- 11898-1 (CAN Specification 2.0)
- Analog interfaces:
- 2 × 12-bit SAR ADCs, up to 20 channels
- 1 × temperature sensor
- 14 × touch-sensing IOs
- Timers:
- 4 × 54-bit general-purpose timers
- 1 × 52-bit system timer
- 3 × watchdog timers
- Low Power Management
- Power Management Unit with five power modes
- Ultra-Low-Power (ULP) coprocessors:
- ULP-RISC-V coprocessor
- ULP-FSM coprocessor
- Security
- Secure boot
- Flash encryption
- 4-Kbit OTP, up to 1792 bits for users
- Cryptographic hardware acceleration:
- AES-128/256 (FIPS PUB 197)
- Hash (FIPS PUB 180-4)
- RSA
- Random Number Generator (RNG)
- HMAC
- Digital signature
Pinout
Chip Revisions
One thing you have to look out for when selecting ESP32 chips is the chip revision. Most modern ICs are designed programmatically using a set of instructions. Sometimes there can be bugs that make it into the semiconductor fabrication stage and can not be fixed by software. Such bugs are fixed with workarounds as a temporary solution. For a permanent solution, the chip design is revised and a new version is produced to replace the affected ones. ESP32 also underwent multiple chip revisions, fixing bugs in each version. When you order new chips and modules, you have to make sure you are getting the latest version. This can be determined by either part labels, or by checking the manufacturing date (week or year code). The following image shows how the marking appears on the chip.
For example, in the image of ESP32-D0WDQ6, the date code is 272018 which translates to week 27 of the year 2018, and the TUB0PKAV07 is the main die serial number. According to Espressif documents, the second character of the chip die should indicate the chip revision. However, the character “U” is not a valid one according to the following table. So we assume it is the third character “B” that is the revision indicator.
| Chip Series | Chip Revision | Marking Indicator |
|---|---|---|
| ESP32 | v0.0 | A |
| v1.0 | B | |
| v1.1 | F | |
| v3.0 | E | |
| v3.1 | G | |
| ESP32-S2 | v0.0 | A |
| v1.0 | B | |
| ESP32-C3 | v0.0 | A |
| v0.1 | B | |
| v0.2 | C | |
| v0.3 | D | |
| v0.4 | E | |
| ESP32-S3 | v0.0 | A |
| v0.1 | B | |
| v0.2 | C | |
| ESP32-C2/ESP8684 | v0.0 | A |
| v1.0 | AA | |
| v1.1 | B | |
| v1.2 | C | |
| ESP32-C6 | v0.0 | A |
| ESP32-H2 | v0.0 | A |
| v0.1 | B |
We are not sure why there is a discrepancy between the official documentation and the actual chip marking. Anyway, you now know how to identify the chip revisions. Additionally, the chip model and revision are printed by the esptool during uploading or can be printed with the following code in ESP-IDF or Arduino IDE. Refer to this ESP-IDF program for more info.
esp_chip_info_t chip_info;
esp_chip_info (&chip_info);
Serial.println ("Chip model: " + String (chip_info.model));
Serial.println ("Chip revision: " + String (chip_info.revision));You can find everything about chip revisions, bugs, and their workarounds in the official errata documents from Espressif.
ESP32-S3-WROOM-1
You can buy bare ESP32-S3 chips and design a system around it. You will need to add an external flash chip, PSRAM if necessary, crystal, reset circuit, and antenna circuit with matched impedance and a suitable antenna or antenna connector. That sounds like too much work, right? In addition to that, if you plan to convert your design into a sellable product, you will also need to get approvals from many regulatory bodies such as FCC depending on where you are going to sell it. That process can be tedious and costly. To alleviate that problem, most manufacturers also produce precertified modules that you can directly integrate into your products. These modules are usually small PCBs with castellated holes that can be directly soldered onto a main PCB; no wiring or connectors are needed. The good thing? Since they are precertified, you don’t need to apply for certification by yourself. This saves you a lot of time and money and allows you to reach the market faster.
Espressif also produces precertified ESP32 modules and one such module is the ESP32-S3-WROOM-1. It integrates the ESP32-S3 SoC, 40 MHz crystal, SPI flash, a reset circuit, and a PCB antenna. Everything you need to get the ESP32-S3 working is right within the module. All you need to do is supply power and upload your program. For this reason, you will find more development boards with ESP32-S3 modules rather than bare chips.
Specifications
| Categories | Items | Specifications |
|---|---|---|
| Certification | RF Certification | FCC, CE, SRRC, ANATEL, NCC, MIC, KCC, WFA, TELEC, IC |
| Wi-Fi Certification | Wi-Fi Alliance | |
| Bluetooth Certification | BQB | |
| Green Certification | RoHS/REACH | |
| Test | Reliability | HTOL/HTSL/uHAST/TCT/ESD |
| Wi-Fi | Protocols | 802.11 b/g/n (802.11n up to 150 Mbps) |
| A-MPDU and A-MSDU aggregation and 0.4 us guard interval support | ||
| Center frequency range of operating channel | 2412 ~ 2484 MHz | |
| Bluetooth | Protocols | Bluetooth LE: Bluetooth 5, Bluetooth mesh |
| Radio | High power mode (20 dBm), -97.5 dBm rx sensitivity | |
| Hardware | Module interfaces | SD card, UART, SPI, SDIO, I2C, LED PWM, Motor PWM, I2S, IR, GPIO, capacitive touch sensor, ADC, Two-Wire Automotive Interface (TWAI), compatible with ISO11898-1 (CAN Specification 2.0) |
| Integrated crystal | 40 MHz | |
| Integrated SPI flash | 8/16 MB | |
| Operating voltage/Power supply | 3.0 V ~ 3.6 V | |
| Operating current | 285~355 mA | |
| Minimum current delivered by power supply | 500 mA | |
| Recommended operating ambient temperature range | -40 °C ~ +85 °C | |
| Package size | 18 mm X 25.5 mm X 3.10 mm | |
| Moisture sensitivity level (MSL) | Level 3 |
Block Diagram
Pinout
Mechanical Drawing
Schematic
As you can see from the schematic, the pins used for the flash memory are not broken out. Only the usable GPIO pins are power pins are broken out. ESP32 needs a 40 MHz or 26 MHz crystal for the clock circuit. You can use the ESP32-S3-WROOM-1 module schematic as a reference for your own board designs based around ESP32-S3 bare chips.
Programming
Before we explain how you can develop software for your ESP32-S3 board using various frameworks and platforms, you should know a few things about the methods of programming an ESP32-S3 SoC and how it differs from other microcontrollers.
ESP32-S3 SoC has a JTAG (Joint Test Action Group) interface for programming and debugging. The JTAG functionality is assigned to GPIO pins given in the following table. You can use the official ESP-Prog debugger/programmer to program or debug your ESP32-S3 chips using the JTAG interface.
| Pin Name | GPIO | Function |
|---|---|---|
MTDI | 41 | Test Data In |
MTCK | 39 | Test Clock |
MTMS | 42 | Test Mode Select |
MTDO | 40 | Test Data Out |
However, the widely used interface for programming ESP32-S3 is not the JTAG, but a serial interface. The UART0 serial port of ESP32-S3 can be used to program the flash memory connected to the ESP32-S3. This is achieved with the help of a bootloader program saved in the ROM of the ESP32-S3. The 448 KB of ROM contains read-only programs that are critical for the functioning of the ESP32-S3 SoC. A user can not erase this program manually or accidentally. The presence of the bootloader prevents you from bricking the ESP32-S3 (you can still brick your ESP32-S3 if you want to) and makes recovery easy even if you did something wrong.
One of the jobs of the bootloader is to check the states of a few GPIO pins called strapping pins and initialize the SoC to different configurations. It can also detect when the user tries to program the flash via the UART0 port. Whenever it detects such an operation, it accepts the data coming through the serial port, writes it to the flash memory, and restarts the SoC. We will see this in action later.
The GPIO pins 43 (U0TXD) and 44 (U0RXD) are used for the UART0 interface by default. You can connect any USB-to-Serial converters such as CP2102, FT232, etc. to the serial port in order to connect an ESP32-S3 board to a computer and upload the firmware through the serial link. Before you can upload your firmware, you need to tell the bootloader about it. That can be done in two ways; by manually pressing the BOOT button or using an auto-programming circuit.
GPIO0 is a strapping pin and the bootloader will enter serial bootloader mode whenever it detects the pin state to be LOW during startup (after a power-up or restart). The GPIO0 is internally pulled up. When the pin state is HIGH, ESP32-S3 will execute the firmware in the flash memory as normal. GPIO0 pin is typically connected to a push-button which if pressed, will connect the GPIO0 to GND. You can find this button on the ESP32-S3-DEV-KIT-NXR8 board. You need to press both the BOOT button and RESET button together and release the RESET button first.
The manual activation of the BOOT button can be automated with a simple auto-programming circuit. This is achieved with the help of two complimentary signals DTR (Data Terminal Ready) and RTS (Request to Send) coming from a USB-Serial chip. These are called flow control pins (together with CTS (Clear to Send)).
The flow control pins can be controlled from the serial monitor provided by the operating system. In Windows, the flow control signals associated with a COM port can be controlled from apps like YAT. The two pins can be used to set the state of both the GPIO0 and RESET/EN pins of the ESP32-S3. When you try to upload a firmware file serially, the DTR and RTS pins are signalled appropriately to put the chip into serial bootloader mode. This removes the need to manually press the BOOT button on the board.
The software tool that takes care of driving the flow control pins and uploading the firmware is the esptool from Espressif. It is an open-source tool written in Python and it works on all operating systems. If you are curious, the reset.py script is what takes care of controlling the flow control pins.
System Organization
Before delving into software development, let’s learn a few things about the software side of things of ESP32-S3. This knowledge is crucial to understanding how your application is loaded and runs on an ESP32-S3.
Flash Partition
The ESP32-S3-WROOM-1 module can have up to 16 MB of flash memory for storing programs and data. To organize the data and programs better, the whole memory can be divided into separate logical sections called partitions. The starting address of each partition and their sizes will be stored in the flash memory. Such a list is called a partition table. ESP32-S3 partition table is stored at an offset 0x8000 (memory address) with a maximum size of 4 KB. A total of 95 entries can be stored in the table. Each entry in the partition table has a name (label), type (app, data, or something else), subtype, and the offset in flash where the partition is loaded. You can configure the partition table according to your application needs using the ESP-IDF tools. For example, the predefined partition table Default_16MB has the following partition scheme.
| # Name | Type | SubType | Offset | Size | Flags |
|---|---|---|---|---|---|
nvs | data | nvs | 0x9000 | 0x5000 | |
otadata | data | ota | 0xe000 | 0x2000 | |
app0 | app | ota_0 | 0x10000 | 0x640000 | |
app1 | app | ota_1 | 0x650000 | 0x640000 | |
spiffs | data | spiffs | 0xc90000 | 0x360000 | |
coredump | data | coredump | 0xFF0000 | 0x10000 |
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x640000,
app1, app, ota_1, 0x650000,0x640000,
spiffs, data, spiffs, 0xc90000,0x360000,
coredump, data, coredump,0xFF0000,0x10000,nvs– Non-volatile storage.otadata– OTA data (stores which OTA partition is active).app0– First OTA firmware slot.app1– Second OTA firmware slotspiffs– SPIFFS filesystem (for files/data storage)coredump– Stores crash dumps for debugging
The app type partition contains executable programs and the data type contains any type of data. There are two app partitions because while one is actively being used the other can be used to download a firmware update. Once the new firmware is completely downloaded, ESP32-S3 can switch to the new partition. You can learn more about ESP32-S3 partitions from the ESP-IDF partition table documentation. If you want to see the default partitions supported by the ESP32-Arduino core, you can find them here.
ESP32-S3 Bootloader
We have already mentioned about the ESP32-S3 bootloader and one of its functions. The following is a set of all functions taken care of by the bootloader.
- Minimal initial configuration of internal modules.
- Initialize Flash Encryption and/or Secure features, if configured.
- Select the application partition to boot, based on the partition table and OTA data (if any).
- Load this image to RAM (IRAM & DRAM) and transfer management to the image that was just loaded.
The bootloader has two stages of execution.
- First Stage Bootloader in ROM loads the second-stage bootloader image to RAM (IRAM & DRAM) from flash offset
0x1000. - The Second Stage Bootloader loads the partition table and main app image from the flash.
Once the bootloader stages are complete the application can start executing. The second-stage bootloader can decide which app partition to execute. ESP32-S3 supports OTA (Over the Air) updates and a new version of your app can be loaded into the OTA partition of the flash. If the bootloader finds a new version of the app, it will start to execute that. You can learn more about how the bootloader works and how the startup process of an ESP32-S3 works from the ESP-IDF bootloader documentation.
FreeRTOS
A Real-Time Operating System (RTOS) for embedded systems helps us manage tasks and data in a better way than a simple infinite loop usually implemented on low-end microcontrollers. FreeRTOS is an open-source RTOS used by the ESP-IDF framework with a few modifications. With it, we can do multiple tasks parallelly, either in the same core or in different cores, and manage inter-process communication and synchronization. We have a dedicated tutorial covering FreeRTOS and how you can write parallel multitasking apps on ESP32 using Arduino.
How to Write Parallel Multitasking Applications for ESP32 using FreeRTOS & Arduino
Learn how to take advantage of the multitasking features of FreeRTOS for ESP32 dual-core SoC using your favorite Arduino IDE. Use our examples to learn about mutex, semaphore and critical section code.
Software Development
Software development for the ESP32 SoC family is carried out with the help of a GCC-based toolchain for Xtensa cores. For ESP32, Espressif has compiled them into a software development framework called ESP-IDF (Espressif IoT Development Framework). All official features and SoCs are first supported by the ESP-IDF before others. In addition to the ESP-IDF, Espressif also officially maintains the arduino-esp32 core for Arduino development. With it, you can write Arduino-style code and use all Arduino libraries with your ESP32-based boards. We will demo both ESP-IDF and Arduino-ESP32 frameworks in this tutorial.
Arduino IDE
The most popular way of developing software for ESP32 boards is through the Arduino Development Framework (ADF). Arduino is simple and intuitive in its design. But simple doesn’t mean it is less powerful. Because the Arduino ESP32 framework uses the same ESP-IDF framework and FreeRTOS for implementing your Arduino code on ESP32-S3. So pretty much everything you can do with ESP-IDF can be done with Arduino framework as well. Another reason why the Arduino framework is the favorite of makers is the availability of Arduino-style libraries. It saves you from writing libraries on your own and you can build faster with other open-source libraries. CIRCUITSTATE also develops and publishes open-source libraries that are compatible with ESP32. You can check them out on our GitHub.
Installing
We will use the latest Arduino IDE 2 for this tutorial. You can use the Boards Manager of the Arduino IDE to search for “esp32” and install the package esp32 by Espressif Systems. You need to have an active internet connection for this to work. If you are unable to find the package, then go to Files → Preference → Additional boards manager URLs: and add the following URL on a new line.
https://espressif.github.io/arduino-esp32/package_esp32_index.jsonAfter saving the preferences, the boards index will be updated and you will be able to install it. The installation can take some time to finish. Wait until it finishes before doing anything else. If you are new to the Arduino IDE and want to learn more about it, we have a dedicated tutorial using the popular Arduino Uno board.
Getting Started with Arduino – Beginner’s Tutorial to Open-Source Hardware Prototyping with Arduino Uno
Learn electronics hardware prototyping and coding with the most popular Arduino open-source microcontroller platform. Learn how to write your first program and upload it to the Arduino Uno board.
After installing everything, you can choose the board from the board selection drop-down menu and then clicking on the Select other board and port…. Unfortunately neither the ESP32-S3-DEV-KIT-NXR8 from Waveshare nor the ESP32-S3_DevKitC-1 from Espressif are listed in the boards list. But do not worry, we can either add the definitions ourselves or choose an existing board that has same or similar features. In this tutorial, we will choose the existing 4D Systems GEN4-ESP32 16MB board from 4D Systems. This board uses the ESP32S3-R8 chip with external 16 MB Flash memory and on-chip 8 MB PSRAM.
Board Definition
If you are wondering where the board definitions are, they are in the boards.txt file that contains all the definitions of the boards supported by the arduino-esp32 core. Whenever support for a new board is to be added, it is done by updating this file. The definition of the 4D Systems GEN4-ESP32 16MB is given below.
gen4-ESP32-S3R8n16.name=4D Systems gen4-ESP32 16MB Modules (ESP32-S3R8n16)
gen4-ESP32-S3R8n16.bootloader.tool=esptool_py
gen4-ESP32-S3R8n16.bootloader.tool.default=esptool_py
gen4-ESP32-S3R8n16.upload.tool=esptool_py
gen4-ESP32-S3R8n16.upload.tool.default=esptool_py
gen4-ESP32-S3R8n16.upload.tool.network=esp_ota
gen4-ESP32-S3R8n16.upload.maximum_size=1310720
gen4-ESP32-S3R8n16.upload.maximum_data_size=327680
gen4-ESP32-S3R8n16.upload.flags=
gen4-ESP32-S3R8n16.upload.extra_flags=
gen4-ESP32-S3R8n16.upload.use_1200bps_touch=false
gen4-ESP32-S3R8n16.upload.wait_for_upload_port=false
gen4-ESP32-S3R8n16.serial.disableDTR=false
gen4-ESP32-S3R8n16.serial.disableRTS=false
gen4-ESP32-S3R8n16.build.tarch=xtensa
gen4-ESP32-S3R8n16.build.bootloader_addr=0x0
gen4-ESP32-S3R8n16.build.target=esp32s3
gen4-ESP32-S3R8n16.build.mcu=esp32s3
gen4-ESP32-S3R8n16.build.core=esp32
gen4-ESP32-S3R8n16.build.variant=esp32_s3r8n16
gen4-ESP32-S3R8n16.build.board=ESP32_S3R8N16
gen4-ESP32-S3R8n16.build.usb_mode=1
gen4-ESP32-S3R8n16.build.cdc_on_boot=1
gen4-ESP32-S3R8n16.build.msc_on_boot=0
gen4-ESP32-S3R8n16.build.dfu_on_boot=0
gen4-ESP32-S3R8n16.build.f_cpu=240000000L
gen4-ESP32-S3R8n16.build.flash_size=16MB (128Mb)
gen4-ESP32-S3R8n16.build.flash_freq=80m
gen4-ESP32-S3R8n16.build.flash_mode=dio
gen4-ESP32-S3R8n16.build.boot=qio
gen4-ESP32-S3R8n16.build.boot_freq=80m
gen4-ESP32-S3R8n16.build.partitions=default
gen4-ESP32-S3R8n16.build.defines=-DBOARD_HAS_PSRAM
gen4-ESP32-S3R8n16.build.loop_core=
gen4-ESP32-S3R8n16.build.event_core=
gen4-ESP32-S3R8n16.build.psram_type=opi
gen4-ESP32-S3R8n16.build.memory_type={build.boot}_{build.psram_type}
gen4-ESP32-S3R8n16.menu.PSRAM.opi=OPI PSRAM
gen4-ESP32-S3R8n16.menu.PSRAM.opi.build.defines=-DBOARD_HAS_PSRAM
gen4-ESP32-S3R8n16.menu.PSRAM.opi.build.psram_type=opi
gen4-ESP32-S3R8n16.menu.FlashMode.qio=QIO 80MHz
gen4-ESP32-S3R8n16.menu.FlashMode.qio.build.flash_mode=dio
gen4-ESP32-S3R8n16.menu.FlashMode.qio.build.boot=qio
gen4-ESP32-S3R8n16.menu.FlashMode.qio.build.boot_freq=80m
gen4-ESP32-S3R8n16.menu.FlashMode.qio.build.flash_freq=80m
gen4-ESP32-S3R8n16.menu.FlashSize.16M=16MB (128Mb)
gen4-ESP32-S3R8n16.menu.FlashSize.16M.build.flash_size=16MB
gen4-ESP32-S3R8n16.menu.LoopCore.1=Core 1
gen4-ESP32-S3R8n16.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1
gen4-ESP32-S3R8n16.menu.LoopCore.0=Core 0
gen4-ESP32-S3R8n16.menu.LoopCore.0.build.loop_core=-DARDUINO_RUNNING_CORE=0
gen4-ESP32-S3R8n16.menu.EventsCore.1=Core 1
gen4-ESP32-S3R8n16.menu.EventsCore.1.build.event_core=-DARDUINO_EVENT_RUNNING_CORE=1
gen4-ESP32-S3R8n16.menu.EventsCore.0=Core 0
gen4-ESP32-S3R8n16.menu.EventsCore.0.build.event_core=-DARDUINO_EVENT_RUNNING_CORE=0
gen4-ESP32-S3R8n16.menu.USBMode.default=Hardware CDC and JTAG
gen4-ESP32-S3R8n16.menu.USBMode.default.build.usb_mode=1
gen4-ESP32-S3R8n16.menu.USBMode.hwcdc=USB-OTG (TinyUSB)
gen4-ESP32-S3R8n16.menu.USBMode.hwcdc.build.usb_mode=0
gen4-ESP32-S3R8n16.menu.CDCOnBoot.cdc=Enabled
gen4-ESP32-S3R8n16.menu.CDCOnBoot.cdc.build.cdc_on_boot=1
gen4-ESP32-S3R8n16.menu.CDCOnBoot.default=Disabled
gen4-ESP32-S3R8n16.menu.CDCOnBoot.default.build.cdc_on_boot=0
gen4-ESP32-S3R8n16.menu.MSCOnBoot.default=Disabled
gen4-ESP32-S3R8n16.menu.MSCOnBoot.default.build.msc_on_boot=0
gen4-ESP32-S3R8n16.menu.MSCOnBoot.msc=Enabled (Requires USB-OTG Mode)
gen4-ESP32-S3R8n16.menu.MSCOnBoot.msc.build.msc_on_boot=1
gen4-ESP32-S3R8n16.menu.DFUOnBoot.default=Disabled
gen4-ESP32-S3R8n16.menu.DFUOnBoot.default.build.dfu_on_boot=0
gen4-ESP32-S3R8n16.menu.DFUOnBoot.dfu=Enabled (Requires USB-OTG Mode)
gen4-ESP32-S3R8n16.menu.DFUOnBoot.dfu.build.dfu_on_boot=1
gen4-ESP32-S3R8n16.menu.UploadMode.default=UART0 / Hardware CDC
gen4-ESP32-S3R8n16.menu.UploadMode.default.upload.use_1200bps_touch=false
gen4-ESP32-S3R8n16.menu.UploadMode.default.upload.wait_for_upload_port=false
gen4-ESP32-S3R8n16.menu.UploadMode.cdc=USB-OTG CDC (TinyUSB)
gen4-ESP32-S3R8n16.menu.UploadMode.cdc.upload.use_1200bps_touch=true
gen4-ESP32-S3R8n16.menu.UploadMode.cdc.upload.wait_for_upload_port=true
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme1=Small App w/ OTA + Huge FS (2MB APP/2MB OTA/12MB SPIFFS)
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme1.build.custom_partitions=gen4esp32_2MBapp_2MBota_12MBspiffs
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme1.upload.maximum_size=2097152
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme2=Medium App w/ OTA + Large FS (4MB APP/4MB OTA/7MB SPIFFS)
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme2.build.custom_partitions=gen4esp32_4MBapp_4MBota_7MBspiffs
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme2.upload.maximum_size=4718592
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme3=Large App w/ OTA (8MB APP/8MB OTA)
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme3.build.custom_partitions=gen4esp32_8MBapp_8MBota
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme3.upload.maximum_size=8323072
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme4=Huge App (16MB APP)
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme4.build.custom_partitions=gen4esp32_16MBapp
gen4-ESP32-S3R8n16.menu.PartitionScheme.gen4esp32scheme4.upload.maximum_size=16646144
gen4-ESP32-S3R8n16.menu.CPUFreq.240=240MHz (WiFi)
gen4-ESP32-S3R8n16.menu.CPUFreq.240.build.f_cpu=240000000L
gen4-ESP32-S3R8n16.menu.CPUFreq.160=160MHz (WiFi)
gen4-ESP32-S3R8n16.menu.CPUFreq.160.build.f_cpu=160000000L
gen4-ESP32-S3R8n16.menu.CPUFreq.80=80MHz (WiFi)
gen4-ESP32-S3R8n16.menu.CPUFreq.80.build.f_cpu=80000000L
gen4-ESP32-S3R8n16.menu.CPUFreq.40=40MHz
gen4-ESP32-S3R8n16.menu.CPUFreq.40.build.f_cpu=40000000L
gen4-ESP32-S3R8n16.menu.CPUFreq.20=20MHz
gen4-ESP32-S3R8n16.menu.CPUFreq.20.build.f_cpu=20000000L
gen4-ESP32-S3R8n16.menu.CPUFreq.10=10MHz
gen4-ESP32-S3R8n16.menu.CPUFreq.10.build.f_cpu=10000000L
gen4-ESP32-S3R8n16.menu.UploadSpeed.921600=921600
gen4-ESP32-S3R8n16.menu.UploadSpeed.921600.upload.speed=921600
gen4-ESP32-S3R8n16.menu.UploadSpeed.115200=115200
gen4-ESP32-S3R8n16.menu.UploadSpeed.115200.upload.speed=115200
gen4-ESP32-S3R8n16.menu.UploadSpeed.256000.windows=256000
gen4-ESP32-S3R8n16.menu.UploadSpeed.256000.upload.speed=256000
gen4-ESP32-S3R8n16.menu.UploadSpeed.230400.windows.upload.speed=256000
gen4-ESP32-S3R8n16.menu.UploadSpeed.230400=230400
gen4-ESP32-S3R8n16.menu.UploadSpeed.230400.upload.speed=230400
gen4-ESP32-S3R8n16.menu.UploadSpeed.460800.linux=460800
gen4-ESP32-S3R8n16.menu.UploadSpeed.460800.macosx=460800
gen4-ESP32-S3R8n16.menu.UploadSpeed.460800.upload.speed=460800
gen4-ESP32-S3R8n16.menu.UploadSpeed.512000.windows=512000
gen4-ESP32-S3R8n16.menu.UploadSpeed.512000.upload.speed=512000
gen4-ESP32-S3R8n16.menu.DebugLevel.none=None
gen4-ESP32-S3R8n16.menu.DebugLevel.none.build.code_debug=0
gen4-ESP32-S3R8n16.menu.DebugLevel.error=Error
gen4-ESP32-S3R8n16.menu.DebugLevel.error.build.code_debug=1
gen4-ESP32-S3R8n16.menu.DebugLevel.warn=Warn
gen4-ESP32-S3R8n16.menu.DebugLevel.warn.build.code_debug=2
gen4-ESP32-S3R8n16.menu.DebugLevel.info=Info
gen4-ESP32-S3R8n16.menu.DebugLevel.info.build.code_debug=3
gen4-ESP32-S3R8n16.menu.DebugLevel.debug=Debug
gen4-ESP32-S3R8n16.menu.DebugLevel.debug.build.code_debug=4
gen4-ESP32-S3R8n16.menu.DebugLevel.verbose=Verbose
gen4-ESP32-S3R8n16.menu.DebugLevel.verbose.build.code_debug=5
gen4-ESP32-S3R8n16.menu.EraseFlash.none=Disabled
gen4-ESP32-S3R8n16.menu.EraseFlash.none.upload.erase_cmd=
gen4-ESP32-S3R8n16.menu.EraseFlash.all=Enabled
gen4-ESP32-S3R8n16.menu.EraseFlash.all.upload.erase_cmd=-eIf you open the Tools menu, you will see a large list of options that you can change. In most cases, you can leave these options to the default and continue working with the board. In case you need to customize them, you need to know the function of each option.
Let us explain those options to you.
- Board
- Choose a board from the list.
- Port
- The active port you need to communicate with the board. In Windows systems, it is a COM port.
- USB CDC On Boot
- Enables or disables the native USB interface of the ESP32-S3.
- CPU Frequency
- The CPU frequency you want to use.
- The larger the frequency, the higher the throughput. It also increases the power consumption.
- Not all frequencies can support Wi-Fi and Bluetooth functions.
- 80~240 MHz for Wi-Fi.
- 10~40 MHz for non Wi-Fi.
- The crystal frequency has to be 40 MHz or 26 MHz.
- Core Debug Level
- Selects how much debugging information has to be printed when running.
- Setting to Verbose will print all possible debug information.
- USB DFU On Boot
- Enters the DFU (Device Firmware Update) mode when enabled through the native USB interface.
- Can only be enabled when the USB mode is OTG.
- Erase All Flash Before Sketch Upload
- Whether to erase the entire flash chip before uploading the code.
- Erasing is writing the flash chip with
0xFF. Since flash chips have a limited (still large) number of write cycles available, we only need to erase portions we want to write to.
- Events Run On
- Selects where the Wi-Fi-related events (callbacks) run.
- Flash Mode
- Determines which type of SPI interface to be used with the flash chip.
- Can be QIO, DIO, QOUT, and DOUT.
- QIO at 80 MHz is the fastest.
- Select depending on the type of flash chip you are using.
- Flash Size
- Selects the flash size.
- Maximum is 16 MB.
- Arduino Runs On
- Selects which CPU core you want to use for the Arduino program. Core 1 is the default. Core 0 is used for RF-related functions.
- USB Firmware MSC On Boot
- USB Mass Storage Class.
- Can be enabled only when the USB is in OTG mode.
- Partition Scheme
- The type of partitioning you want to use.
- PSRAM
- Whether to enable PSRAM or not.
- Upload Mode
- Choose between UART mode and USB-OTG mode.
- Upload Speed
- Selects the upload speed in bits.
- Lower the upload speed if you are encountering uploading issues.
- USB Mode
- Select between CDC/JTAG or USB-OTG.
- In Hardware CDC/JTAG mode, the ESP32-S3 will create a serial port and a JTAG interface.
Connecting the Board
You can use a USB-C cable to connect the board to your computer. Multiple COM ports will be opened in your computer. The COM port is a serial communication port where you can send or receive binary data. The COM port number is automatically assigned by the operating system and is not permanent for your board. The OS can reassign the COM port to another device if needed. The OS assigns the COM port number based on the availability. So it is important to check the COM port associated with your device every time you plug it on the computer.
You can open the device manager of your system to see the COM port. In Windows, the COM ports will be listed under Ports (COM & LPT). Additionally, you can see all related ports and interfaces from a single device connection, you can group the view by containers by selecting View -> Devices by container option.
Since ESP32-S3-DEV-KIT-NXR8 has a CH334 4-port USB hub chip, it can create up to 4 instances of USB devices on this list. In the board design though, only two interfaces are used and therefore you can see two interfaces associated with the board.
- USB JTAG/serial debug unit
- USB Composite Device
- USB JTAG/serial debug unit
- USB Serial Device (COM12)
- USB-Enhanced-SERIAL CH343 (COM13)
- USB-Enhanced-SERIAL CH343 (COM13)
The first one is the native USB interface of the ESP32-S3. It can work as a USB host, JTAG interface as well as a serial device. You can connect USB client devices directly to the ESP32-S3 or use the JTAG interface for programming and debugging. The serial interface can be used for programming and communication.
The second one is the CH343 USB-to-Serial converter connected to the UART0 port of the ESP32-S3. This can also be used for programming and communication. You can choose either the COM12 or COM13 for programming. But remember that when you print something from ESP32-S3, the data goes to one of these ports. It is important to choose the port correctly to see where the data comes. We will show this further down.
When you connect your board to the computer, and open the serial monitor through the board’s COM port, in this case COM13, you will see a strange message on the serial monitor every time the board is reset. The message looks like something below.
ESP-ROM:esp32s3-20210327
Build:Mar 27 2021
rst:0x1 (POWERON),boot:0x8 (SPI_FAST_FLASH_BOOT)
SPIWP:0xee
mode:DIO, clock div:1
load:0x3fce2820,len:0x1150
load:0x403c8700,len:0x4
load:0x403c8704,len:0xc24
load:0x403cb700,len:0x30b4
entry 0x403c88b8This diagnostic startup message is printed by the ESP32-S3’s bootloader program through UART0 port at a baudrate of 115200 bps. The message contains some important working parameters related to flash memory, CPU clock, and startup reason among other things. This message is printed even before your actual code starts and baudrate doesn’t depend on the baudrate you are going to use for your board. For example, if you are going to print some messages at 9600 bps through the serial port, the boot message will still be printed at 115200 bps and you will see some garbage data on the serial monitor before your actual messages.
You can disable the ESP32-S3 serial boot message by pulling the GPIO46 pin HIGH during startup or reset.
Compiling & Uploading
Below is a simple blink sketch to blink the onboard RGB LED of ESP32-S3-DEV-KIT-NXR8. The LED is connected to GPIO38. Since this an RGB LED we have to do more than simply switching the GPIO pin. For this, we need the Adafruit NeoPixel library to control serial RGB LEDs. You can find and install this library from the Arduino IDE’s Library Manager. After installing the library, create a new sketch with the following code.
#include <Arduino.h>
#include <Adafruit_NeoPixel.h>
#define LED_RGB 38 // RGB LED is connected to the GPIO 8
#define PORT_SERIAL Serial0 // Use Serial1 for communication
Adafruit_NeoPixel pixels (1, LED_RGB, NEO_GRB + NEO_KHZ800);
void setup() {
// put your setup code here, to run once:
PORT_SERIAL.begin (115200);
PORT_SERIAL.println ("Blink with ESP32-S3");
pixels.begin();
}
void loop() {
pixels.clear();
pixels.setPixelColor (0, pixels.Color (150, 0, 0));
pixels.show();
delay (500);
pixels.setPixelColor (0, pixels.Color (0, 150, 0));
pixels.show();
delay (500);
pixels.setPixelColor (0, pixels.Color (0, 0, 150));
pixels.show();
delay (500);
}
Before uploading, you have to select the board from the Tools → Board → esp32 → 4D Systems GEN4-ESP32 16MB and the COM (serial) port the board is connected to. Clicking the Upload button will compile and upload the code to the ESP32-S3 board. A compilation log will be printed to the console window. If your program has any errors, the compilation and uploading process will stop and the error will be shown in the console log. For example, the compilation log from our IDE is given below.
FQBN: esp32:esp32:gen4-ESP32-S3R8n16
Using board 'gen4-ESP32-S3R8n16' from platform in folder: C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1
Using core 'esp32' from platform in folder: C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1
cmd /c if exist "C:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink\\partitions.csv" COPY /y "C:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink\\partitions.csv" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\partitions.csv"
cmd /c if not exist "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\partitions.csv" if exist "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\variants\\esp32_s3r8n16\\gen4esp32_2MBapp_2MBota_12MBspiffs.csv" COPY "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\variants\\esp32_s3r8n16\\gen4esp32_2MBapp_2MBota_12MBspiffs.csv" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\partitions.csv"
cmd /c if not exist "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\partitions.csv" COPY "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\tools\\partitions\\default.csv" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\partitions.csv"
cmd /c IF EXIST "C:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink\\bootloader.bin" ( COPY /y "C:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink\\bootloader.bin" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\Blink.ino.bootloader.bin" ) ELSE ( IF EXIST "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\variants\\esp32_s3r8n16\\bootloader.bin" ( COPY "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\variants\\esp32_s3r8n16\\bootloader.bin" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\Blink.ino.bootloader.bin" ) ELSE ( "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esptool_py\\5.0.dev1\\esptool.exe" --chip esp32s3 elf2image --flash-mode dio --flash-freq 80m --flash-size 16MB -o "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\Blink.ino.bootloader.bin" "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3\\bin\\bootloader_qio_80m.elf" ) )
esptool.py v4.8.1
Creating ESP32S3 image...
Merged 2 ELF sections.
Successfully created ESP32S3 image.
cmd /c if exist "C:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink\\build_opt.h" COPY /y "C:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink\\build_opt.h" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\build_opt.h"
cmd /c if not exist "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\build_opt.h" type nul > "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\build_opt.h"
cmd /c type nul > "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/file_opts"
cmd /c COPY /y "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3\\sdkconfig" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\sdkconfig"
1 file(s) copied.
Detecting libraries used...
C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp-x32\2411/bin/xtensa-esp32s3-elf-g++ -c @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/cpp_flags -w -Os -Werror=return-type -w -x c++ -E -CC -DF_CPU=240000000L -DARDUINO=10607 -DARDUINO_ESP32_S3R8N16 -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32_S3R8N16" -DARDUINO_VARIANT="esp32_s3r8n16" -DARDUINO_PARTITION_default -DARDUINO_HOST_OS="windows" -DARDUINO_FQBN="esp32:esp32:gen4-ESP32-S3R8n16:UploadSpeed=921600,USBMode=default,CDCOnBoot=cdc,MSCOnBoot=default,DFUOnBoot=default,UploadMode=default,CPUFreq=240,FlashMode=qio,FlashSize=16M,PartitionScheme=gen4esp32scheme1,DebugLevel=none,PSRAM=opi,LoopCore=1,EventsCore=1,EraseFlash=none" -DESP32=ESP32 -DCORE_DEBUG_LEVEL=0 -DARDUINO_RUNNING_CORE=1 -DARDUINO_EVENT_RUNNING_CORE=1 -DBOARD_HAS_PSRAM -DARDUINO_USB_MODE=1 -DARDUINO_USB_CDC_ON_BOOT=1 -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_USB_DFU_ON_BOOT=0 @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/defines -IC:\Users\vishn\AppData\Local\Temp\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\Blink -iprefix C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/include/ @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/includes -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/qio_opi/include -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1\cores\esp32 -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1\variants\esp32_s3r8n16 @C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A/build_opt.h @C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A/file_opts C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\sketch\Blink.ino.cpp -o nul
Alternatives for Adafruit_NeoPixel.h: [Adafruit NeoPixel@1.15.1]
ResolveLibrary(Adafruit_NeoPixel.h)
-> candidates: [Adafruit NeoPixel@1.15.1]
C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp-x32\2411/bin/xtensa-esp32s3-elf-g++ -c @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/cpp_flags -w -Os -Werror=return-type -w -x c++ -E -CC -DF_CPU=240000000L -DARDUINO=10607 -DARDUINO_ESP32_S3R8N16 -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32_S3R8N16" -DARDUINO_VARIANT="esp32_s3r8n16" -DARDUINO_PARTITION_default -DARDUINO_HOST_OS="windows" -DARDUINO_FQBN="esp32:esp32:gen4-ESP32-S3R8n16:UploadSpeed=921600,USBMode=default,CDCOnBoot=cdc,MSCOnBoot=default,DFUOnBoot=default,UploadMode=default,CPUFreq=240,FlashMode=qio,FlashSize=16M,PartitionScheme=gen4esp32scheme1,DebugLevel=none,PSRAM=opi,LoopCore=1,EventsCore=1,EraseFlash=none" -DESP32=ESP32 -DCORE_DEBUG_LEVEL=0 -DARDUINO_RUNNING_CORE=1 -DARDUINO_EVENT_RUNNING_CORE=1 -DBOARD_HAS_PSRAM -DARDUINO_USB_MODE=1 -DARDUINO_USB_CDC_ON_BOOT=1 -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_USB_DFU_ON_BOOT=0 @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/defines -IC:\Users\vishn\AppData\Local\Temp\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\Blink -iprefix C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/include/ @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/includes -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/qio_opi/include -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1\cores\esp32 -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1\variants\esp32_s3r8n16 -Id:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel @C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A/build_opt.h @C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A/file_opts C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\sketch\Blink.ino.cpp -o nul
Using cached library dependencies for file: d:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel\Adafruit_NeoPixel.cpp
Using cached library dependencies for file: d:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel\Adafruit_Neopixel_RP2.cpp
Using cached library dependencies for file: d:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel\esp.c
Using cached library dependencies for file: d:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel\esp8266.c
Using cached library dependencies for file: d:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel\kendyte_k210.c
Generating function prototypes...
C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp-x32\2411/bin/xtensa-esp32s3-elf-g++ -c @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/cpp_flags -w -Os -Werror=return-type -w -x c++ -E -CC -DF_CPU=240000000L -DARDUINO=10607 -DARDUINO_ESP32_S3R8N16 -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32_S3R8N16" -DARDUINO_VARIANT="esp32_s3r8n16" -DARDUINO_PARTITION_default -DARDUINO_HOST_OS="windows" -DARDUINO_FQBN="esp32:esp32:gen4-ESP32-S3R8n16:UploadSpeed=921600,USBMode=default,CDCOnBoot=cdc,MSCOnBoot=default,DFUOnBoot=default,UploadMode=default,CPUFreq=240,FlashMode=qio,FlashSize=16M,PartitionScheme=gen4esp32scheme1,DebugLevel=none,PSRAM=opi,LoopCore=1,EventsCore=1,EraseFlash=none" -DESP32=ESP32 -DCORE_DEBUG_LEVEL=0 -DARDUINO_RUNNING_CORE=1 -DARDUINO_EVENT_RUNNING_CORE=1 -DBOARD_HAS_PSRAM -DARDUINO_USB_MODE=1 -DARDUINO_USB_CDC_ON_BOOT=1 -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_USB_DFU_ON_BOOT=0 @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/defines -IC:\Users\vishn\AppData\Local\Temp\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\Blink -iprefix C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/include/ @C:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/flags/includes -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.4-858a988d-v1\esp32s3/qio_opi/include -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1\cores\esp32 -IC:\Users\vishn\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.2.1\variants\esp32_s3r8n16 -Id:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel @C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A/build_opt.h @C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A/file_opts C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\sketch\Blink.ino.cpp -o C:\Users\vishn\AppData\Local\Temp\2097598961\sketch_merged.cpp
C:\Users\vishn\AppData\Local\Arduino15\packages\builtin\tools\ctags\5.8-arduino11/ctags -u --language-force=c++ -f - --c++-kinds=svpf --fields=KSTtzns --line-directives C:\Users\vishn\AppData\Local\Temp\2097598961\sketch_merged.cpp
Compiling sketch...
"C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp-x32\\2411/bin/xtensa-esp32s3-elf-g++" -MMD -c "@C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/flags/cpp_flags" -Os -Werror=return-type -DF_CPU=240000000L -DARDUINO=10607 -DARDUINO_ESP32_S3R8N16 -DARDUINO_ARCH_ESP32 "-DARDUINO_BOARD=\"ESP32_S3R8N16\"" "-DARDUINO_VARIANT=\"esp32_s3r8n16\"" -DARDUINO_PARTITION_default "-DARDUINO_HOST_OS=\"windows\"" "-DARDUINO_FQBN=\"esp32:esp32:gen4-ESP32-S3R8n16:UploadSpeed=921600,USBMode=default,CDCOnBoot=cdc,MSCOnBoot=default,DFUOnBoot=default,UploadMode=default,CPUFreq=240,FlashMode=qio,FlashSize=16M,PartitionScheme=gen4esp32scheme1,DebugLevel=none,PSRAM=opi,LoopCore=1,EventsCore=1,EraseFlash=none\"" -DESP32=ESP32 -DCORE_DEBUG_LEVEL=0 -DARDUINO_RUNNING_CORE=1 -DARDUINO_EVENT_RUNNING_CORE=1 -DBOARD_HAS_PSRAM -DARDUINO_USB_MODE=1 -DARDUINO_USB_CDC_ON_BOOT=1 -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_USB_DFU_ON_BOOT=0 "@C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/flags/defines" "-IC:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink" -iprefix "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/include/" "@C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/flags/includes" "-IC:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/qio_opi/include" "-IC:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\cores\\esp32" "-IC:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\variants\\esp32_s3r8n16" "-Id:\\Code\\Arduino\\Sketches\\libraries\\Adafruit_NeoPixel" "@C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/build_opt.h" "@C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/file_opts" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\sketch\\Blink.ino.cpp" -o "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\sketch\\Blink.ino.cpp.o"
Compiling libraries...
Compiling library "Adafruit NeoPixel"
Using previously compiled file: C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\libraries\Adafruit_NeoPixel\Adafruit_Neopixel_RP2.cpp.o
Using previously compiled file: C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\libraries\Adafruit_NeoPixel\esp8266.c.o
Using previously compiled file: C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\libraries\Adafruit_NeoPixel\kendyte_k210.c.o
Using previously compiled file: C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\libraries\Adafruit_NeoPixel\esp.c.o
Using previously compiled file: C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A\libraries\Adafruit_NeoPixel\Adafruit_NeoPixel.cpp.o
Compiling core...
cmd /c echo -DARDUINO_CORE_BUILD > "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/file_opts"
Using precompiled core: C:\Users\vishn\AppData\Local\arduino\cores\0fc2df77673b77f08afbf5e812fbb801\core.a
cmd /c type nul > "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/file_opts"
Linking everything together...
"C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp-x32\\2411/bin/xtensa-esp32s3-elf-g++" "-Wl,--Map=C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.map" "-LC:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/lib" "-LC:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/ld" "-LC:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/qio_opi" -Wl,--wrap=esp_panic_handler "@C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/flags/ld_flags" "@C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/flags/ld_scripts" -Wl,--start-group "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\sketch\\Blink.ino.cpp.o" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\libraries\\Adafruit_NeoPixel\\Adafruit_NeoPixel.cpp.o" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\libraries\\Adafruit_NeoPixel\\Adafruit_Neopixel_RP2.cpp.o" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\libraries\\Adafruit_NeoPixel\\esp.c.o" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\libraries\\Adafruit_NeoPixel\\esp8266.c.o" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\libraries\\Adafruit_NeoPixel\\kendyte_k210.c.o" "C:\\Users\\vishn\\AppData\\Local\\arduino\\cores\\0fc2df77673b77f08afbf5e812fbb801\\core.a" "@C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3/flags/ld_libs" -Wl,--end-group -Wl,-EL -o "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.elf"
"C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esptool_py\\5.0.dev1/esptool.exe" --chip esp32s3 elf2image --flash-mode dio --flash-freq 80m --flash-size 16MB --elf-sha256-offset 0xb0 -o "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.bin" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.elf"
esptool.py v4.8.1
Creating ESP32S3 image...
Merged 2 ELF sections.
Successfully created ESP32S3 image.
"C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\tools\\gen_esp32part.exe" -q "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/partitions.csv" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.partitions.bin"
cmd /c if exist "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\libraries\\Insights" "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1\\tools\\gen_insights_package.exe" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A" Blink.ino "C:\\Users\\vishn\\AppData\\Local\\Temp\\.arduinoIDE-unsaved2025621-35384-9pwpc5.a6y3l\\Blink"
cmd /c if exist "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\libraries\\ESP_SR" if exist "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3\\esp_sr\\srmodels.bin" COPY /y "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp32-arduino-libs\\idf-release_v5.4-858a988d-v1\\esp32s3\\esp_sr\\srmodels.bin" "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A\\srmodels.bin"
"C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esptool_py\\5.0.dev1/esptool.exe" --chip esp32s3 merge-bin -o "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.merged.bin" --pad-to-size 16MB --flash-mode keep --flash-freq keep --flash-size keep 0x0 "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.bootloader.bin" 0x8000 "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.partitions.bin" 0xe000 "C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\hardware\\esp32\\3.2.1/tools/partitions/boot_app0.bin" 0x10000 "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.bin"
esptool.py v4.8.1
Wrote 0x1000000 bytes to file 'C:\Users\vishn\AppData\Local\arduino\sketches\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.merged.bin', ready to flash to offset 0x0.
Using library Adafruit NeoPixel at version 1.15.1 in folder: D:\Code\Arduino\Sketches\libraries\Adafruit_NeoPixel
"C:\\Users\\vishn\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\esp-x32\\2411/bin/xtensa-esp32s3-elf-size" -A "C:\\Users\\vishn\\AppData\\Local\\arduino\\sketches\\974FBC30BB31210A3ED1A6FD61827C3A/Blink.ino.elf"
Sketch uses 336930 bytes (16%) of program storage space. Maximum is 2097152 bytes.
Global variables use 21228 bytes (6%) of dynamic memory, leaving 306452 bytes for local variables. Maximum is 327680 bytes.
esptool.py v4.8.1
Serial port COM12:
Connecting...
Connected to ESP32-S3 on COM12:
Chip type: ESP32-S3 (QFN56) (revision v0.2)
Features: Wi-Fi, BT 5 (LE), Dual Core + LP Core, 240MHz, Embedded PSRAM 8MB (AP_3v3)
Crystal frequency: 40MHz
USB mode: USB-Serial/JTAG
MAC: 94:a9:90:07:4b:e8
Uploading stub flasher...
Running stub flasher...
Stub flasher running.
Changing baud rate to 921600...
Changed.
Configuring flash size...
Flash will be erased from 0x00000000 to 0x00004fff...
Flash will be erased from 0x00008000 to 0x00008fff...
Flash will be erased from 0x0000e000 to 0x0000ffff...
Flash will be erased from 0x00010000 to 0x00062fff...
Compressed 20112 bytes to 12993...
Writing at 0x00000000 [ ] 0.0% 0/12993 bytes...
Writing at 0x00004e90 [==============================] 100.0% 12993/12993 bytes...
Wrote 20112 bytes (12993 compressed) at 0x00000000 in 0.3 seconds (505.4 kbit/s).
Hash of data verified.
Compressed 3072 bytes to 144...
Writing at 0x00008000 [ ] 0.0% 0/144 bytes...
Writing at 0x00008c00 [==============================] 100.0% 144/144 bytes...
Wrote 3072 bytes (144 compressed) at 0x00008000 in 0.0 seconds (563.3 kbit/s).
Hash of data verified.
Compressed 8192 bytes to 47...
Writing at 0x0000e000 [ ] 0.0% 0/47 bytes...
Writing at 0x00010000 [==============================] 100.0% 47/47 bytes...
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.1 seconds (757.8 kbit/s).
Hash of data verified.
Compressed 337072 bytes to 182530...
Writing at 0x00010000 [ ] 0.0% 0/182530 bytes...
Writing at 0x0001c243 [=> ] 9.0% 16384/182530 bytes...
Writing at 0x0002921e [====> ] 18.0% 32768/182530 bytes...
Writing at 0x0002eb60 [=======> ] 26.9% 49152/182530 bytes...
Writing at 0x00034544 [=========> ] 35.9% 65536/182530 bytes...
Writing at 0x00039ec1 [============> ] 44.9% 81920/182530 bytes...
Writing at 0x0003f5d6 [===============> ] 53.9% 98304/182530 bytes...
Writing at 0x00045008 [=================> ] 62.8% 114688/182530 bytes...
Writing at 0x0004ab4c [====================> ] 71.8% 131072/182530 bytes...
Writing at 0x0005573c [=======================> ] 80.8% 147456/182530 bytes...
Writing at 0x0005b23f [=========================> ] 89.8% 163840/182530 bytes...
Writing at 0x00061480 [============================> ] 98.7% 180224/182530 bytes...
Writing at 0x000624b0 [==============================] 100.0% 182530/182530 bytes...
Wrote 337072 bytes (182530 compressed) at 0x00010000 in 2.5 seconds (1095.4 kbit/s).
Hash of data verified.
Hard resetting via RTS pin...
As you can read from the log, the blink sketch is taking 16% or 336930 bytes of the flash memory with the maximum app partition being 2097152 bytes, or around 2 MB. The partition table used by the Arduino project looks like below.
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x200000,
app1, app, ota_1, 0x210000,0x200000,
spiffs, data, spiffs, 0x410000,0xBE0000,
coredump, data, coredump,0xFF0000,0x10000,The blink sketch was saved to the app0 partition with a maximum size of 2097152 bytes (0x200000 in hex). You can also see there is an app1 partition with a subtype ota_1. This is reserved for OTA updates and a new version of your app can be saved here when you push it. The size of the OTA partition is also 2 MB. But what if you don’t need the OTA partition and you have a large app? For that, you can add a custom partition table as file partitions.csv to your sketch folder. During compilation, the toolchain will find the file and use it for flash partition.
Analysing the compilation log, we can learn a few more things. One is the use of a stub. A flasher stub is a program loaded before your actual code is written. The stub is like the ROM bootloader but faster and more optimized. After the stub is loaded and running, the actual writing of the flash begins. You can see which address ranges each data is written to.
We know that an Arduino sketch is not a complete C/C++ source file. It is missing the main() function and many other basic constructs. So where is the main.cpp file? The Arduino IDE and consecutively the arduino-esp32 core converts your Arduino sketch to a proper C++ source file before compiling it. Your Arduino sketch then becomes an external .cpp file for that main project. For example, if your sketch name is Blink.ino, then the file becomes Blink.ino.cpp. Inside the arduino-esp32 package directory, there is a main.cpp file that acts as the backbone of your project. The content of the file is shown below.
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_task_wdt.h"
#include "soc/rtc.h"
#include "Arduino.h"
#if (ARDUINO_USB_CDC_ON_BOOT | ARDUINO_USB_MSC_ON_BOOT | ARDUINO_USB_DFU_ON_BOOT) && !ARDUINO_USB_MODE
#include "USB.h"
#if ARDUINO_USB_MSC_ON_BOOT
#include "FirmwareMSC.h"
#endif
#endif
#include "chip-debug-report.h"
#ifndef ARDUINO_LOOP_STACK_SIZE
#ifndef CONFIG_ARDUINO_LOOP_STACK_SIZE
#define ARDUINO_LOOP_STACK_SIZE 8192
#else
#define ARDUINO_LOOP_STACK_SIZE CONFIG_ARDUINO_LOOP_STACK_SIZE
#endif
#endif
TaskHandle_t loopTaskHandle = NULL;
#if CONFIG_AUTOSTART_ARDUINO
#if CONFIG_FREERTOS_UNICORE
void yieldIfNecessary(void) {
static uint64_t lastYield = 0;
uint64_t now = millis();
if ((now - lastYield) > 2000) {
lastYield = now;
vTaskDelay(5); //delay 1 RTOS tick
}
}
#endif
bool loopTaskWDTEnabled;
__attribute__((weak)) size_t getArduinoLoopTaskStackSize(void) {
return ARDUINO_LOOP_STACK_SIZE;
}
__attribute__((weak)) bool shouldPrintChipDebugReport(void) {
return false;
}
void loopTask(void *pvParameters) {
#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
// sets UART0 (default console) RX/TX pins as already configured in boot or as defined in variants/pins_arduino.h
Serial0.setPins(gpioNumberToDigitalPin(SOC_RX0), gpioNumberToDigitalPin(SOC_TX0));
#endif
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
printBeforeSetupInfo();
#else
if (shouldPrintChipDebugReport()) {
printBeforeSetupInfo();
}
#endif
setup();
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
printAfterSetupInfo();
#else
if (shouldPrintChipDebugReport()) {
printAfterSetupInfo();
}
#endif
for (;;) {
#if CONFIG_FREERTOS_UNICORE
yieldIfNecessary();
#endif
if (loopTaskWDTEnabled) {
esp_task_wdt_reset();
}
loop();
if (serialEventRun) {
serialEventRun();
}
}
}
extern "C" void app_main() {
#ifdef F_XTAL_MHZ
#if !CONFIG_IDF_TARGET_ESP32S2 // ESP32-S2 does not support rtc_clk_xtal_freq_update
rtc_clk_xtal_freq_update((rtc_xtal_freq_t)F_XTAL_MHZ);
rtc_clk_cpu_freq_set_xtal();
#endif
#endif
#ifdef F_CPU
setCpuFrequencyMhz(F_CPU / 1000000);
#endif
#if ARDUINO_USB_CDC_ON_BOOT && !ARDUINO_USB_MODE
Serial.begin();
#endif
#if ARDUINO_USB_MSC_ON_BOOT && !ARDUINO_USB_MODE
MSC_Update.begin();
#endif
#if ARDUINO_USB_DFU_ON_BOOT && !ARDUINO_USB_MODE
USB.enableDFU();
#endif
#if ARDUINO_USB_ON_BOOT && !ARDUINO_USB_MODE
USB.begin();
#endif
loopTaskWDTEnabled = false;
initArduino();
xTaskCreateUniversal(loopTask, "loopTask", getArduinoLoopTaskStackSize(), NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
}
#endifAs you can see setup() and loop() functions are invoked in the main.cpp file, inside a function called loopTask(). The starting point of the app is the app_main() function. Among other things, the app_main() will create a new FreeRTOS task using the loopTask() function and run it on the ARDUINO_RUNNING_CORE which has value 1. The task has a priority of 1. Since the loop() call appears in an infinite for loop, it is executed indefinitely.
VS Code + Arduino
Arduino IDE (even version 2) is limited in functionality and slow even on fast computers. Visual Studio Code (VS Code) is a general-purpose IDE from Microsoft. It can be used to develop software using almost any language or framework. VS Code and its powerful features can be leveraged for Arduino development using the community maintained version of the Arduino Extension. The official Arduino extension from Microsoft is now deprecated. You need to install the Arduino CLI for this to work. We have a detailed tutorial on how you can install VS Code and the Arduino extension for Arduino development.
How to Use VS Code for Creating and Uploading Arduino Sketches
Learn how to use the popular VS Code IDE to develop Arduino projects and upload your sketches to Arduino boards directly, without using Arduino IDE.
To compile your Arduino sketches for the ESP32-S3-DEV-KIT-NXR8, you just need to select the board and the correct serial port.
PlatformIO
PlatformIO is an open-source unified framework for developing embedded software. It unifies a large number of SDKs, toolchains, frameworks, protocols, processor architectures, programmers, and debuggers into a single platform. PIO makes it extremely easy to develop and debug your embedded projects, without resorting to vendor-specific tools. PIO can be installed as an extension to VS Code and you can create Arduino or ESP-IDF projects with it. You don’t need to install Arduino IDE or Arduino CLI for the PIO extension to work. PIO can install and configure everything for you as long as you have an internet connection. We highly suggest that you check out PIO, because once you use it, you won’t go back to other tools.
Arduino Framework
When creating a new project, you can select the board and the framework you want to use. PIO supports Arduino and ESP-IDF frameworks for ESP32-S3. When using the Arduino framework using PlatformIO for the ESP32-S3-DEV-KIT-NXR8 board, you will see the same limitation as we have seen before. The ESP32-S3-DEV-KIT-NXR8 will not be available on the supported board list. As a workaround, you can either use the 4D Systems GEN4-ESP32 16MB board or create your own board definition. In this case, we will create a new board definition. Create a new folder called boards in the root of your project and add a new JSON file called esp32-s3-devkitc-1-n16r8v.json. Add the following contents to the file.
{
"build": {
"arduino":{
"ldscript": "esp32s3_out.ld",
"partitions": "default_16MB.csv",
"memory_type": "qio_opi"
},
"core": "esp32",
"extra_flags": [
"-DARDUINO_ESP32S3_DEV",
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_USB_CDC_ON_BOOT=1"
],
"f_cpu": "240000000L",
"f_flash": "80000000L",
"flash_mode": "qio",
"psram_type": "opi",
"hwids": [
[
"0x303A",
"0x1001"
]
],
"mcu": "esp32s3",
"variant": "esp32s3"
},
"connectivity": [
"wifi",
"bluetooth"
],
"debug": {
"default_tool": "esp-builtin",
"onboard_tools": [
"esp-builtin"
],
"openocd_target": "esp32s3.cfg"
},
"frameworks": [
"arduino",
"espidf"
],
"name": "Espressif ESP32-S3-DevKitC-1-N16R8V (16 MB QD, 8MB PSRAM)",
"upload": {
"flash_size": "16MB",
"maximum_ram_size": 327680,
"maximum_size": 16777216,
"require_upload_port": true,
"speed": 921600
},
"url": "https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/hw-reference/esp32s3/user-guide-devkitc-1.html",
"vendor": "Espressif"
}
After that, you can add the following lines to your platformio.ini configuration file to choose the new board.
[env]
platform = espressif32
board = esp32-s3-devkitc-1-n16r8v
board_build.mcu = esp32s3
framework = arduinoYou can also debug your ESP32-S3 Arduino projects if you have a suitable debugger such as the ESP-Prog. If you want to learn more about PlatformIO, we recommend checking out the following tutorial.
Getting Started with PlatformIO – Unified IDE for Embedded Software Development
Learn how to use the PlatformIO unified ecosystem for embedded software development with the help of modern Visual Studio Code IDE.
ESP-IDF
Similar to how you have done for the Arduino project, you can select ESP-IDF as the framework when you are creating a new PIO project. PIO will install the latest stable version of the ESP-IDF toolchain and it can take some time. Below is a simple program to blink a simple LED connected to the GPIO42. We are not driving the RGB LED here to keep things simple.
#include <stdio.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#define LED_PIN GPIO_NUM_42
void app_main() {
gpio_reset_pin (LED_PIN);
gpio_set_direction (LED_PIN, GPIO_MODE_OUTPUT);
static uint8_t ledState = 0;
while (1) {
gpio_set_level (LED_PIN, ledState);
ledState = !ledState;
vTaskDelay (1000 / portTICK_PERIOD_MS);
}
}The platformio.ini configuration file looks like below. Don’t forget to add the custom board definition to your project.
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[env]
platform = espressif32
board = esp32-s3-devkitc-1-n16r8v
board_build.mcu = esp32s3
framework = espidf
Since the ESP-IDF doesn’t have setup() or loop() functions, we have to add all the initialization code to the app_main() function and all the repeating code to an infinite loop.
Example Programs
We already saw the Blink program in action. So now we will show you a few more example programs. We will use PlatformIO for these examples. To make your life easier, we have combined all of the example programs in a single GitHub repository and single PIO project. You can simply select the example you want to try and compile and upload it to your board. Download the project from the following page.
After downloading, extract it anywhere in your system and open the folder in VS Code. At this point, we assume that you have installed and configured both VS Code and PlatformIO in your system. If not, you can go back to that step and finish them. Following is our platformio.ini configuration file.
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
;=========================================================================================;
; PlatformIO default environment.
[platformio]
default_envs = Hello-World
;=========================================================================================;
[env]
platform = espressif32
board = esp32-s3-devkitc-1-n16r8v
board_build.mcu = esp32s3
framework = arduino
board_build.flash_size = 16MB
; board_build.psram = enabled
monitor_filters = esp32_exception_decoder
; board_build.partitions = partitions.csv
; upload_protocol = esp-builtin
; upload_protocol = esp-prog
; upload_speed = 921600
; debug_tool = esp-builtin
; debug_tool = esp-prog
; debug_speed = 12000
; debug_port = COM25
; build_type = debug
; debug_init_break = tbreak setup
; monitor_speed = 115200
build_flags =
-DARDUINO_USB_MODE=1
-DCONFIG_ARDUINO_EVENT_RUNNING_CORE=1
; -DCORE_DEBUG_LEVEL=5
;=========================================================================================;
[env:Blink]
build_src_filter = +<Blink/>
lib_deps =
${env.lib_deps} ; Inherit common dependencies
https://github.com/adafruit/Adafruit_NeoPixel.git
;=========================================================================================;
[env:Hello-World]
build_src_filter = +<Hello-World/>
lib_deps =
${env.lib_deps} ; Inherit common dependencies
;=========================================================================================;
[env:Check-PSRAM]
build_src_filter = +<Check-PSRAM/>
lib_deps =
${env.lib_deps} ; Inherit common dependencies
;=========================================================================================;
[env:WiFi-Scan]
build_src_filter = +<WiFi-Scan/>
lib_deps =
${env.lib_deps} ; Inherit common dependencies
;=========================================================================================;
[env:WiFi-Connect]
build_src_filter = +<WiFi-Connect/>
lib_deps =
${env.lib_deps} ; Inherit common dependencies
;=========================================================================================;
[env:WiFi-Web-Server]
build_src_filter = +<WiFi-Web-Server/>
lib_deps =
${env.lib_deps} ; Inherit common dependencies
https://github.com/adafruit/Adafruit_NeoPixel.git
;=========================================================================================;
[env:BLE-Serial]
build_src_filter = +<BLE-Serial/>
lib_deps =
${env.lib_deps} ; Inherit common dependencies
;=========================================================================================;
Following is our custom board file.
{
"build": {
"arduino":{
"ldscript": "esp32s3_out.ld",
"partitions": "default_16MB.csv",
"memory_type": "qio_opi"
},
"core": "esp32",
"extra_flags": [
"-DARDUINO_ESP32S3_DEV",
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_USB_CDC_ON_BOOT=1"
],
"f_cpu": "240000000L",
"f_flash": "80000000L",
"flash_mode": "qio",
"psram_type": "opi",
"hwids": [
[
"0x303A",
"0x1001"
]
],
"mcu": "esp32s3",
"variant": "esp32s3"
},
"connectivity": [
"wifi",
"bluetooth"
],
"debug": {
"default_tool": "esp-builtin",
"onboard_tools": [
"esp-builtin"
],
"openocd_target": "esp32s3.cfg"
},
"frameworks": [
"arduino",
"espidf"
],
"name": "Espressif ESP32-S3-DevKitC-1-N16R8V (16 MB QD, 8MB PSRAM)",
"upload": {
"flash_size": "16MB",
"maximum_ram_size": 327680,
"maximum_size": 16777216,
"require_upload_port": true,
"speed": 921600
},
"url": "https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/hw-reference/esp32s3/user-guide-devkitc-1.html",
"vendor": "Espressif"
}
Blink
After opening the project in VS Code, you will get a window similar to the following. The appearances can be different but that is not an issue. Here we have opened the Blink program.
At the bottom panel, you can find the current target starting from env:. Clicking this will bring up all of the examples included in the project. Select any of them, compile and upload. Make sure to choose the correct COM port before uploading.
After uploading the code, you can see the Red, Blue and Green LEDs blinking alternatively. Following is the compilation and upload log.
* Executing task: C:\PIO\penv\Scripts\platformio.exe run --target upload --environment Blink
Processing Blink (platform: espressif32; board: esp32-s3-devkitc-1-n16r8v; framework: arduino)
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Verbose mode can be enabled via `-v, --verbose` option
CONFIGURATION: https://docs.platformio.org/page/boards/espressif32/esp32-s3-devkitc-1-n16r8v.html
PLATFORM: Espressif 32 (6.10.0) > Espressif ESP32-S3-DevKitC-1-N16R8V (16 MB QD, 8MB PSRAM)
HARDWARE: ESP32S3 240MHz, 320KB RAM, 16MB Flash
DEBUG: Current (esp-builtin) On-board (esp-builtin) External (cmsis-dap, esp-bridge, esp-prog, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa)
PACKAGES:
- framework-arduinoespressif32 @ 3.20017.241212+sha.dcc1105b
- tool-esptoolpy @ 1.40501.0 (4.5.1)
- tool-mkfatfs @ 2.0.1
- tool-mklittlefs @ 1.203.210628 (2.3)
- tool-mkspiffs @ 2.230.0 (2.30)
- toolchain-riscv32-esp @ 8.4.0+2021r2-patch5
- toolchain-xtensa-esp32s3 @ 8.4.0+2021r2-patch5
LDF: Library Dependency Finder -> https://bit.ly/configure-pio-ldf
LDF Modes: Finder ~ chain, Compatibility ~ soft
Found 34 compatible libraries
Scanning dependencies...
Dependency Graph
|-- Adafruit NeoPixel @ 1.15.1+sha.70d02aa
Building in release mode
Compiling .pio\build\Blink\src\Blink\main.cpp.o
Building .pio\build\Blink\bootloader.bin
Generating partitions .pio\build\Blink\partitions.bin
esptool.py v4.5.1
Creating esp32s3 image...
Merged 1 ELF section
Successfully created esp32s3 image.
Compiling .pio\build\Blink\lib8dc\Adafruit NeoPixel\Adafruit_NeoPixel.cpp.o
Compiling .pio\build\Blink\lib8dc\Adafruit NeoPixel\Adafruit_Neopixel_RP2.cpp.o
Compiling .pio\build\Blink\lib8dc\Adafruit NeoPixel\esp.c.o
Compiling .pio\build\Blink\lib8dc\Adafruit NeoPixel\esp8266.c.o
Compiling .pio\build\Blink\lib8dc\Adafruit NeoPixel\kendyte_k210.c.o
Compiling .pio\build\Blink\FrameworkArduino\Esp.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\FirmwareMSC.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\FunctionalInterrupt.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\HWCDC.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\HardwareSerial.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\IPAddress.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\IPv6Address.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\MD5Builder.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\Print.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\Stream.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\StreamString.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\Tone.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\USB.cpp.o
Archiving .pio\build\Blink\lib8dc\libAdafruit NeoPixel.a
Compiling .pio\build\Blink\FrameworkArduino\USBCDC.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\USBMSC.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\WMath.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\WString.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\base64.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\cbuf.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-adc.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-bt.c.o
Indexing .pio\build\Blink\lib8dc\libAdafruit NeoPixel.a
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-cpu.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-dac.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-gpio.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-i2c-slave.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-i2c.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-ledc.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-matrix.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-misc.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-psram.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-rgb-led.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-rmt.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-sigmadelta.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-spi.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-time.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-timer.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-tinyusb.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-touch.c.o
Compiling .pio\build\Blink\FrameworkArduino\esp32-hal-uart.c.o
Compiling .pio\build\Blink\FrameworkArduino\firmware_msc_fat.c.o
Compiling .pio\build\Blink\FrameworkArduino\libb64\cdecode.c.o
Compiling .pio\build\Blink\FrameworkArduino\libb64\cencode.c.o
Compiling .pio\build\Blink\FrameworkArduino\main.cpp.o
Compiling .pio\build\Blink\FrameworkArduino\stdlib_noniso.c.o
Compiling .pio\build\Blink\FrameworkArduino\wiring_pulse.c.o
Compiling .pio\build\Blink\FrameworkArduino\wiring_shift.c.o
Archiving .pio\build\Blink\libFrameworkArduino.a
Indexing .pio\build\Blink\libFrameworkArduino.a
Linking .pio\build\Blink\firmware.elf
Retrieving maximum program size .pio\build\Blink\firmware.elf
Checking size .pio\build\Blink\firmware.elf
Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
RAM: [= ] 5.8% (used 19164 bytes from 327680 bytes)
Flash: [ ] 4.4% (used 285989 bytes from 6553600 bytes)
Building .pio\build\Blink\firmware.bin
esptool.py v4.5.1
Creating esp32s3 image...
Merged 2 ELF sections
Successfully created esp32s3 image.
Configuring upload protocol...
AVAILABLE: cmsis-dap, esp-bridge, esp-builtin, esp-prog, espota, esptool, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa
CURRENT: upload_protocol = esptool
Looking for upload port...
Auto-detected: COM12
Uploading .pio\build\Blink\firmware.bin
esptool.py v4.5.1
Serial port COM12
Connecting...
Chip is ESP32-S3 (revision v0.2)
Features: WiFi, BLE
Crystal is 40MHz
MAC: 94:a9:90:07:4b:e8
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 921600
Changed.
Configuring flash size...
Flash will be erased from 0x00000000 to 0x00003fff...
Flash will be erased from 0x00008000 to 0x00008fff...
Flash will be erased from 0x0000e000 to 0x0000ffff...
Flash will be erased from 0x00010000 to 0x00055fff...
Compressed 15104 bytes to 10429...
Writing at 0x00000000... (100 %)
Wrote 15104 bytes (10429 compressed) at 0x00000000 in 0.2 seconds (effective 485.5 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 146...
Writing at 0x00008000... (100 %)
Wrote 3072 bytes (146 compressed) at 0x00008000 in 0.0 seconds (effective 522.4 kbit/s)...
Hash of data verified.
Compressed 8192 bytes to 47...
Writing at 0x0000e000... (100 %)
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.1 seconds (effective 704.0 kbit/s)...
Hash of data verified.
Compressed 286352 bytes to 161365...
Writing at 0x00010000... (10 %)
Writing at 0x0001bf34... (20 %)
Writing at 0x0002499e... (30 %)
Writing at 0x0002a3e3... (40 %)
Writing at 0x0002f902... (50 %)
Writing at 0x00034d6b... (60 %)
Writing at 0x0003be65... (70 %)
Writing at 0x00045716... (80 %)
Writing at 0x0004b63c... (90 %)
Writing at 0x00050e3c... (100 %)
Wrote 286352 bytes (161365 compressed) at 0x00010000 in 2.1 seconds (effective 1093.0 kbit/s)...
Hash of data verified.
Leaving...
Hard resetting via RTS pin...
======================================================================= [SUCCESS] Took 10.33 seconds =======================================================================
Environment Status Duration
------------- -------- ------------
Blink SUCCESS 00:00:10.332
======================================================================== 1 succeeded in 00:00:10.332 ========================================================================
* Terminal will be reused by tasks, press any key to close it.Hello World
Now we will try to print a “Hello World!” message through the serial port. The default Serial instance prints to the USB-CDC serial port and the for the UART0, you have to use the Serial0.
//============================================================================================//
/*
Filename: main.cpp [ESP32-S3-DEV-KIT-NXR8 -> Hello-World]
Description: Prints "Hello World!" to the serial port every 500 milliseconds.
Framework: Arduino, PlatformIO
Author: Vishnu Mohanan (@vishnumaiea, @vizmohanan)
Maintainer: CIRCUITSTATE Electronics (@circuitstate)
Version: 0.1
License: MIT
Source: https://github.com/CIRCUITSTATE/ESP32-S3-DEV-KIT-NXR8
Last Modified: +05:30 13:30:46 PM 22-06-2025, Sunday
*/
//============================================================================================//
#include <Arduino.h>
//============================================================================================//
// #define PORT_SERIAL Serial // Use USB for communication
#define PORT_SERIAL Serial0 // Use UART0 for communication
//============================================================================================//
/**
* @brief Setup runs once.
*
*/
void setup() {
PORT_SERIAL.begin (115200);
}
//============================================================================================//
/**
* @brief Infinite loop.
*
*/
void loop() {
PORT_SERIAL.println ("Hello World!");
delay (500);
}
//============================================================================================//Wi-Fi Web Server
There are many Wi-Fi-related examples available from Arduino. Here, we are going to show you a simple web server sketch that will connect your ESP32-S3 to a Wi-Fi network and allow you to control an LED from a web browser. We will use the built-in RGB LED as the control target. In place of yourssid and yourpassword, you need to enter the actual Wi-Fi network name and the password before uploading the code. Below is the code.
//============================================================================================//
/*
Filename: main.cpp [ESP32-S3-DEV-KIT-NXR8 -> WiFi-Web-Server]
Description: A simple web server that lets you blink an LED via the web. This sketch will print
the IP address of your WiFi Shield (once connected) to the Serial monitor. From there,
you can open that address in a web browser to turn on and off the built-in LED.
If the IP address of your shield is yourAddress:
http://yourAddress/H turns the LED on
http://yourAddress/L turns it off
This example is written for a network using WPA2 encryption. For insecure
WEP or WPA, change the Wifi.begin() call and use Wifi.setMinSecurity()
accordingly.
Created for arduino 25 Nov 2012 by Tom Igoe
Framework: Arduino, PlatformIO
Author: Vishnu Mohanan (@vishnumaiea, @vizmohanan)
Maintainer: CIRCUITSTATE Electronics (@circuitstate)
Version: 0.1
License: MIT
Source: https://github.com/CIRCUITSTATE/ESP32-S3-DEV-KIT-NXR8
Last Modified: +05:30 16:52:46 PM 22-06-2025, Sunday
*/
//============================================================================================//
#include <WiFi.h>
#include <Adafruit_NeoPixel.h>
//============================================================================================//
#define PIN_LED_RGB 38 // RGB LED is connected to the GPIO 38
// #define PORT_SERIAL Serial // Use USB for communication
#define PORT_SERIAL Serial0 // Use UART0 for communication
//============================================================================================//
Adafruit_NeoPixel led (1, PIN_LED_RGB, NEO_GRB + NEO_KHZ800);
const char* ssid = "your_ssid";
const char* password = "your_password";
WiFiServer server (80);
//============================================================================================//
void setup() {
PORT_SERIAL.begin (115200);
delay (10);
led.begin();
led.clear();
// We start by connecting to a WiFi network
PORT_SERIAL.println();
PORT_SERIAL.println();
PORT_SERIAL.print ("Connecting to ");
PORT_SERIAL.print (ssid);
WiFi.begin (ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay (500);
PORT_SERIAL.print (".");
}
PORT_SERIAL.println ("");
PORT_SERIAL.println ("WiFi connected.");
PORT_SERIAL.print ("IP address: ");
PORT_SERIAL.println (WiFi.localIP());
server.begin();
}
//============================================================================================//
void loop() {
WiFiClient client = server.available(); // listen for incoming clients
if (client) { // if you get a client,
PORT_SERIAL.println ("New Client."); // print a message out the serial port
String currentLine = ""; // make a String to hold incoming data from the client
while (client.connected()) { // loop while the client's connected
if (client.available()) { // if there's bytes to read from the client,
char c = client.read(); // read a byte, then
PORT_SERIAL.write (c); // print it out the serial monitor
if (c == '\n') { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a
// row. that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200
// OK) and a content-type so the client knows what's coming, then a
// blank line:
client.println ("HTTP/1.1 200 OK");
client.println ("Content-type:text/html");
client.println();
// the content of the HTTP response follows the header:
client.print ("Click <a href=\"/H\">here</a> to turn the LED on.<br>");
client.print ("Click <a href=\"/L\">here</a> to turn the LED off.<br>");
// The HTTP response ends with another blank line:
client.println();
// break out of the while loop:
break;
}
else { // if you got a newline, then clear currentLine:
currentLine = "";
}
}
else if (c != '\r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
// Check to see if the client request was "GET /H" or "GET /L":
if (currentLine.endsWith ("GET /H")) {
led.setPixelColor (0, led.Color (0, 150, 0));
led.show();
}
if (currentLine.endsWith ("GET /L")) {
led.clear();
led.show();
}
}
}
// close the connection:
client.stop();
PORT_SERIAL.println ("Client Disconnected.");
}
}
//============================================================================================//As soon as your board is connected to the Wi-Fi network, it will print the IP address assigned to it. The IP address is assigned by the Wi-Fi access point (AP, or the router) and can not be fixed. The AP will assign the next free IP when your board tries to reconnect. This makes the IP dynamic. You can open the serial monitor and reset the board to see the board’s IP address.
If you copy the IP address and paste it into a web browser, you will get a page like the one below. In our case, the IP address is 192.168.1.23. The board opens HTTP port 80 as soon as it is connected to the network. That is why we can open the page served by the ESP32-S3 board. You can click on the two links to either turn on or off the LED. When you click on the links, an extra parameter is sent with the address. The parameter is either H (High) or L (Low). When the web server receives this parameter, it turns the LED ON/OFF.
Bluetooth LE
Unlike the ESP32 which supports both Classic and Low Energy (LE) versions of Bluetooth, the ESP32-S3 only supports BLE v5. To demonstrate the BLE feature of the ESP32-S3 board, we are going to create a simple Nordic UART Service example with which you can send and receive serial data using a serial monitor and the NRF Connect app from Nordic Semiconductor. Try uploading the following code to your ESP32 board.
//============================================================================================//
/*
Filename: main.cpp [ESP32-S3-DEV-KIT-NXR8 -> BLE-Serial]
Description: Based on Neil Kolban example for IDF:
https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
Ported to Arduino ESP32 by Evandro Copercini. Modified by CIRCUITSTATE Electronics.
This example created a BLE service with ID 6E400001-B5A3-F393-E0A9-E50E24DCCA9E
(Nordic UART Service) and device name "UART Service". You can find the device by scanning
the BLE. There are two associated characteristics:
1. 6E400002-B5A3-F393-E0A9-E50E24DCCA9E - RX Characteristic
Data you send through serial monitor will be received on the device end through this.
2. 6E400003-B5A3-F393-E0A9-E50E24DCCA9E - TX Characteristic
Data you send from the device uising Write operation will be sent back to the serial monitor
though this. The design of creating the BLE server is:
1. Create a BLE Server
2. Create a BLE Service
3. Create a BLE Characteristic on the Service
4. Create a BLE Descriptor on the characteristic
5. Start the service.
6. Start advertising.
Framework: Arduino, PlatformIO
Author: Vishnu Mohanan (@vishnumaiea, @vizmohanan)
Maintainer: CIRCUITSTATE Electronics (@circuitstate)
Version: 0.1
License: MIT
Source: https://github.com/CIRCUITSTATE/ESP32-S3-DEV-KIT-NXR8
Last Modified: +05:30 21:20:32 PM 22-06-2025, Sunday
*/
//============================================================================================//
#include <Arduino.h>
#include <BLE2902.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
//============================================================================================//
// #define PORT_SERIAL Serial // Use USB for communication
#define PORT_SERIAL Serial0 // Use UART0 for communication
// See the following for generating UUIDs:
// https://www.uuidgenerator.net/
#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
//============================================================================================//
BLEServer *pServer = NULL;
BLECharacteristic *pTxCharacteristic;
bool deviceConnected = false;
bool oldDeviceConnected = false;
//============================================================================================//
class MyServerCallbacks : public BLEServerCallbacks {
void onConnect (BLEServer *pServer) { deviceConnected = true; };
void onDisconnect (BLEServer *pServer) { deviceConnected = false; }
};
//============================================================================================//
class MyCallbacks : public BLECharacteristicCallbacks {
void onWrite (BLECharacteristic *pCharacteristic) {
std::string rxValue = pCharacteristic->getValue();
if (rxValue.length() > 0) {
PORT_SERIAL.print ("Received Value: ");
for (int i = 0; i < rxValue.length(); i++) PORT_SERIAL.print (rxValue [i]);
PORT_SERIAL.println();
}
}
};
//============================================================================================//
void setup() {
PORT_SERIAL.begin (115200);
// Create the BLE Device
BLEDevice::init ("UART Service");
// Create the BLE Server
pServer = BLEDevice:: createServer();
pServer->setCallbacks (new MyServerCallbacks());
// Create the BLE Service
BLEService *pService = pServer->createService (SERVICE_UUID);
// Create a BLE Characteristic
pTxCharacteristic = pService->createCharacteristic (CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
pTxCharacteristic->addDescriptor (new BLE2902());
BLECharacteristic *pRxCharacteristic = pService->createCharacteristic (CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
pRxCharacteristic->setCallbacks (new MyCallbacks());
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->start();
PORT_SERIAL.println ("Waiting a client connection to notify..");
}
//============================================================================================//
void loop() {
if (deviceConnected) {
if (PORT_SERIAL.available() > 0) {
String serialString = PORT_SERIAL.readString();
PORT_SERIAL.println ("Sending Value: " + serialString);
pTxCharacteristic->setValue ((std::string) serialString.c_str());
pTxCharacteristic->notify();
delay (10); // bluetooth stack will go into congestion, if too many packets are sent
}
}
// disconnecting
if (!deviceConnected && oldDeviceConnected) {
delay (500); // give the bluetooth stack the chance to get things ready
pServer->startAdvertising(); // restart advertising
PORT_SERIAL.println ("Start advertising");
oldDeviceConnected = deviceConnected;
}
// connecting
if (deviceConnected && !oldDeviceConnected) {
// do stuff here on connecting
oldDeviceConnected = deviceConnected;
}
}
//============================================================================================//After uploading the code to your board, you can open the serial monitor with a baudrate 115200. To connect to the board, you first need to install the NRF Connect app on your smartphone and launch it. You can also use the desktop app if you have any Nordic BLE development dongle/board. In the SCANNER window, you can scan for all Bluetooth devices and if the ESP32-S3 is up and running, you should see a device named “UART Service”. Connect to the device using the CONNECT button. After connecting, the app will open a new tab that lists all the services and characteristics served by the Bluetooth device. In our case, there is only a single BLE service Nordic UART Service, and the two characteristics associated with it; TX Characteristic and RX Characteristic. From the serial monitor, you can send any data and it will be received by the TX Characteristic. In order to see the data, simply enable the notification by tapping the triple download button on the app. Here, we are sending “Hello” from the serial monitor. The data will be shown as the Value in the app.
To send any data back to the serial monitor, you can use the RX Characteristic. Use the up-pointing button in the RX Characteristic to write a new value. Here, we are sending the value “World”. As soon as you hit SEND, the value will appear on the serial monitor.
Debugging
ESP32-S3 projects can be debugged using the official ESP-Prog debug probe. We have a dedicated tutorial on debugging ESP32 code using PlatformIO. Even though this was written for the ESP32, the files and configurations can be easily modified to support ESP32-S3.
Debugging ESP32 Arduino & ESP-IDF Projects using ESP-Prog and PlatformIO
Learn how to use the official Espressif ESP-Prog to debug your ESP32 Arduino and ESP-IDF projects with the help of PlatformIO.
With that, we can wind up this tutorial. There is so much to learn about the awesome ESP32-S3. But we can not cover everything in a single post. In the upcoming tutorials, we will delve deep into the features of ESP32-S3. Hope this tutorial was informative and helpful to you. If not, please let us know in the comments how we can improve this tutorial. Happy tinkering 🔧
Links
- ESP32-S3-DEV-KIT-N8R8 – Waveshare
- ESP32-S3-DEV-KIT-N8R8 – Wiki
- Espressif ESP32-S3 SoC – Official Product Page
- ESP32-S3 SoC – Datasheet [PDF]
- ESP32-S3 SoC Series – Errata
- Espressif Chip Identification Information
- ESP32-S3-WROOM-1 – Datasheet [PDF]
- Getting Started with Arduino Nano ESP32 Wi-Fi & IoT Development Board
- Waveshare ESP32-S3-DEV-KIT-NxR8 Wi-Fi Development Board – Pinout Diagram & Arduino Reference
- Espressif ESP-Prog ESP32 Debugger/Programmer
- ESP32-S3 Partition Tables
- ESP32-S3 Bootloader and Startup
- ESP32-S3 JTAG Debugging
- ESP32-S3 SPI Flash Modes
- ESP32-S3 Flasher Stub
- arduino-esp32 – GitHub
- ESP-IDF – GitHub
- Espressif esptool – GitHub
- FreeRTOS – Official Website
- Visual Studio Code – Download
- Arduino CLI
- PlatformIO – Official Website
- nRF Connect for Mobile – Google Playstore
Short Link
- Short URL to this page – https://www.circuitstate.com/getstartesp32-s3
