ESP32 DevKit V1

What is the ESP32?

The ESP32 is a system-on-chip (SoC) designed by Espressif Systems, released in 2016. It integrates a dual-core Xtensa LX6 processor at 240 MHz, 520 KB SRAM, 4 MB flash (on the DevKit), 802.11 b/g/n Wi-Fi, Bluetooth 4.2 + BLE, and a comprehensive set of peripherals — all in a 5 × 5 mm package.

The DevKit V1 breakout board exposes these capabilities on a 30-pin header that plugs directly into a breadboard, includes a USB-to-UART converter (CP2102 or CH340C), a 3.3V LDO regulator, and BOOT/RST buttons for programming.

Why it matters for AI builders

The ESP32 is the standard wireless bridge in physical AI systems:

• Data collection — stream IMU, encoder, and force sensor data over Wi-Fi to a Python server for building training datasets
• Remote inference — receive inference results from a cloud or edge server, execute them as motor commands
• MQTT broker client — publish sensor readings and subscribe to command topics in multi-robot systems
• BLE HID — act as a Bluetooth keyboard or gamepad for wireless robot teleoperation
• Camera module — the ESP32-CAM variant adds OV2640 camera for low-cost visual AI at the edge
• OTA updates — update robot firmware wirelessly without connecting a USB cable

Working principle

Dual-core architecture. The ESP32 has two Xtensa LX6 cores:

• Core 0 (PRO_CPU) — runs the Wi-Fi/Bluetooth protocol stack (FreeRTOS tasks managed by the SDK)
• Core 1 (APP_CPU) — runs loop() in the Arduino framework; runs your application

For time-sensitive tasks (PID control, encoder reading), pin the task to Core 1 using xTaskCreatePinnedToCore() to avoid contention with the Wi-Fi stack.

GPIO flexibility. Unlike the Arduino Uno where only pins 3,5,6,9,10,11 support PWM, the ESP32 can assign PWM (LEDC peripheral) to virtually any GPIO. Similarly, I2C and SPI buses can be routed to any GPIO pair via the GPIO matrix.

Key parameters

Pinout

Wiring

Code

Connect to Wi-Fi and send sensor data over HTTP

#include <WiFi.h>
#include <HTTPClient.h>

const char* SSID = "YourNetworkName";
const char* PASS = "YourPassword";
const char* SERVER = "http://192.168.1.100:5000/data";

void setup() {
  Serial.begin(115200);

  WiFi.begin(SSID, PASS);
  Serial.print("Connecting");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500); Serial.print(".");
  }
  Serial.println("\nConnected. IP: " + WiFi.localIP().toString());
}

void loop() {
  float sensor_value = analogRead(34) * (3.3 / 4095.0);  // ADC1 — safe with Wi-Fi

  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(SERVER);
    http.addHeader("Content-Type", "application/json");

    String payload = "{\"value\": " + String(sensor_value, 3) + "}";
    int code = http.POST(payload);
    Serial.printf("HTTP POST: %d | value: %.3f\n", code, sensor_value);
    http.end();
  }

  delay(1000);
}

Dual-core: control loop on Core 1, Wi-Fi on Core 0

#include <WiFi.h>

// Shared data protected by mutex
portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
volatile float latest_sensor = 0.0;

// Task running on Core 1 — real-time sensor reading at 100 Hz
void controlTask(void* param) {
  while (true) {
    float reading = analogRead(34) * (3.3 / 4095.0);
    portENTER_CRITICAL(&mux);
    latest_sensor = reading;
    portEXIT_CRITICAL(&mux);
    vTaskDelay(10 / portTICK_PERIOD_MS);  // 100 Hz
  }
}

void setup() {
  Serial.begin(115200);

  // Pin control task to Core 1
  xTaskCreatePinnedToCore(
    controlTask,    // task function
    "ControlTask",  // name
    2048,           // stack size (bytes)
    NULL,           // parameter
    1,              // priority
    NULL,           // task handle
    1               // core ID
  );

  // Wi-Fi runs on Core 0 — Arduino loop() also Core 1
  WiFi.begin("SSID", "PASS");
}

void loop() {
  // loop() runs on Core 1 alongside controlTask
  portENTER_CRITICAL(&mux);
  float val = latest_sensor;
  portEXIT_CRITICAL(&mux);

  Serial.println(val);
  delay(500);
}

MQTT client — publish sensor data

#include <WiFi.h>
#include <PubSubClient.h>

const char* SSID = "Network";
const char* PASS = "Password";
const char* BROKER = "192.168.1.100";

WiFiClient wifiClient;
PubSubClient mqttClient(wifiClient);

void reconnect() {
  while (!mqttClient.connected()) {
    if (mqttClient.connect("esp32-robot")) {
      mqttClient.subscribe("robot/command");  // subscribe to command topic
    }
    delay(500);
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  String msg = "";
  for (unsigned int i = 0; i < length; i++) msg += (char)payload[i];
  Serial.printf("Command received: %s\n", msg.c_str());
  // Parse and execute motor command here
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) delay(200);
  mqttClient.setServer(BROKER, 1883);
  mqttClient.setCallback(callback);
}

void loop() {
  if (!mqttClient.connected()) reconnect();
  mqttClient.loop();

  float imu_pitch = 12.3;  // replace with real IMU reading
  String payload = String(imu_pitch, 2);
  mqttClient.publish("robot/imu/pitch", payload.c_str());
  delay(50);  // 20 Hz publish rate
}

Test procedure

Common mistakes

Robotics and AI use cases

Beginner project — Wi-Fi sensor dashboard

Connect an MPU-6050 to the ESP32. Read roll and pitch using a complementary filter. Serve a simple HTML page from the ESP32's built-in web server that displays the current angles, refreshed every 500 ms via JavaScript fetch.

Key learning: WiFiServer, HTTP GET handler, JSON serialisation, browser polling.

Advanced project — Real-time robot telemetry streamer

Stream 6-DOF IMU data + 2× encoder values + battery voltage over MQTT at 50 Hz to a Python subscriber that logs to a CSV file and plots a live dashboard using Matplotlib or Plotly Dash. Implement data loss detection by embedding a sequence counter in each packet.

Key learning: Dual-core FreeRTOS, MQTT QoS levels, Python MQTT subscriber, real-time plotting, packet loss metrics.