Unit 3: Output devices with NodeMCU

I. Orientation

NodeMCU is an ESP8266-based development board used to connect sensors, processing logic, and output devices in IoT systems. It operates mainly at 3.3 V logic, so output devices must be connected with correct voltage, current, and protection arrangements. The ESP8266 generates control signals through GPIO pins, while external circuits often provide the voltage or current required by displays and motors.

• Controller: The ESP8266 executes the program and produces digital signals, serial data, or pulse-width modulation (PWM).
• Logic level: GPIO HIGH is approximately 3.3 V. A 5 V signal connected directly to an ESP8266 GPIO can damage the board.
• Current limitation: A GPIO pin is intended for logic control, not for powering motors or high-current loads.
• Common ground: NodeMCU and an external supply or driver circuit must share a ground reference.
• GPIO naming: Board labels such as D1 and D2 map to ESP8266 GPIO numbers. For example, D1 commonly maps to GPIO5 and D2 to GPIO4.
• Output principle: A display receives data directly or through a driver, whereas a motor normally requires a transistor, MOSFET, or motor-driver integrated circuit.
• Software model: Arduino-style functions such as pinMode(), digitalWrite(), analogWrite(), and library-specific display functions are commonly used.

II. LCD Interfacing with NodeMCU — Character display output

An LCD provides a human-readable output for values such as temperature, device status, and network information. A standard 16 × 2 character LCD contains two rows of sixteen characters and commonly uses the HD44780-compatible interface.

A. Purpose and operating principle

The LCD controller stores characters in display memory and receives commands or character data from NodeMCU. In parallel mode, several GPIO pins are needed; in I²C mode, an adapter reduces the connection to two signal lines.

• Display size: A 16 × 2 LCD displays 16 columns and 2 rows. A 20 × 4 LCD provides 20 columns and 4 rows.
• Parallel signals: The usual pins are RS, E, and data lines D4–D7 when four-bit mode is selected.
  • RS: Register Select; LOW selects commands and HIGH selects character data.
  • E: Enable; a pulse tells the LCD to read the current data.
  • D4–D7: Four-bit data bus used to transmit one character in two groups of four bits.
• I²C adapter: A PCF8574-based backpack converts I²C data into LCD control signals, usually requiring only SDA and SCL.
• Contrast: The V0 or contrast pin is adjusted with a potentiometer, often 10 kΩ, to make characters visible.
• Electrical caution: Many LCD modules are powered at 5 V. Their I²C backpack may pull SDA or SCL up to 5 V, so a bidirectional level shifter or suitably configured 3.3 V-compatible module is required.

B. LCD interfacing with NodeMCU

LCD interfacing with NodeMCU is normally performed through an I²C backpack because it saves GPIO pins and simplifies wiring. On a typical ESP8266 NodeMCU arrangement, D2 is SDA and D1 is SCL.

• Typical I²C connections:
  • SDA: LCD backpack SDA to NodeMCU D2, GPIO4.
  • SCL: LCD backpack SCL to NodeMCU D1, GPIO5.
  • VCC: Use a supply compatible with both the backpack and its logic levels.
  • GND: Connect LCD ground to NodeMCU ground.
• I²C address: Common addresses are 0x27 and 0x3F; the actual address depends on the backpack configuration.
• Initialization: The library is initialized with the LCD address and dimensions, for example LiquidCrystal_I2C lcd(0x27, 16, 2).
• Cursor position: lcd.setCursor(column, row) uses zero-based positions, so lcd.setCursor(0, 1) selects the first character of the second row.
• Example program:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("NodeMCU Ready");
}

void loop() {
  int value = analogRead(A0);
  lcd.setCursor(0, 1);
  lcd.print("ADC: ");
  lcd.print(value);
  lcd.print("    ");
  delay(500);
}

Here, value is the integer returned by the ESP8266 analog input, and the trailing spaces erase old characters when a shorter value replaces a longer one.

C. Applications and limitations

LCDs are useful when a user must read changing text locally, but they are not ideal for high-speed graphics or very compact battery devices.

• Applications: Show sensor readings, Wi-Fi connection state, IP addresses, menus, alarms, and actuator status.
• Advantages: Text is readable, the interface is inexpensive, and I²C reduces GPIO usage from approximately six or more pins to two.
• Refresh limitation: Rapidly clearing and rewriting the whole display can cause flicker. Updating only changed positions is more efficient.
• Power requirement: The LCD backlight may consume significant current compared with the ESP8266, especially in battery-powered systems.
• Troubleshooting: A blank display often results from incorrect contrast, wrong I²C address, missing common ground, or unsafe 5 V pull-ups.

III. Seven Segment Interfacing with NodeMCU — Numeric indication

A seven-segment display represents decimal digits using seven individually controlled LED segments named a through g; an optional eighth LED, dp, provides a decimal point. It is suitable for counters, timers, voltage readings, and simple status values.

A. Purpose and operating principle

Each segment is an LED, so it must be driven with a current-limiting resistor. The display may be common cathode or common anode, and the logic required to illuminate a segment differs between the two types.

• Segment structure: The seven LEDs are arranged as a, b, c, d, e, f, and g. Lighting a, b, c, d, e, and f displays 0.
• Common cathode: All cathodes share a common connection to ground. A segment turns on when its individual anode is driven HIGH.
• Common anode: All anodes share a common connection to the positive supply. A segment turns on when its individual cathode is driven LOW.
• Current limiting: Each segment should have a resistor, commonly between 220 Ω and 1 kΩ. The resistor limits LED current according to:

R = (VGPIO - VF) / IF

R is resistance in ohms, VGPIO is the GPIO voltage, VF is the LED forward voltage, and IF is the desired segment current.

• GPIO protection: Driving all seven segments directly can use seven GPIO pins and may approach the board's total current limits. A transistor array, shift register, or display driver is preferable for larger displays.

B. Seven segment interfacing with NodeMCU

Seven segment interfacing with NodeMCU requires a correct segment map and a digit pattern that matches the display type. A common-cathode single-digit display can be controlled using seven GPIO outputs, with each segment connected through a resistor.

• Connection arrangement: Connect a–g to selected GPIO pins through separate resistors and connect the common cathode to GND.
• Pattern representation: A seven-bit pattern can be stored in an array. Each bit corresponds to one segment; the exact order must match the wiring.
• Common-cathode digit patterns: For the order a,b,c,d,e,f,g, the conceptual ON segments for digit 2 are a,b,d,e,g.
• Program example:

const uint8_t segPins[7] = {D0, D1, D2, D5, D6, D7, D8};

// Common-cathode patterns: a b c d e f g
const uint8_t digits[10][7] = {
  {1,1,1,1,1,1,0}, // 0
  {0,1,1,0,0,0,0}, // 1
  {1,1,0,1,1,0,1}, // 2
  {1,1,1,1,0,0,1}, // 3
  {0,1,1,0,0,1,1}, // 4
  {1,0,1,1,0,1,1}, // 5
  {1,0,1,1,1,1,1}, // 6
  {1,1,1,0,0,0,0}, // 7
  {1,1,1,1,1,1,1}, // 8
  {1,1,1,1,0,1,1}  // 9
};

void showDigit(uint8_t n) {
  for (int i = 0; i < 7; i++)
    digitalWrite(segPins[i], digits[n][i]);
}

Here, n is a digit from 0 to 9, and each 1 means that the corresponding common-cathode segment is driven HIGH. For common-anode displays, the output logic is inverted.

• Pin selection caution: GPIO0, GPIO2, and GPIO15 influence ESP8266 boot mode. A display connected to these pins must not force an invalid level during reset.
• Multi-digit displays: Several digits can share segment lines through multiplexing. The controller activates one digit at a time quickly enough that persistence of vision creates a continuous display.

C. Applications and limitations

Seven-segment displays provide fast numeric feedback but are less flexible than LCDs and can consume more GPIO current when many segments are illuminated.

• Applications: Display countdown values, scores, measured voltage, frequency, temperature digits, and appliance settings.
• Readability: The fixed segment shapes are highly visible from a distance, making them suitable for simple numeric panels.
• Character limitation: Letters are restricted and often ambiguous; a seven-segment display cannot present sentences or detailed menus.
• Multiplexing trade-off: Multiplexing reduces pin count but requires timed scanning. Excessively low refresh rates produce visible flicker.
• Driver option: A MAX7219 or similar driver can control multiple digits while handling segment current and multiplex timing, reducing the software and GPIO burden.

IV. Interfacing DC motor with NodeMCU — Electromechanical output

A DC motor converts electrical energy into rotational motion. Because its winding draws more current than a NodeMCU GPIO can safely supply and produces inductive voltage when switched off, it must be controlled through a driver circuit.

A. Purpose and operating principle

Interfacing a DC motor with NodeMCU means using the ESP8266 as a low-power control source while an external transistor, MOSFET, or H-bridge handles motor current. The controller determines ON/OFF state, speed, and possibly direction.

• Current separation: The motor receives power from an external supply rated for its voltage and stall current; the GPIO drives only the control input of the driver.
• Flyback protection: A motor is inductive. When current is interrupted, its stored magnetic energy creates a voltage spike. A flyback diode provides a safe current path.
• Low-side switching: An N-channel logic-level MOSFET can connect the motor's negative terminal to ground when its gate is driven HIGH.
• Gate protection: A gate resistor, such as 100–330 Ω, limits switching transients, while a 10 kΩ pulldown keeps the MOSFET OFF during reset.
• Common ground: The motor supply negative terminal and NodeMCU GND must be connected when the control signal is referenced to the NodeMCU.
• Direction control: A single transistor provides one direction. An H-bridge is required to reverse polarity and control forward/reverse motion.

B. Interfacing DC motor with NodeMCU

Interfacing DC motor with NodeMCU is commonly implemented with an L293D, L298N, TB6612FNG, or a logic-level MOSFET, depending on motor current and efficiency requirements.

• Driver connections using a typical H-bridge module:
  • IN1 and IN2: Direction-control inputs connected to two NodeMCU GPIO pins.
  • EN or PWM: Enable input receiving a PWM signal for speed control.
  • VM: Motor supply input, such as 5–12 V according to the motor rating.
  • GND: Shared ground between driver and NodeMCU.
  • OUT1 and OUT2: Driver outputs connected to the motor terminals.
• Direction logic:

IN1 = HIGH, IN2 = LOW   -> forward
IN1 = LOW,  IN2 = HIGH  -> reverse
IN1 = LOW,  IN2 = LOW   -> coast or disable
IN1 = HIGH, IN2 = HIGH  -> brake on many drivers

The exact braking behavior depends on the driver module.

• PWM speed control: analogWrite(pin, duty) varies the average motor voltage. On ESP8266 Arduino cores, the duty range is commonly 0 to 1023, although board-core settings can change this range.
• Example program:

const int IN1 = D5;
const int IN2 = D6;
const int ENA = D7;

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);
}

void loop() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  analogWrite(ENA, 700);  // duty value: 700 of 1023
  delay(3000);

  analogWrite(ENA, 0);
  delay(1000);

  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  analogWrite(ENA, 500);
  delay(3000);

  analogWrite(ENA, 0);
  delay(1000);
}

Here, ENA is the driver enable input, and values 700 and 500 represent different PWM duty levels rather than guaranteed motor speeds.

C. Applications and limitations

Motor interfacing enables physical movement, but electrical noise, startup current, and mechanical load must be considered in the design.

• Applications: Fans, pumps, wheels, conveyor mechanisms, blinds, locks, and robotic vehicles.
• Stall current: A motor may draw its highest current when starting or mechanically blocked. The driver and supply must be rated above this value.
• Noise control: Place a ceramic capacitor, commonly 0.1 µF, across motor terminals to reduce brush noise; additional supply capacitors near the driver help absorb transients.
• Voltage compatibility: A 3.3 V GPIO may not reliably drive every bipolar driver input. Select a driver specified for 3.3 V logic or add level shifting.
• Thermal loss: Older drivers such as L293D use bipolar transistor stages and waste more voltage as heat than modern MOSFET drivers.
• Control limitation: Open-loop PWM changes approximate speed but does not regulate it under changing load. Encoder feedback is needed for accurate speed control.