Unit 1: Getting started with NodeMCU - Subjective Questions

NodeMCU is an open-source development board based on the ESP8266 Wi-Fi-enabled microcontroller. It combines a microcontroller, wireless networking capability, USB-to-serial interface, voltage regulation, and programmable input/output pins on a single board.

Major features include:

• ESP8266 microcontroller: Provides processing capability and integrated 2.4 GHz Wi-Fi.
• Digital GPIO pins: Used to connect LEDs, relays, switches, sensors, and other digital devices.
• Analog input: The board generally provides one analog input pin for reading variable voltages.
• USB-to-serial interface: Allows program transfer and serial communication with a computer.
• Voltage regulator: Allows the board to be powered through the USB connection or a suitable external supply.
• Arduino IDE support: Programs can be written using the Arduino programming environment and C/C++-based sketches.
• Wireless connectivity: Enables communication with cloud services, mobile applications, web servers, and other IoT devices.

These features make NodeMCU useful for rapid prototyping and low-cost IoT applications.

NodeMCU can interface with a wide range of peripherals through its GPIO, analog, and communication interfaces.

Important peripherals include:

• LEDs: Connected to digital output pins for status indication or lighting control.
• Push buttons and switches: Connected to digital input pins to detect user actions.
• Sensors: Temperature, humidity, light, motion, gas, and distance sensors can provide data to the board.
• Relays: Used to control high-voltage or high-current appliances indirectly.
• Displays: OLED, LCD, and seven-segment displays can present sensor readings or system status.
• Motors and servos: Can be controlled using suitable driver circuits and PWM signals.
• Keypads: Allow users to enter commands or values.
• Storage devices: EEPROM, flash memory, or SD card modules can store data.
• Communication modules: I2C and SPI peripherals such as real-time clocks, displays, and external sensors can be connected.
• Audio devices: Buzzers and simple sound modules can be driven through output pins.

External drivers, resistors, level converters, or transistors may be required when a peripheral consumes more current or operates at a different voltage than the NodeMCU.

The following steps are used to set up NodeMCU with the Arduino IDE:

1. Install the Arduino IDE: Download and install a compatible version of the Arduino IDE.
2. Connect NodeMCU: Connect the board to the computer using a data-capable USB cable.
3. Install ESP8266 board support: Open the Board Manager settings and add the ESP8266 board package URL to the Additional Boards Manager URLs field.
4. Install the package: Search for the ESP8266 package in Boards Manager and install it.
5. Select the board: Choose the appropriate NodeMCU or ESP8266 development board from the Boards menu.
6. Select the serial port: Choose the COM port or device port assigned to NodeMCU.
7. Configure upload settings: Set the appropriate upload speed, flash size, and other board options if required.
8. Open or write a sketch: Create a program such as a blinking LED application.
9. Compile the sketch: Use the Verify option to check the program for errors.
10. Upload the sketch: Select Upload and wait until the IDE transfers the program to the board.
11. Test the program: Observe the connected peripheral or use the Serial Monitor to verify operation.

The USB driver must be installed correctly, and the selected board and port must match the actual hardware.

Serial port programming is the process of transferring a program from a computer to the NodeMCU through a serial communication interface. The program is compiled on the computer and then uploaded to the flash memory of the ESP8266.

The USB-to-serial converter performs the following functions:

• Converts data between the computer's USB format and the microcontroller's UART serial format.
• Provides a communication path for uploading firmware and sketches.
• Allows the Serial Monitor to exchange text and data with the running program.
• Helps control reset and boot-mode signals during automatic programming on many NodeMCU boards.
• May provide power to the board through the USB connection.

During uploading, the IDE opens the selected serial port, resets the board if necessary, places the ESP8266 into programming mode, and sends the compiled binary. After the upload is complete, the board restarts and executes the new program. A correct driver, USB data cable, board selection, and serial port selection are necessary for successful communication.

A GPIO pin can be configured as an output using pinMode(). The output state is controlled using digitalWrite().

const int ledPin = D1;

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

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Explanation:

• ledPin identifies the GPIO pin connected to the LED.
• pinMode(ledPin, OUTPUT) configures the selected pin as an output.
• digitalWrite(ledPin, HIGH) drives the pin to its high logic level and turns the LED on in a normally wired circuit.
• digitalWrite(ledPin, LOW) drives the pin low and turns the LED off.
• delay(1000) pauses execution for 1000 milliseconds, or 1 second.

An appropriate series resistor should be connected with the LED to limit current. The circuit must also respect the NodeMCU's logic voltage and maximum GPIO current.

The steps for configuring a NodeMCU GPIO pin as an output are:

1. Select a suitable GPIO pin: Choose a pin that is available and appropriate for the connected device.
2. Declare the pin: Assign a meaningful name to the pin in the program.
3. Set the pin mode: Use pinMode(pin, OUTPUT) in the setup() function.
4. Set the output state: Use digitalWrite(pin, HIGH) or digitalWrite(pin, LOW) for digital control.
5. Use PWM when required: Use a PWM-compatible function such as analogWrite() when controlling LED brightness or motor speed.
6. Connect the load correctly: Use a resistor for an LED and a transistor, driver, or relay module for higher-current loads.

Example:

const int outputPin = D2;

void setup() {
  pinMode(outputPin, OUTPUT);
  digitalWrite(outputPin, LOW);
}

Initializing the pin to a known state prevents unwanted activation of the connected device during startup.

The following precautions are important when using GPIO pins as outputs:

• Use logic-compatible devices: NodeMCU GPIO pins operate at approximately 3.3 V logic. A 5 V signal must not be connected directly to an input or output pin.
• Limit output current: A GPIO pin should not directly drive high-current devices such as motors, lamps, or relays.
• Use current-limiting resistors: LEDs require a series resistor to prevent excessive current.
• Use driver circuits: Transistors, MOSFETs, motor drivers, or relay modules should be used for loads requiring more current.
• Add flyback protection: Inductive loads such as relays and motors require a flyback diode when appropriate.
• Avoid short circuits: Directly connecting an output pin to ground or another driven output may damage the board.
• Check boot-sensitive pins: Some ESP8266 pins affect boot mode and must not be pulled to an incorrect level during reset.
• Initialize pins early: Configure and initialize output pins in setup() to avoid unpredictable states.

Following these precautions protects the ESP8266 and improves the reliability of the IoT device.

A GPIO pin can read a digital switch using pinMode() and digitalRead().

const int buttonPin = D5;
const int ledPin = D1;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

Explanation:

• The button is connected between D5 and ground.
• INPUT_PULLUP enables the internal pull-up resistor.
• When the button is released, the input reads HIGH.
• When the button is pressed, the input is connected to ground and reads LOW.
• The LED is turned on when the button is pressed.

This arrangement reduces the need for an external pull-up resistor and prevents the input from floating.

A GPIO pin is configured as an input by using the pinMode() function:

pinMode(inputPin, INPUT);

The pin can then be read using:

int state = digitalRead(inputPin);

An input pin must have a defined logic level. If it is not connected to a definite voltage, it may float and produce unpredictable readings. Pull-up and pull-down resistors solve this problem.

• A pull-up resistor connects the input to the positive supply so that the default state is logic HIGH. Pressing a switch can connect the pin to ground, producing LOW.
• A pull-down resistor connects the input to ground so that the default state is logic LOW. Pressing a switch can connect the pin to the positive supply, producing HIGH.
• NodeMCU commonly supports the internal pull-up configuration through INPUT_PULLUP.

The selected resistor arrangement must be compatible with the ESP8266 voltage limits.

The three modes have different purposes:

• INPUT: The pin is placed in high-impedance input mode and senses an external logic signal. An external pull-up or pull-down resistor may be required to prevent a floating input.
• INPUT_PULLUP: The pin is configured as an input with an internal pull-up resistor enabled. The default state is generally HIGH, and a switch connected to ground changes the reading to LOW.
• OUTPUT: The pin actively drives a logic level. The program can set it to HIGH or LOW using digitalWrite().

The choice depends on the circuit. INPUT is appropriate when the external circuit already provides a stable signal. INPUT_PULLUP is convenient for switches and open-drain devices. OUTPUT is used for devices such as LEDs, control signals, and driver inputs. Incorrect mode selection can cause unreliable readings or electrical damage.

A floating GPIO input is a pin that is configured as an input but is not connected to a defined logic level. Because the pin has high impedance, it can pick up electrical noise from the environment and alternate unpredictably between HIGH and LOW.

Symptoms of a floating input include:

• Random LED or relay activation.
• Inconsistent button readings.
• Different readings when a person touches the circuit.
• Unstable sensor or control behavior.

It can be prevented by:

• Enabling the internal pull-up resistor with INPUT_PULLUP.
• Connecting an external pull-up resistor to the supply voltage.
• Connecting an external pull-down resistor to ground.
• Ensuring that the sensor or switching circuit always drives the input to a valid logic level.

For example, a button connected between a GPIO pin and ground can use INPUT_PULLUP. In this case, the program interprets LOW as the pressed state and HIGH as the released state.

Serial communication allows NodeMCU to exchange text and data with a computer through the USB-to-serial interface. It is useful for debugging, displaying sensor readings, and receiving commands.

Example:

void setup() {
  Serial.begin(115200);
  Serial.println("NodeMCU started");
}

void loop() {
  Serial.println("System is running");
  delay(1000);
}

Explanation:

• Serial.begin(115200) initializes UART communication at a baud rate of 115200 bits per second.
• Serial.println() sends a message followed by a new line.
• The Serial Monitor must use the same baud rate as the program.
• The USB cable and selected serial port provide the communication path.

When a program receives data, functions such as Serial.available() and Serial.read() can be used to test for and read incoming characters. Matching the baud rate and selecting the correct port are essential for readable output.

ESP8266 and ESP32 are popular Wi-Fi-enabled microcontroller families, but ESP32 generally provides more capabilities.

ESP8266 is suitable for simple Wi-Fi sensors, switches, and monitoring systems. ESP32 is preferable for applications requiring Bluetooth, more sensors, greater processing power, audio, touch input, or several simultaneous peripherals.

NodeMCU based on ESP8266 has several advantages:

• Integrated Wi-Fi: Internet connectivity is available without an additional network module.
• Low cost: It is inexpensive and widely available.
• Small size: It can be used in compact prototypes.
• Arduino IDE support: Developers can use familiar programming tools and libraries.
• Large community: Many examples, tutorials, and software libraries are available.
• Low-power modes: Sleep modes can be used in battery-operated designs.
• GPIO and communication support: Sensors and modules can be connected using digital pins, UART, SPI, and I2C.

Limitations include:

• Fewer GPIO pins than many ESP32 boards.
• Usually only one analog input on common NodeMCU boards.
• No integrated Bluetooth on the ESP8266.
• GPIO pins operate at 3.3 V and have limited current capability.
• Some pins have boot-time restrictions.
• Timing-sensitive operations may be affected by Wi-Fi activity.
• It is less powerful than ESP32 for demanding processing and multitasking.

Therefore, ESP8266 NodeMCU is effective for basic connected devices, while more complex designs may require ESP32.

NodeMCU development boards often print labels such as D0, D1, D2, and D3 on the circuit board. These labels are board-specific names that correspond to actual ESP8266 GPIO numbers.

Common mappings include:

• D0 corresponds to GPIO16.
• D1 corresponds to GPIO5.
• D2 corresponds to GPIO4.
• D3 corresponds to GPIO0.
• D4 corresponds to GPIO2.
• D5 corresponds to GPIO14.
• D6 corresponds to GPIO12.
• D7 corresponds to GPIO13.
• D8 corresponds to GPIO15.

The Arduino core usually allows programs to use board labels such as D1, which improves readability. However, libraries, datasheets, and low-level ESP8266 functions may refer to GPIO numbers. Understanding the mapping prevents incorrect wiring and programming errors.

Some pins also have special boot functions, so their startup behavior must be considered before connecting external circuits.

The time period of one complete blink cycle is the sum of the ON time and the OFF time:

Substituting the given values:

The blinking frequency is the reciprocal of the time period:

Therefore:

Thus, the LED completes one full ON-OFF cycle every 2 seconds, and its blinking frequency is approximately 0.5 Hz. In a real NodeMCU program, the actual period may be slightly longer because instruction execution and operating-system or Wi-Fi activity add small delays.

The three modes represent different ways of interacting with electrical signals:

• Digital input: Reads one of two logic states, normally HIGH or LOW. It is suitable for push buttons, switches, motion sensors, and digital status signals. The function digitalRead() is used.
• Digital output: Produces one of two logic states, HIGH or LOW. It is suitable for LEDs, control signals, and driver circuits. The function digitalWrite() is used.
• Analog input: Measures a variable voltage and converts it into a digital numerical value using an analog-to-digital converter. It is suitable for potentiometers, light sensors, and analog measurement circuits. The function analogRead() is used.

Digital signals represent discrete states, while analog signals vary continuously over a voltage range. On a typical ESP8266 NodeMCU board, only one analog input is exposed, and its allowable voltage range must be checked because it may differ between the ESP8266 chip and the development board.

A systematic troubleshooting process includes the following checks:

1. Check the USB cable: Confirm that it supports data transfer and is not only a charging cable.
2. Check power: Verify that the board powers up and that the power indicator behaves normally.
3. Check the driver: Install or repair the USB-to-serial driver required by the board.
4. Check the serial port: Confirm that the correct COM port or device port is selected.
5. Check board selection: Select the correct NodeMCU or ESP8266 board in the Arduino IDE.
6. Close conflicting software: Ensure that another serial terminal is not using the same port.
7. Lower upload speed: Try a lower upload speed if communication is unreliable.
8. Reset the board: Press the reset button and retry the upload.
9. Check boot pins: Remove external circuits that may force a boot-sensitive pin to an invalid level.
10. Inspect error messages: Use the IDE output to identify timeout, permission, or synchronization errors.

These checks isolate problems involving hardware, drivers, configuration, power, and boot mode.

Polling repeatedly checks the input pin in the main program loop. For example, the program can call digitalRead() continuously and respond when the value changes.

Advantages of polling:

• Simple to understand and implement.
• Suitable for slow inputs such as buttons.
• The program controls exactly when the input is checked.

Limitations of polling:

• Consumes processor time continuously.
• May miss short pulses if the loop is delayed.
• Long delays can reduce responsiveness.

Interrupt-based detection configures the microcontroller to run an interrupt service routine when a selected signal transition occurs, such as RISING, FALLING, or CHANGE.

Advantages of interrupts:

• Responds quickly to external events.
• Avoids continuously checking the pin.
• Suitable for pulse counting and time-sensitive events.

Interrupt limitations include restrictions on what should be executed inside the interrupt routine and possible switch bounce. Interrupt routines should be short, and shared variables may need appropriate handling. Polling is adequate for simple controls, while interrupts are useful for fast or irregular events.

NodeMCU should not drive a relay coil or appliance directly from a GPIO pin. Instead, the GPIO pin controls a relay module or a transistor-based driver circuit.

A typical arrangement works as follows:

• The NodeMCU GPIO provides a 3.3 V control signal.
• A transistor or relay module uses this signal to energize the relay coil.
• A separate suitable supply provides the coil current.
• A flyback diode protects the driver from the voltage generated when the coil is switched off, unless the relay module already includes protection.
• The relay contacts switch the appliance circuit while electrically isolating it from the low-voltage control circuit.

Safety considerations include:

• Do not connect mains voltage directly to NodeMCU.
• Use a properly rated, enclosed relay module.
• Maintain suitable creepage, clearance, and insulation distances.
• Disconnect mains power before modifying the circuit.
• Use fuses and protective enclosures where appropriate.
• Have qualified personnel handle hazardous-voltage wiring.

For low-voltage demonstrations, a relay module with an optocoupler and transistor driver is usually safer and easier to use.