ESP32 DevKit Architecture, Pinout, and Programming Practice

Comprehensive practice flashcards covering the ESP32 DevKit v1 board layout, internal chip specs, power pins, GPIO features, ADC/DAC/PWM peripherals, serial communication (UART, I2C, SPI), Arduino IDE configuration, and LED blink programming.

ESP32-WROOM-32 Module

The silver metal-cased module at the center of the ESP32 DevKit board containing the core processor, memory, and primary supporting components.

Espressif Systems

The semiconductor company that designs and manufactures the main ESP32 chip.

ESP32-D0WD

The specific dual-core ESP32 chip model housed beneath the metal shield of the module (also referenced as the ESP32-T0WD).

RF Shield

The metal enclosure covering the module that blocks electromagnetic interference to provide cleaner signals and prevent the chip from broadcasting unwanted radio emissions.

Heat Sink (Metal Enclosure)

The metal shield acting as a thermal radiator to absorb and dissipate heat generated when the chip runs Wi-Fi and Bluetooth.

System on a Chip (SoC)

An integrated circuit that consolidates multiple computing systems—including processors, memory, radio transceivers, and peripherals—onto a single silicon die.

Microcontroller Unit (MCU)

A small computer on a single integrated circuit specifically engineered to monitor, interface with, and control external electronic hardware.

Dual-Core Processor

A 32-bit computing architecture capable of clocking up to $240\,\text{MHz}$, enabling concurrent multitasking such as processing Wi-Fi traffic on one core while executing user program code on the other.

Internal SRAM

The $520\,\text{KB}$ of high-speed static random-access memory built into the ESP32 chip used for active runtime instructions and variable storage.

Onboard Flash Memory

The $4\,\text{MB}$ non-volatile storage chip enclosed inside the module used to permanently store compiled program firmware and files.

Micro-USB / USB-C Port

The physical connector on the development board that delivers electrical power from a computer or adapter and serves as the data highway for uploading code.

LDO Voltage Regulator

The onboard power regulator that steps down incoming $5\,\text{V}$ from USB or external inputs safely to $3.3\,\text{V}$ to protect the ESP32 chip from voltage damage.

EN Button

The physical enable/reset push button that momentarily pulls the EN pin low to reboot the ESP32 and restart firmware execution from the beginning.

BOOT Button

A push button that, when held down during reboot or power-up, forces the ESP32 into bootloader mode to permit manual firmware flashing.

Bootloader Mode

A specialized operating state where the chip halts program execution and listens across serial lines to accept and write a newly compiled sketch into flash memory.

Automatic Bootloader Circuit

An onboard circuit where the USB-to-UART bridge automatically manipulates GPIO $0$ and the EN pin to enter bootloader mode without manual button pressing.

USB-to-UART Bridge

A dedicated translator IC that converts USB communication from a computer into asynchronous serial UART signals readable by the ESP32.

CP2102

A widely used USB-to-UART bridge controller chip manufactured by Silicon Labs located near the USB port on many ESP32 DevKit boards.

CH340

A common alternative USB-to-serial interface chip utilized by third-party ESP32 development boards.

CH9102

A USB-to-UART bridge converter chip found on select modern ESP32 boards requiring its own specific operating system driver.

Silicon Labs CP210x Universal Windows Driver

The official driver package required by Windows PCs to recognize CP2102-equipped ESP32 boards as valid COM communication ports.

VIN Pin

The external power input pin that accepts voltages typically between $5\,\text{V}$ and $12\,\text{V}$ (ideally $5\,\text{V}$ to $7\,\text{V}$) and directs them through the onboard voltage regulator.

3V3 Pin

A power pin providing a clean, regulated $3.3\,\text{V}$ output to drive external sensors, or capable of taking an external regulated $3.3\,\text{V}$ input directly.

GND Pins

Ground pins that establish the common zero-volt reference point for all power supplies, sensors, and electronic signals in a circuit.

General Purpose Input/Output (GPIO)

Flexible digital pins on the microcontroller that software can configure either to read electrical input states or to drive electrical output signals.

Total Chip GPIO Count

The $34$ programmable GPIO pins present on the physical silicon of the ESP32 chip (out of $48$ total pins on the raw die).

Broken-Out DevKit Pins

The approximately $30$ header pins routed out from the chip to the physical edges of the DevKit v1 board, yielding about $25$ directly usable GPIOs.

Input-Only GPIOs

Pins GPIO $34$, $35$, $36$, $37$, $38$, and $39$, which lack internal output driver circuitry and can only be used to read inputs.

Strapping Pins

Special pins—including GPIO $0$, $2$, $5$, $12$, and $15$—whose voltage levels are sampled during power-up to determine how the chip boots.

GPIO 0

A critical strapping pin that forces the ESP32 into ROM bootloader mode when held low at startup, or into normal SPI flash boot mode when held high.

Boot Glitch Pins

Pins such as GPIO $1$, $3$, $5$, $14$, and $15$ that can briefly fluctuate high or output a PWM signal during startup, posing risks if connected to relays.

GPIO Interrupts

A hardware feature supported by all ESP32 GPIOs that permits the processor to pause main execution instantly and respond to an external signal transition.

GPIO Expansion Board

An accessory board recommended to replace loose jumper breadboard connections and safeguard sensitive strapping pins from accidental voltage fluctuations.

Analog-to-Digital Converter (ADC)

An internal peripheral that measures a continuous analog voltage between $0\,\text{V}$ and $3.3\,\text{V}$ and translates it into a discrete digital number.

12-Bit ADC Resolution

The quantization precision of the ESP32 ADC that partitions analog readings into $4,096$ steps, representing voltages as numbers from $0$ to $4,095$.

ADC1

The primary ADC unit with $8$ channels mapped across GPIOs $32$ through $39$, capable of operating without interference when Wi-Fi is transmitting.

ADC2

The secondary ADC controller featuring $10$ channels on GPIOs $0$ to $4$, $12$ to $15$, and $25$ to $27$, which shares hardware with the Wi-Fi subsystem.

Wi-Fi ADC Limitation

A hardware constraint where ADC2 cannot take accurate analog measurements whenever the Wi-Fi radio is engaged, requiring projects with Wi-Fi to use ADC1 pins.

Arduino Uno ADC Comparison

A standard Arduino Uno features a $10\text{-bit}$ ADC ($0$ to $1,023$), making the ESP32's $12\text{-bit}$ ADC ($0$ to $4,095$) four times more precise.

Pulse Width Modulation (PWM)

A control technique that rapidly toggles an output between fully on and fully off to simulate intermediate voltages for LED dimming, motor speed, or tone generation.

Duty Cycle

The ratio or percentage of active high time during one full period of a PWM pulse train, dictating the average power delivered to a device.

PWM Channels

The $16$ independent hardware channels on the ESP32 that can be mapped in software to generate PWM signals on almost any GPIO pin.

Digital-to-Analog Converter (DAC)

An integrated peripheral that performs the inverse of an ADC by transforming digital integer values into true, smooth analog voltages between $0\,\text{V}$ and $3.3\,\text{V}$.

ESP32 DAC Pins

The two dedicated hardware digital-to-analog output pins located on GPIO $25$ and GPIO $26$.

8-Bit DAC Resolution

The bit depth of the ESP32 DAC, which produces $256$ distinct analog voltage steps between $0\,\text{V}$ and $3.3\,\text{V}$ for tasks like basic audio synthesis.

Capacitive Touch Sensing

A built-in detection mechanism on $10$ GPIO pins that registers minute changes in electrical charge caused by the presence or touch of a human finger.

Touch Button

A simple user interface input fabricated merely by connecting a bare wire to any touch-enabled GPIO, requiring no extra mechanical switches.

Universal Asynchronous Receiver-Transmitter (UART)

A serial communication protocol using independent transmit (TX) and receive (RX) wires to exchange data asynchronously without a synchronizing clock line.

Baud Rate

The predetermined data transmission rate in symbols or bits per second agreed upon by both communicating UART devices.

UART0

The default hardware UART interface wired directly to the USB-to-serial converter, used primarily for code uploads and Serial Monitor debugging.

UART1

The secondary hardware UART peripheral, mapped internally by default to GPIO $9$ and $10$, often reassigned in software to avoid onboard flash pins.

UART2

The third independent hardware UART peripheral available for connecting external serial modules like GPS units or GSM modems.

UART Pin Remapping

The internal multiplexing capability of the ESP32 allowing serial TX and RX lines to be assigned in code to alternative GPIO pins, such as RX to GPIO $16$ and TX to GPIO $17$.

Inter-Integrated Circuit (I2C)

A synchronous two-wire serial bus enabling a master device to communicate with multiple addressed peripheral devices using only data and clock lines.

SDA (Serial Data)

The bidirectional data wire in an I2C communication interface over which bits are sent and received.

SCL (Serial Clock)

The synchronizing clock line in an I2C communication interface driven by the master device to coordinate data timing.

Default I2C Pins

The standard factory-assigned pins on the ESP32 for I2C communication: GPIO $21$ for SDA and GPIO $22$ for SCL.

Serial Peripheral Interface (SPI)

A high-speed, four-wire synchronous communication standard optimal for high-bandwidth peripherals like SD card modules and TFT display screens.

Default SPI Pins

The common hardware GPIO pins allocated for primary SPI communication on the ESP32: GPIO $23$, GPIO $19$, GPIO $18$, and GPIO $5$.

Hardware SPI Controllers

The two dedicated, high-speed SPI interfaces provided by the ESP32 architecture for demanding display and memory communication.

Arduino IDE 2.3.10

The modern major release of the Arduino Integrated Development Environment highlighted in the tutorial for configuring and flashing ESP32 projects.

Arduino IDE 1.8.19

The legacy, stable version of the Arduino IDE mentioned as an alternative software platform for programming the ESP32.

Additional Boards Manager URLs

The preferences configuration field in Arduino IDE where users paste Espressif's repository link to enable the installation of ESP32 board packages.

ESP32 Board Package 2.0.10

The older, stable official Espressif board support package version selected and installed via the Boards Manager in the programming lesson.

ESP32 Dev Module

The standard target board profile selected within the Arduino IDE board menu for programming original ESP32 DevKit development boards.

ESP32 SoC Family Variations

Distinct processor lines within the ESP32 family—including the ESP32-S3, ESP32-C3, and ESP32-C6—that require specific individual board selections.

USB Data Cable

A USB cable containing dedicated internal data lines (D+ and D-), required for sketch uploading, unlike power-only charging cables.

COM Port

The serial communications port identifier assigned by the Windows operating system to the connected ESP32 board.

Windows Device Manager

The operating system management console used to identify connected USB-to-UART bridge controllers and manually install or update device drivers.

setup() Function

The initialization function in an Arduino sketch that executes exactly once when the ESP32 starts or resets, used for configuring pins and starting peripherals.

loop() Function

The primary execution block in an Arduino sketch that runs repeatedly in an endless loop as long as the ESP32 remains powered.

Built-In Programmable LED

An onboard status LED pre-wired to a specific GPIO pin on some development boards, whose exact pin mapping is not standardized across vendors.

GPIO 4 (Tutorial Circuit)

The specific digital pin selected in the tutorial to connect to the positive terminal of an external LED on a breadboard.

Current-Limiting Resistor

A passive component wired in series between an ESP32 output pin and an external LED to restrict current flow and avoid burning out the LED or chip.

pinMode() Function

The Arduino programming function used to assign a specific pin to behave either as an input or an output.

OUTPUT Parameter

The operational mode passed into pinMode() that activates a pin's internal push-pull buffer to drive voltage high or low.

digitalWrite() Function

The Arduino function used to write an electrical state—either HIGH or LOW—to a configured digital output pin.

HIGH State

A digital state representing logic $1$, which drives an ESP32 GPIO pin to $3.3\,\text{V}$ to turn an active-high LED on.

LOW State

A digital state representing logic $0$, which pulls an ESP32 GPIO pin to $0\,\text{V}$ (ground) to turn an active-high LED off.

delay() Function

An Arduino timing function that suspends program execution for a specified duration in milliseconds, such as delay(1000) for $1,000\,\text{ms}$ ($1\,\text{second}$).