ESP-NOW Joystick Robot Car: Two ESP32 Boards, No Router

Phone showing a BLE control app next to an ESP32 robot car

ESP-NOW Joystick Robot Car: Two ESP32 Boards, No Router

This ESP-NOW joystick robot car uses two ESP32 DevKit V1 boards. One board reads a PS2 joystick and sends drive commands with ESP-NOW. The other board receives them and drives two TT motors through an L298N. ESP-NOW needs no router, no Wi-Fi password, and no phone app, and the car stops by itself when the link drops.

Quick facts

Item Value
Boards 2 x ESP32 DevKit V1, 30-pin WROOM-32
Radio ESP-NOW, 2.4 GHz, up to 250 byte payloads in version 1
Motors 2 x TT 130 gear motors, 3 to 6 V
Driver L298N, 2 A per channel, 1.8 to 3.2 V drop at 1 A
Logic voltage 3.3 V on the ESP32; L298N inputs read high from 2.3 V
Failsafe Car stops if no packet arrives for 500 ms

ESP-NOW joystick robot car: what is ESP-NOW and why use it?

ESP-NOW is a connectionless protocol from Espressif that sends small packets directly from one ESP32 to another. It uses the 2.4 GHz radio, but it needs no access point, no router, and no IP address. The sender addresses the receiver by its MAC address, and the receiver answers with a callback when a packet lands.

A robot car is a good fit because the packets are small and the latency is low. A joystick sends two numbers, forward and turn, about 20 times per second. That fits in a packet of a few bytes. Wi-Fi with a web server also works, but it adds a router, a connection step, and a web page. Bluetooth also works, but it adds pairing and a phone app. ESP-NOW keeps the link between two boards you own.

The cost is range and pairing effort. ESP-NOW range in open air is similar to Wi-Fi range, and walls cut it fast. You must also copy the receiver MAC address into the sender sketch. That is a one-time step, and the build steps below show it.

How does the two-board layout work?

The remote board is an ESP32 DevKit V1 with a PS2 joystick module. It reads the joystick X and Y analog pins, maps them to speed and turn values, and sends one small struct with ESP-NOW. It sends 20 packets per second. It draws only the board current, about 80 mA on average and peaking near 240 mA while transmitting, from its USB supply or a small battery pack.

The car board is a second ESP32 DevKit V1 on the chassis. It receives the struct, converts speed and turn into left and right motor speeds, and writes PWM to the L298N enable pins. It also runs a watchdog timer. If 500 ms pass with no packet, it sets both motors to zero. That is the failsafe, and it matters when the car drives out of range or the remote battery dies.

Both boards must use the same Wi-Fi channel. ESP-NOW peers are registered on a channel, and the sender and receiver must agree. This build sets channel 1 on both boards. Keep the struct identical on both boards. If the sizes differ, the receiver reads garbage.

What parts do you need?

You need two ESP32 DevKit V1 boards, one robot car chassis kit, one L298N module, one PS2 joystick module, and jumper wires. The chassis kit in the parts list includes the frame, TT motors, wheels, a speed encoder, and a battery box. Use the battery box for the motors only, through the L298N, and power the car ESP32 from USB or a separate 5 V source during testing.

Do not power the motors from the ESP32 5 V pin. The TT motors draw far more current than a USB port or a board regulator can supply, and the voltage dips will reset the board. The L298N exists to keep motor current on its own supply. The wiring table below keeps the two supplies separate except for a shared ground.

How do you find the receiver MAC address?

Upload a short sketch to the car board that prints WiFi.macAddress() to the serial monitor at 115200 baud. Set WiFi.mode(WIFI_STA) first, because some cores print zeros before the mode is set. Copy the address from the monitor, for example A4:CF:12:34:56:78, and write it in the sender sketch as {0xA4, 0xCF, 0x12, 0x34, 0x56, 0x78}.

The sender registers that address as a peer with esp_now_add_peer(). The receiver needs no peer entry for a one-way link. It only registers a receive callback with esp_now_register_recv_cb(). The callback signature changed in Arduino core 3.0, so the code below uses a version guard for the receive callback. The sketch as a whole needs core 3.x (target 3.3.13, the stable 3.x release), because analogWrite does not exist in core 2.x. Core 4.0 is not verified for this sketch.

How does the joystick map to motor speed?

The joystick gives two analog readings, one for X and one for Y. Each reading runs 0 to 4095 on the ESP32 12-bit ADC. Center is near 2047. The sender subtracts the center, applies a dead zone of about 200 counts so a resting stick sends zero, and maps the result to a speed range of -255 to 255.

The car mixes speed and turn into left and right speeds. Left speed equals speed plus turn, and right speed equals speed minus turn. Each value is then clamped to -255 to 255. A positive value drives the motor forward, a negative value drives it in reverse, and zero stops it. The L298N direction pins set the direction, and the enable pin PWM sets the speed.

Test the mix on blocks before the car touches the floor. Lift the chassis, run the remote, and watch both wheels. Forward should spin both wheels forward. A right turn should slow or reverse the right wheel. If a wheel runs backward, swap its two motor wires at the L298N output, not in code.

Wiring

Wire the build with the power off. Check every connection in the table before you connect any battery or USB cable.

From To Notes
Joystick VCC Remote ESP32 3V3 3.3 V logic; the joystick module runs on 3.3 V or 5 V
Joystick GND Remote ESP32 GND Common ground
Joystick VRx Remote ESP32 GPIO 34 ADC1 pin; input only, safe with Wi-Fi running
Joystick VRy Remote ESP32 GPIO 35 ADC1 pin; input only, safe with Wi-Fi running
Joystick SW Remote ESP32 GPIO 32 Pushbutton; use INPUT_PULLUP and read LOW as pressed
Car ESP32 GPIO 25 L298N ENA PWM speed, left motor
Car ESP32 GPIO 26 L298N ENB PWM speed, right motor
Car ESP32 GPIO 27, 14 L298N IN1, IN2 Left motor direction, 3.3 V logic is enough; L298N reads high from 2.3 V
Car ESP32 GPIO 33, 13 L298N IN3, IN4 Right motor direction; GPIO 33 is used instead of GPIO 12, which is a flash-voltage strapping pin and must stay low at boot
L298N OUT1, OUT2 Left TT motor Motor wires; swap here to fix reversed direction
L298N OUT3, OUT4 Right TT motor Motor wires
Battery box positive L298N 12 V terminal Motor supply, 6 V from 4 AA cells; keep the 5 V jumper on at 12 V or less
Battery box negative L298N GND and car ESP32 GND Common ground is required; without it the L298N inputs float
USB 5 V Car ESP32 USB port Logic supply only; never route motor current through USB

Power budget

The car has two separate supplies. The motors run from 4 AA cells at about 6 V into the L298N. The L298N drops about 2 V, so each TT motor sees about 4 V. That is normal for this driver and is why a 6 V pack suits 3 to 6 V TT motors.

The car ESP32 runs from USB 5 V during testing. It draws about 80 to 160 mA with the radio on. The L298N logic draws about 40 to 60 mA from the motor supply through its own regulator when the 5 V jumper is fitted. Never feed the motors from the ESP32 5 V pin or from the same USB port that powers the board.

The remote ESP32 runs from USB 5 V. It draws about 80 mA on average, peaking near 240 mA while sending. A small USB power bank works for outdoor driving. Keep the remote and the car on the same ESP-NOW channel, channel 1 in the code below.

Build steps

  1. Assemble the chassis kit, fit the TT motors and wheels, and mount the L298N and the car ESP32 on the top plate.
  2. Wire the L298N outputs to the motors and the motor battery to the L298N 12 V terminal. Leave the 5 V jumper on for a 6 V pack.
  3. Wire the car ESP32 to the L298N control pins from the wiring table. Join the battery negative to the ESP32 ground.
  4. Upload the MAC print sketch to the car board, read its address from the serial monitor, and write it into the sender sketch.
  5. Upload the receiver sketch to the car board and the sender sketch to the remote board. Keep the struct identical in both files.
  6. Wire the joystick to the remote ESP32 from the wiring table. Power the remote from USB.
  7. Lift the car off the floor, push the stick forward, and confirm both wheels spin forward. Push right and confirm the right wheel slows.
  8. Set the car on the floor, drive it in a straight line, then walk away until it stops. The 500 ms failsafe should halt it when the link drops.

Code

Libraries: none beyond the ESP32 Arduino core (WiFi.h, esp_now.h and esp_wifi.h ship with the core). Board: ESP32 DevKit V1, Arduino core 3.3.13. analogWrite arrived in core 3.0, so core 2.x will not compile these sketches. Upload the receiver sketch to the car board first, then the sender sketch to the remote board.

// Receiver sketch: ESP-NOW robot car (car board)
// Board: ESP32 DevKit V1. Core: Arduino ESP32 3.x.
#include 
#include 
#include 

// Motor pins on the car board
const int ENA = 25;   // Left motor PWM
const int IN1 = 27;   // Left motor direction A
const int IN2 = 14;   // Left motor direction B
const int ENB = 26;   // Right motor PWM
const int IN3 = 33;   // Right motor direction A (GPIO 12 avoided: strapping pin)
const int IN4 = 13;   // Right motor direction B

// Must match the sender struct exactly, same order and types.
typedef struct {
  int16_t speed;  // -255 to 255, forward is positive
  int16_t turn;   // -255 to 255, right is positive
} DriveCommand;

DriveCommand cmd = {0, 0};
unsigned long lastPacketMs = 0;
const unsigned long FAILSAFE_MS = 500;  // Stop if no packet for 500 ms

void driveMotor(int pwmPin, int inA, int inB, int speed) {
  if (speed >= 0) {
    digitalWrite(inA, HIGH);
    digitalWrite(inB, LOW);
    analogWrite(pwmPin, speed);
  } else {
    digitalWrite(inA, LOW);
    digitalWrite(inB, HIGH);
    analogWrite(pwmPin, -speed);
  }
}

void stopMotors() {
  analogWrite(ENA, 0);
  analogWrite(ENB, 0);
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
}

// Callback signature changed in Arduino core 3.0; this guard covers both.
#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
void onReceive(const esp_now_recv_info_t *info, const uint8_t *data, int len) {
#else
void onReceive(const uint8_t *mac, const uint8_t *data, int len) {
#endif
  if (len == sizeof(cmd)) {
    memcpy(&cmd, data, sizeof(cmd));
    lastPacketMs = millis();
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
  pinMode(ENB, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT);
  stopMotors();
  WiFi.mode(WIFI_STA);
  esp_wifi_set_channel(1, WIFI_SECOND_CHAN_NONE);  // Sender must use the same channel
  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    return;
  }
  esp_now_register_recv_cb(onReceive);
  lastPacketMs = millis();
}

void loop() {
  if (millis() - lastPacketMs > FAILSAFE_MS) {
    stopMotors();  // Link lost: halt the car
    return;
  }
  int left = constrain(cmd.speed + cmd.turn, -255, 255);
  int right = constrain(cmd.speed - cmd.turn, -255, 255);
  driveMotor(ENA, IN1, IN2, left);
  driveMotor(ENB, IN3, IN4, right);
  delay(20);
}

// ---------- Sender sketch: ESP-NOW joystick remote ----------
// Board: ESP32 DevKit V1, Arduino core 3.3.13. Upload to the remote board.
// Replace receiverMac with the MAC address of the car board.
#include 
#include 
#include 

uint8_t receiverMac[] = {0xA4, 0xCF, 0x12, 0x34, 0x56, 0x78};  // Your car board

const int JOY_X = 34;  // ADC1 pin
const int JOY_Y = 35;  // ADC1 pin
const int JOY_SW = 32; // Pushbutton, INPUT_PULLUP

typedef struct {
  int16_t speed;  // Must match the receiver struct exactly
  int16_t turn;
} DriveCommand;

DriveCommand cmd = {0, 0};

int readAxis(int pin) {
  int v = analogRead(pin) - 2047;  // Center is near 2047
  if (v > -200 && v < 200) return 0;  // Dead zone
  return map(constrain(v, -2047, 2047), -2047, 2047, -255, 255);
}

void setup() {
  Serial.begin(115200);
  pinMode(JOY_SW, INPUT_PULLUP);
  WiFi.mode(WIFI_STA);
  esp_wifi_set_channel(1, WIFI_SECOND_CHAN_NONE);  // Receiver must use the same channel
  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    return;
  }
  esp_now_peer_info_t peer = {};
  memcpy(peer.peer_addr, receiverMac, 6);
  peer.channel = 1;
  peer.encrypt = false;
  if (esp_now_add_peer(&peer) != ESP_OK) {
    Serial.println("Failed to add peer");
  }
}

void loop() {
  cmd.speed = readAxis(JOY_Y);  // Forward is positive
  cmd.turn = readAxis(JOY_X);   // Right is positive
  esp_now_send(receiverMac, (uint8_t *) &cmd, sizeof(cmd));
  delay(50);  // 20 packets per second
}

Test and tune it

Drive the car toward a wall at low speed and release the stick. The car should stop within half a second of the last packet. If it keeps rolling, the failsafe is not running, so check that lastPacketMs updates only inside the receive callback.

If one wheel spins backward, swap that motor's two wires at the L298N output. If the car turns left when you push right, swap the sign of the turn value in the sender, or swap the left and right motor wiring as a pair.

If packets stop arriving beyond a few feet indoors, check that both boards use channel 1 and that the receiver antenna area is clear of the metal chassis plate. Move the car board above the plate if the link is weak.

FAQ

Does ESP-NOW need a router?

No. ESP-NOW sends packets directly from one ESP32 to another by MAC address. It needs no router, no Wi-Fi password, and no internet connection.

What is the ESP-NOW range?

Range is similar to 2.4 GHz Wi-Fi in open air and drops fast through walls. Keep the receiver antenna clear of metal plates and test the failsafe at the edge of range.

Why does my car keep driving after I switch the remote off?

The receiver is not running a link-loss watchdog, or the watchdog timeout is too long. This build stops the motors after 500 ms with no packet. Check that lastPacketMs updates only in the receive callback.

Can I use ESP-NOW with an ESP32-S3 or ESP32-C3 as well?

Yes. ESP-NOW works across the ESP32 family, but the sender and receiver must use the same channel and the same struct. Check the pinout post for your exact board before you wire the L298N.

Why do the motors run slow on a 6 V pack?

The L298N drops about 2 V, so a 6 V pack gives each motor about 4 V. That is normal for this driver. A higher supply is not an option here: the pack is already 6 V and the TT motors are rated 3 to 6 V. Switch to a MOSFET driver such as the TB6612FNG for less drop.

Parts used

Build it with the ESP32 DevKit V1 Development Board, 30-Pin WROOM-32 (two boards, one for the remote and one for the car), the Smart Robot Car Chassis Kit with Speed Encoder and Battery Box for Arduino, 2WD / 4WD, the L298N Dual H-Bridge Motor Driver Module for Arduino, and the HiLetgo Game Joystick Sensor Module, PS2, 2-Axis with Pushbutton. The L298N robot car build in L298N Robot Car: Wire and Drive Two DC Motors covers the same driver in a wired build, and the ESP32 vs ESP32-S3 vs ESP32-C3 vs ESP32-C6 comparison helps if you pick a different board for the remote.

Sources

Last updated: 2026-11-21. Search volume: not verified. Product links use the store short link form with the product ID; confirm the product slug at publish time.

ESP32 vs ESP32-S3 vs ESP32-C3 vs ESP32-C6: Which Chip for Your Project

ESP32-S2 Mini board beside an ESP32-S3 DevKitC board

ESP32 vs ESP32-S3 vs ESP32-C3 vs ESP32-C6: Which Chip for Your Project

ESP32 vs ESP32-S3 is the first choice to make: pick the S3 for cameras, displays and on-device AI, and pick the original ESP32 for Bluetooth Classic or the widest tutorial base. Pick the ESP32-C3 for a low cost Wi-Fi sensor, and pick the ESP32-C6 for Matter, Thread and Zigbee work.

ESP32 vs ESP32-S3 vs ESP32-C3 vs ESP32-C6 at a glance

The table below gives the chip level numbers from the Espressif datasheets. Board level GPIO counts differ, because a small board breaks out fewer pins than the chip provides. Check your exact board pinout before you wire anything.

Spec (unit) ESP32 ESP32-S3 ESP32-C3 ESP32-C6
CPU core Dual Xtensa LX6 Dual Xtensa LX7 Single RISC-V Single RISC-V plus LP core
Max clock (MHz) 240 240 160 160
SRAM (KB) 520 512 400 512
GPIO pins (count) 34 45 22 30
Wi-Fi Wi-Fi 4, 2.4 GHz Wi-Fi 4, 2.4 GHz Wi-Fi 4, 2.4 GHz Wi-Fi 6, 2.4 GHz
Bluetooth Classic plus BLE 4.2 BLE 5 BLE 5 BLE 5.3
802.15.4 Thread/Zigbee No No No Yes
Native USB No USB OTG USB Serial/JTAG USB Serial/JTAG
PSRAM support Up to 8 MB external Up to 16 MB in package No No
ADC channels (count, bits) 18, 12-bit 20, 12-bit 6, 12-bit 7, 12-bit
DAC channels (count) 2, 8-bit 0 0 0

Sources for the table: Espressif ESP32 Series Datasheet v5.3, ESP32-S3 Series Datasheet v2.2 (2026-03-05), ESP32-C3 Series Datasheet v2.5, and ESP32-C6 Series Datasheet v1.6 (2026-11-10).

Which ESP32 chip should you choose first?

Start from the radio and the workload, not from the price. A board that costs a few dollars less is a false saving when it lacks the radio your project needs. Work through the three questions below in order. The first question that gives a single answer decides the chip.

First, do you need Thread, Zigbee or Matter? Only the ESP32-C6 in this group has an 802.15.4 radio. The C6 also brings Wi-Fi 6 on 2.4 GHz and Bluetooth 5.3. If your device must join a Matter fabric over Thread, the C6 is the only pick here. Second, do you need a camera, a parallel display or on-device AI? The ESP32-S3 is the pick. Its dual cores, PSRAM support and vector instructions handle camera frames and display buffers that starve the smaller chips. Third, do you need Bluetooth Classic, for audio streaming or a legacy serial link? Only the original ESP32 in this group has Bluetooth Classic. The S3, C3 and C6 offer Bluetooth LE only.

If none of those three questions decides it, you are choosing between a general purpose board and a low cost sensor node. The original ESP32 is the general purpose default, with 34 GPIO pins and the largest body of tutorials. The ESP32-C3 is the low cost sensor node, with 22 GPIO pins and a single RISC-V core at 160 MHz. That core is ample for reading sensors and posting data over Wi-Fi.

How do the CPUs compare?

The original ESP32 and the ESP32-S3 each have two Xtensa cores at up to 240 MHz. The ESP32 uses LX6 cores. The S3 uses LX7 cores with vector instructions that speed neural network and signal processing work. In practice, the S3 runs the same Wi-Fi stack on one core while your application code runs on the other, with headroom left for a display or a camera.

The ESP32-C3 and ESP32-C6 each have one RISC-V core at up to 160 MHz. A single core at 160 MHz reads sensors, drives a small display and holds a Wi-Fi connection without strain. It struggles only when you add a second heavy job, such as continuous audio processing or a camera stream. The C6 adds a low power RISC-V core at 20 MHz that can run while the main core sleeps, which suits battery powered sensors that wake on a schedule.

Clock speed alone misleads. The S3 at 240 MHz with two cores and 512 KB of SRAM does roughly twice the concurrent work of the C3 at 160 MHz with one core and 400 KB of SRAM. For a temperature logger the difference is invisible. For a camera it decides whether the project works at all.

What radios does each chip have?

All four chips have 2.4 GHz Wi-Fi. The ESP32, S3 and C3 use Wi-Fi 4. The C6 uses Wi-Fi 6, which improves efficiency on a busy 2.4 GHz network but does not add a 5 GHz band. None of these four chips has 5 GHz Wi-Fi. If your network is 5 GHz only, none of them connects, and you need a different board or a 2.4 GHz access point.

Bluetooth splits the group. The original ESP32 has Bluetooth Classic and Bluetooth LE 4.2. Bluetooth Classic matters for audio profiles and for older serial port profile links. The S3 has Bluetooth LE 5, the C3 has Bluetooth LE 5, and the C6 has Bluetooth LE 5.3. Bluetooth LE suits sensors, beacons and phone apps. It does not carry classic audio streaming.

The ESP32-C6 is the only chip here with an IEEE 802.15.4 radio, which carries Thread and Zigbee. Espressif positions the C6 for Matter end devices, over Wi-Fi or over Thread. If you are building a smart home sensor that must speak Matter over Thread, the C6 is the chip. The other three cannot add that radio in software.

How much GPIO, ADC and memory do you get?

GPIO count decides how many sensors, buttons and outputs a board can carry. The ESP32-S3 leads with 45 programmable GPIO pins at the chip level. The original ESP32 has 34. The ESP32-C6 has 30 in the QFN40 package and 22 in the QFN32 package, so check the exact module. The ESP32-C3 has 22. Small boards break out fewer pins than the chip has, so a C3 SuperMini exposes fewer usable pins than the 22 the chip provides. Read the board pinout for the exact board you hold.

ADC channels follow the same pattern. The original ESP32 has 18 ADC channels at 12-bit resolution across two ADC units, and ADC2 cannot be read while Wi-Fi runs. The S3 has 20 ADC channels at 12-bit. The C6 has 7 and the C3 has 6. If your project reads four or more analog sensors plus a battery voltage, the C3 runs out of analog pins fast, while the ESP32 and S3 have room to spare.

Memory decides frame buffers and display work. The original ESP32 has 520 KB of SRAM. The S3 has 512 KB plus support for up to 16 MB of PSRAM in package, which is what makes camera frames and large displays practical. The C6 has 512 KB of SRAM with no PSRAM support. The C3 has 400 KB with no PSRAM support. A camera frame at usable resolution needs PSRAM or a large SRAM buffer, which is why camera projects belong on the S3.

What about USB, DAC and touch?

Native USB splits the group in a way that matters every time you flash a board. The ESP32-S3 has full speed USB OTG, so it can act as a USB device or host, and it has a USB Serial/JTAG controller for flashing and debugging over one USB cable. The C3 and C6 have USB Serial/JTAG for flashing and debugging, but no full USB OTG peripheral. The original ESP32 has no native USB at all, so its boards carry a USB to serial chip such as the CP2102, and flashing goes through that chip.

DAC output exists only on the original ESP32 in this group, with two 8-bit DAC channels. The S3, C3 and C6 have no DAC. If your project needs a true analog voltage out, rather than a filtered PWM signal, the original ESP32 is the pick, or you add an external DAC chip to one of the others.

Touch sensing is available on the original ESP32 with 10 touch pins and on the S3 with 14 touch pins. The C3 and C6 have no capacitive touch peripheral in the same form. A touch button project is simpler on the ESP32 or the S3.

Which board should you buy for each project type?

Use this verdict table as a starting point, then check the pinout post for the exact board before you order. Each verdict names the chip and the reason in one line.

Project type Pick this chip Why
Camera or AI vision ESP32-S3 PSRAM, dual cores, camera interface, vector instructions
Colour display or HMI ESP32-S3 PSRAM and LCD interface, 45 GPIO pins
Matter, Thread or Zigbee ESP32-C6 Only chip here with 802.15.4, plus Wi-Fi 6
Low cost Wi-Fi sensor ESP32-C3 Single core is ample, 22 GPIO pins, USB flashing
Bluetooth Classic audio or SPP ESP32 Only chip here with Bluetooth Classic
General purpose learning board ESP32 34 GPIO pins, DAC, touch, largest tutorial base
Battery sensor with deep sleep ESP32-C6 Low power core, 7 uA deep sleep class

The boards in stock that match these picks are linked in the parts section below. The ESP32 DevKit V1 is the original ESP32 board. The ESP32-S3 DevKitC-1 is the S3 board. The ESP32-C3 SuperMini and the ESP32-C6 SuperMini are the small form factor C3 and C6 boards.

What mistakes do builders make when they pick?

The first mistake is buying the C3 for a camera. The C3 has no camera interface and no PSRAM, so a camera project on a C3 fails at the hardware level, not in code. The second mistake is buying the S2 or C3 for Bluetooth Classic audio. Those chips have no Bluetooth Classic radio, and no library adds one. The third mistake is buying the original ESP32 for a Matter over Thread device. It has no 802.15.4 radio.

The fourth mistake is counting chip GPIO pins instead of board pins. A SuperMini board breaks out a subset of the chip pins, and some chip pins are used by flash memory or the USB circuit. Read the pinout post for your exact board variant and count the broken out, usable pins. The fifth mistake is ignoring the ADC2 and Wi-Fi conflict on the original ESP32. If your sensor sits on an ADC2 pin, readings stop when Wi-Fi starts. Move the sensor to an ADC1 pin, GPIO 32 to 39.

For the board behind this comparison, start with the ESP32 DevKit V1 guide: how to use the board for WiFi projects.

FAQ

Which ESP32 is best for beginners?

The original ESP32 DevKit V1 is the safest first board. It has 34 GPIO pins, Bluetooth Classic and BLE, a DAC and touch pins, and the largest set of tutorials. Start there unless a radio requirement points at another chip.

Is the ESP32-S3 better than the ESP32?

The S3 is faster for camera, display and AI work because of its dual LX7 cores, PSRAM support and vector instructions. It is not better for Bluetooth Classic audio, because it has no Bluetooth Classic radio, and it has no DAC.

Can the ESP32-C3 run a camera?

No. The C3 has no camera interface and no PSRAM support, so it cannot hold camera frames. Use the ESP32-S3 for camera projects.

Does the ESP32-C6 have Wi-Fi 6 on 5 GHz?

No. The C6 has Wi-Fi 6 on 2.4 GHz only. It has no 5 GHz radio. Its advantage is Wi-Fi 6 efficiency plus the 802.15.4 radio for Thread and Zigbee.

Can I use the same Arduino code on all four chips?

Most Arduino code ports across the four chips with a board selection change, because the Arduino core supports all of them. Code that uses chip specific features, such as the DAC on the original ESP32 or the camera interface on the S3, does not port.

Parts used

ESP32 DevKit V1 Development Board, 30-Pin WROOM-32: the original ESP32 board for general purpose projects and Bluetooth Classic work. ESP32-S3 Development Board DevKitC-1 N8R2 N16R8: the S3 board for camera, display and AI projects, with PSRAM options. ESP32-C3 SuperMini Development Board, 4-Pack: the low cost C3 board for Wi-Fi sensor nodes. ESP32-C6 SuperMini Development Board, 2-Pack: the C6 board for Matter, Thread and Zigbee projects.

Sources

Last updated: 2026-11-21. Search volume: not verified. Product links use the store short link form with the product ID; confirm the product slug at publish time.