###### Project Report - LNU IoT 2023 - Sreehas Sreejith -st223gk
**Table of Contents:**
[TOC]
Project Overview
===
**Title:** **IoT-powered Smart Temperature and Humidity Monitoring System**
The aims is to develop an IoT-based system for monitoring and collecting temperature and humidity data using a temperature sensor. The project will be implemented by **Sreehas Thyparambil Sreejith**, a student with the credentials **st223gk**. The estimated timeframe for completing the project is approximately **4 weeks** including the report writing.
Objective
===
The objective of the project is to develop an IoT-based system for monitoring temperature and humidity by collecting those data using a temperature sensor **DHT11** and microcontroller board **Raspberry Pi Pico WH**. My main goal is to collect real-time temperature and humidity data from the DHT11 sensor and visualize them continuously on the **Adafruit IO platform** through **MQTT Protocol**.
In the possible next phase, the collected temperature and humidity data, along with triggered webhook messages, will be utilized to control the operation of devices such as heaters, air conditioners (ACs), and humidifiers. This phase involves leveraging the gathered data to make informed decisions and automatically adjust the settings of these devices based on the monitored environmental conditions.
*Please note that I have mentioned more practical implementation at the end of this document.*
Material
===
I purchased the start kit which is recommended by Linnaeus University for this Applied IoT course from **Electrokit.com** for a total cost of **428 SEK**, including tax.
#### **List of Materials that was included in the start kit**
1x Raspberry Pi Pico WH
1x Kopplingsdäck 840 anslutningar
1x USB-kabel A- hane – micro B 5p hane 1.8m
20x Labbsladd 30cm hane/hane
10x Labbsladd 30cm hona/hane
10x Motstånd kolfilm 0.25W 330ohm (330R)
10x Motstånd kolfilm 0.25W 560ohm (560R)
10x Motstånd kolfilm 0.25W 1kohm (1k)
10x Motstånd kolfilm 0.25W 10kohm (10k)
5x LED 5mm röd diffus 1500mcd
5x LED 5mm gul diffus 1500mcd
5x LED 5mm grön diffus 80mcd
2x Fotomotstånd CdS 4-7 kohm
1x Tilt switch
1x MCP9700 TO-92 Temperaturgivare
1x TLV49645 SIP-3 Hall-effektsensor digital
1x Magnet Neo35 Ø5mm x 5mm
1x Digital temperatur- och fuktsensor DHT11
#### **List of Materials and Technologies that I used for this project and its specifications**
###### **1) <u>Raspberry Pi Pico WH:**</u>
 Fig.1.1. Raspberry Pi Pico WH (hitechchain.se)
The Raspberry Pi Pico WH **(Fig.1.1)** is a microcontroller board based on the RP2040 chip. It provides sufficient processing power and GPIO pins for interfacing with various sensors and components.
###### **2) <u>USB Cable A-male to Micro B 5p male:**</u>
 Fig.1.2. Breadboard (hitechchain.se)
The USB cable **(Fig.1.2)** is used to power the Raspberry Pi Pico WH and establish communication with a computer or power source.
###### **3) <u>Breadboard - 840 connections:**</u>
 Fig.1.3. Breadboard (electrokit.com)
The breadboard **(Fig.1.3)** with 840 connections offers a convenient platform for prototyping and connecting electronic components without soldering.
###### **4) <u>Jumper Wires:**</u>
 
Fig.1.4. Jumper Wires Male to male | Fig.1.5. Jumper Wires Female to male (electrokit.com)
Jumper wires **(Fig.1.4 & Fig.1.5)** are used to establish electrical connections between components on the breadboard.The package includes 20 male-to-male labbsladd (30cm) and 10 female-to-male labbsladd (30cm) wires but I only used 3 male-to-male and 3 female-to-male to achieve my goal.
###### **5) <u>DHT11 Digital Temperature and Humidity Sensor:**</u>
 Fig.1.6. DHT11 Sensor (electrokit.com)
The DHT11 sensor **(Fig.1.6)** is used to measure temperature and humidity levels. It provides a digital output and has a temperature measurement range of 0 to 50 degrees Celsius with ±2 degrees Celsius accuracy. The humidity measurement range is 20% to 90% with ±5% accuracy.
###### **6) <u>Technology Used to Visualize Data: ADAFRUIT through MQTT Protocol**</u>
Fig.1.7.(io.adafruit.com)
In order to visualize and track the temperature and humidity data from the DHT11 sensor, I integrated the Adafruit IO platform into my project. Adafruit IO offers a user-friendly interface for data visualization and allows seamless communication between the Raspberry Pi Pico WH and the platform.
Fig.1.8.(www.mqtt.org)
To establish a connection between the Raspberry Pi Pico WH and Adafruit IO, I utilized the MQTT (Message Queuing Telemetry Transport) protocol. MQTT is a lightweight messaging protocol that enables efficient and reliable communication between devices and servers. It is well-suited for IoT applications where bandwidth and power consumption are critical.
Computer Setup
===
#### <u>**Installed VS Code, Node js & Pymakr Plugin**</u>
For this IoT project, I utilized an Apple MacBook Pro Mid 2015 model running macOS Monterey as my development environment. I installed **Node js** before installing IDE and To enhance my coding experience, I opted for **Microsoft Visual Studio Code** as my integrated development environment (IDE). Visual Studio Code offers a wide range of features and extensions that streamline the development process. To further augment my workflow, I installed the **Pymakr plugin** directly from the extension manager within Visual Studio Code. Pymakr provides seamless integration with my Raspberry Pi Pico WH microcontroller, enabling efficient code deployment and debugging.
In addition, I noticed that both the Project section and Device section were visible, indicating that I had successfully installed all the necessary components and set up the environment correctly. This observation confirmed that my installation of Microsoft Visual Studio Code as the IDE, along with the Pymakr plugin, was successful.
#### <u>**Updated Firmware and tested code to confirm the communication**</u>
To flash the Raspberry Pi Pico board with MicroPython firmware and test code, I visited the MicroPython website at (https://micropython.org/download/rp2-pico-w/) and downloaded the **MicroPython firmware** in the UF2 format. It was crucial to ensure that I downloaded the latest version available under the releases category to have the most up-to-date features and improvements. With the micro-USB end of the cable connected to the Raspberry Pi Pico's port, I held down the BOOTSEL key on the board. While keeping the key pressed, I connected the USB type-A end of the cable to the USB port on my computer. Once the Raspberry Pi Pico was connected in BOOTSEL mode, a new drive named "RPI-RP2" appeared in the file system. I located the downloaded UF2 firmware file and copied it to this newly opened drive. After a brief moment, the board automatically disconnected from my computer and then reconnected. This reconnection indicated that the firmware flashing process was underway. By following these steps, I successfully flashed the Raspberry Pi Pico board with the MicroPython firmware. This firmware provides the necessary foundation for running and testing MicroPython code on the board. With the flashing completed, I was ready to proceed with uploading and executing my test code to verify the functionality of the board and ensure a smooth setup for my IoT project.
#### <u>**Tested the board**</u>
During the testing phase, I followed the following steps to verify the functionality of the Raspberry Pi Pico board:
**Step 1:** I input the code snippet provided below after the >>> symbols in the MicroPython REPL (Read-Eval-Print Loop) interface:
```python=1
print("Good Luck With Your Studies From LNU!")
```
**Step 2:** As expected, the connected board responded with the exact same text, confirming the successful execution of the code. This response was displayed in the MicroPython REPL interface, providing reassurance that the board was functioning properly.See **(Fig.2)**
Fig.2.0 (Screenshot from VS Code)
The purpose of this test was to ensure that the board was capable of executing basic code and producing the expected output. By receiving the response "Good Luck With Your Studies From LNU!" from the connected Raspberry Pi Pico board, it confirmed that the board was operational and able to execute code instructions.
This successful test result indicated that the board, firmware, and code execution were all functioning correctly, setting a solid foundation for further development and implementation of the IoT project.
Overall, the testing phase verified the basic functionality of the Raspberry Pi Pico board, providing confidence in its performance and validating its capability to execute code accurately.
#### <u>**Importing Library**</u>
The Raspberry Pi Pico WH, which is the newly released MCU variant I used for this project, comes with a built-in library that allows seamless communication with the DHT11 sensor. This means that there was no need for me to import any external libraries specifically for the DHT11 sensor.
With the inbuilt library provided by the Raspberry Pi Pico WH, I was able to establish a direct connection and retrieve data from the DHT11 sensor without any additional setup or configuration. This streamlined the development process and eliminated the need for additional dependencies.
Sensor Connection
===
Fig.3.0 (Circuit Diagram)
During the sensor connection process, the following steps were followed:
**Step 1:** The USB cable was connected to the sensor, but it was not immediately connected to the computer to avoid any potential damage to the sensor due to incorrect connections.
**Step 2:** To power up the breadboard, a black-colored male-to-male jumper wire was utilized. The ground (GND) pin of the sensor, which corresponds to the 38th pin, was connected to the positive (+) power rails of the breadboard.
**Step 3:** A red-colored male-to-male jumper wire was employed to establish a power connection. The 3V3 (Out) pin of the sensor, located on the 36th pin, was connected to the negative (-) power rails of the breadboard. This ensured a stable power supply for the sensor.
**Step 4:** For powering up the DHT11 sensor, a red-colored female-to-male jumper wire was used. The Vcc (+) pin of the sensor was connected to the positive (+) power rails of the breadboard, providing the necessary power to the sensor.
**Step 5:** To complete the power connections, a black-colored female-to-male jumper wire was utilized. The ground (-) pin of the sensor was connected to the negative (-) power rails of the breadboard, establishing the ground connection.
**Step 6:** To enable data collection, a blue-colored female-to-male jumper wire was employed. It was used to connect the data pin (S-Signal) of the sensor to GP27 on the Raspberry Pi Pico board. GP27 corresponds to the analog-to-digital converter (ADC1) and is located on the 32nd pin. This connection facilitated the transmission of data from the sensor to the board.
**Step 7:** After carefully double-checking all the connections to ensure their accuracy and proper alignment, the USB cable was finally connected to the computer. This allowed the Raspberry Pi Pico W board to receive a voltage of approximately 5 volts (5V) from the USB power source. The board is designed to operate within this voltage range, ensuring the proper functioning of the board and its components.
*It is worth noting that when connecting the DHT11 sensor to the Raspberry Pi Pico board, it is crucial to observe the voltage requirements. The sensor operates at a voltage of 3.3V, which is within the operating range of the Pico board. Therefore, the Pico board provides a voltage of 3.3V to the DHT11 sensor for both power supply and communication purposes. This voltage compatibility ensures the safe and accurate operation of the sensor with the Raspberry Pi Pico board.*
Fig.3.1. (Photo of Actual Setup - Top View)
Data Reading
===
In the data reading section, the primary objective was to confirm the successful connection between the sensor and the Raspberry Pi Pico board, as well as to obtain the current room temperature reading from the sensor. To achieve this, the following code snippet was executed:
```python=1
import dht
import machine
sensor = dht.DHT11(machine.Pin(27))
sensor.measure()
print(sensor.temperature())
```
This code imports the necessary modules, namely dht and machine, to enable communication with the DHT11 sensor and interact with the hardware components of the Raspberry Pi Pico board, respectively.
An instance of the DHT11 class from the dht module is created and assigned to the variable sensor. The constructor of the DHT11 class takes the pin number as its parameter, indicating the pin on the Raspberry Pi Pico board to which the data line of the sensor is connected. In this case, pin number 27 was used for the connection.
Upon initializing the sensor, the measure() method is invoked on the sensor object. This method instructs the sensor to take a measurement of the temperature and humidity in the surrounding environment.
The temperature() method is then called on the sensor object to retrieve the measured temperature value. This value is subsequently printed to the console using the print() function.
Upon executing the code, the output displayed the current room temperature, which was observed to be **26 degrees Celsius** as shown in the **(Fig.4.0)**.
This successful output reaffirmed the accuracy of the connections established between the DHT11 sensor and the Raspberry Pi Pico board, thus confirming their proper functionality.
Fig.4.0 (Screenshot from VS Code)
Network Connection - WiFi as Gateway
===
To enable internet connectivity for my development board, I utilized the built-in WiFi functionality of the Raspberry Pi Pico WH and connected to my home Wi-Fi. The following steps outline the process I followed to connect the development board to my home wireless router:
###### <u>Creation of secrets.py File:</u>
To safeguard the security of my WiFi credentials, I created a file named "secrets.py." Within this file, I stored the necessary information in a dictionary format. However, for the purpose of this report, I have substituted the actual values with placeholders. The "secrets.py" file contained the following code:
```python=1
secrets = {
'ssid': 'My WiFi Username', # Placeholder for WiFi username
'password': 'My WiFi Password', # Placeholder for WiFi password
}
```
Please note that I have deliberately withheld the actual WiFi username and password to maintain the confidentiality of my personal information.
###### <u>Integration of Code into boot.py:</u>
The next step involved copying the provided self-commented code, given by LNU University (https://hackmd.io/@lnu-iot/rJVQizwUh), into the "boot.py" file. This file is executed automatically upon booting the Raspberry Pi Pico WH.
###### <u>Connection Troubleshooting:</u>
Upon running the code, I encountered an issue where the output displayed "waiting for connection..." without any further progress. To resolve this, I had to force quit the Visual Studio Code (VS Code) application and disconnect the USB cable from my computer. Subsequently, I relaunched VS Code and reconnected the USB cable. Additionally, I disabled the 5GHz frequency on my home router and utilized only the 2.4GHz WiFi connection. These troubleshooting steps were necessary to establish a successful connection.
###### <u>Successful Connection and HTTP Request:</u>
After resolving the connection issues, my Raspberry Pi Pico WH successfully connected to my home wireless router. It obtained an IP address and initiated an HTTP request as shown in **(Fig.5.0)**. This indicated that the network connection was established and the development board was able to communicate with the desired network resources.
Fig.5.0 (Screenshot from VS Code)
*By following these steps and addressing the encountered troubleshooting challenges, I successfully connected my Raspberry Pi Pico WH to my home wireless router. This allowed the development board to access the internet and perform HTTP requests, enabling further functionality and interaction with online resources.*
Visualized Random Data
===
To establish network connectivity and visualize data, I utilized the built-in WiFi capabilities of the Raspberry Pi Pico WH and integrated it with the **Adafruit IO platform**. The following steps outline the process I followed:
###### Adafruit IO Account Setup:
I began by creating and registering an account with Adafruit IO. This account provided access to the Adafruit control panel and other features necessary for data visualization and communication.
###### Feed Creation:
Within the Adafruit IO control panel, I navigated to the IO tab and selected Feeds. Here, I created two feeds: "Randoms" and "Lights." The "Randoms" feed was designed to showcase random values generated by the development board and display them in a line chart. The "Lights" feed allowed control over the development board's LED, enabling remote toggling of its state.
###### Dashboard Creation:
To visualize the data, I created a dashboard within the Adafruit IO control panel. This involved selecting the Dashboard option under the IO tab, naming the dashboard, and providing a description. The newly created dashboard served as a visual interface for monitoring and interacting with the data.
###### Block Configuration:
Within the dashboard, I utilized various block options, such as line charts and toggle switches, to visualize and control the data. I connected the line chart block to the "Randoms" feed, displaying the incoming values. Similarly, I connected the toggle switch block to the "Lights" feed, allowing me to remotely turn the development board's LED on and off. By configuring the layout and resizing the blocks, I customized the appearance of the dashboard.
###### Adafruit Credentials Integration:
To establish communication between the Raspberry Pi Pico and Adafruit IO, I needed to incorporate my Adafruit credentials into the code. By accessing my Adafruit account, I obtained the necessary information, including the username, active key, and MQTT by Key. I securely stored these credentials for later use in the project.
###### Code Implementation:
In the VS Code environment, I created a new file called "mqtt.py" and copied the provided code, which facilitated the interaction between the Raspberry Pi Pico and Adafruit IO. Additionally, I modified certain sections of the main.py code, such as the WiFi credentials and the Adafruit IO credentials, to ensure proper connectivity.
###### Data Publication and Subscription:
Upon running the code, the Raspberry Pi Pico began publishing random temperature values, ranging from 0 to 100 as shown in **(Fig.6.0 & Fig.6.1)**, to the Adafruit MQTT server every **19 to 20 seconds**.
Fig.6.0. (Screenshot from Adafruit Feed History- Sent every 19 to 20 seconds)
Fig.6.1. (Screenshot from Adafruit Feed Line Chart - Random from June 20 to June 22)
###### Webhook Integration:
To forward the data from Adafruit IO to a Discord server, I employed webhooks. Within the Discord application, I created a server specifically for the project. Then, by accessing the server's settings and selecting Integrations, I generated a webhook URL. Returning to the Adafruit IO control panel, I navigated to the Actions tab under the IO tab and created a new reactive action. This action was configured to send a webhook message to the Discord server whenever the "Randoms" feed value exceeded a specified threshold (80 in this case). The message included the value and timestamp of the data received. I limited the frequency of webhook messages to every fifteen minutes to avoid flooding the Discord server.
###### Data Visualization and Communication:
Upon submitting the action configuration, I began receiving random values from the development board via the "Randoms" feed. When the values exceeded the specified threshold (80 in this case), Adafruit IO triggered a webhook message, forwarding the value and timestamp to the Discord server I created earlier as shown in **(Fig.6.2)**.
Fig.6.2. (Screenshot from Discord Server)
*Overall, this network connection and data visualization setup proved instrumental for me to build a temperature and humidity monitoring system next, showcasing the data continuously on the Adafruit IO platform, and relaying relevant information to the Discord server.*
Visualized Actual Temperature and Humidity Data
===
In order to generate actual temperature and humidity data and send it to a Discord server via Adafruit IO, modifications were made to the provided code. The objective was to send data from DHT11 sensor such as temperature and humidity. This section explains the changes made to the code to achieve the desired functionality.
#### Code Modifications:
###### Importing the DHT Library:
The code given by Linnaeus University did not include the necessary library for reading temperature and humidity values. The **"dht"** library was imported to enable the Raspberry Pi Pico W board to communicate with the DHT11 sensor.
###### Reading Temperature and Humidity:
A DHT11 object was created, specifying the pin to which the sensor was connected. The **'dh.measure()'** function was used to read the temperature and humidity values from the sensor. These values were then stored in the variables **'temp'** and **'hum'**, respectively and the output in the terminal shows the current temperature and humidity as shown in **(Fig.7.0)**.
```python=34
# FUNCTIONS
dh = dht.DHT11(Pin(27))
dh.measure()
temp = dh.temperature()
hum = dh.humidity()
msg_temp = "The temperature is " + str(temp) + 'C'
msg_hum = "The humidity is %d%%" % hum
print(msg_temp)
print(msg_hum)
```
Output on the Terminal:
Fig.7.0 (Screenshot from VS Code Terminal)
###### Publishing Data to Adafruit IO:
Within the **'send_random()'** function, the values of **'temp'** and **'hum'** were published to their respective feeds on the Adafruit IO MQTT server using the **'client.publish()'** function. The **'AIO_RANDOMS_FEED'** and **'AIO_LIGHTS_FEED'** were used as the topics for publishing temperature and humidity values, respectively and the output in the terminal shows that it has connected to my IP address and connected to Adafruit and published the value to my respective feeds as shown in **(Fig.7.1)**.
```python=90
some_number = random_integer(100)
print("Publishing: {0} to {1} ... ".format(temp, AIO_RANDOMS_FEED))
print("Publishing: {0} to {1} ... ".format(hum, AIO_LIGHTS_FEED), end='')
try:
msgTmp = str(temp) + 'C'
msgHum = str(hum) + '%'
client.publish(topic=AIO_RANDOMS_FEED, msg=msgTmp)
client.publish(topic=AIO_LIGHTS_FEED, msg=msgHum)
print("DONE")
except Exception as e:
print("FAILED")
finally:
last_random_sent_ticks = time.ticks_ms()
```
Output on the Terminal:
Fig.7.1 (Screenshot from VS Code Terminal)
*Additional print statements were added to display the publishing status and the values being sent to Adafruit IO for debugging and verification purposes.*
###### My Dashboard View:
During the execution of the code, the focus was on establishing connections, publishing temperature and humidity values to respective feeds on Adafruit IO, and visualizing the data in a line chart graph. By leveraging the capabilities of Adafruit IO, the temperature and humidity values were transformed into a visually appealing line chart as shown in **(Fig.7.2)**.
Fig.7.2 (Screenshot of Dashboard from Adafruit IO)
#### Webhook Message Conditions Changed:
Instead of relying on a single threshold random values, multiple conditions were introduced to trigger webhook messages. The conditions included as shown in **(Fig.7.0)**:
*If temperature is greater than 25°C, a webhook message with the temperature value would be sent.
If temperature is less than 10°C, a webhook message with the temperature value would be sent.
If humidity is greater than 45%, a webhook message with the humidity value would be sent.
If humidity is less than 30%, a webhook message with the humidity value would be sent.*
I got the message from Adafruit to Discord server through Webhook when my temperature and humidity went above the set value as shown in **(Fig.7.1)**
Fig.7.0 (Screenshot from Adafruit - Actions)
Fig.7.1 (Screenshot from Discord)
Final Codes
===
www.github.com/Sreehasabs/st223gk_LNU_IoT_2023.git
Practical Implemetation, Conclusion And Final Thoughts
===
In the previous phase of the project, the code was further enhanced to include triggers based on temperature and humidity thresholds. By modifying the conditions in the Adafruit IO actions, webhook messages were sent to a Discord server when the temperature exceeded 25 degrees Celsius and the humidity surpassed 45%. This modification was made to verify the functionality of the webhook integration and ensure that messages were being properly sent when the specified conditions were met.
Upon testing, it was observed that when the temperature reached 26 degrees Celsius and the humidity rose to 48%, webhook messages were promptly sent to the Discord server. This confirmed that the Adafruit IO platform successfully communicated with the Discord webhook, delivering the desired temperature and humidity values. The integration between Adafruit IO and Discord was effective in providing real-time updates on the environmental conditions within the monitored space.
Moving forward, the project will proceed to the possible next phase, which involves utilizing the temperature and humidity data and the triggered webhook messages to control the operation of devices such as heaters, air conditioners (ACs), and humidifiers. By incorporating suitable control logic, these devices will be activated or deactivated based on the measured temperature and humidity, ensuring a comfortable and healthy living environment.
**Possible real time project:** I worked as a customer service representative at Touring Cars, a motorhome company located between Stockholm and Uppsala in Sweden, They encountered molding issues under the mattress as shown in **(Fig.8.0)** and ceiling in some of their vehicles due to high humidity. At that time, I wasn't aware of a suitable solution to address this problem. However, through this recent course on IoT, I have learned about a potential solution that could help prevent mold growth. By utilizing the Raspberry Pi Pico and the DHT11 sensor, we can monitor the temperature and humidity levels inside the motorhomes or garages where the vehicles are kept idle during the off-season.With this data, we can trigger devices such as dehumidifiers or ventilation systems to maintain optimal humidity levels and prevent mold formation.
Fig.8.0 - (Actual photo of mold on the mattress in one of the motorhome vehicle)
Throughout the project, several aspects could have been improved or approached differently to enhance the overall outcome:
###### Enhanced User Interface:
While the project focused primarily on the backend functionality, incorporating a user interface for easier interaction and control would have added value. A user-friendly interface could provide options to set thresholds, view real-time data, and customize automation triggers.
###### Extended Functionality:
To further enhance the project, additional features could have been explored. For example, incorporating machine learning algorithms to analyze historical data and predict future temperature and humidity trends could have provided valuable insights for maintaining optimal living conditions.
###### Integration with Other Smart Home Systems:
Expanding the project's scope by integrating it with other smart home systems or platforms, such as Google Home or Amazon Alexa, would have allowed for seamless control and automation of various devices based on the temperature and humidity data.
*Overall, the project was a valuable learning experience, highlighting the potential of IoT technologies and MicroPython in monitoring and managing environmental conditions. By considering the suggested improvements and exploring additional features, future iterations of the project can offer enhanced functionality, usability, and integration within a smart home ecosystem.*
Sign in with Wallet
Connect another wallet