Components · 9 min read

ESP32-S3 DevKitC Guide: N16R8, Two USB Ports, PSRAM, Arduino IDE

ESP32-S3 DevKitC guide: what N16R8 and N8R2 mean, UART vs USB port, USB CDC On Boot, OPI PSRAM, the GPIO48 RGB LED, Arduino IDE settings and USB HID.

The ESP32-S3 is Espressif's dual-core Wi-Fi and Bluetooth chip, upgraded with native USB, more pins, large PSRAM and vector instructions that speed up AI workloads. The board you'll see most often is the ESP32-S3-DevKitC-1 and its clones: it carries two USB-C ports, a BOOT and an RST button and a single addressable RGB LED. Codes such as N16R8 or N8R2 on the board or module tell you the size of the flash memory and the PSRAM, and they're the key to getting the Arduino IDE settings right.

In this guide you'll learn how the ESP32-S3 differs from the classic ESP32, what the model codes mean, which of the two USB ports to use and when, the USB CDC On Boot setting that fixes an empty Serial Monitor, and how to pick the right PSRAM mode (OPI or QSPI). Then you'll write a test sketch that lights the onboard RGB LED, an example that allocates a 1 MB buffer in PSRAM and a HID project that makes the ESP32-S3 show up on your computer as a USB keyboard.

What is the ESP32-S3? How it differs from the classic ESP32

The ESP32-S3 wasn't designed to replace the classic ESP32 but to fill the gaps it left. The biggest difference is native USB: the chip can connect straight to a computer with no USB-to-serial converter in between and present itself as a serial port, keyboard, mouse or MIDI device. Its Xtensa LX7 cores add vector instructions for signal processing and neural network maths, and dedicated camera (DVP) and parallel LCD interfaces make imaging projects easier. Two things are missing, though: there's no Bluetooth Classic (only Bluetooth 5 LE), and there's no DAC for analog output.

FeatureESP32 (classic)ESP32-S3
ProcessorXtensa LX6, dual-core, 240 MHzXtensa LX7, dual-core, 240 MHz, vector instructions
Internal SRAM520 KB512 KB
PSRAMUp to 4 MB on WROVER modules2 MB Quad or 8 MB Octal, depending on the module
BluetoothClassic and BLE 4.2BLE 5 only (with long range support)
USBNone, needs a separate USB-serial chipNative USB OTG and USB Serial/JTAG
Usable GPIOAbout 3445
Touch pins1014
DAC (analog output)2 channels, 8-bitNone
Camera and display interfaceCamera over I2S (ESP32-CAM)Dedicated DVP camera and parallel LCD interface
Classic ESP32 DevKit board
A classic ESP32 DevKit: its single USB port goes to a USB-serial chip. On the ESP32-S3-DevKitC-1, a second USB-C port is wired directly to the chip.

ESP32-S3 model codes: what does N16R8 mean?

The code on the module's metal shield or in the seller's listing is easy to read: the number after N is the flash size and the number after R is the PSRAM size, both in megabytes. N16R8 means 16 MB of flash and 8 MB of PSRAM; N8R2 means 8 MB of flash and 2 MB of PSRAM. The code also tells you how the PSRAM is connected: on ESP32-S3-WROOM-1 modules, R2 is four-line Quad SPI (QSPI) PSRAM and R8 is eight-line Octal SPI (OPI) PSRAM. A trailing V (as in N32R8V) marks WROOM-2 modules whose flash and PSRAM run at 1.8 V. You choose the PSRAM setting in the Arduino IDE based on this information.

CodeFlashPSRAMArduino IDE PSRAM setting
N88 MBNoneDisabled
N1616 MBNoneDisabled
N4R24 MB2 MB Quad (QSPI)QSPI PSRAM
N8R28 MB2 MB Quad (QSPI)QSPI PSRAM
N8R88 MB8 MB Octal (OPI)OPI PSRAM
N16R816 MB8 MB Octal (OPI)OPI PSRAM
N32R8V (WROOM-2)32 MB Octal, 1.8 V8 MB Octal (OPI)OPI PSRAM and Flash Mode: OPI 80MHz
On R8 modules, the ones with Octal PSRAM, GPIO 35, 36 and 37 are wired to the PSRAM and can't be used for anything else; connect a sensor to them and the board crashes at boot. On V-coded WROOM-2 modules, GPIO 47 and 48 run at 1.8 V, so don't try to drive a module that expects 3.3 V from those pins.

Two USB ports: UART vs USB

The two USB-C ports on the ESP32-S3-DevKitC-1 don't do the same job. The port marked UART (COM on some clones) goes to a USB-serial chip, a CP2102N or a CH343P depending on the board revision, which in turn connects to the ESP32-S3's UART0 lines (GPIO 43 and 44). It's the same as the single port on classic ESP32 boards and puts the board into download mode automatically during uploads. The port marked USB is wired directly to the chip's GPIO 19 (D-) and GPIO 20 (D+). Plug into it and the computer sees the ESP32-S3's own USB peripheral with no chip in between; Windows 10 and 11, macOS and Linux need no driver.

FeatureUART (COM) portUSB port (native)
Connected toUART0 (GPIO 43 and 44) through a USB-serial chipDirectly to GPIO 19 (D-) and GPIO 20 (D+)
DriverCP210x or CH343, depending on the chipNot needed
Name on the computerCOMx, /dev/cu.usbserial-… or /dev/cu.wchusbserial…COMx (USB JTAG/serial debug unit), /dev/cu.usbmodem…, /dev/ttyACM0
Serial output goes hereWith USB CDC On Boot: DisabledWith USB CDC On Boot: Enabled
Uploading codeAlways, with automatic resetUsually; the port can vanish if the sketch crashes or enters deep sleep
USB keyboard and mouse (HID)Not possiblePossible with USB Mode: USB-OTG (TinyUSB)
The native USB port can disappear from your computer when the running sketch crashes or the board enters deep sleep. To recover the board, hold BOOT, press and release RST, then release BOOT: the board enters download mode and the port reappears. Once the upload finishes, press RST once to start the new sketch.

The USB CDC On Boot setting: why is the Serial Monitor empty?

This is the problem ESP32-S3 users run into most: the sketch uploads, the board runs, but not a single line reaches the Serial Monitor. The reason is which port your sketch's Serial object writes to. With Tools > USB CDC On Boot set to Disabled, Serial writes to UART0, the UART port; if your cable is in the USB port, the messages never reach you. Set it to Enabled and Serial is routed to the native USB port. The rule is simple: match the setting to the port your cable is in. Enabled for the USB port, Disabled for the UART port. With Enabled, a wait such as while (!Serial) in your code loops forever when the board isn't connected to a computer, so use a few seconds of delay or a timeout instead.

Arduino IDE settings (ESP32S3 Dev Module)

MenuFor N16R8For N8R2Note
BoardESP32S3 Dev ModuleESP32S3 Dev ModuleAlso the right choice for clone boards
USB CDC On BootEnabledEnabledDisabled if you use the UART port
Flash Size16MB (128Mb)8MB (64Mb)The N value in the model code
Partition Scheme16M Flash (3MB APP/9.9MB FATFS)8M with spiffs (3MB APP/1.5MB SPIFFS)For large sketches and a file system
PSRAMOPI PSRAMQSPI PSRAMThe R value in the model code
Flash ModeQIO 80MHzQIO 80MHzOPI 80MHz on V-coded WROOM-2 modules
USB ModeHardware CDC and JTAGHardware CDC and JTAGUSB-OTG (TinyUSB) for a USB keyboard or mouse
Upload ModeUART0 / Hardware CDCUART0 / Hardware CDCThe default is fine

ESP32-S3 support is part of Espressif's esp32 package that you install from the Boards Manager; no separate package is needed. You'll find the setup steps in the Arduino IDE installation guide. The menu names are the same in the 2.x and 3.x core. Get the PSRAM setting wrong and you'll see one of two symptoms: with Disabled, the sketch runs but behaves as if there were no PSRAM; with QSPI PSRAM selected on a board with Octal PSRAM, the board prints PSRAM ID read error at boot and can't use the PSRAM.

First test: RGB LED, serial port and PSRAM

The RGB LED on the DevKitC-1 is a WS2812-type addressable LED; it's driven by a single pin and lit with color data rather than with digitalWrite like a normal LED. The ESP32 Arduino core has a ready-made function for it: neopixelWrite in 2.x and rgbLedWrite in 3.x. On revision 1.0 of the board and on most clones the LED is on GPIO 48; on Espressif's revision 1.1 it's on GPIO 38, so check the revision printed on the back of your board. Some clone boards have a small solder jumper marked RGB next to the LED; if the LED never lights up, that jumper may be open. The sketch below lights the LED red, green and blue in turn and prints the flash and PSRAM size to the Serial Monitor at startup.

C++ (Arduino IDE)
1// ESP32-S3: dahili RGB LED, seri port, PSRAM ve flaş testi
2// ESP32-S3: onboard RGB LED, serial port, PSRAM and flash test
3const int RGB_PIN = 48;                 // DevKitC-1 v1.0 ve çoğu klon: 48, v1.1: 38 / v1.0 and most clones: 48, v1.1: 38
4
5void setRgb(uint8_t r, uint8_t g, uint8_t b) {
6#if ESP_ARDUINO_VERSION_MAJOR >= 3
7  rgbLedWrite(RGB_PIN, r, g, b);        // çekirdek 3.x / core 3.x
8#else
9  neopixelWrite(RGB_PIN, r, g, b);      // çekirdek 2.x / core 2.x
10#endif
11}
12
13void setup() {
14  Serial.begin(115200);
15  delay(1500);                          // USB'nin açılmasını bekle / give the USB port time to come up
16  Serial.println("ESP32-S3 hazir / ready");
17  Serial.printf("Flash: %lu bayt / bytes\n", (unsigned long)ESP.getFlashChipSize());
18  Serial.printf("PSRAM: %lu bayt / bytes\n", (unsigned long)ESP.getPsramSize());   // 0 ise menüden aç / if 0, enable it in the menu
19}
20
21void loop() {
22  setRgb(40, 0, 0);  delay(500);        // kırmızı / red
23  setRgb(0, 40, 0);  delay(500);        // yeşil / green
24  setRgb(0, 0, 40);  delay(500);        // mavi / blue
25  setRgb(0, 0, 0);   delay(500);        // kapalı / off
26}

On an N16R8 board with the right settings, the Serial Monitor shows 16,777,216 bytes on the Flash line (the value you chose in the Flash Size menu) and a value close to 8 MB on the PSRAM line; the small gap is the space the PSRAM allocator keeps for itself. If the PSRAM line shows 0, check the PSRAM setting in the menu. If nothing arrives at all, set USB CDC On Boot to match the port your cable is in.

Using PSRAM: large buffers

The ESP32-S3's 512 KB of internal memory is shared between the Wi-Fi stack, Bluetooth and your code, and declaring a big array eats it up fast. That's why PSRAM matters: camera frame buffers, a full-screen drawing buffer for a color display, audio recordings or large JSON documents don't fit in internal memory but fit comfortably in 8 MB of PSRAM. In Arduino you allocate memory from PSRAM with ps_malloc; most ESP32 libraries (such as the camera driver) already use PSRAM on their own. PSRAM is slower than internal memory, so keep small, frequently used variables in regular RAM.

C++ (Arduino IDE)
1// PSRAM'de 1 MB tampon ayırmak / allocating a 1 MB buffer in PSRAM
2void setup() {
3  Serial.begin(115200);
4  delay(1500);
5  if (!psramFound()) {
6    Serial.println("PSRAM yok: Araçlar > PSRAM ayarını kontrol et / no PSRAM: check Tools > PSRAM");
7    return;
8  }
9  const size_t SIZE = 1024 * 1024;                       // 1 MB, dahili RAM'e sığmaz / does not fit in internal RAM
10  uint8_t* buffer = (uint8_t*)ps_malloc(SIZE);           // PSRAM'den ayır / allocate from PSRAM
11  if (buffer == NULL) {
12    Serial.println("Ayrılamadı / allocation failed");
13    return;
14  }
15  memset(buffer, 0xA5, SIZE);                            // tamponu doldur / fill the buffer
16  Serial.printf("1 MB tampon hazır, boş PSRAM / buffer ready, free PSRAM: %lu\n", (unsigned long)ESP.getFreePsram());
17  free(buffer);
18}
19
20void loop() {
21}

Why the ESP32-S3? Cameras, AI and USB HID

  • Camera projects: the dedicated DVP camera interface and 8 MB of PSRAM give higher resolutions and frame rates with OV2640 or OV5640 cameras. To compare with the classic approach, see the ESP32-CAM guide.
  • AI and audio: thanks to the vector instructions, Espressif's ESP-DL and ESP-SR libraries run tasks such as face detection and wake word recognition right on the chip.
  • USB HID: the board can connect to a computer as a keyboard, mouse, gamepad or MIDI device, which makes it ideal for macro pads and presentation remotes.
  • Color displays: the parallel LCD interface and PSRAM make it easier to draw smooth interfaces on large TFT screens.
  • More pins: 45 GPIOs and 14 touch pins give you room to breathe in projects with lots of sensors and buttons.
  • Bluetooth 5 LE: long range mode and 2 Mbps are supported; using BLE is covered in the ESP32 Bluetooth BLE guide.

USB HID: turning the ESP32-S3 into a keyboard

One of the most fun things the classic ESP32 can't do is make the ESP32-S3 show up on your computer as a real USB keyboard. Set Tools > USB Mode to USB-OTG (TinyUSB) and plug the cable into the port marked USB. The sketch below types Hello and presses Enter every time you press the board's BOOT button (GPIO 0). USB HID sends key positions, not letters, and the computer translates those positions according to its own keyboard layout. On layouts such as German QWERTZ, French AZERTY or Turkish Q, some letters, digits and symbols can come out differently, so the example uses letters that land on the same keys in every layout.

C++ (Arduino IDE)
1// ESP32-S3 USB klavye: BOOT düğmesine basınca bilgisayara "Hello" yazar
2// ESP32-S3 USB keyboard: types "Hello" on the computer when you press BOOT
3// Araçlar > USB Mode: "USB-OTG (TinyUSB)" seç, kabloyu "USB" yazan porta tak
4// Tools > USB Mode: select "USB-OTG (TinyUSB)", plug the cable into the port marked "USB"
5#if !(defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32S2)) || ARDUINO_USB_MODE
6// Bu kart ya da bu USB Mode ayarı USB HID desteklemez / no USB HID on this board or USB Mode
7void setup() {
8  Serial.begin(115200);
9}
10
11void loop() {
12  Serial.println("USB Mode: USB-OTG (TinyUSB) gerekli / required");
13  delay(2000);
14}
15#else
16#include "USB.h"
17#include "USBHIDKeyboard.h"
18
19USBHIDKeyboard Keyboard;
20const int BUTTON_PIN = 0;               // BOOT düğmesi / BOOT button
21
22void setup() {
23  pinMode(BUTTON_PIN, INPUT_PULLUP);
24  Keyboard.begin();
25  USB.begin();
26}
27
28void loop() {
29  if (digitalRead(BUTTON_PIN) == LOW) {
30    Keyboard.print("Hello");            // klavye düzeninden bağımsız harfler / layout-safe letters
31    Keyboard.write(KEY_RETURN);
32    while (digitalRead(BUTTON_PIN) == LOW) {
33      delay(10);                        // bırakılana kadar bekle / wait until released
34    }
35    delay(50);                          // titreşim payı / debounce margin
36  }
37}
38#endif
Once USB Mode is set to USB-OTG (TinyUSB), the native USB port no longer works as a serial port and JTAG; you either upload through the UART port or put the board into download mode with the BOOT and RST buttons. To go back to normal use, set USB Mode to Hardware CDC and JTAG again and program the board once in download mode.

ESP32-S3 pins: what to watch out for

PinsStatusNote
GPIO 0, 3, 45, 46Use with careStrapping pins; their level at boot matters
GPIO 19, 20Reserved for USBThe native USB D- and D+ lines
GPIO 43, 44UART0TX and RX of the UART port
GPIO 35, 36, 37Don't use on R8 modulesWired to the Octal PSRAM
GPIO 26–32Not broken outWired to the flash and PSRAM inside the module
GPIO 1–10ADC1Reads analog values reliably even with Wi-Fi on
GPIO 11–20ADC2Unreliable when used together with Wi-Fi
GPIO 1–14TouchUnlike the classic ESP32, the value rises when touched
GPIO 8 and 9I2CDefault SDA and SCL in the Arduino core
GPIO 47, 481.8 V on V modulesRun at 1.8 V on WROOM-2
When you port code written for the classic ESP32 to the S3, always check the pin numbers: GPIO 22, 23, 24 and 25 don't exist on the ESP32-S3 at all, GPIO 26 and 27 are reserved for the flash inside the module, and the default I2C pins are 8 and 9 instead of 21 and 22. You can see your board's full map in the Pinout tool.

Common problems and fixes

SymptomCauseFix
Serial Monitor is emptyCable in the USB port, USB CDC On Boot: DisabledSet it to Enabled or plug the cable into the UART port
The port disappears after uploadingThe sketch crashed, went into deep sleep, or USB Mode is USB-OTGPress RST while holding BOOT, then upload
Constant resets or PSRAM ID read errorThe PSRAM setting doesn't match the moduleChoose OPI PSRAM for R8 and QSPI PSRAM for R2
The RGB LED doesn't lightRevision 1.1 board (GPIO 38) or an open RGB solder jumperChange RGB_PIN, solder the jumper closed
Serial Bluetooth not available or not enabledThe ESP32-S3 has no Bluetooth ClassicUse the BLE library instead of BluetoothSerial
'dacWrite' was not declared in this scopeThe ESP32-S3 has no DACUse PWM with an RC filter or an I2S audio amplifier
Failed to connect to ESP32-S3The board didn't enter download modeEnter download mode with BOOT and RST; details in the ESP32 Failed to Connect guide

Once you understand its two ports and the PSRAM setting, the ESP32-S3 is as easy to use as the classic ESP32 and far more capable. Since the board's RGB LED is really a single-pixel WS2812, the ESP32 WS2812B NeoPixel Strip Control project in the BlueGrays app makes a good next step; you can also follow the app's other ESP32 projects step by step with their wiring diagrams and ready-made code, and adapt them to this board by moving the pin numbers to pins that exist on the S3.

Frequently asked questions

What does N16R8 mean on an ESP32-S3?

N16 means the module has 16 MB of flash memory and R8 means 8 MB of PSRAM. On ESP32-S3-WROOM-1 modules, R8 PSRAM is connected over Octal SPI (OPI), so in the Arduino IDE you should select OPI PSRAM for PSRAM and 16MB for Flash Size.

Which USB port should I use on the ESP32-S3 DevKitC?

Both ports work for uploading and the Serial Monitor. The UART port behaves like a classic ESP32 and is used with USB CDC On Boot: Disabled; the USB port connects directly to the chip, needs no driver and is used with USB CDC On Boot: Enabled. If you want to build a USB keyboard or mouse, you need the USB port.

Why is my ESP32-S3 not printing to the Serial Monitor?

Most likely the cable is in the USB port while USB CDC On Boot is set to Disabled, so Serial output goes to the UART port. Set it to Enabled and upload again, or plug the cable into the UART port and set the Serial Monitor to the same baud rate as your sketch.

How do I enable PSRAM on the ESP32-S3 in the Arduino IDE?

Under Tools > PSRAM, pick the option that matches your module: OPI PSRAM for R8 modules, QSPI PSRAM for R2 modules. In your code, psramFound() tells you whether PSRAM was detected, and ps_malloc() allocates large buffers from it.

Does the ESP32-S3 support Bluetooth Classic?

No. The ESP32-S3 only supports Bluetooth 5 LE, so the BluetoothSerial library and direct pairing with Classic devices such as the HC-05 don't work. Use the BLE library to talk to a phone; if you need Bluetooth Classic, choose the classic ESP32.

Which pin is the built-in LED on the ESP32-S3 DevKitC-1?

The built-in LED on the ESP32-S3-DevKitC-1 is an addressable RGB LED, on GPIO 48 on board revision 1.0 and most clones, and on GPIO 38 on revision 1.1. It's lit by sending a color with neopixelWrite on core 2.x or rgbLedWrite on core 3.x rather than with digitalWrite.

See all projects
ESP32 Built-in LED Blink
ES-4Beginner

ESP32 Built-in LED Blink

Blinking the built-in blue LED on the ESP32 DevKit V1. No external components required! The first project you should try when you buy an ESP32. GPIO 2 is connected to the built-in LED.

4.8(29)
54
LED Blink with ESP32
ES-1Beginner

LED Blink with ESP32

Teaches basic GPIO output usage with ESP32. We achieve a blinking effect by turning an LED on and off from a digital pin. ESP32 version of the classic blink project on Arduino UNO; the basic blink commands in the Arduino environment are the same, but the ESP32's pin layout and 3.3 V GPIO levels differ from those of the Arduino UNO.

4.7(37)
108
ESP32 WS2812B NeoPixel Strip Control
ES-24Intermediate
Premium

ESP32 WS2812B NeoPixel Strip Control

WS2812B (NeoPixel) addressable LEDs are smart RGB LEDs that can be chained and controlled from a single data pin. In this project we drive an 8-LED WS2812B strip with the Adafruit_NeoPixel library and create a smooth rainbow animation. The ESP32's 3.3V logic works with most WS2812B batches; if it gets unstable, we show the fix with a 470Ω series resistor and a 1000µF capacitor. The animation shifts the hue in HSV color space.

4.9(19)
30
ESP32 Wi-Fi STA Connection (with LCD Screen)
ES-25Advanced

ESP32 Wi-Fi STA Connection (with LCD Screen)

In this project, we connect the ESP32 to the home Wi-Fi network in Station (STA) mode in a secure, fault-tolerant manner. We store the SSID and password in a separate secrets.h file to prevent leaking to Git, set up an auto-reconnect mechanism, and display the RSSI signal level and IP address on an I2C LCD screen. The internal LED works as a status indicator. It is a production-grade connection manager.

4.4(21)
38
ESP32 Asynchronous Web Server (with IP Display on LCD)
ES-27Advanced

ESP32 Asynchronous Web Server (with IP Display on LCD)

In this project, we’re turning the ESP32 into an asynchronous web server that you can control from your phone or computer on the same Wi-Fi network. Thanks to the ESPAsyncWebServer library, the server can process multiple requests simultaneously (unlike the classic WebServer.h, which blocks on a single request). You’ll be able to open the ESP32’s IP address in a browser and click the ON/OFF buttons (the /on and /off routes) to turn the LED connected to GPIO 5 on and off.

4.8(16)
26
ESP32 mDNS: Accessing the Device via bluegrays-esp.local (with LCD Screen)
ES-29Advanced
Premium

ESP32 mDNS: Accessing the Device via bluegrays-esp.local (with LCD Screen)

In this project we add an mDNS (Multicast DNS) service to the ESP32, so you reach it by a readable host name like bluegrays-esp.local instead of an IP address. Even if the IP assigned by DHCP changes, the device always answers to the same name. A small web server on the board lets you control the LED from your browser at http://bluegrays-esp.local/.

4.8(14)
23
ESP32 OTA Update — Wireless Firmware Installation (With LCD Screen)
ES-30Advanced
Premium

ESP32 OTA Update — Wireless Firmware Installation (With LCD Screen)

In this project you'll learn to upload new firmware to the ESP32 over Wi-Fi, without a USB cable. With the ArduinoOTA library the ESP32 becomes visible on the network and shows up automatically as bluegrays-ota under "Network port" in the Arduino IDE. The first upload goes over USB; after that every update is wireless, a key feature for devices out in the field.

4.6(14)
22
ESP32 Deep Sleep — Battery Saving (OLED + RTC RAM Counter)
ES-33Advanced
Premium

ESP32 Deep Sleep — Battery Saving (OLED + RTC RAM Counter)

The ESP32's Deep Sleep mode shuts down the CPU and most peripherals, cutting current draw to about 10µA, which is vital for battery-powered IoT devices. This project uses three wake-up sources: a timer (15 s), an external pin (EXT0, the button on GPIO 33) and a touch pin (T0/GPIO 4). Counters marked with RTC_DATA_ATTR survive deep sleep.

4.3(10)
16