Meet the ESP32

Two kinds of computer

A single-board computer like the Pi and a microcontroller like the ESP32 are both "computers", and engineering treats them as different species because every number in their comparison differs by orders of magnitude:

Read the table as trade-offs, not rankings. The Pi's operating system is why it can run Mosquitto, Flask and your control app at once, and also why it boots slowly and burns power; the ESP32's bareness is why it starts instantly and runs on next to nothing, and also why it will never host your dashboard. The row that forces this week's hand is analog input: the Pi simply has no ADC, so "how bright is it?" is a question the ESP32 answers and the Pi cannot. Background on the species: microcontroller and ESP32; the chip's maker documents it at Espressif's product page.

Node and hub: you are here

The board, part by part

Your kit's board is an ESP32 DevKit: the ESP32 module itself plus everything needed to develop on it comfortably. A tour, metal side up:

• The module with the antenna (the metal can and the zigzag trace at one end): the actual ESP32, its flash chip and the printed Wi-Fi antenna. Keep fingers and wires off the antenna end when the radio matters, from next week on.
• The USB connector and its bridge chip: USB carries 5 V power and a serial data line; a small bridge chip (CP210x or CH340, board depending) translates USB to the chip's serial port. Your laptop sees it as a "COM port" or /dev/tty..., and that is the REPL's road in. No port appearing usually means a power-only cable or a missing bridge driver.
• The 3.3 V regulator: the board takes USB's 5 V and makes the 3.3 V everything runs at. Week 4's rule 1 carries over verbatim: the logic is 3.3 V, never put 5 V on a GPIO pin, and the 5 V pin (often marked VIN) feeds the regulator, not your circuits.
• EN and BOOT buttons: EN resets the chip (a fresh start without unplugging); BOOT, held during a connection attempt, puts the chip in firmware-download mode. You may never need BOOT; Thonny usually manages it, and the troubleshoot page says when to press it yourself.
• The pin headers: GPIO, power and ground rows that plug straight into your breadboard. This week's cast: 3V3 and GND for the circuits, GPIO2 (most DevKits wire the onboard LED here), GPIO25 for the external LED, GPIO34 for the light reading. One family trait to respect now: GPIO 34 to 39 are input-only, perfect for sensing, useless for driving anything.

Boards vary in detail (pin count, bridge chip, LED pin); the MicroPython ESP32 quick reference is the course's settling authority, the way pinout.xyz was for the Pi.

Firmware, and MicroPython as firmware

On the Pi, Week 2's boot chain ended in an operating system that then loads programs; on a microcontroller there is no such chain. Whatever sits in the chip's flash memory is the machine's entire behaviour, running directly at power-on: that program is called firmware. Normally firmware is compiled C, rebuilt and reflashed for every change. MicroPython is the move that makes this course possible: a firmware whose job is to be a Python interpreter, with a tiny filesystem for your scripts. Flash it once, and from then on "changing the firmware's behaviour" means editing a Python file, exactly the workflow you already own. It is a lean reimplementation of Python 3 for machines with kilobytes, not gigabytes: the language is the one you know; the standard library is a careful subset; and a new module, machine, exposes the chip's pins and peripherals (reference).

Flashing with Thonny

1. Cable and port

   Connect the board with a USB data cable. A power LED lights; your laptop gains a serial port. No port after a minute: switch cables first, then install the bridge driver named on the troubleshoot table.

2. Point Thonny at the board

   In Thonny: Tools → Options → Interpreter, choose MicroPython (ESP32) and the board's port. Thonny is the same editor from Week 4; only the interpreter choice is new.

3. Install the firmware

   Use the interpreter dialog's install or update MicroPython option, which downloads the official firmware and flashes it over the cable (the independent route, downloading from micropython.org/download and flashing with esptool, does the same thing by hand). A progress bar, a couple of minutes, done; this is a once-per-board event.

4. Meet the REPL

   The Shell pane shows a MicroPython banner and the familiar >>>. That prompt runs on the ESP32, reached over the serial line: the same live-conversation REPL as Week 4, with a new machine on the other end. 2 + 2 to say hello.

First blink, from the REPL

>>> from machine import Pin
>>> led = Pin(2, Pin.OUT)
>>> led.on()
>>> led.off()

The onboard LED answers (on a few boards it is wired inverted, so on and off swap; the lesson survives). Read the line with Week 6 eyes: Pin is a class, Pin(2, Pin.OUT) a constructor call with two facts, led an instance with methods. Then the loop, as a script this time, pasted into Thonny's editor and run:

from machine import Pin
from time import sleep

led = Pin(2, Pin.OUT)
while True:
    led.on()
    sleep(0.5)
    led.off()
    sleep(0.5)

time.sleep survives the trip to MicroPython unchanged. Ctrl+C in the Shell interrupts the loop and returns the prompt, the serial REPL's version of a habit you already have.

MicroPython vs the Python you know

main.py: the board becomes an appliance

Save a script to the device (Thonny: File → Save as → MicroPython device) under the name main.py, and MicroPython runs it automatically at every power-up, laptop or no laptop. Plug the board into any USB charger and your blink runs forever: the moment a script becomes main.py, the board stops being a peripheral and becomes an appliance, which is the whole microcontroller idea in one file name. Two habits from day one: keep the canonical copy of every board script in your Git repository and upload working versions, the board's filesystem is a deployment target, not your archive; and remember that a main.py with an infinite loop keeps the REPL busy, Ctrl+C interrupts it when the cable returns.

Checklist for this stage

• I can name four order-of-magnitude differences between the Pi and the ESP32, and both machines' natural roles
• I located the module and antenna, USB bridge, regulator, EN/BOOT, and this week's pins on my board
• MicroPython is flashed and the serial REPL answers 2 + 2
• I blinked the onboard LED from the REPL, then from a script, and interrupted it with Ctrl+C
• I saved a script as main.py, power-cycled on a charger or power bank, and watched it run headless

Check yourself