ABOUT

ESP8266 WHAT IT IS
• A low-cost System-on-a-Chip (SoC) made by
Espressif Systems.
• It's essentially a microcontroller with built-in Wi-
Fi networking capabilities.

WHAT CAN IT DO
• Connect to Wi-Fi: Allows your projects to join
existing Wi-Fi networks or create their own
(Access Point).
• Run Programs: Executes code to read sensors,
control outputs, process data, and communicate
Esp8266 NodeMCU over the network.
• Ideal for: Simple IoT devices, Wi-Fi sensors, basic
remote control, and data logging over Wi-Fi.
ABOUT
ESP8266 PINS AND INTERFACE
• GPIO: Around 11-17 General Purpose
Input/Output pins (number varies depending on
the specific module).
• Wi-Fi: Integrated 2.4 GHz
• Common Interfaces:
⚬ UART (Serial communication)
⚬ SPI (Serial Peripheral Interface)
⚬ I2C (Inter-Integrated Circuit)
⚬ PWM (Pulse Width Modulation)
⚬ Analog Input: 1x Analog-to-Digital Converter
(ADC) pin (usually 10-bit resolution).

Esp8266 NodeMCU -
PinOut
Check which pin is safe to use: https://randomnerdtutorials.com/esp8266-pinout-reference-gpios/
ABOUT WHAT IT IS
ESP32 - WROOM32 • A more powerful, next-generation SoC from
Espressif Systems, designed as an upgrade to the
ESP8266.
• A microcontroller featuring both integrated Wi-Fi
and Bluetooth.

WHAT CAN IT DO
• Connect to Wi-Fi: Same capabilities as ESP8266 but
often with better performance.
• Connect via Bluetooth: Supports both Bluetooth
Classic and Bluetooth Low Energy (BLE).
• Run Complex Programs: Significantly faster
processor (dual-core up to 240 MHz) and more RAM
allow for more demanding tasks, faster processing,
and handling Wi-Fi/Bluetooth simultaneously.
Esp32-WROOM32 • Ideal for: Advanced IoT projects, applications needing
Bluetooth, projects requiring more processing power
or more I/O pins, low-power BLE devices.
ABOUT
ESP32 - WROOM32 PINS AND INTERFACE
• GPIO: Around 11-17 General Purpose
Input/Output pins (number varies depending on
the specific module).
• Wi-Fi: Integrated 2.4 GHz
• Common Interfaces:
⚬ UART (Serial communication)
⚬ SPI (Serial Peripheral Interface)
⚬ I2C (Inter-Integrated Circuit)
⚬ PWM (Pulse Width Modulation)
⚬ Analog Input: 1x Analog-to-Digital Converter
(ADC) pin (usually 10-bit resolution).

ESP32-WROOM32
Pinout
Check which pin is safe to use: https://randomnerdtutorials.com/esp8266-pinout-reference-gpios/
WARNING
Please note:
• There are many types of ESP32/ESP8266, that are either
different version of the boards or made by different
manufacturers.
• The pinout of each board may be different.
• Please refer to the DATASET of your chosen board for accurate
information.

ESP32 - NodeMCU- ESP32 - S3 ESP8266 -

32S ESP01
WARNING
Recommendation
• For beginners it is best to use more common and well documented boards.
• For ESP32 that uses WROOM32 chip, the pinouts are similar for most boards.
• Here are some recommendations:

Esp8266 NodeMCU (V3) ESP32 - NodeMCU- ESP32-WROOM32 - 30 Pin

32S
Purchase Link:
• https://www.thegioiic.com/esp32-nodemcu-luanode32-module-thu-phat-wifi-30-chan
• https://www.thegioiic.com/esp32-nodemcu-luanode32-module-thu-phat-wifi-30-chan-type-
c
• https://www.thegioiic.com/esp32-s-nodemcu-mach-thu-phat-wifi-bluetooth
• https://www.thegioiic.com/lua-esp8266-nodemcu-v3-ch340-wifi-module-iot
SETTING UP
YOUR IDE
SETTING UP
YOUR IDE - ARDUINO IDE

What is the Arduino IDE?

• IDE = Integrated Development
Environment.
• It's a free, open-source software
application created by the Arduino team.
• Runs on your computer (Windows,
macOS, Linux).
• Specifically designed to make
programming microcontroller boards
easy.
SETTING UP
YOUR IDE - ARDUINO IDE
What is it Used For?
• Writing Code: Simple text editor for writing your programs (called "sketches") in the Arduino
language (based on C/C++).
• Verifying/Compiling Code: Checks your code for errors and translates it into instructions the
microcontroller understands.
• Uploading Code: Sends your compiled program from the computer to the microcontroller
board (like Arduino, ESP8266, ESP32) via USB.
• Managing Boards: Select the specific type of board you are using.
• Managing Libraries: Easily add pre-written code packages (libraries) to control sensors,
displays, motors, Wi-Fi, etc.
• Serial Monitor: Built-in window to send/receive messages between your computer and the
microcontroller – essential for debugging and seeing output.
SETTING UP
YOUR IDE - ARDUINO IDE
Please Download the latest version of the Program at:
https://www.arduino.cc/en/software/

Here is a very detailed Tutorial of how to set up your Boards:

• For ESP8266: https://randomnerdtutorials.com/installing-esp8266-nodemcu-
arduino-ide-2-0/
• For ESP32: https://randomnerdtutorials.com/installing-esp32-arduino-ide-2-0/
UPLOADING
YOUR FIRST
PROGRAM
“HELLO_WORLD’’
UPLOADING Blink - Hello_World of IOT
This program will blink the built-in light
YOUR FIRST of your ESP32/ESP8266.
PROGRAM

Creating a new “Sketch” Write the Code and Verify Choose the Board and Port
UPLOADING
YOUR FIRST
PROGRAM
Trouble Shooting
No Ports Founded
• Case 1: No USB Driver for CP210X
⚬ Some Board manufacturer use the CP2102 UART Chip instead of
the CH340:
⚬ Install USB Drivers – CP210x USB to UART Bridge (Windows PC)
⚬ Install USB Drivers – CP210x USB to UART Bridge (Mac OS X)
• Case 2: Bad USB cable
⚬ Some Micro-USB/USB-C cable may do not have a wire to for Data
transmission, we recommend using a high quality phone charger
with data transfer capabilities/ keyboard wire or buy one at:
⚬ https://www.thegioiic.com/day-cap-nap-sac-micro-usb-4-loi-
dai-1m-mau-
⚬ https://www.thegioiic.com/cap-nap-sac-type-c-mau-trang-dai-
1m
UPLOADING
YOUR FIRST
PROGRAM
Trouble Shooting
Which Board/Port To Choose:
• Which Board to Choose:
⚬ ESP32- WROOM32 30 PIN: ESP32 DEV MODULE. 7
⚬ ESP32-NODEMCU 32-S: NODE32S.
⚬ ESP8266 (V3): Generic ESP8266 module.

• Which Port to Choose:

⚬ In the case that there are to many ports and you do not know
which one is your Board, You can go to Device Manager → Ports.
⚬ Usually the USB-SERIAL CH340 or CP210X will be the Device.
UPLOADING Blink - Hello_World of IOT
This program will blink the built-in light
YOUR FIRST of your ESP32/ESP8266.
PROGRAM

Error of not in Download Mode: Press and Hold the “BOOT” or

“Flash” button when the terminal says: Connecting . . .

Press Upload Button

Successfully Uploaded the Code

ESP32 COMMUNICATION
& INTERFACING
BEFORE
WE START
Simulation is a great way to learn, to
code simple IOT programs without
buying the physical Parts.
• Wokwi is a Great Website for this:
⚬ https://wokwi.com/
• It also have Bluetooth and Wifi
Simulation, however you need to
pay to use these feature. (or use
the PlatformIO extension in
VSCode) Platform-IO
Documentations
DEVICE
SIMULATION
DEVICE
SIMULATION

You can add more

parts:
E.g. LED and Resistor
DEVICE
SIMULATION

Simulating the Blink

Program
SERIAL COMMUNICATION
Serial communication is a process where data is sent or received one
bit at a time, sequentially, over a single communication channel or wire.
Allowing us to:
• Debug: Print status messages, variable values, and error codes to
see what the ESP32 is doing.
• Log Data: Send readings or data to a computer for storage and
analysis.
• Interact: Send commands from a computer to the ESP32 to control
its behavior.
• Program: The flashing of the ESP32 often happens over a serial
connection (via USB).
SERIAL COMMUNICATION
UART PROTOCOL (Universal Asynchronous Receiver/Transmitter):
• A hardware component that facilitates serial communication
between devices.
• "Asynchronous" means the sender and receiver agree on a speed
(baud rate) and use start/stop bits to frame each byte of data to
time the bits.
SERIAL COMMUNICATION
UART PROTOCOL (Universal Asynchronous Receiver/Transmitter):

• The UART 0 pins on the ESP32 is the default

and is linked to the USB port for flashing.
• You should not use UART 0 for
communication, instead use UART 1, UART 2...,
otherwise flashing will fail.
• You can also remap UART pins to other pins,
you should use the safe pins*.

Checkout this link for more info: https://randomnerdtutorials.com/esp32-uart-

communication-serial-arduino/
*Safe pins: Check out the pinouts (link in the slides) to see if the pin is OKAY TO USE.
SERIAL COMMUNICATION
The Serial Monitor

A built-in tool in the Arduino IDE (and similar IDEs like PlatformIO) that acts as
a terminal. It allows you to:
• View Output: See any data the ESP32 sends via Serial.print() or
Serial.println().
• Send Input: Type data and send it to the ESP32 for your code to read via
Serial.read().
Baud Rate: speed in bits per second (bps).
• It's critical that the baud rate set in the Serial Monitor exactly matches the
rate specified in your ESP32 code (e.g., Serial.begin(115200)).
• Common rates include 9600, 115200 . If they don't match, you'll see
garbage characters or nothing at all.
SERIAL COMMUNICATION
Basic Commands Reference
• Serial.begin(baudrate): Initializes the default serial port (UART0) and sets the communication speed.
Example: Serial.begin(115200);
• Serial.print(data): Sends data to the serial port. The data can be text, numbers, variables, etc. It does not
automatically add a new line after the data. Example: Serial.print("Value: "); Serial.print(sensorValue);
• Serial.println(data): Similar to Serial.print(), but adds a newline character (\n) and a carriage return (\r) at
the end, so the next print will start on a new line in the Serial Monitor. Example: Serial.println("Hello,
ESP32!");
• Serial.printf(format, ...): Allows for formatted printing, similar to printf in C. This is very useful for neatly
displaying variables. Example: Serial.printf("Temperature: %.2f C, Humidity: %d %%\n", temp, hum);
• Serial.available(): Returns the number of bytes (characters) available for reading from the serial port.
Useful to check if there's incoming data before trying to read it. Example: if (Serial.available() > 0) { ... }
• Serial.read(): Reads a single incoming byte (character) from the serial buffer. Returns -1 if no data is
available. Example: char incomingByte = Serial.read();
• Serial.readString(): Reads characters from the serial buffer into a String object until a timeout occurs.
• Serial.readStringUntil(terminator): Reads characters into a String until a specific terminator character is
encountered or a timeout occurs. Example: String command = Serial.readStringUntil('\n');
Example time:
Head to Wokwi.com to and follow along
with the coding walkthrough.

Serial Monitor Test:

https://wokwi.com/projects/432034872801320961 - Example on Wokwi
GPIO - GENERAL PURPOSE INPUT/OUTPUT
These are digital pins on the ESP32 that you can
programmatically control.
• They are the "eyes, ears, and hands" of the
microcontroller:
⚬ Output: Control LEDs, relays, send signals to other
chips.
⚬ Input: Read the state of buttons, switches, or
signals from sensors.
• Each GPIO pin can be configured to be either an input
(to read signals) or an output (to send signals).
GPIO - GENERAL PURPOSE INPUT/OUTPUT
The Voltage Level: ESP32 GPIOs operate at a
3.3V logic level.
• A HIGH signal is ~3.3V.
• A LOW signal is ~0V (GND).
• Crucial Warning: ESP32 pins are generally
NOT 5V tolerant. Connecting a 5V signal
directly to an ESP32 input pin can damage it.
Use a logic level shifter if you need to
interface with 5V devices.
• When picking a GPIO pin, you should aways
check if it is OKAY TO USE.
https://randomnerdtutorials.com/esp32-pinout-reference-gpios/
GPIO - GENERAL PURPOSE INPUT/OUTPUT
The pinMode(pin, MODE) function is used in your setup() to configure a GPIO
pin's behavior.
• pin: The GPIO number you want to configure (e.g., 2, 13, 27).
• MODE:
⚬ OUTPUT: Configures the pin as a digital output. You can then set it HIGH or LOW.
⚬ INPUT: Configures the pin as a digital input. You can then read its state. By default,
an input pin is "floating" – if nothing is connected, its state can be unpredictable.
⚬ INPUT_PULLUP: Configures the pin as a digital input and enables an internal pull-
up resistor. This connects the pin to VCC (3.3V) through this resistor. If an external
switch then connects the pin to GND, the pin will read LOW. If the switch is open, it
reads HIGH.
⚬ INPUT_PULLDOWN: internal pull-down resistors, connecting the pin to GND.
*Note: On the ESP32, the GPIO pin number is the same as the actual pin number on the board (D-x or G-x with x
as an int), but on the esp8266, it might be different!
GPIO - GENERAL PURPOSE INPUT/OUTPUT
DIGITAL INPUT - OUTPUT
INPUT: The digitalWrite(pin, VALUE) function sets the state of a GPIO
pin configured as an OUTPUT.
• pin: The GPIO number.
• VALUE:
⚬ HIGH: Sets the pin's output voltage to 3.3V.
⚬ LOW: Sets the pin's output voltage to 0V (GND).
OUTPUT: The digitalRead(pin) function reads the current state of a GPIO
pin configured as an INPUT or INPUT_PULLUP.
• Returns HIGH (usually 1) if the voltage is above a certain threshold.
• Returns LOW (usually 0) if the voltage is below a certain threshold.

*Read about debouncing!

GPIO - GENERAL PURPOSE INPUT/OUTPUT
ADC - ANALOG to DIGITAL CONVERTER

Take an analog voltage, which is a continuous signal that can have any value within a
certain range (output of a potentiometer or types of sensors), and convert it to a
digital number that the microcontroller can understand and process.
• Resolution: The ESP32's ADCs are typically 12-bit. They can represent an analog
voltage as a digital value ranging from 0 up to 212 - 1 = 4095.
⚬ A 0V input correspond to a digital value of 0.
⚬ The maximum input voltage (e.g., 3.3V) would correspond to a value of 4095.
GPIO - GENERAL PURPOSE INPUT/OUTPUT
ADC - ANALOG to DIGITAL CONVERTER

• ADC Channels/Units: Two main ADC units:

ADC1 and ADC2.
⚬ If you are using any wifi function, ADC2 will
not be usable, find out why!
• To read an analog value, analogRead(pin):
⚬ pin: The GPIO number that is ADC-capable
(e.g., 34, 36).
⚬ It returns an integer value based on the
ADC's resolution and the current
attenuation setting (e.g., 0-4095 for 12-bit
resolution).
• What about analogWrite()? learn about PWM!
https://docs.arduino.cc/language-reference/en/functions/analog-io/analogWrite/
Example time:
Head to Wokwi.com to and go along
with the coding walkthrough.

https://wokwi.com/projects/431669258019392513 - Blink
https://wokwi.com/projects/431670205810590721 - Blink with button
https://wokwi.com/projects/431671388988226561 - Digital Sensor
https://wokwi.com/projects/431673863990706177 - Analog Sensor
COMMUNICATION PROTOCOLS: I2C AND SPI
I²C (Inter - Integrated Circuit) read as “I-two-C or I-Squared-C”

• Two-Wire Interface: It uses only two signal lines:

⚬ SDA (Serial Data): Carries the actual data being transmitted.
⚬ SCL (Serial Clock): Carries the clock signal, synchronizing data transfer,
generated by the master.
COMMUNICATION PROTOCOLS: I2C AND SPI
I2C (Inter - Integrated Circuit) read as “I-two-C or I-Squared-C”

• Master-Slave Architecture: One device on the bus is the "master" (usually the
ESP32), which initiates communication and generates the clock signal. Other
devices are "slaves" (sensors, displays), which respond to the master.
• Addressing: Each slave device on an I²C bus has a unique 7-bit (or sometimes 10-
bit) address. This allows the master to select which slave it wants to communicate
with, so multiple slaves can share the same SDA and SCL lines.
*Note: You can get the address in the device documentation or using a address_scanner script.
*See more at: https://randomnerdtutorials.com/esp32-i2c-communication-arduino-ide/
COMMUNICATION PROTOCOLS: I2C AND SPI
Using I²C (Wire.h library) Basic Commands
#include <Wire.h>
• Wire.begin(optional_sdaPin, optional_sclPin): Initializes the I²C bus. Call this in setup(). If
pins are not specified, it uses the defaults (SDA - GPIO 21, SCL - GPIO 22).
• Wire.beginTransmission(deviceAddress): Starts communication with the slave device at
the given 7-bit address.
• Wire.write(data): Sends a byte of data (or an array of bytes) to the slave.
• Wire.endTransmission(): Ends the transmission. It returns a status code (0 for success).
• Wire.requestFrom(deviceAddress, numBytes): The master requests numBytes of data
from the slave.
• Wire.available(): Returns the number of bytes available to be read after a requestFrom().
• Wire.read(): Reads a byte of data that was sent from the slave.
Example time:
Head to Wokwi.com to and go along
with the coding walkthrough.

https://wokwi.com/projects/431672190021741569 - I2C Device Scanner

https://wokwi.com/projects/431672174285759489 - I2C Sensor and LCD
COMMUNICATION PROTOCOLS: I2C AND SPI
SPI (Serial Peripheral Interface)
Typically uses four wires (though 3-wire variations exist):
• MOSI (Master Out, Slave In): Data from Master to Slave.
• MISO (Master In, Slave Out): Data from Slave to Master.
• SCLK (Serial Clock): Clock signal generated by the Master to
synchronize data transfer.
• CS (Chip Select): Used by the Master to select which Slave
device it wants to communicate with. Each slave needs its own
dedicated CS line. This line is active LOW.
• Master-Slave Architecture: Similar to I²C, the ESP32 is typically
the Master.
• Full-Duplex: Data can be sent from Master to Slave (MOSI) and
from Slave to Master (MISO) at the same time on the same clock
cycle.
COMMUNICATION PROTOCOLS: I2C AND SPI
SPI (Serial Peripheral Interface)
• The ESP32 has multiple SPI controllers. Two main ones are often referred to as VSPI
(Versatile SPI) and HSPI (Hardware SPI). The ESP32-WROOM-32 module also has two
more SPI controllers (SPI0/SPI1) that are typically used for accessing the integrated
flash memory and PSRAM, so they are not usually available for general peripheral
use.
• Default Pins (Arduino Core for VSPI):
⚬ GPIO23 for MOSI
⚬ GPIO19 for MISO
⚬ GPIO18 for SCLK
⚬ GPIO5 for CS (though any GPIO can be used as a CS pin, controlled manually
by your code). These pins can also be reconfigured.

*Read more at: https://randomnerdtutorials.com/esp32-spi-communication-

arduino/
COMMUNICATION PROTOCOLS: I2C AND SPI
Using SPI (SPI.h library) Basic Commands
#include <SPI.h>
• SPI.begin(sckPin, misoPin, mosiPin, ssPin): Initializes the SPI bus. If pins are not specified, it uses the
defaults for VSPI. The ssPin here is often a default, but you'll usually control CS pins manually.
• SPI.beginTransaction(SPISettings(speed, bitOrder, dataMode)): Configures the SPI bus settings for a
specific device before communication.
⚬ speed: Clock speed (e.g., 1000000 for 1MHz).
⚬ bitOrder: MSBFIRST or LSBFIRST.
⚬ dataMode: SPI_MODE0, SPI_MODE1, SPI_MODE2, or SPI_MODE3 (defines clock polarity and phase).
• digitalWrite(csPin, LOW): Manually activate the Chip Select line for the target slave device by pulling it
LOW.
• SPI.transfer(data): Sends a byte of data and receives a byte of data simultaneously. If you only want to
send, you can ignore the return value. If you only want to receive, you can send a dummy byte (e.g.,
0x00).
• SPI.transfer(buffer, size): Transfers multiple bytes.
• digitalWrite(csPin, HIGH): Manually deactivate the Chip Select line by pulling it HIGH after the
transaction.
• SPI.endTransaction(): Releases the SPI bus configuration.
Example time:
Please read more at
https://randomnerdtutorials.com/esp3
2-spi-communication-arduino/

https://wokwi.com/projects/431673072369170433 - Example on Wokwi

ESP32 - WIFI FUNCTIONALITY
Introductory
• This is considered one of the most
compelling features of the ESP32.
Built-in WiFi (and Bluetooth) makes it
an excellent choice for Internet of
Things (IoT) projects.
• It supports 2.4 GHz WiFi (IEEE 802.11
b/g/n) standards.
• The ESP32 can operate in several WiFi
modes, giving you flexibility in how it
connects to or creates networks.

*See more at: https://randomnerdtutorials.com/esp32-useful-wi-fi-functions-

arduino/
ESP32 - WIFI FUNCTIONALITY
Modes of Operation
Station Mode (STA):
• The ESP32 acts like a typical WiFi client device (like your laptop or smartphone).
⚬ Purpose: It connects to an existing WiFi network, usually provided by a wireless
router.
⚬ Once connected, it can access the internet (if the router has internet
connectivity) or communicate with other devices on the same local network. IoT
devices that need to send data to a server or be controlled over the internet.
ESP32 - WIFI FUNCTIONALITY
Modes of Operation

Access Point Mode (AP):

• The ESP32 creates its own WiFi network. Other devices (like phones, tablets,
or other ESP32s) can then connect directly to the ESP32's network.
• Purpose: Useful for:
⚬ Direct device-to-device communication when no existing WiFi network is
available.
⚬ Initial configuration of an ESP32 device (e.g., a phone connects to the
ESP32's AP to provide credentials for the home WiFi network).
⚬ Creating a small, localized network.
⚬ The ESP32 in AP mode acts like a mini-router .
ESP32 - WIFI FUNCTIONALITY
Modes of Operation

STA+AP Mode (Station + Access Point):

• The ESP32 can operate in both modes simultaneously. It can be connected
to an existing WiFi network (STA) while also hosting its own network (AP).
• Purpose: Can be useful for bridging networks or for devices that need to
offer a direct configuration interface while also being connected to a main
network.
ESP32 - WIFI FUNCTIONALITY
Basic Wifi Commands (Wifi.h Library): STA MODE
• const char* ssid = "YourNetworkSSID";
• const char* password = "YourNetworkPassword";
• WiFi.begin(ssid, password);: Initiates the connection attempt. This is non-
blocking, so you need to check the status.
• WiFi.status(): Returns the connection status. Key values:
⚬ WL_CONNECTED: Successfully connected.
⚬ WL_IDLE_STATUS, WL_NO_SSID_AVAIL, WL_CONNECT_FAILED,
WL_CONNECTION_LOST, WL_DISCONNECTED, etc.
• WiFi.localIP(): Once connected, this returns the IP address assigned to the
ESP32 by the router.
ESP32 - WIFI FUNCTIONALITY
Basic Wifi Commands (Wifi.h Library): STA MODE
• const char* ssid = "YourNetworkSSID";
• const char* password = "YourNetworkPassword";
• WiFi.begin(ssid, password);: Initiates the connection attempt. This is non-
blocking, so you need to check the status.
• WiFi.status(): Returns the connection status. Key values:
⚬ WL_CONNECTED: Successfully connected.
⚬ WL_IDLE_STATUS, WL_NO_SSID_AVAIL, WL_CONNECT_FAILED,
WL_CONNECTION_LOST, WL_DISCONNECTED, etc.
• WiFi.localIP(): Once connected, this returns the IP address assigned to the
ESP32 by the router.
ESP32 - WIFI FUNCTIONALITY
Basic Wifi Commands (Wifi.h Library): AP MODE
• const char* ap_ssid = "ESP32_AP";
• const char* ap_password = "password123"; // Use a good password, min 8
chars for WPA2-PSK
• WiFi.softAP(ap_ssid, ap_password);: Creates the Access Point.
• WiFi.softAPIP(): Returns the IP address of the ESP32's AP (usually something
like 192.168.4.1 by default).
Example time:
Open Wokwi.com to follow the walkthrough
Connect to a Wifi (STA-MODE): https://wokwi.com/projects/432082678927045633
Send a HTTP get request: https://wokwi.com/projects/432082971549025281
Control led with Webserver: https://randomnerdtutorials.com/esp32-web-server-
arduino-ide/

Please read more at https: https://randomnerdtutorials.com/esp32-useful-wi-fi-functions-arduino/

Pro tips
Dashboards:
• It is best practice to create your own Web App dashboard and communicate via HTTP,
MQTT or SDK either locally host or using a cloud provider (check out Azure IOT Hub, AWS
things ...)
• You could also use these platforms to quickly create a dashboard to visualize and remote
control your system:
⚬ Node-Red: this software helps construct dashboard quickly without much coding.
￭ https://nodered.org/docs/getting-started/
￭ https://flowfuse.com/blog/2024/11/esp32-with-node-red/
⚬ Blynk: This is a famous and powerful but free Iot Cloud provider, it can also create dashboard
quickly without much coding.
￭ https://docs.blynk.io/en
⚬ Thinkspeak: A free and easy to use Cloud IOT platform:
￭ https://www.mathworks.com/help/thingspeak/index.html
￭ https://randomnerdtutorials.com/esp32-thingspeak-publish-arduino/
⚬ Adafruit-IO: https://learn.adafruit.com/adafruit-esp32-s2-feather/adafruit-io-send-and-receive-
data
Pro tips
Platform-IO + Wokwi:
• While the Arduino IDE is fantastic for beginners with its straightforward setup, as your IoT
projects become more ambitious, you will want a more powerful environment.
• PlatformIO as a VS Code extension, grants you robust library management that simplifies
finding and integrating necessary code:
⚬ Versatile board support
⚬ Integrated debugging features to quickly troubleshoot your code.
⚬ You can leverage all your favorite VS Code features and extensions alongside
PlatformIO for a truly customized setup.
• Wokwi, a VS Code extension, provides powerful simulation capabilities, crucially including
Wi-Fi functionality. This allows you to:
⚬ Test complex IoT scenarios, such as data communication with other virtual devices or
cloud platforms, all without needing physical hardware.
• https://platformio.org/install/ide?install=vscode
• https://docs.wokwi.com/vscode/getting-started
• https://docs.wokwi.com/vscode/project-config
PROJECTS 1.Smart Weather Station:
IDEAS ⚬ Collect Environmental data using the microcontroller.
⚬ Analyze the data.
⚬ Visualize the Data on a Dashboard.
⚬ Notify the User of the Weather data (Phone app,
email).
2.Smart Irrigation System:
⚬ Collect the soil moisture of the a plant.
⚬ Analyze if the plants need to be water.
⚬ Automatically water the plant (via Pump).
⚬ Notify/ Shows to the user state of the plant.
⚬ Manual Stop trigger (Via Phone app/ Dashboard).
PROJECTS 3. Gas-Leak Detector:
IDEAS • Collect Harmful Gas data in the environment.
• Compare to the threshold.
• Notify the user when the air is no longer safe (Beep/Phone
App/Email).
• Display the current condition of the gas in the environment on a
dashboard or phone app.
4. Heart-Monitoring Device:
• Collect heart beat data from the user.
• Notify if the heart beat is too high (Beep, Phone App, Email).
• Display the heart beat in a dashboard or phone app.
PROJECTS
IDEAS
These are just some simple ideas for you to reference.
Feel free to add more or create your own ideas (add some AI into it!)
A submission form with the requirements will be sent later on Moodle!
We recommend using Github to manage your project, and send the link to
us if you have questions.
Ask for guidance, not for answers!

Helpline: [email protected]