A step-by-step workshop for the ESP32 Camera 4WD Robot Car Kit. Every lab has code you can copy with one click. Work through the modules in order; each one builds on the last.
Fill these in once. Every code block on this site updates with your values, so the code you copy is ready to upload. Your instructor will give you the team ID, WiFi and broker address.
Saved in this browser only.
| Part | Qty | What it does |
|---|---|---|
| ESP32-CAM board + USB adapter | 1 | The brain: WiFi, Bluetooth and a camera |
| L298N motor driver | 1 | Lets the small ESP32 signals switch big motor currents |
| TT DC gear motors + wheels | 4 | Move the robot (wired as a left pair and a right pair) |
| External WiFi antenna | 1 | Longer WiFi range |
| 18650 Li-ion batteries | 3 | About 11.1–12.6 V for the motors and board (often bought separately) |
| USB cable | 1 | Uploads code from your PC |
18650 batteries store a lot of energy. Insert them the right way round (check + and −), never short the terminals, switch the robot off when you are not using it, and only charge them in a proper 18650 charger with someone watching.
Have the kit folder on your computer? Open Tutorial Video › Demo Video › Demo Video.mp4 here to play it on this page.
The yellow Copy button copies a whole code block. Paste it into a new Arduino sketch with Ctrl+V.
Download gives you a .zip with a ready-made sketch folder. Unzip it and open the .ino in Arduino IDE.
Press Mark done when a lab works. Your progress shows in the course map on the left.
You need three things before you can upload code: the Arduino IDE, the ESP32 board package, and the CH340 USB driver. Do this once per computer.
Go to arduino.cc/en/software and download Arduino IDE 2.x for your system (Windows, macOS or Linux).
Run the installer and accept the defaults. If Windows asks to install USB drivers, click Install.
Open Arduino IDE. You should see an empty sketch with setup() and loop().
Already have an old Arduino IDE 1.x? The kit manual recommends uninstalling it and installing the latest version.
Click the Boards Manager icon on the left side (or Tools › Board › Boards Manager…).
Type esp32 in the search box. Find esp32 by Espressif Systems.
Pick version 3.1.0 (the version the kit was tested with; newer 3.x versions also work with this site's code) and click INSTALL. It downloads a lot, so give it a few minutes.
Wait for "Successfully installed platform esp32" in the Output panel.
Open File › Preferences, paste this URL into Additional boards manager URLs, click OK, then search again.
The USB adapter under the ESP32-CAM uses a CH340 chip to turn USB into serial. Windows needs a driver for it, otherwise no COM port appears.
Download CH341SER from the chip maker's site: wch-ic.com › CH341SER (Windows). Mac and Linux usually work without a driver.
Plug the ESP32-CAM adapter into your PC with the USB cable, run the installer and click INSTALL. You should see "Driver install success!"
Open Device Manager (search for it in the Start menu) › Ports (COM & LPT). You should see USB-SERIAL CH340 (COMx). Remember the number.
| Setting | Choose |
|---|---|
| Tools › Board | esp32 › AI Thinker ESP32-CAM |
| Tools › Port | The COMx you saw in Device Manager |
| Serial Monitor speed | 115200 baud |
| Upload | Click the round → button and wait for "Done uploading" |
Get to know the board before it drives anything. You'll print messages, blink LEDs, scan for WiFi and stream live video.
| Chip | ESP32 (dual core, up to 240 MHz), 4 MB PSRAM |
| Wireless | WiFi 802.11 b/g/n + Bluetooth 4.2 / BLE |
| Camera | OV3660 on this kit (3 MP) |
| GPIO 4 | White flash LED (very bright) |
| GPIO 33 | Small red LED, on when LOW |
| GPIO 12–15 | Free pins → motor driver |
| RST button | Restarts your program |
Goal: upload your first sketch and read messages from the board in the Serial Monitor.
In Arduino IDE choose File › New Sketch, delete everything, and paste the code below.
Check Board = AI Thinker ESP32-CAM and the right Port, then click Upload.
Open Tools › Serial Monitor and set the speed to 115200 baud. Press RST on the board if the screen is empty.
"Hello from my ESP32-CAM!" followed by the chip model, CPU speed, PSRAM size (about 4096 KB) and MAC address every second.
Change delay(1000) to delay(250). What happens? Write your own name into the first message.
Goal: control an output pin with digitalWrite(). This LED is "active LOW", which surprises everyone the first time.
The tiny red LED on the back of the ESP32-CAM blinks twice per second.
Make it blink an SOS: three short, three long, three short.
Goal: learn PWM, the same trick we'll use later to control motor speed.
PWM switches a pin on and off thousands of times per second. The duty (0–255) is how much of each cycle the pin is ON. 0 = always off, 128 = half the time, 255 = always on. The LED (or motor) only "feels" the average.
The flash LED is extremely bright at full power. Keep MAX_BRIGHTNESS low and don't look straight into it.
Make the LED "breathe" faster or slower by changing delay(20).
Goal: first wireless lab. See every network around you and how strong it is.
A numbered list of networks every 5 seconds. Find your classroom WiFi. Is the signal better than −70 dBm?
Screw on the external antenna and compare the numbers. (Some boards need a tiny jumper resistor moved to use the antenna; ask your instructor.)
Goal: stream live video from the robot's camera to a browser on the classroom WiFi. This uses an example that comes with the ESP32 package.
Open File › Examples › ESP32 › Camera › CameraWebServer.
Find the Select camera model lines (in the main tab, or in the board_config.h tab on newer versions). Switch off the model that's on and switch on AI_THINKER:
Find the WiFi lines near the top of the main tab and replace them with:
Upload. Open the Serial Monitor (115200) and press RST. Wait for Camera Ready! Use 'http://192.168.x.x' to connect.
On a phone or laptop on the same WiFi, open that address and click Start Stream.
Here the ESP32 joins an existing WiFi network (station mode). In Module 4 the robot makes its own hotspot (access-point mode). Both are useful.
The ESP32 can't power a motor directly: its pins give a few milliamps at 3.3 V, and a motor wants hundreds of milliamps. The L298N driver sits in between, like a set of electronic switches.
Goal: connect the battery, the L298N, the four motors and the ESP32-CAM exactly like the kit diagram. Batteries OUT while you wire.
| From (ESP32-CAM adapter) | Wire in diagram | To (L298N) | Job |
|---|---|---|---|
| 5V | red | 5V | Powers the ESP32-CAM from the L298N's regulator |
| GND | black | GND | Shared ground (must be connected!) |
| IO14 | orange | IN1 | Motor A (OUT1/OUT2) direction |
| IO15 | blue | IN2 | Motor A (OUT1/OUT2) direction |
| IO13 | tan | IN3 | Motor B (OUT3/OUT4) direction |
| IO12 | yellow | IN4 | Motor B (OUT3/OUT4) direction |
| Battery + | red, via switch | 12V | Motor power (3 × 18650 ≈ 11.1–12.6 V) |
| Battery − | black | GND | Battery ground |
The kit comes with its firmware already loaded. Insert the batteries, lift the robot, switch on and press RST: the motors briefly run. That tells you the motor wiring is alive.
Each motor channel has two inputs. Make one input "on" and the other "off" and the motor spins one way; swap them and it spins the other way; both off and it stops. In this kit the ENA/ENB jumpers stay on (channels always enabled), and the code sends PWM to the IN pins to set the speed. So a "1" in the table below really means "PWM at the current speed".
Click a direction to see which pins are driven and how each side's wheels turn.
| Move | IO13 IN3 | IO12 IN4 | IO14 IN1 | IO15 IN2 |
|---|---|---|---|---|
| Forward | 0 | speed | 0 | speed |
| Backward | speed | 0 | speed | 0 |
| Turn left | speed | 0 | 0 | speed |
| Turn right | 0 | speed | speed | 0 |
| Stop | 0 | 0 | 0 | 0 |
Goal: check that every motor turns the right way. This replaces the kit firmware; you can re-upload it later from Module 4.
Put the robot on a box or cup so the wheels hang in the air.
Upload the sketch. Switch the battery on. After 2 seconds it runs forward, backward, left, right, once.
Watch each wheel. Press RST to repeat.
| What you see | Fix |
|---|---|
| One wheel turns backwards on "Forward" | Swap that motor's two wires in its OUT terminal. |
| A whole side turns backwards | Swap the two wires of that side's OUT terminal (or swap IN1↔IN2 / IN3↔IN4). |
| "Left" turns right | Swap the pin numbers of LEFT_* and RIGHT_* in the code. |
| Motors only buzz | Raise speed (try 200) or charge the batteries. |
| Nothing moves | Battery switch on? Shared GND wire connected? Batteries above 11.1 V? |
setMotors(l0, l1, r0, r1) writes one PWM value to each of the four L298N inputs. Every movement is just a different pattern of those four numbers, exactly like the table above.
Goal: your first "remote control", through the USB cable. The PC sends letters, the ESP32 turns them into movements.
Upload, open the Serial Monitor at 115200, robot still on its box.
Type w and press Enter. The wheels spin forward until you send x.
Add a b key that blinks the flash LED, or a q key that spins on the spot for exactly one second.
Now we cut the cable. The robot runs a small web server, and any phone or laptop browser becomes the remote. First with the kit's own firmware (with live camera), then with code you write yourself.
Goal: use the factory program: camera stream plus drive buttons. If you uploaded Labs 1–7, re-upload the kit code first (Part B).
Turn on the power switch. The small red LED on the ESP32-CAM lights up when its WiFi is ready. If not, press RST.
On your phone open WiFi settings and join ESP32-CAM Robot (no password).
Open a browser and go to 192.168.4.1.
Hold a green button to drive; release to stop. Yellow buttons switch the flash LED.
The remote page simply opens these addresses in the background. Try typing them into a PC browser that's connected to the robot's WiFi:
Goal: put the camera robot program back on the board, with a WiFi name that's unique to your team, so twenty robots called "ESP32-CAM Robot" don't confuse everyone.
Unzip it. Keep all three files in the folder ESP32_Camera_4WD_Robot_Car_OV3660_V3.
Open the .ino file. All three files appear as tabs.
Change line 9 so the hotspot carries your team name:
Board AI Thinker ESP32-CAM, your Port, Upload. Then repeat Part A with your new WiFi name.
Goal: write the web server yourself: hold-to-drive buttons for phones, WASD keys for PCs, a speed slider, and a safety stop.
Upload. The Serial Monitor shows Hotspot: Robot-student01.
Join that WiFi (password robot1234) and open 192.168.4.1.
Phone: hold the arrows. PC: hold W A S D or the arrow keys.
| Address | What the ESP32 does |
|---|---|
| / | Sends the remote page (HTML stored in PAGE) |
| /cmd?c=forward | Drives. While you hold a button, the page repeats this every 200 ms |
| /speed?v=200 | Sets PWM speed 0–255 |
| /light?on=1 | Flash LED on (0 = off) |
If your phone locks or walks out of range, the "stop" message may never arrive. The robot stops itself when it hears nothing for 0.6 s. Real robots always have a failsafe like this.
Add a "Spin" button that sends /cmd?c=left, or change the button colours in the <style> part of PAGE.
With a web remote, your phone talks straight to one robot. With MQTT, everything talks to a central broker, and the broker passes messages on. One dashboard can drive many robots, and many screens can watch one robot.
| Word | Meaning | In our robot |
|---|---|---|
| Broker | The post office. Receives every message and forwards it. | Mosquitto on the instructor's PC |
| Topic | The address on the envelope, like a folder path | imakewemake/robot/student01/cmd |
| Publish | Send a message to a topic | Node-RED publishes forward:800 |
| Subscribe | Ask the broker for every message on a topic | The robot subscribes to its /cmd topic |
| Retained | The broker keeps the last message for newcomers | /online stays "online" or "offline" |
| Last Will | A message the broker sends if a client vanishes | Robot loses power → broker publishes "offline" |
| Wildcards | + = one level, # = everything below | imakewemake/robot/+/online |
Download and install Mosquitto from mosquitto.org/download (the Windows 64-bit installer). Mac: brew install mosquitto.
Open C:\Program Files\mosquitto\mosquitto.conf in Notepad (as Administrator), and add these lines at the end. Without them, Mosquitto 2 only accepts connections from the same PC.
Allow port 1883 through the Windows firewall:
If the Mosquitto Windows service is already running, stop it in Services, then start the broker so you can see every connection:
Find this PC's IP address with ipconfig (IPv4 Address, e.g. 192.168.1.100) and write it on the board. That's the broker IP students type into their settings.
Watch robots join:
Robots, student laptops and the broker PC must be on the same 2.4 GHz-capable WiFi, and the network must allow devices to talk to each other. Guest networks with "client isolation" block this. A cheap dedicated router works best.
Goal: see MQTT messages with your own eyes before the robot joins in.
Install MQTT Explorer from mqtt-explorer.com.
New connection → Host 192.168.1.100, Port 1883, no username → Connect.
In the Publish panel, topic imakewemake/robot/student01/cmd, message hello, click Publish. It appears in the topic tree on the left.
Look at what other teams are publishing. That's the "many screens, one broker" idea.
Goal: the robot joins the classroom WiFi, connects to the broker, obeys commands on its /cmd topic and reports its status.
Install the library: Sketch › Include Library › Manage Libraries…, search PubSubClient, install the one by Nick O'Leary.
Check your team settings at the top of the code (they come from the settings on the Start page).
Upload, open the Serial Monitor. You should see WiFi OK then MQTT OK, listening on …/cmd. The red LED on the board turns on when it's connected to the broker.
In MQTT Explorer, publish forward:1000 to your /cmd topic. The robot drives for one second. Open the /status topic to see its JSON report. Command-line fans can use:
forward stops by itself after 3 s (MAX_MOVE_MS).The robot can't reach the broker. Check the broker IP, that the broker PC's firewall allows port 1883, and that the robot and broker are on the same network.
Node-RED lets you program by wiring boxes ("nodes") together in a browser. It speaks MQTT out of the box, and with Dashboard 2.0 it can build a control panel that works on any phone or PC.
Install Node.js LTS from nodejs.org (accept the defaults).
Open Command Prompt (Windows) or Terminal (Mac/Linux) and run these one at a time. The first line should print a version like v22.x. On Mac/Linux you may need sudo before npm.
Leave that window open. Open http://127.0.0.1:1880 in your browser: that's the Node-RED editor.
Install the dashboard: menu ☰ › Manage palette › Install, search for this and click install:
For each lab below: click Copy, then in Node-RED open ☰ › Import, paste with Ctrl+V, click Import, then the red Deploy button (top right). Or use Download and choose select a file to import.
Goal: send commands with one click and watch the robot's status come back. Your team ID and broker IP are already filled in.
Import and Deploy. Under each MQTT node a small green connected label should appear.
Click the square button on the left of Forward 1 s. The robot drives for a second.
Open the Debug sidebar (bug icon, top right) to see the status messages arriving every 2 seconds.
Click Dance!. The Square dance function sends eight timed moves in a row.
| Node | What it does |
|---|---|
| inject | A button inside the editor. Sends a fixed message, e.g. forward:1000 |
| mqtt out | Publishes whatever arrives to your robot's /cmd topic |
| mqtt in | Subscribes to /status and /online |
| function | A little JavaScript. Here: a timed list of moves |
| debug | Prints messages in the Debug sidebar |
Open the Square dance node and design your own routine: a zig-zag, a figure eight, a "parking" move. Change the numbers, Deploy, click Dance!
Goal: a real control panel with drive buttons, speed and step-time sliders, a light switch and live status, usable from any phone on the classroom WiFi.
Make sure @flowfuse/node-red-dashboard is installed (Setup step 4), then import and Deploy.
Each tap of an arrow moves the robot for the Step time set on the slider. STOP stops at once.
On your phone (same WiFi), open http://<your-laptop-IP>:1880/dashboard. Find your laptop IP with ipconfig.
An arrow button sends forward → the add step time function turns it into forward:600 using the slider value it remembered in flow.stepMs → mqtt out publishes it. The robot's status JSON comes back through mqtt in → split status → four text widgets.
msg.payload.rssi./online topic changes to "online".You've gone from blinking an LED to driving a robot through a broker from a dashboard. The same pattern (sensor or actuator → ESP32 → MQTT → Node-RED) runs smart greenhouses, factory monitors and home automation. Swap the motors for a sensor and you have an IoT device.
| GPIO | Connected to | Notes |
|---|---|---|
| 14 | L298N IN1 | Right motors (code: RIGHT_M0) |
| 15 | L298N IN2 | Right motors (code: RIGHT_M1) |
| 13 | L298N IN3 | Left motors (code: LEFT_M0) |
| 12 | L298N IN4 | Left motors (code: LEFT_M1). Boot-sensitive pin; if the board won't boot, unplug this wire while uploading |
| 4 | White flash LED | PWM brightness, keep low |
| 33 | Red status LED | Active LOW |
| 0 | Boot button / camera clock | Hold during reset for upload mode |
| Code | Meaning |
|---|---|
| pinMode(33, OUTPUT); | Make pin 33 an output |
| digitalWrite(33, LOW); | Set the pin to 0 V (turns the red LED on) |
| ledcAttachChannel(pin, 2000, 8, 4); | PWM on pin: 2000 Hz, 8-bit (0–255), channel 4 |
| ledcWrite(pin, 170); | Set PWM duty (speed or brightness) |
| Serial.println("hi"); | Print to the Serial Monitor |
| WiFi.softAP(name, pass); | Make a hotspot (robot is 192.168.4.1) |
| WiFi.begin(name, pass); | Join an existing WiFi network |
| mqtt.publish(topic, text); | Send an MQTT message |
| mqtt.subscribe(topic); | Receive messages on a topic |
| Problem | Most likely fix |
|---|---|
| No COM port | Data USB cable, CH340 driver, different USB socket |
| "Failed to connect" when uploading | Hold IO0, tap RST, release IO0, upload again |
| Board keeps restarting (brownout) | Turn the battery on, charge the batteries |
| Robot doesn't move | Battery switch, shared GND, batteries above 11.1 V, speed above ~120 |
| Wheel goes the wrong way | Swap that motor's two wires |
| 192.168.4.1 won't open | Phone mobile data off, right robot WiFi, press RST |
| Stuck on "WiFi connecting…" | Name/password exact? 2.4 GHz network? |
| MQTT rc=−2 | Wrong broker IP, firewall port 1883, different network |
| Node-RED MQTT says "disconnected" | Edit the broker node, check the IP, Deploy again |
| Dashboard nodes show as "unknown" | Install @flowfuse/node-red-dashboard, then restart Node-RED |