Français

Lessons · Lesson K1 · Code basics · 30 min

Your first program: connect and upload code to your ESP32

From a box of parts to a blinking LED and your first message on screen, one step at a time. About 30 minutes, with a troubleshooting table for when something refuses to work.

New here? Install the tools first: Get set up.

What you need

  • An ESP32 development board. This lesson uses the ESP32-DevKitC, the board Espressif designs itself. It is small, and it has pins on both sides so you can plug it into a breadboard [7].
  • A USB cable that carries data. The DevKitC V4 has a Micro-USB socket and the cable goes between that socket and your computer [7]. Some cables are made only for charging and have no data wires inside. With one of those, your computer will never see the board [6]. If the board does not show up later, swapping the cable is the first thing to try.
  • A computer. Arduino IDE 2 runs on 64-bit Windows 10 or newer, on macOS 10.15 “Catalina” or newer, and on 64-bit Linux [2].
  • For the blink part: a breadboard, one LED, one 220 Ω resistor and two jumper wires. Lesson E3 explains why the resistor is there.

Check your board’s USB socket. Clone boards come with different sockets. Match your cable to the socket you actually see on your board.

What you need for lesson K1 The parts laid out side by side, drawn flat: an ESP32-DevKitC seen from above with its USB socket on the left and its two buttons, EN and BOOT, beside the socket; a USB cable that carries data; a laptop; a breadboard; one LED with a long leg (plus) and a short leg (minus); one 220 ohm resistor; two jumper wires. FIG. 1 — WHAT YOU NEEDENBOOTESP32-DevKitC (top view)USB socketBOOTcomputerWindows, macOS or LinuxMicro-USBUSB-AUSB data cablebreadboard+−LED220 Ωresistor2 jumper wires
Tap the diagram to open it full screen.
Data cable or charge-only cable Two USB cables cut open. A data cable has four wires inside: 5 V, ground, D plus and D minus; the two data wires let the computer talk to the board, so a port appears. A charge-only cable has only the 5 V and ground wires. The board's power light comes on with both cables, so the light proves nothing about data: if no port appears, swap the cable first. FIG. 2 — DATA CABLE VS CHARGE-ONLYaData cable5 VD+D−GNDdatapowerlight onPort listCOM3The computer sees the board.bCharge-only cable5 VGNDno data wirespowerlight onPort list(nothing new)The board gets power, nothing else.Both look the same from outside. No new port? Swap the cable first.
Tap the diagram to open it full screen.

Step 1: Install Arduino IDE 2

The Arduino IDE is the program where you write code, press one button, and send it to your board. Download it from the Arduino software page (arduino.cc/en/software) [2].

  • Windows: run the file you downloaded and follow the installer. It may take a few minutes [2].
  • macOS: copy the downloaded file into your Applications folder [2].
  • Linux: download the 64-bit AppImage. Before the first launch, make it executable: right-click the file, open Properties, then the Permissions tab, and tick “Allow executing file as program”. Then double-click it [2]. If it refuses to start, your system may be missing a small helper called FUSE. On Ubuntu 22.04 or newer the Arduino guide gives sudo add-apt-repository universe followed by sudo apt install libfuse2; on Fedora, dnf install fuse [2].

Open the IDE once to make sure it starts. You will see an empty sketch. A sketch is just Arduino’s word for a program [12].

Installing Arduino IDE 2 Three simplified sketches, one per system. Windows: run the installer you downloaded and click through to the end. macOS: drag the downloaded app into the Applications folder. Linux: right-click the AppImage, open Properties, then Permissions, tick Allow executing file as program, then double-click it. FIG. 3 — INSTALL THE IDEWindowsSetupInstalling…NextRun the file youdownloaded.macOSArduino IDEApplicationsCopy it intoApplications.LinuxPropertiesPermissionsAllow executingfile as programRight-click the AppImage,tick the box, double-click.Simplified drawings: your screens will look a little different.
Tap the diagram to open it full screen.
The Arduino IDE 2 window, simplified A simplified drawing of the IDE window, not a screenshot. Top left: the checkmark button verifies your code and the right-arrow button uploads it. Next to them, the board and port drop-down. Top right: the Serial Monitor button. Left column: the Boards Manager icon among other tools. Middle: the editor, where your sketch goes. Bottom: the console, where messages and errors appear. FIG. 4 — THE IDE, SIMPLIFIEDSelect Boardvoid setup() {  // put your setup code here}void loop() {  // runs again and again}OutputDone compiling.12345671Verifychecks and builds your code2Uploadsends it to the board3Board and portwhich board, which socket4Serial Monitormessages from the board5Boards Manageradds board packages6Editoryour sketch (program)7Consoleprogress and errorsSimplified drawing, not a screenshot: positions match, details differ.
Tap the diagram to open it full screen.

Step 2: Teach the IDE about the ESP32

Out of the box, the IDE knows Arduino’s own boards. A board package is an add-on that translates the usual Arduino commands into what one particular family of chips understands [3]. For the ESP32 the package comes from Espressif, the company that makes the chip [1].

2a. Tell the IDE where to find it.

  1. Open the Preferences window [1]. In current versions it sits under File on Windows and Linux. On macOS it is not in the File menu: look in the application menu (the one named Arduino IDE) for Preferences or Settings, depending on your version.
  2. Find the field Additional boards manager URLs and paste this address [1]:
https://espressif.github.io/arduino-esp32/package_esp32_index.json
  1. Click OK. If the field already holds another address, separate the two with a comma [1].

2b. Install the package.

  1. In the left-hand column of the IDE, click the Boards Manager icon (the board icon) [3].
  2. Type esp32 in the search field. Pick the package made by Espressif, then press INSTALL [3].
  3. Wait for it to finish. It can take a few minutes. The installed version number shows under the package name [3].
  4. Restart the IDE [1].
Adding the ESP32 board package Two simplified panels. Panel a, the Preferences window: the field named Additional boards manager URLs is highlighted with Espressif's address written in it, then the OK button. Panel b, the IDE with the Boards Manager open in the left column: esp32 is typed in the search field, and the INSTALL button of the package by Espressif Systems is highlighted. Restart the IDE when it finishes. FIG. 5 — ADD THE ESP32 BOARD PACKAGEaFile › Preferences (macOS: app menu)PreferencesSketchbook location:Editor font size:14Additional boards manager URLs:https://espressif.github.io/arduino-esp32/package_esp32_index.json1OK2Already an address there? Separate them with a comma.bBoards Manager: search, then INSTALLArduino IDE 2123BOARDS MANAGEResp32esp32by Espressif Systemsx.y.zINSTALL1Click the board icon.2Type esp32.3INSTALL the Espressif one.4Wait, then restart the IDE.
Tap the diagram to open it full screen.

Step 3: Plug in the board and find its port

Connect the board to your computer with the data cable. A small LED lights up on the DevKitC when it receives 5 V from USB. That is only the power light, and it tells you nothing about the data connection [7].

Your computer talks to the ESP32 through a small helper chip on the board, a USB-to-UART bridge. The computer gives it a name, called a port: COM3 on Windows, something like /dev/ttyUSB0 on Linux, /dev/cu.usbserial-... on macOS [5][7].

Find your port. The IDE lists the ports it finds under Tools > Port. You can also check by hand [5]:

  • Windows: open Device Manager and look at the list of COM ports. Unplug the board, plug it back in, and note which entry disappears and reappears.
  • Linux: run ls /dev/tty* once with the board unplugged and once with it plugged in. The new name is your port.
  • macOS: same trick with ls /dev/cu.*.

If no new port appears, you may need a driver. Most of the time you need to do nothing: the driver comes with your operating system and installs itself when you plug the board in [5]. When it does not, you have to know which bridge chip your board carries:

  • How to read the chip name. Find the small square chip near the USB socket and read the text printed on its top. A magnifier helps. Espressif’s guide links CP210x and FTDI drivers; your board’s user guide names its chip [5]. Many clone boards use a CH340 chip made by WCH [10]. Once the board is plugged in, the name also shows up in your system’s device list, for example “Silicon Labs CP210x UART Bridge” [6].
  • CP210x: download the driver from Silicon Labs (the Espressif guide links to the “USB to UART Bridge VCP Drivers” page at silabs.com/developers/usb-to-uart-bridge-vcp-drivers) [5].
  • CH340: SparkFun keeps a step-by-step guide with the driver files for Windows, macOS and Linux [10].
  • macOS extra: after installing a driver, the system may ask you to allow it. On macOS 13 and later, look in System Settings > Privacy & Security; on older versions, in System Preferences > Security & Privacy > General [5]. Either way you are looking for a message about software from the developer (Silicon Labs or FTDI).

Then unplug the board, plug it back in, and look at the port list again.

ESP32-DevKitC: what is where Top view of a DevKitC-style board, USB socket on the left. Beside the socket: the EN button (reset) and the BOOT button. Just right of the socket: the small square USB-to-UART bridge chip; read the name printed on top, such as CP2102 or CH340. Near it, the power LED. On the right, the ESP32 module with its antenna at the far end. Pins run along both long edges. Below, a port list before and after plugging in: one new entry, COM3, appears; that is your board. FIG. 6 — THE BOARD, TOP VIEWENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GNDUSB socketEN = resetBOOT buttonpower LEDbridge chip: read the name on top(CP2102, CH340…)ESP32 moduleantenna at the endpin names are printed next to each pinFind the port: unplug, plug back in, spot the new lineboard unpluggedPortsCOM1board plugged inPortsCOM1COM3← new: your boardLinux: /dev/ttyUSB0 · macOS: /dev/cu.usbserial-…
Tap the diagram to open it full screen.

Step 4: Pick the board and the port

At the top of the IDE, next to the verify and upload buttons, there is a drop-down menu. If it does not show your board by itself, choose “Select other board and port…”, or go to Tools > Board and Tools > Port and pick them by hand [4].

  • Board: under the esp32 entries, choose ESP32 Dev Module. It is the generic ESP32 entry and it works well for the DevKitC. If your board carries a different chip, such as an ESP32-S3, pick the entry named for that chip instead.
  • Port: choose the one you found in the last step.

The board name appears in bold once the IDE sees a connection [4].

Picking the board and the port Simplified drawing of the board and port selection. The drop-down at the top of the IDE is open on Select other board and port. On the left, the board list filtered with esp32: ESP32 Dev Module is highlighted. On the right, the port list: COM3 is highlighted. On Linux the port looks like /dev/ttyUSB0, on macOS like /dev/cu.usbserial followed by a code. Once connected, the board name shows in bold in the drop-down. FIG. 7 — PICK THE BOARD AND THE PORTESP32 Dev Module← shows in bold once connectedor: Tools › Board and Tools › PortSelect Other Board and PortBOARDSPORTSesp32ESP32C3 Dev ModuleESP32 Dev Module1ESP32 Wrover ModuleESP32S3 Dev ModuleCOM3Serial Port (USB)2Linux: /dev/ttyUSB0macOS: /dev/cu.usbserial-…OK3Other chip, such as ESP32-S3? Pick the entry with that chip's name.
Tap the diagram to open it full screen.

Step 5: Build the LED circuit

Most DevKitC boards have no LED you can control from code. The official DevKitC V4 lists only a power light, which switches on when 5 V arrives [7]. Some clone boards do carry a small blue LED, often on GPIO 2, but this varies from board to board. We add our own LED on GPIO 26 so that everyone gets the same result. (GPIO means “general-purpose input/output”: a pin your code can switch on and off or read [16].)

Wire it like this, with the board unplugged:

  1. Plug the DevKitC into the breadboard (it is designed for that [7]). Many ESP32 boards are wide and cover every hole on one side of a standard breadboard. If yours does, use two breadboards side by side, or plug your jumper wires into the free side only.
  2. Connect a jumper wire from the pin marked 26 to one end of the 220 Ω resistor.
  3. Connect the other end of the resistor to the long leg of the LED, called the anode. The long leg is the positive side [15].
  4. Connect the short leg (the cathode) to a pin marked GND [15].

Why 220 Ω? The ESP32 runs on 3.3 V logic, so a pin that is switched on gives 3.3 V [17]. A red LED keeps about 2 V for itself, so about 1.3 V is left across the resistor, and Ohm’s law gives (3.3 − 2) ÷ 220 ≈ 0.006 A, about 6 mA, a gentle current for an LED. Lesson E3 walks through this calculation.

LED on GPIO 26 through a 220 ohm resistor Top view of a breadboard with the DevKitC across the centre gap, USB on the left, its 26 and GND pins in the top row. Wire 1, green, goes from the hole next to pin 26 to row 24. The 220 ohm resistor bridges row 24 and row 28. The LED's long leg, the anode, marked plus, sits in row 28; its short leg, the cathode, in row 29. Wire 2, black, goes from row 29 back to the hole next to a GND pin. Below, the same circuit as a schematic: GPIO 26, 220 ohm resistor, LED, ground; about 6 mA flows when the pin is HIGH at 3.3 V. FIG. 8 — LED ON GPIO 26+−−+jihgfedcba15101520242832ENBOOT5VCMDD3D213GND121427262533323534VNVPEN3V3220 Ω+LED121green: GPIO 26 → row 242black: row 29 → GNDLED: long leg (+, anode) in row 28 · short leg (−, flat side) in row 29.Holes f to j of one numbered row are joined inside: parts in the same row connect.Wire with the board unplugged.The same circuit as a schematicGPIO 26220 ΩI(3.3 − 2) ÷ 220≈ 0.006 A = 6 mAHIGH = 3.3 V
Tap the diagram to open it full screen.

In the IDE, go to File > New Sketch (or simply use the empty one) and replace everything with this:

// Tinker Mission, lesson K1: Blink an external LED
// Wiring: GPIO 26 -> 220 ohm resistor -> LED long leg (anode); LED short leg (cathode) -> GND

const int LED_PIN = 26;   // the pin the LED is wired to

void setup() {
  // Runs once, when the board powers up or is reset.
  pinMode(LED_PIN, OUTPUT);   // this pin sends signals out
}

void loop() {
  // Runs again and again, forever.
  digitalWrite(LED_PIN, HIGH);  // pin at 3.3 V: LED on
  delay(500);                   // wait 500 ms (half a second)
  digitalWrite(LED_PIN, LOW);   // pin at 0 V: LED off
  delay(500);
}

Download the sketch folder (.zip)

Read it like a recipe:

  • const int LED_PIN = 26; gives the number 26 a name, so the rest of the code says what it means. If you move the wire later, you change one line [12].
  • pinMode(LED_PIN, OUTPUT); tells the board that this pin will send signals out [12].
  • digitalWrite(LED_PIN, HIGH); puts the pin at its high voltage, which is 3.3 V on the ESP32 [17], and the LED lights up. LOW brings it back to 0 V and the LED goes dark [12].
  • delay(500); makes the board wait 500 milliseconds. There are 1000 milliseconds in a second [12]. While it waits, the board does nothing else [15].

What setup() and loop() do. Every sketch needs these two functions [12]. setup() runs once, when the board starts or is reset. It is the place to prepare things, such as pin modes [13]. loop() runs again and again, as long as the board has power. It is where your program does its actual work [13].

The setup/loop wheel
The setup/loop wheel Interactive. On the left, the Blink sketch with the line that runs now highlighted. On the right, setup() sits outside a wheel: it runs once. The wheel holds the four lines of loop(): pin 26 HIGH, wait 500 ms, pin 26 LOW, wait 500 ms, then back to the top, forever. The centre shows the LED state and the pin voltage for each step. Use Step to advance one line at a time. FIG. W1 — SETUP() ONCE, LOOP() FOREVERconst int LED_PIN = 26;void setup() {  pinMode(LED_PIN, OUTPUT);}void loop() {  digitalWrite(LED_PIN, HIGH);  delay(500);  digitalWrite(LED_PIN, LOW);  delay(500);}setup()runs onceafter power-onor resetHIGH500 msLOW500 msloop() runs again and againLED offGPIO 26 = 0 VThe board starts (power on or reset).loop() pass: 0

Swipe the drawing sideways to see all of it.

The board starts (power on or reset).


Step 7: Upload

  1. Click the verify button (the checkmark). The IDE checks your code and builds it without sending anything. Errors, if any, appear in the console at the bottom [4].
  2. Click the upload button (the right arrow). The IDE builds the code again and sends it to the board [4].
  3. Watch the console. When the upload starts it prints Connecting followed by a row of dots [8]. When it finishes, a message pops up at the bottom right of the IDE [4], and the LED starts blinking.

If the dots keep going and the upload fails. Nothing is broken. The ESP32 has to be put into a special listening state called download mode before it accepts new code. Many boards do this on their own. When yours does not, you do it with the buttons [5][6]:

  • Easy way: hold down the BOOT button while the upload runs [6].
  • Manual way: hold BOOT, press EN (the reset button) once, then release BOOT. On Espressif’s DevKitC, holding BOOT while pressing EN is exactly what starts download mode [7]. Then start the upload [5].

Inside the chip, BOOT works by pulling a pin called GPIO 0 down to 0 V while the chip restarts [6][9].

Still failing? Look at the table at the end of this lesson.

Upload, and what to do if it hangs at Connecting Three panels. Panel 1: after clicking upload, the console prints Connecting followed by dots; the dots mean the computer is still trying to reach the chip. Panel 2, the easy way: hold the BOOT button down while the upload runs. Panel 3, the manual way: hold BOOT, press EN once, then release BOOT; the chip is now in download mode, start the upload. FIG. 9 — UPLOAD1uploadOutputSerial port COM3Connecting......dots = still tryingIf it ends in “Failed to connect”,use the BOOT button →2Easy wayENBOOTHold BOOT duringthe whole upload.3Manual wayENBOOT211hold BOOT2press EN once3release BOOT, upload
Tap the diagram to open it full screen.

Step 8: Say hello with the Serial Monitor

A blinking LED shows that something runs. The Serial Monitor lets the board talk back, with words and numbers on your screen. It is also your best tool for finding out what your code is really doing.

Replace the sketch with this one and upload it:

// Tinker Mission, lesson K1: say hello to the Serial Monitor
// Open the Serial Monitor and set it to 115200 baud.

int counter = 0;   // a place to store a number

void setup() {
  Serial.begin(115200);   // start the serial link at 115200 bits per second
}

void loop() {
  Serial.print("Hello from my ESP32! Count: ");
  Serial.println(counter);   // print the number, then go to a new line
  counter = counter + 1;     // add one
  delay(1000);               // wait one second
}

Download the sketch folder (.zip)

Now open the Serial Monitor with the button at the top right of the IDE. It opens as a tab in the bottom panel [14]. Look for the baud rate setting there and choose 115200 [14].

Baud rate is the speed of the conversation, in bits per second [11]. Both sides must use the same one. The ESP32’s default console speed is 115200 [5], which is why our sketch says Serial.begin(115200). You should see a new line every second, counting up.

Right after a reset, you may also see some extra text before your own lines. That is the chip’s start-up report, printed at the same 115200 speed [9].

Serial Monitor at 115200 baud Simplified drawing of the bottom panel of the IDE with the Serial Monitor tab open. Lines read Hello from my ESP32! Count: 0, then 1, then 2, one per second. At the bottom right, the baud rate drop-down is set to 115200 baud, circled; an arrow links it to the line Serial.begin(115200) in the sketch: both must match, or you see strange symbols. FIG. 10 — SERIAL MONITORin your sketchSerial.begin(115200);Serial Monitor buttontop right of the IDEOutputSerial Monitor ×Message (Enter to send)New Line115200 baudHello from my ESP32! Count: 0Hello from my ESP32! Count: 1Hello from my ESP32! Count: 2…one new line every secondBoth must say 115200, or you see strange symbols.must match
Tap the diagram to open it full screen.

When something goes wrong

Take it one row at a time, and change one thing before you try again.

What you see Likely reason What to try
No port in the list, or the port appears and disappears Charge-only cable, missing driver, or a worn port Use another cable that carries data. Try another USB port on the computer, plugged in directly rather than through a hub. Install the driver for your bridge chip (CP210x or CH340, see Step 3). Unplug and replug [5][6][10]
“Permission denied” on the port (Linux) Your user account is not allowed to use the serial port Add yourself to the dialout group: sudo usermod -a -G dialout $USER (on Arch Linux the group is uucp). Then log out and back in for it to apply [4][5]
“Failed to connect” or “Timed out waiting for packet header” The board did not enter download mode, or the link is poor Hold BOOT during upload. Change the cable and the USB port. Disconnect anything wired to the TX and RX pins. Close any other program that has the port open, such as another serial terminal [6][9]
Upload starts, then stops with random errors part-way Unstable link or a weak power supply Use a shorter, good-quality cable. Avoid hubs. Plug into a port on the computer itself [9]
Compile errors mention the wrong board, or the code builds but nothing works as expected Wrong board selected Check Tools > Board and pick ESP32 Dev Module (or the entry named for your chip). The board package is what translates your code for one specific chip, so a mismatch matters [3][6]
Serial Monitor shows strange symbols Baud rate mismatch Set the monitor to 115200 to match Serial.begin(115200) [11]
Serial Monitor shows nothing at all Your board has two USB sockets, or the monitor is attached to another port Press EN once to restart the sketch while the monitor is open. On boards with a UART socket and a separate native USB socket, use the right socket and setting. The classic ESP32 DevKitC has just the UART one [6]
The IDE says the port is busy Another program holds the port Close other serial monitors or terminals, then retry [9]

No board yet? Try a simulator

If your board has not arrived, you can still practise the ideas of this lesson in an online ESP32 simulator called Wokwi: https://wokwi.com/. It runs in the browser, so there is nothing to install. It is a good way to try the Blink sketch before touching any wire.


Check yourself

Three short questions. Nothing is saved, take your time.

  1. How many times does the code inside setup() run after you power up the board?

    • Once
    • Over and over
    • Once per second
    Show the answer

    Once. setup() runs a single time, at power-up or after a reset; loop() is the part that repeats [13].

  2. You open the Serial Monitor and see a stream of strange symbols instead of your text. What is the most likely cause?

    • The LED is on the wrong pin
    • The baud rate in the Serial Monitor does not match the one in the sketch
    • The resistor is too small
    Show the answer

    The baud rate in the Serial Monitor does not match the one in the sketch. Both sides of a serial link must use the same speed. If they differ, the receiver sees garbage [11]. Our sketch uses 115200, so the monitor must say 115200 too [5].

  3. The upload stays stuck at "Connecting......" and ends in "Failed to connect". What do you try first?

    • Rewrite the sketch from scratch
    • Try another USB cable that carries data and hold the BOOT button during the upload
    • Install a second copy of the IDE
    Show the answer

    Try another USB cable that carries data and hold the BOOT button during the upload. Some cables only charge and carry no data, and on some boards you must hold BOOT while uploading [6].


Sources

Show the 17 sources
  1. Espressif, Arduino-ESP32 documentation, “Installing” (the stable Boards Manager URL, https://espressif.github.io/arduino-esp32/package_esp32_index.json; add it in Preferences under “Additional Boards Manager URLs”; install the esp32 platform; restart the IDE) — https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html
  2. Arduino, “Downloading and installing the Arduino IDE 2” (system requirements; install steps for Windows, macOS and Linux; AppImage and FUSE) — https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/
  3. Arduino, “Installing a board package in the IDE 2” (what a board package is; Boards Manager icon, search, INSTALL; version tag) — https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-board-manager/
  4. Arduino, “How to upload a sketch with the Arduino IDE 2” (verify and upload buttons; board drop-down; Tools > Board and Tools > Port; the “Permission denied” fix on Linux) — https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-uploading-a-sketch/
  5. Espressif, ESP-IDF Programming Guide, “Establish Serial Connection with ESP32” (USB-to-UART drivers for CP210x and FTDI; driver normally bundled with the OS; finding the port on Windows, Linux and macOS; dialout/uucp group; default console baud 115200; manual download mode) — https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/establish-serial-connection.html
  6. Espressif, Arduino-ESP32 documentation, “Troubleshooting” (charge-only cables; “Failed to connect… Timed out waiting for packet header”; hold BOOT while uploading; download mode and GPIO 0; board not detected; ESP32 Dev Module; bridge name such as Silicon Labs CP210x) — https://docs.espressif.com/projects/arduino-esp32/en/latest/troubleshooting.html
  7. Espressif, ESP32-DevKitC V4 User Guide (Micro-USB port; power LED; BOOT and EN buttons; USB-to-UART bridge; breadboard use) — https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32/esp32-devkitc/user_guide.html
  8. Espressif, esptool documentation, “Flashing firmware” (example output with “Connecting………” while the tool reaches the chip) — https://docs.espressif.com/projects/esptool/en/latest/esp32/esptool/flashing-firmware.html
  9. Espressif, esptool documentation, “Troubleshooting” (bootloader won’t respond; permissions and other programs holding the port; unstable cables and hubs; boot log at 115200; GPIO 0 held low enters the serial bootloader) — https://docs.espressif.com/projects/esptool/en/latest/esp32/troubleshooting.html and https://docs.espressif.com/projects/esptool/en/latest/esp32/advanced-topics/boot-mode-selection.html
  10. SparkFun, “How to Install CH340 Drivers” (CH340 is a USB-to-serial chip made by WCH; found on development boards; driver files and steps) — https://learn.sparkfun.com/tutorials/how-to-install-ch340-drivers
  11. SparkFun, “Serial Communication” (baud rate; both sides must match; mismatch produces garbage; 115200 as a common rate) — https://learn.sparkfun.com/tutorials/serial-communication
  12. Arduino, “Arduino Sketches” (a sketch is a program; setup() and loop(); pinMode, digitalWrite, delay; milliseconds) — https://docs.arduino.cc/learn/programming/sketches/
  13. Arduino, “BareMinimum” example (setup() runs once after power-up or reset; loop() repeats) — https://docs.arduino.cc/built-in-examples/basics/BareMinimum/
  14. Arduino, “Using the Serial Monitor tool” (IDE 2 Serial Monitor button at top right, tab in the bottom panel, baud rate setting) — https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-serial-monitor/
  15. Arduino, “Blink” example (long leg anode, short leg cathode to GND; resistor in series; delay() stops everything else for that time) — https://docs.arduino.cc/built-in-examples/basics/Blink/
  16. Espressif, Arduino-ESP32 documentation, “GPIO” (GPIO = general-purpose input/output; pinMode, digitalWrite) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/gpio.html
  17. Adafruit, “Adafruit HUZZAH32 ESP32 Feather: Pinouts” (the ESP32 runs on 3.3 V power and logic; GPIO pins are not 5 V safe unless stated otherwise) — https://learn.adafruit.com/adafruit-huzzah32-esp32-feather/pinouts

Pinch or double-tap to zoom, swipe to change diagram.Scroll with Ctrl or double-click to zoom. Arrow keys change diagram.