Back to Subject

Unit 1: Getting started with NodeMCU

ECE237 — Architecting Smart Iot Devices 11 min read

I. Orientation — Embedded Wi-Fi control with the ESP8266

NodeMCU is an open-source development platform commonly built around the ESP8266EX Wi-Fi microcontroller. It combines a programmable processor, wireless networking, digital input/output, serial communication, and power-regulation circuitry on a small development board. Programs are normally written using the Arduino IDE, PlatformIO, or Lua-based NodeMCU firmware and transferred through a USB-to-serial interface.

  • Governing principle: A microcontroller reads electrical signals from sensors, processes them in firmware, and produces outputs for actuators such as LEDs, relays, and motors.
  • Logic convention: ESP8266 GPIO pins operate at approximately 3.3 V; a 5 V signal can damage the input.
  • Programming convention: Firmware is uploaded through a serial bootloader using the USB-to-UART bridge.
  • Pin convention: Board labels such as D1 are aliases for ESP8266 GPIO numbers; for example, NodeMCU D1 normally maps to GPIO5.
  • Electrical convention: GPIO pins are not power supplies for high-current loads. A separate transistor, MOSFET, relay driver, or motor driver is required for such loads.
  • Boot constraint: Certain pins, especially GPIO0, GPIO2, and GPIO15, must have suitable logic levels during reset for normal boot.
  • Timing convention: Digital signals are binary states, while analog signals vary continuously and must be converted using an ADC.

II. NodeMCU Board and supported peripherals — Hardware foundation

The NodeMCU board provides a convenient interface to the ESP8266 by adding USB connectivity, voltage regulation, reset controls, and accessible header pins. The exact pin count and flash capacity can vary among NodeMCU versions, but the ESP-12E or ESP-12F style board is the common form.

A. NodeMCU Board and supported peripherals

This subsection identifies the main hardware blocks and the peripherals that can be connected to the board.

  • Microcontroller: The ESP8266EX contains a 32-bit Tensilica L106 processor commonly clocked at 80 MHz or 160 MHz, with integrated 2.4 GHz Wi-Fi.
  • Operating voltage: The ESP8266 core and GPIO logic use 3.3 V, normally supplied by an onboard regulator from the USB 5 V input.
  • USB interface: A USB-to-UART chip, often CH340 or CP2102, converts computer USB data into 3.3 V serial signals for programming and monitoring.
  • Digital GPIO: GPIO pins can be configured as inputs or outputs. Typical exposed aliases include:
    • D0 = GPIO16
    • D1 = GPIO5
    • D2 = GPIO4
    • D3 = GPIO0
    • D4 = GPIO2, commonly connected to the onboard LED
    • D5 = GPIO14
    • D6 = GPIO12
    • D7 = GPIO13
    • D8 = GPIO15
  • Analog input: A0 connects to the ESP8266 ADC. The bare ESP8266 ADC range is generally 0–1.0 V; many NodeMCU boards add a voltage divider so the board pin can accept approximately 0–3.3 V. The specific board schematic must be checked.
  • Serial peripheral: UART supports communication with computers, GPS modules, GSM modules, and other microcontrollers. Upload communication normally uses TX and RX.
  • SPI peripheral: SPI is suitable for displays, SD cards, Ethernet controllers, and radio modules. It uses clock, data, and chip-select signals.
  • I²C peripheral: I²C supports sensors, RTC modules, and IO expanders using two shared lines: SDA for data and SCL for clock. On Arduino-style ESP8266 projects, D2 and D1 are commonly used as SDA and SCL, respectively.
  • PWM output: Software-controlled PWM can vary LED brightness or motor-driver input duty cycle. A duty cycle of 50% means the output is high for half of each period.
  • Interrupt capability: Many GPIO pins can trigger an interrupt on a rising edge, falling edge, or change of state, useful for buttons and pulse sensors.
  • Peripheral limitations: GPIO6–GPIO11 are generally connected internally to flash memory and should not be used as ordinary GPIO. GPIO16 has special limitations and does not support every peripheral or interrupt feature.

III. Setting up nodemcu — Preparing the development environment

Setting up nodemcu requires installing the software tools, selecting the correct board profile, and confirming that the computer can access the board’s serial port.

A. Setting up nodemcu

This subsection explains the basic sequence for preparing a NodeMCU board for Arduino-based programming.

  • Hardware connection: Connect the NodeMCU to the computer with a USB cable that supports data transfer; charge-only cables cannot upload firmware.
  • Driver installation: Install the driver for the board’s USB-UART chip, such as the CH340 or CP210x driver, when the operating system does not recognize the device.
  • Board package: In Arduino IDE, add the ESP8266 board package through the Board Manager and select an ESP8266-compatible board, commonly NodeMCU 1.0 (ESP-12E Module).
  • Port selection: Select the serial port that appears when the board is connected. On Windows this may be COM3 or COM4; on Linux it may appear as /dev/ttyUSB0 or /dev/ttyUSB1.
  • Upload settings: Common working settings include a baud rate of 115200, flash mode DIO, and a suitable flash-size selection such as 4MB, depending on the board.
  • Library management: Install libraries for attached devices, such as an OLED library or a temperature-sensor library, through the IDE’s library manager.
  • Initial verification: Upload the standard Blink program and observe the onboard LED, often attached to D4. Because that LED may be active-low, writing LOW can turn it on and HIGH can turn it off.
  • Power requirement: USB normally supplies adequate current for the board, but Wi-Fi transmission can create short current peaks. An unstable USB hub or weak regulator may cause resets.

IV. Serial port programming — Transferring and observing firmware

Serial port programming uses the UART bootloader to transfer compiled firmware from a computer to the ESP8266. The same serial connection can display runtime messages through the Serial Monitor.

A. Serial port programming

This subsection describes the upload process and the essential serial settings.

  • Bootloader entry: During reset, the ESP8266 checks boot-strap pins. With the appropriate GPIO0 state, it enters UART download mode and accepts new firmware.
  • Automatic reset: Most NodeMCU boards use control signals from the USB-UART chip to toggle reset and GPIO0, so the IDE can enter programming mode automatically.
  • Compilation process: The IDE converts source code into machine code, links required libraries, and creates a binary image before uploading it through the selected port.
  • Serial wiring: UART data is crossed between devices: the computer-side transmitter reaches the ESP8266 receiver, and the ESP8266 transmitter reaches the computer-side receiver.
  • Baud matching: The Serial Monitor must use the same baud rate as the program. For example:
CPP
void setup() {
  Serial.begin(115200);
  Serial.println("NodeMCU ready");
}

void loop() {
  delay(1000);
}

Here, 115200 is the number of serial symbols transmitted per second.

  • Upload versus runtime output: Uploading uses the bootloader protocol; after reset, user code can use Serial.print() for diagnostics. These are related but distinct stages.
  • Common failures: “Port not found” usually indicates a driver, cable, or selection problem; “Timed out waiting for packet header” often indicates boot-mode, reset, or power trouble.
  • Pin conflict: Using the hardware UART pins for external circuitry can interfere with uploading or logging. Disconnect devices that drive RX during programming when necessary.
  • Message discipline: Add clear labels and line endings to diagnostic output, such as Serial.println("sensor timeout");, so events can be distinguished in the monitor.

V. Configuring general purpose input output pins as output — Driving digital devices

An output GPIO actively drives a logic level onto a connected circuit. The firmware must configure the pin before writing to it, and the connected load must remain within the pin’s current and voltage limits.

A. Configuring general purpose input output pins as output

This subsection explains how a GPIO output is initialized and controlled.

  • Pin initialization: Use pinMode(pin, OUTPUT) in setup() so the pin is configured before the main loop begins.
  • Logic states: digitalWrite(pin, HIGH) produces a level near 3.3 V; digitalWrite(pin, LOW) produces a level near 0 V.
  • Example operation: The following program flashes an LED connected to D1 through a suitable resistor:
CPP
const int LED_PIN = D1;

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

Here, LED_PIN identifies D1, and 500 represents 500 ms.

  • LED protection: A typical indicator LED requires a series resistor, such as 220 ohms to 1 kOhm, to limit current. Connecting an LED directly can overload the GPIO.
  • Active-low devices: A relay module or onboard LED may turn on when its input is LOW. The electrical action must therefore be checked rather than assumed from the word HIGH.
  • Current limitation: GPIO outputs are intended for small loads. Motors, lamps, solenoids, and relay coils require a driver stage with a flyback diode where inductive loads are present.
  • Startup behavior: Some pins briefly change state during reset or boot. Avoid placing a critical actuator on a boot-sensitive pin unless its startup behavior is controlled.
  • PWM distinction: digitalWrite() selects only two states. Brightness or speed control requires PWM, for example using analogWrite(), where the duty cycle determines the average delivered power.

VI. Configuring general purpose input output pins as input — Reading digital states

An input GPIO senses whether an external voltage is interpreted as logic low or logic high. A stable external bias is necessary; an unconnected input can randomly alternate because it is floating.

A. Configuring general purpose input output pins as input

This subsection shows how switches and digital sensors are connected and read reliably.

  • Input initialization: Use pinMode(pin, INPUT) when an external circuit supplies a defined logic level.
  • Internal pull-up: INPUT_PULLUP connects a weak internal resistor to 3.3 V, allowing a switch to connect the pin to ground:
CPP
const int BUTTON_PIN = D2;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Serial.begin(115200);
}

void loop() {
  if (digitalRead(BUTTON_PIN) == LOW) {
    Serial.println("Pressed");
  }
  delay(50);
}

Here, LOW means the button is closed because the switch pulls D2 to ground.

  • External pull-down: A resistor connected from the input to ground establishes LOW when the switch is open; the switch then connects the input to 3.3 V for HIGH.
  • Input interpretation: digitalRead(pin) returns HIGH or LOW, not a voltage measurement. Use analogRead(A0) when the magnitude of a varying signal is required.
  • Debouncing: Mechanical contacts may produce several rapid transitions. A delay such as 50 ms, a time-based filter using millis(), or hardware debouncing prevents one press from being counted repeatedly.
  • Voltage safety: Never apply 5 V directly to an ESP8266 GPIO. Use a resistor divider, level shifter, or compatible 3.3 V sensor interface.
  • Interrupt use: For fast events, an interrupt can respond to an edge without repeatedly polling. The interrupt service routine should remain short and avoid slow serial operations.
  • Boot-sensitive inputs: A switch connected to GPIO0, GPIO2, or GPIO15 can prevent normal boot if it forces an incorrect level during reset.

VII. Comparison of ESP8266 and ESP32 — Choosing the controller

ESP32 is the newer and generally more capable family, while ESP8266 remains useful for simple, low-cost Wi-Fi devices. The correct choice depends on peripheral requirements, power budget, software support, and project complexity.

A. Comparison of ESP8266 and ESP32

This subsection contrasts the two families using practical hardware and programming criteria.

  • Processing capability:
    1. ESP8266: Usually a single-core 32-bit processor at 80/160 MHz, suitable for basic sensing, web servers, and MQTT clients.
    2. ESP32: Common variants provide dual-core Xtensa processors around 160–240 MHz; some newer variants use different cores. Extra processing capacity benefits encryption, multitasking, and signal processing.
  • Wireless features:
    1. ESP8266: Integrated 2.4 GHz Wi-Fi.
    2. ESP32: Integrated 2.4 GHz Wi-Fi plus Bluetooth support, commonly Bluetooth Classic and Bluetooth Low Energy on original ESP32 devices.
  • GPIO and analog capability: ESP32 boards generally expose more GPIO, more ADC channels, DAC outputs on many original ESP32 variants, touch sensing, and additional hardware peripherals. ESP8266 commonly offers one ADC input and fewer practical GPIO pins.
  • Communication interfaces: Both support UART, SPI, and I²C through hardware or software configuration, but ESP32 usually provides more UART controllers, PWM channels, and flexible peripheral routing.
  • Memory and application scope: ESP32 modules commonly offer more RAM and flash options, making them better suited to local web interfaces, Bluetooth applications, displays, and larger protocol stacks.
  • Power management: Both support sleep modes. ESP32 generally provides a broader set of low-power and wake-up options, but actual battery life depends on board regulator losses, peripherals, Wi-Fi duty cycle, and firmware.
  • Cost and simplicity: ESP8266 boards are often cheaper and adequate when one Wi-Fi link and a small number of GPIO lines are sufficient. ESP32 costs slightly more but provides greater expansion capacity.
  • Compatibility caution: GPIO numbering, ADC behavior, boot pins, and library support differ between families. Code written for D1, D2, or ESP8266-specific APIs should not be assumed to work unchanged on an ESP32 board.
  • Selection rule: Choose ESP8266 for compact Wi-Fi sensing or control with modest peripherals; choose ESP32 when Bluetooth, multiple analog channels, higher processing capacity, or many simultaneous interfaces are required.
Next
Unit 2