ESP32 Lesson Plan: First Class Prep Checklist and 40-Minute Flow

When you write an ESP32 lesson plan, boil the first class down to one goal: by the end, every group has uploaded code to its own ESP32 and lit an LED. Wi-Fi, sensors and phone control belong to later lessons. Whether 40 minutes is enough depends less on what you do in class than on what you do before it: is the USB-to-serial driver installed, is the ESP32 board package in the Arduino IDE, and does the cable on the desk actually carry data? If those three are ready, the first upload takes five minutes; if not, half the lesson goes on "I can't see the port".

This post gives you a package you can take to class tomorrow: a copyable checklist for one week before, the day before and the morning of the lesson, a materials table, a minute-by-minute 40-minute flow, two sketches that compile, five ways the ESP32 differs from the Arduino Uno, one-minute fixes for the eight most common problems and exit questions. Let's say you have a class of 24 and split the students into 8 groups of three; every number below assumes that. If your periods are 45 or 50 minutes, the extra time is your buffer. If the ESP32 is still new to you, read what is the ESP32 first.

First lesson goal: why just one LED?

In a first ESP32 lesson you have two options: demo an impressive Wi-Fi project, or have everyone get something small working with their own hands. The second teaches far more. To light an LED a student has to run through the whole chain once from start to finish: open the code, pick the board and port, compile, upload, build the circuit, see the result, then change a value and upload again. Once that chain works, later lessons only add new parts. If you jump to Wi-Fi before it works, network passwords, drivers and cables pile on top of each other and telling which one caused the error becomes almost impossible. That's why this plan has no network in the first class: first the board's built-in LED, then a single external LED on the breadboard, and for fast groups both blinking in turn.

Pre-lesson preparation checklist

Split the preparation into three stages. You can copy and print the list or share it with the school's IT technician; jobs that need admin rights, such as installing drivers and software, go through them in most schools. One week before:

• Count the boards and check the model. This plan is written for the 30-pin ESP32 DevKit (with the ESP32-WROOM-32 module); on 38-pin boards the code is the same, only the pin order differs.
• Read the small chip next to the board's USB port: is it a CP2102, a CH340 or a CH9102? That decides which driver you need.
• Have Arduino IDE 2 installed on the classroom computers. School machines usually need admin rights for installs, so book a slot with IT.
• In the Arduino IDE, install the esp32 by Espressif Systems package from the Boards Manager. It downloads hundreds of megabytes; on a school network, 40 minutes may not be enough if you try it in class.
• Install the USB-to-serial driver, plug in a board and check that a new port appears under Tools > Port.
• Test your cables: upload to a board with each one, sort out the charge-only cables and mark the data cables with coloured tape.
• Plug an ESP32 into a breadboard and check whether free holes remain on both sides. If not, each group gets two breadboards.
• Find out the school network's limits: the ESP32 only connects to 2.4 GHz Wi-Fi, and enterprise networks that ask for a username and password are hard to deal with. You won't use Wi-Fi in the first class, but you'll need this information for later lessons.

The day before, every computer should be ready for class; the aim is that no setup step is done for the first time during the lesson. Set aside ten minutes on the morning of the lesson too. Both lists are in one place:

• Day before: Do a test upload on every computer. Plug in the board, select ESP32 Dev Module and the port, upload the built-in LED sketch and watch the LED blink. The first compile can take more than a minute; this trial also speeds up later compiles.
• Day before: On Windows, put a label with the port number (COM3, COM5 and so on) on the side of the computer. The same board plugged into the same USB socket usually gets the same number.
• Day before: Pack the group boxes: board, cable, breadboard, two LEDs, two 220 Ω resistors, four jumper wires. Keep the spare set on the teacher's desk.
• Day before: Save both sketches to the desktop of every computer; if the internet slows down, students open the code from there.
• Day before: Check that the ESP32 Built-in LED Blink project opens in BlueGrays on the projector.
• Morning of: Turn on the computers, open the Arduino IDE and check that the board is still set to ESP32 Dev Module.
• Morning of: Draw a simple sketch of the board on the whiteboard: USB port, BOOT, EN, GND, 3V3 and GPIO5 (labelled D5 on the board).
• Morning of: Write one line in the corner of the board: "Stuck on Connecting...? Hold BOOT."
• Morning of: Count the LEDs and resistors in the boxes one last time and put the cables on top.

Driver, board package and BOOT: details you need to know

You may see two ESP32 packages in the Arduino IDE Boards Manager. For classroom boards the right one is Espressif's esp32 package; the one called "Arduino ESP32 Boards" is for Arduino's own Nano ESP32. After installing, choose ESP32 Dev Module under Tools > Board > esp32. If the package doesn't show up in the list, you need to add Espressif's package address to the additional boards manager URLs in Preferences; you'll find the steps in what is the ESP32. ESP32 sketches take longer to compile than Uno sketches; even for an LED blink the first compile can take over a minute. Tell students this up front, or they'll keep hitting Upload while the progress bar seems stuck. The board's USB-to-serial chip decides which driver to install:

The BOOT button is wired to the ESP32's GPIO0 pin. When an upload starts, the board has to enter programming mode; most DevKits do this on their own using two signals from the USB-to-serial chip. With some board and cable combinations this automatic switch fails: the "Connecting..." dots in the output keep going and you end up with a "Failed to connect to ESP32" error. The fix is to hold BOOT as soon as "Connecting..." appears and release it when the progress lines starting with "Writing at" begin to scroll. The EN button restarts the board; if the upload finished but the code doesn't seem to run, one press of EN is enough. If the problem keeps coming back on the same board, lowering Upload Speed in the Tools menu from 921600 to 115200 usually helps. On macOS the port name usually starts with cu.usbserial or cu.SLAB_USBtoUART.

Materials list: per group and for a class of 24

Split 24 students into groups of three and you get 8 groups; with one spare you prepare 9 sets. If you prefer pairs, you need 12 groups plus a spare, so 13 sets, and more computers to match. No part needs soldering. The reason for two LEDs and two resistors per group is simple: an LED plugged in backwards or with a broken leg is very common in a first lesson, and you don't want a group waiting.

The 40-minute lesson flow

The flow is built on two free BlueGrays projects: first ESP32 Built-in LED Blink (no circuit, just the board and cable), then LED Blink with ESP32 (GPIO5, a 220 Ω resistor and an LED). Both projects have the parts list, circuit diagram, code, blocks and Understand the code open for free. Hand out three roles in each group and rotate them at every stage: one on the keyboard, one building the circuit, one reading the diagram and code from a phone or the projector. That way nobody spends 40 minutes just watching.

The code: built-in LED and external LED

The two sketches below use the same pins and timings as the projects in the app and compile straight away with ESP32 Dev Module selected in the Arduino IDE. The first one blinks the LED on the board once a second. On most ESP32 DevKit boards this blue LED is wired to GPIO2. On the Arduino Uno the built-in LED was on pin 13; students who have used an Uno may type 13 out of habit, so point out the difference early.

1// ESP32 Dahili LED Yakma / ESP32 built-in LED blink
2// Çoğu ESP32 DevKit kartında dahili LED GPIO2'dedir / On most ESP32 DevKit boards the built-in LED is on GPIO2
3int BUILTIN_LED_PIN = 2;   // Kartına göre değişebilir / May differ on your board
4
5void setup() {
6  pinMode(BUILTIN_LED_PIN, OUTPUT);   // Pini çıkış yap / Set the pin as output
7}
8
9void loop() {
10  digitalWrite(BUILTIN_LED_PIN, HIGH);   // LED'i yak / Turn the LED on
11  delay(1000);                           // 1 saniye bekle / Wait 1 second
12  digitalWrite(BUILTIN_LED_PIN, LOW);    // LED'i söndür / Turn the LED off
13  delay(1000);                           // 1 saniye bekle / Wait 1 second
14}
15

The circuit for the second sketch: from GPIO5 to one end of the 220 Ω resistor, from the other end of the resistor to the LED's long leg (anode), and from the LED's short leg (cathode) to GND. The ESP32 pin outputs 3.3 V; about 2 V drops across a red LED, and the remaining 1.3 V across 220 Ω gives roughly 6 mA. That's enough for a clearly visible LED and doesn't strain the pin. If you use a different colour, check the resistor with the LED resistor calculator. In the mini task, fast groups combine the two sketches: they set both pins as outputs in setup() and write one HIGH while the other is LOW in loop().

1// ESP32 ile LED Yakma: harici LED / ESP32 external LED blink
2// Bağlantı: GPIO5 -> 220 Ω direnç -> LED uzun bacak (+), kısa bacak (-) -> GND
3// Wiring: GPIO5 -> 220 ohm resistor -> LED long leg (+), short leg (-) -> GND
4const int LED_PIN = 5;   // Harici LED pini (kartta D5) / External LED pin (D5 on the board)
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);   // Pini çıkış yap / Set the pin as output
8}
9
10void loop() {
11  digitalWrite(LED_PIN, HIGH);   // Pin 3,3 V verir, LED yanar / Pin outputs 3.3 V, LED on
12  delay(500);                    // Yarım saniye bekle / Wait half a second
13  digitalWrite(LED_PIN, LOW);    // Pin 0 V verir, LED söner / Pin outputs 0 V, LED off
14  delay(500);                    // Yarım saniye bekle / Wait half a second
15}
16

5 ways the ESP32 differs from the Arduino Uno

Some of your students may have used an Arduino Uno before. The code is written in the same Arduino language and setup() and loop() are where they always are, but the hardware is different, and most errors in a first lesson come from these differences. You can cover the five points below in a few minutes while getting to know the board. For a more detailed comparison, see Arduino vs ESP32.

The 8 most common problems in class and one-minute fixes

Exit questions and a preview of lesson two

1. Which pin on the board does the number 5 in the code refer to? Why might the board say "D5" next to that pin?
2. What changed on the LED when you wrote delay(200) instead of delay(1000)? How many times a second does the LED blink now?
3. Why didn't the LED light when it was plugged in backwards? Which leg of the LED goes on the resistor side?
4. What voltage do the ESP32's pins output? Why shouldn't we connect an LED or a module directly to the 5V pin?

The answers show which idea needs revisiting in lesson two; a student who answers 2.5 to the second question has understood timing. In lesson two you add a button to the same circuit: in the ESP32 LED Control with Push Button (Push) project the LED stays on while you hold the button, and in ESP32 LED Control with Pushbutton (Toggle) every press flips its state. Both are free and have blocks; students read an input for the first time and make a decision with if. In lesson three or four you can move on to Wi-Fi; for that lesson, keep the status code table from ESP32 won't connect to Wi-Fi at hand. The Wi-Fi ESP32 projects in BlueGrays are Premium; if you want your students to move on to them, we explain how giving each one a code from an educator package works, instead of separate subscriptions, in Premium codes for a class.

How do you use BlueGrays in class?

• Find the project: In Discover › Projects, use Filter to set the platform to ESP32 and Price to free. ESP32 projects suited to first lessons, such as LED, button, traffic light, light sensor and distance sensor, come fully unlocked.
• Required Components and Circuit Diagram: The parts list is ready with quantities. You can zoom the diagram and put it on the projector, or save it with Save to Gallery and print it.
• Source Code: Copy puts the code on the clipboard. If a student opened the project on a phone, Copy Link gives a link to open the code on the computer, so nobody has to type it by hand.
• Understand the code: First the What does this code do? summary, then the Step by step explanation, the If you get stuck section and the Try it yourself task. It's a ready next step for groups that finish the mini task early.
• Show as blocks: All free ESP32 projects have a block view. Turn the switch on and the code is replaced by blocks of the same program, and the tab becomes Understand the blocks. The blocks are for reading; they aren't edited in the app or uploaded to the board, and the board always gets the real code.
• Let's build it together: A guided mode that walks through getting the parts ready, building the circuit, uploading the code, and running and testing. The screen stays on, so the group can follow the steps with the phone lying on the desk; at the end, I made it marks the project as done.

The first lesson may look like just one LED, but in those 40 minutes students go through compiling, uploading, pin numbers, the 3.3 V limit and debugging once, and every later ESP32 lesson builds on that. We cover every section of the project page in detail in the project page guide. If you want to build both projects yourself once before class, open ESP32 Built-in LED Blink in the BlueGrays app; the diagram, code, blocks and Understand the code are all there, and your rehearsal won't take more than ten minutes.