Lab 02 - MQTT - NODEMCU-2

LAB 02 – Integrating NodeMCU (ESP8266)
with MQTTx and EMQX Broker for Real

Time Communication
Lab Objective: To equip students with practical skills in setting up and managing MQTT communications
within an Internet of Things (IoT) ecosystem. Students will configure a NodeMCU device to send and
receive messages through the EMQX MQTT broker, and use MQTTx as a versatile client to interact with
the broker. This lab aims to demonstrate the principles of MQTT, a cornerstone protocol for IoT
communications, emphasizing hands-on experience in real-time data exchange, device connectivity, and
basic troubleshooting of networked interactions.
Learning Outcomes:
• Understand the fundamentals of MQTT protocol including topics, subscriptions, and messaging.
• Configure and use an EMQX broker to facilitate MQTT communications.
• Configure NodeMCU (ESP8266) using Arduino IDE
• Implement a NodeMCU client that can publish to and subscribe from MQTT topics.
• Use MQTTx client to simulate an IoT device or application, interacting with the MQTT broker.
• Analyze and troubleshoot common issues in MQTT communications to ensure reliable data
exchange.
Part 01- NODEMCU (ESP8266)

Configuration and Setup:
In this initial phase of the lab, students will focus on setting up the NodeMCU module, which is a low-cost
IoT platform equipped with an ESP8266 WiFi chip. The primary objectives will be to configure the
NodeMCU to connect to a WiFi network and ensure that it can communicate reliably over the Internet.
This setup is foundational, as a stable WiFi connection is crucial for the successful operation of IoT devices
in real-world scenarios. Students will learn to flash the NodeMCU with appropriate firmware, write simple
scripts to handle WiFi connectivity, and perform basic network tests to verify connectivity.
1. Equipment and Software Needed
• Hardware: ESP8266 module (e.g., NodeMCU, Wemos D1 mini)
CEN445 Lab 02 Dr. Huma Zia

• USB Cable: Micro USB cable (for most ESP8266 boards like NodeMCU)
• Computer: PC with Windows, macOS, or Linux
2. Install the Arduino IDE
• Download the Arduino IDE from Arduino's official website.
• Follow the installation instructions specific to your operating system.
3. Install ESP8266 Board in Arduino IDE
• Open Arduino IDE, go to File > Preferences.
• In the Additional Board Manager URLs field, enter the following URL:
http://arduino.esp8266.com/stable/package_esp8266com_index.json
• Click "OK" to close the Preferences window.
• Go to Tools > Board > Boards Manager...
• In the Boards Manager, type "ESP8266" into the search bar, find the ESP8266 by ESP8266
Community, and click "Install".
4. Install Necessary Drivers
• Windows: Most ESP8266 modules use a CH340 or CP2102 USB-to-serial chip that might require
drivers.
• Download the driver for CP2102 depending on your module. These are available on the
Silicon Labs website, which provides drivers for Windows, macOS, and Linux. Here's the
link: https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers

• Run the installer to install the driver.
• Check your device manager to check which com port is being used for the ESP8266.
• macOS/Linux: Drivers are typically included in the OS or automatically downloaded and

installed. However, if the device is not recognized, you might need to manually install drivers
following similar steps as Windows.
5. Configure Arduino IDE for ESP8266
• Plug your ESP8266 module into your computer using the USB data cable.
• Open the Arduino IDE.
• Select the correct board by going to Tools > Board and choosing your specific ESP8266 module
(e.g., NodeMCU 1.0).

• Select the correct port:
• Windows: Go to Tools > Port and select the COM port associated with the ESP8266
(usually denoted as COM3, COM4, etc.).
• macOS/Linux: Go to Tools > Port and select the /dev/cu.SLAB_USBtoUART or similar

for your board.
6. Load and Run an Example Sketch
• In the Arduino IDE, go to File > Examples > ESP8266> Blink.
• This will blink the builtin Led on your board. The verifies that board is connected and working
• Click the "Upload" button to compile and upload the sketch.

• Once uploaded, you should see the builtin LED of the ESP8266 board start blinking.
7. Verify Wifi of ESP8266
• In the Arduino IDE, go to File>Example>ESP8266Wifi>WifiScan
• Upload this code to your ESP8266 and open the Serial Monitor to check the output. It should
list all available WiFi networks. If no networks are listed, there may be an issue with the WiFi
module or its configuration. Make sure baud rate is the same in serial monitor as put in the code
(e.g 115200)
• Once Wifi scanning is done, select your Wifi and run the below code to verify Wifi Connectivity.
#include <ESP8266WiFi.h>
void setup() {
Serial.begin(115200);
WiFi.begin("YOUR_SSID", "YOUR_PASSWORD");
while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void loop() {
// Keep loop empty.
}
• Replace "YOUR_SSID" and "YOUR_PASSWORD" with your actual WiFi credentials. This
script attempts to connect to your WiFi and prints the IP address upon successful
connection.

8. Safety and Handling Precautions
• Handle the board carefully to avoid damaging static-sensitive components.
• Ensure the board is disconnected from power when making hardware changes.
• Follow lab safety protocols when working with electronic components.
This guideline provides a foundational path for students to start experimenting with the ESP8266 in a lab
setting, from installation to running their first program. Each step is crucial for understanding and
successfully using the ESP8266 in various projects.

Part 02: Using EMQX broker to
communicate between ESP8266 client and
MQTTExplorer client
Overview
With the NodeMCU configured and connected to the internet, the second part of the lab transitions to
the core topic of MQTT communication. Here, students will implement and test MQTT-based messaging
using the NodeMCU as an MQTT client and the EMQX broker to facilitate message passing. MQTTx, a
cross-platform MQTT desktop client, will be used to simulate another client in the MQTT system, allowing
students to explore both publishing and subscribing functionalities. This part emphasizes understanding
MQTT's lightweight messaging protocol, which is pivotal for IoT environments where low power usage
and network bandwidth are key considerations.
Prerequisites
• ESP8266 board (e.g., NodeMCU)
• Arduino IDE with ESP8266 board support installed
• Micro USB cable
• Internet connection
Step 1: Preparing Your Code
Copy and paste the code provided below into a new sketch in the Arduino IDE. This is a basic MQTT
example where your ESP8266 will connect to an MQTT broker, Publish a message for a specific topic,
and listen for messages on the same topic. For this code to work, the library (PubSubClient.h) needs to
be installed. Install the library in Arduino IDE by going to Tools>Manage libraries. Search for this library
(PubSubClient by Nick O’Leary), and click install.
Step 2: Replace WiFi Credentials and other messaging details
• SSID: Enter the SSID of your WiFi network.

• PASSWORD: Enter the password of your WiFi network.
• You can change your topic to what you want to publish or subscribe to.
• Mqtt_broker can be selected as per requirements. Here the MQTT broker is “broker.emqx.io”
Step 3: Uploading the Code
• Connect your ESP8266 module to your computer using the USB cable.
• In the Arduino IDE, select the correct board and port under Tools > Board and Tools > Port.
• Click the Upload button to compile and upload the sketch to your ESP8266.
Step 4: Monitoring Communication
• Open the Serial Monitor from the Arduino IDE (magnifying glass icon in the top right corner).
• Set the baud rate to 115200 (bottom right of the Serial Monitor window).
• Observe the outputs as your ESP8266 connects to WiFi and the MQTT broker, and listens for
messages.
Step 5: Experiment Further
• Modify the topic and message content.
• Explore adding more topics and handling multiple messages.
• Consider integrating sensors or actuators based on the MQTT messages.
#include <PubSubClient.h>
// WiFi
const char *ssid ="Your WIFI SSID"; // Enter your WiFi name
const char *password ="WIFI PSWD"; // Enter WiFi password
// MQTT Broker
const char *mqtt_broker = "broker.emqx.io";
const char *topic = "esp8266/HZ";
const char *mqtt_username = "emqx";
const char *mqtt_password = "public";
const int mqtt_port = 1883;
WiFiClient espClient;
PubSubClient client(espClient);
void setup() {

// Set software serial baud to 115200;
// connecting to a WiFi network
WiFi.begin(ssid, password);
delay(500);
Serial.println("Connecting to WiFi..");
Serial.println(WiFi.status());
}
Serial.println("Connected to the WiFi network");
//connecting to a mqtt broker
client.setServer(mqtt_broker, mqtt_port);
client.setCallback(callback);
while (!client.connected()) {
String client_id = "esp8266-client-";
client_id += String(WiFi.macAddress());
Serial.printf("The client %s connects to the public mqtt broker\n",
client_id.c_str());
if (client.connect(client_id.c_str(), mqtt_username, mqtt_password)) {
Serial.println("Public emqx mqtt broker connected");
} else {
Serial.print("failed with state ");
Serial.print(client.state());
delay(2000);
}
}
// publish and subscribe
client.publish(topic, "hello emqx");
client.subscribe(topic);
}
void callback(char *topic, byte *payload, unsigned int length) {

Serial.print("Message arrived in topic: ");
Serial.println(topic);
Serial.print("Message:");
for (int i = 0; i < length; i++) {
Serial.print((char) payload[i]);
}
Serial.println();
Serial.println("-----------------------");
}
void loop() {
client.loop();
}

Part 03: IoT Control with ESP8266: Remote
Built-in LED Management Using MQTT
Messages
This task involves programming an ESP8266 module to control its built-in LED using MQTT messages. The
ESP8266 connects to a WiFi network and establishes communication with an MQTT broker hosted on
broker.emqx.io. It subscribes to a specific MQTT topic and listens for incoming messages that dictate the
LED's state—either "LED ON" to turn the LED on or "LED OFF" to turn it off.
The ESP8266 setup includes configuring WiFi credentials, connecting to the MQTT broker, and setting up
a callback function that reacts to received MQTT messages by controlling the LED. This task effectively
demonstrates the integration of simple IoT control mechanisms using MQTT, a lightweight messaging
protocol, making it a practical example of remote device management and real-time state control in
embedded systems.
Step 1: Hardware and Software Setup
• Hardware: Use an ESP8266 module, which has built-in WiFi capabilities and sufficient GPIO pins
for simple control tasks such as LED management.
• Software: Program the ESP8266 using the Arduino IDE, which supports the ESP8266 board after
adding the necessary board manager URL.
Step 2: Establish WiFi Connection
• Configure the ESP8266 to connect to a local WiFi network by providing the SSID and password.
This step is crucial for enabling the ESP8266 to access the internet and communicate with the
MQTT broker.
Step 3: Connect to MQTT Broker
• Set up the MQTT client on the ESP8266 to connect to broker.emqx.io. Use MQTT credentials if
required by the broker for authentication.
• Implement a reconnection strategy to ensure the ESP8266 remains connected to the MQTT
broker or attempts to reconnect if the connection is lost.
Step 4: Subscribe to MQTT Topic

• Subscribe to a specific topic (e.g., esp8266/HZ) that the ESP8266 will listen to for controlling the
LED. This MQTT topic will receive commands that determine the LED's state.
Step 5: Implement Control Logic
• Define a callback function that triggers whenever a message is received on the subscribed topic.
This function checks the content of the message and controls the LED accordingly.
• Use simple string comparisons within the callback to determine whether the LED should be turned
on or off based on the messages "LED ON" or "LED OFF".
Step 6: Testing and Validation
• Publish messages to the MQTT topic (e.g esp8266/HZ) using an external MQTT client (e.g., MQTTx)
to test if the LED on the ESP8266 responds appropriately to the commands.
• Monitor the ESP8266's serial output to debug and confirm that it receives the correct commands
and that the LED's state changes as expected.
Code:
// WiFi
const char *ssid ="PRJ"; // Enter your WiFi name
const char *password ="PRJ2017@"; // Enter WiFi password
// MQTT Broker
void setup() {
pinMode(LED_BUILTIN, OUTPUT); // Initialize the LED_BUILTIN pin as an output
delay(500);

}
client_id.c_str());
} else {
delay(2000);
}
}
}

payload[length] = '\0'; // Ensure payload is null-terminated
Serial.print("Message:");
String message = "";
for (int i = 0; i < length; i++) {
Serial.print((char) payload[i]);
message += (char)payload[i]; // Append each char to the message string
}
Serial.println();
Serial.println("-----------------------");
// Check for the specific commands and adjust LED state

if (message == "LED ON") {
digitalWrite(LED_BUILTIN, LOW); // Turns the LED on (active low)
} else if (message == "LED OFF") {
digitalWrite(LED_BUILTIN, HIGH); // Turns the LED off (active high)
}

}
void loop() {
client.loop();
}

Part 04: IoT Device Control for LED and
Servo Motor Functions with ESP8266,
EMQX, and MQTTx
Servo Motor Control with ESP8266
Objective: To control the position of a servo motor using MQTT messages received through an
ESP8266 module. This setup demonstrates basic IoT control capabilities and introduces students to
the practical applications of MQTT in device automation.
Hardware Required:
ESP8266 module
Servo motor
Breadboard and jumper wires
External power supply for the servo (recommended if the servo requires more than 5V or if it draws
significant current)
Circuit Setup:
Connect the Servo to the ESP8266:
Signal Pin: Connect the servo's control (signal) wire (usually orange or yellow) to a GPIO pin on the
ESP8266 that supports PWM. Common choices are GPIO12, GPIO13, or GPIO14.
Power and Ground: Connect the power (red) and ground (brown or black) wires of the servo directly
to an external power supply. If your servo operates at 5V and doesn’t draw much current, you can
connect it to the 5V and GND pins of the ESP8266.
Software Setup:
Programming the ESP8266:
Use the Arduino IDE with the ESP8266 board definitions installed.
Include libraries: <ESP8266WiFi.h>, <PubSubClient.h>, and <Servo.h>.
Write a script to connect the ESP8266 to WiFi, connect to an MQTT broker, subscribe to a topic, and
use messages from this topic to set the angle of the servo.
Code Overview:
The ESP8266 connects to the MQTT broker.
It subscribes to a specific topic ("esp8266/controls").

Upon receiving a message with a numeric value (0-180), the servo's position is adjusted according to
this value.
Challenges and Learning Outcomes:
Learn to handle real-time data from the network.
Understand the basics of PWM (Pulse Width Modulation) in controlling servo motors.
Explore MQTT, a lightweight messaging protocol ideal for IoT applications.
Programming the ESP8266:
#include <Servo.h>
// WiFi
const char *ssid = "PRJ"; // Enter your WiFi name
const char *password = "PRJ2017@"; // Enter WiFi password
// MQTT Broker

Servo myServo; // Servo object
void setup() {
myServo.attach(D1); // Attach servo to pin D1

delay(500);
}
// connecting to a mqtt broker

client_id.c_str());
} else {
delay(2000);
}
}
}

payload[length] = '\0'; // Null terminate the string
String message = String((char*)payload);

Serial.print("Message: ");
Serial.println(message);
int pos = message.toInt(); // Convert message to integer

if (pos >= 0 && pos <= 180) {
myServo.write(pos); // Move servo to position from message
}
}
void loop() {
client.loop();
}
MQTTx Web Publisher Setup
• Open MQTTx and connect to the EMQX broker using the broker address broker.emqx.io, and
username and password specified in your ESP8266 code.
• Publish angle values (from 0 to 180) to the topic esp8266/Z.
Test and Validate
• Power up your ESP8266 and ensure it connects to WiFi and the MQTT broker.
• Use MQTTx to send control messages and observe the LED and motor responding to your
commands.

LED Control with ESP8266
Objective: To turn an LED on and off using MQTT messages sent from a remote client to an ESP8266.
This project helps students understand digital output control via WiFi and the use of MQTT for simple
commands.
Hardware Required:
• ESP8266 module
• LED
• Resistor (typically 220 ohms to 330 ohms)
• Breadboard and jumper wires
Circuit Setup:
1. Connect the LED to the ESP8266:
• Anode (Longer Leg): Connect to one end of the resistor.
• Other End of Resistor: Connect to any GPIO pin on the ESP8266 (common choices are
GPIO2 or GPIO16).
• Cathode (Shorter Leg): Connect directly to one of the GND pins on the ESP8266.

Software Setup:
1. Programming the ESP8266:
• Include necessary libraries: <ESP8266WiFi.h> and <PubSubClient.h>.
• Write a script to connect to WiFi, connect to an MQTT broker, subscribe to a topic, and
control the state of the LED based on the messages received (e.g., "ON" or "OFF").
Code Overview:
• The ESP8266 listens for MQTT messages.
• Commands like "ON" and "OFF" control the state of the LED.
• Demonstrates digital output handling and basic IoT communication.
MQTTx Web Publisher Setup
• Open MQTTx and connect to the EMQX broker using the broker address broker.emqx.io, and
username and password specified in your ESP8266 code.
• Publish angle values (from 0 to 180) to the topic esp8266/Z.
Test and Validate
• Power up your ESP8266 and ensure it connects to WiFi and the MQTT broker.
• Use MQTTx to send control messages and observe the LED and motor responding to your
commands.
// WiFi credentials
const char *ssid = "PRJ"; // Enter your WiFi name
const char *password = "PRJ2017@"; // Enter WiFi password
// MQTT Broker settings


// Define the LED pin
const int ledPin = D2; // GPIO16 on ESP8266 is mapped to D0
void setup() {
pinMode(ledPin, OUTPUT); // Set the LED pin as an output
digitalWrite(ledPin, LOW); // Ensure LED is off when starting up
delay(500);
}
client_id.c_str());
} else {
delay(2000);
}
}
}

payload[length] = '\0'; // Null terminate the string
String message = String((char*)payload);
Serial.print("Message: ");
Serial.println(message);

// Control LED based on the message received
if (message == "ON") {
digitalWrite(ledPin, HIGH); // Turn LED on
} else if (message == "OFF") {
digitalWrite(ledPin, LOW); // Turn LED off
}
}
void loop() {
client.loop();
}

Deliverables:
1. Lab Report
A comprehensive lab report should be submitted with the following sections:
Introduction
• A brief overview of the objectives of the lab.
• An explanation of the technologies used: ESP8266, EMQX broker, and MQTT protocol.
Execution Summary
• A detailed account of how the students set up and configured the ESP8266 and connected it to
the EMQX broker.
• Describe the process of using MQTTExplorer or MQTTx to send and receive messages.
• Include any modifications made to the provided code or setup.
Results
• Detailed results of the implementation, including screenshots of the system in operation (e.g.,
MQTT messages being published and subscribed, actions performed by the ESP8266 like LED
control and servo movement).
• Any observations on the system’s performance, including responsiveness and any potential
issues encountered.
Discussion
• Analysis of how the system worked. Discuss the role of MQTT in IoT communications based on
the lab experience.
• Discuss any discrepancies between expected and actual results and possible reasons for these
discrepancies.
Conclusion
• A summary of what was learned through the lab.
• Reflection on the benefits and limitations of using MQTT for IoT device control.
2. Video Demonstration
A video that clearly shows:
• The complete setup and how each component is integrated.
• The operational demonstration of controlling the LED and servo motor via MQTT messages.

• Explanation and commentary on what the video is demonstrating, including how the system
responds to MQTT commands.
3. Code Review Document
• A document that includes a review of the provided code. Students should explain each part of
the code, how it contributes to the functionality of the project, and any changes they made.
• Highlight any parts of the code that were particularly challenging or required debugging.
4. Reflection Essay
• A reflective essay discussing:
• The practical application of the lab in real-world scenarios.
• Personal insights gained from completing the lab.
• How the experience might influence future projects or career choices in the field of IoT.
Submission Guidelines
• All documents should be submitted in PDF format, except the video, which should be uploaded
to a suitable platform and linked within the lab report.
• Ensure all files are clearly named and organized, with the student name(s) and ID(s) included in
each file.

Lab 02 - MQTT - NODEMCU-2

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lab 02 - MQTT - NODEMCU-2

Uploaded by

Copyright:

Available Formats

LAB 02 – Integrating NodeMCU (ESP8266)

with MQTTx and EMQX Broker for Real

• Configure and use an EMQX broker to facilitate MQTT communications.

• Configure NodeMCU (ESP8266) using Arduino IDE

Part 01- NODEMCU (ESP8266)

1. Equipment and Software Needed

• Hardware: ESP8266 module (e.g., NodeMCU, Wemos D1 mini)

CEN445 Lab 02 Dr. Huma Zia

• Computer: PC with Windows, macOS, or Linux

2. Install the Arduino IDE

• Download the Arduino IDE from Arduino's official website.

• Follow the installation instructions specific to your operating system.

3. Install ESP8266 Board in Arduino IDE

• Open Arduino IDE, go to File > Preferences.

• Click "OK" to close the Preferences window.

• Go to Tools > Board > Boards Manager...

4. Install Necessary Drivers

CEN445 Lab 02 Dr. Huma Zia

• macOS/Linux: Drivers are typically included in the OS or automatically downloaded and

5. Configure Arduino IDE for ESP8266

• Open the Arduino IDE.

CEN445 Lab 02 Dr. Huma Zia

• macOS/Linux: Go to Tools > Port and select the /dev/cu.SLAB_USBtoUART or similar

6. Load and Run an Example Sketch

• In the Arduino IDE, go to File > Examples > ESP8266> Blink.

• Click the "Upload" button to compile and upload the sketch.

CEN445 Lab 02 Dr. Huma Zia

7. Verify Wifi of ESP8266

• In the Arduino IDE, go to File>Example>ESP8266Wifi>WifiScan

while (WiFi.status() != WL_CONNECTED) {

CEN445 Lab 02 Dr. Huma Zia

• Handle the board carefully to avoid damaging static-sensitive components.

• Follow lab safety protocols when working with electronic components.

CEN445 Lab 02 Dr. Huma Zia

• ESP8266 board (e.g., NodeMCU)

• Arduino IDE with ESP8266 board support installed

• Micro USB cable

Step 1: Preparing Your Code

Step 2: Replace WiFi Credentials and other messaging details

• SSID: Enter the SSID of your WiFi network.

CEN445 Lab 02 Dr. Huma Zia

Step 3: Uploading the Code

Step 4: Monitoring Communication

Step 5: Experiment Further

• Modify the topic and message content.

• Explore adding more topics and handling multiple messages.

• Consider integrating sensors or actuators based on the MQTT messages.

CEN445 Lab 02 Dr. Huma Zia

void callback(char *topic, byte *payload, unsigned int length) {

CEN445 Lab 02 Dr. Huma Zia

Step 1: Hardware and Software Setup

Step 2: Establish WiFi Connection

Step 3: Connect to MQTT Broker

Step 4: Subscribe to MQTT Topic

CEN445 Lab 02 Dr. Huma Zia

Step 5: Implement Control Logic

Step 6: Testing and Validation

CEN445 Lab 02 Dr. Huma Zia

void callback(char *topic, byte *payload, unsigned int length) {

// Check for the specific commands and adjust LED state

CEN445 Lab 02 Dr. Huma Zia

CEN445 Lab 02 Dr. Huma Zia

Breadboard and jumper wires

Connect the Servo to the ESP8266:

void callback(char topic, byte payload, unsigned int length) {

void callback(char topic, byte payload, unsigned int length) {

void callback(char topic, byte payload, unsigned int length) {

void callback(char topic, byte payload, unsigned int length) {