Author: Ali AhmdiDounchali
ID: aa227fi
# Overview
###### tags:`Raspberry Pi Pico W` , `mqtt`, `Adafruit IO`,

<div style="text-align: justify;">
In this project, our aim is to regulate the temperature of the server room using two industrial fans and an air conditioner. Typically, a significant amount of electricity is consumed by the server room's cooling system. However, in our proposed method, we intend to minimize energy consumption based on the location.

To achieve this objective, we plan to utilize the outside air for cooling the server room and maintaining it within the appropriate temperature range. As Skelleftea experiences temperature fluctuations ranging from -35 to +35 degrees Celsius throughout the year, for almost ten months, the temperature remains below 20 degrees Celsius. Given that the ideal temperature range for the server room is between 18 and 24 degrees Celsius, we will utilize the outside temperature to cool the server room effectively.
</div>

### Time To Complete
<div style="text-align: justify;">
This project required approximately 20 hours for implementation, with a learning period spanning over 4 weeks.

</div>


# Objective

<div style="text-align: justify;">
Traditional cooling systems consume a significant amount of electricity, resulting in high energy costs and environmental impacts. Therefore, I wanted to use outside air to cool the server room, with the aim of minimizing energy consumption and optimizing cooling efficiency.
This project aims to provide a more sustainable and cost-effective cooling solution for server rooms.
By implementing this system and analyzing the collected data, we can gain valuable insights into the effectiveness of using outside air to cool the server room. We expect to see energy savings and improved efficiency compared to traditional cooling methods.
</div>

# Material
<div style="text-align: justify;">

</div>

| Tech & Kits | Used material | Price + Store |
|------------------------|----------------------------------------------------|-------------------|
| Start Kit - Applied IoT at Linnaeus University (2023) | Raspberry Pi Pico W, Breadboard, USB A -> Micro B, Jumping wires Male-Male, Digital Temperature- and Humidity Sensor DH11 | 399 SEK, [Electrokit Start Kit](https://www.electrokit.com/produkt/start-kit-applied-iot-at-linnaeus-university-2023/) |
| Sensor Kit, 25 modules | Push button momentary, lightsensor, Passive Buzzer | 299.00 SEK, [Electrokit Sensor Kit – 25 moduler](https://www.electrokit.com/produkt/sensor-kit-25-moduler/) |

## List of material:
Picture|Material|Price (SEK)|
|------------------------|----------------------------------------------------|-------------------|
||Raspberry Pi Pico W |98.00|
||DHT11 | 49.00|
||DHT22|99.00|
||Case Fan|69.00|
||Breadboard | 69.00|
||Jumper cables M-to-M | 29.00|
||micro-USB cable | 39.00|

## List of Specifications

### Raspberry pi pico W:
<div style="text-align: justify;">
The Raspberry Pi Pico W is a compact and powerful microcontroller board. It features the RP2040 chip, which is designed by Raspberry Pi. The Pico W provides ample processing power and GPIO pins for various projects. It offers built-in Wi-Fi and Bluetooth connectivity, allowing seamless wireless communication. With a small form factor, the Pico W is highly versatile and can be easily integrated into IoT projects, robotics, and other electronics applications. It is programmable in MicroPython, C, and other programming languages, making it accessible for beginners and advanced users alike. The Raspberry Pi Pico W is an excellent choice for those seeking a cost-effective and feature-rich microcontroller board.
</div>

#### Pinout and design files


### DHT11:
<div style="text-align: justify;">
The DHT11 sensor is a low-cost, digital temperature and humidity sensor that utilizes a capacitive humidity sensing element and a thermistor for temperature measurement. It provides accurate temperature readings with a range of 0 to 50 degrees Celsius and humidity measurements with a range of 20% to 80%. The sensor communicates with the microcontroller using a single-wire digital interface, making it easy to integrate into various projects. It has a relatively low power consumption and is widely used in applications such as weather stations, HVAC systems, and home automation projects where monitoring temperature and humidity levels is crucial.
</div>

### DHT22
<div style="text-align: justify;">
The DHT22 sensor, also known as the AM2302, is a high-precision digital temperature and humidity sensor. It incorporates a capacitive humidity sensing element and a thermistor for accurate temperature measurements. The DHT22 offers a wide operating range, with temperature readings ranging from -40 to 80 degrees Celsius and humidity measurements ranging from 0% to 100%. It communicates with the microcontroller through a single-wire digital interface, making it easy to integrate into various projects. The sensor provides reliable and precise data, making it suitable for applications such as climate monitoring, greenhouse automation, and indoor environmental control systems.
</div>

# Computer setup

## Installing VS Code IDE
<div style="text-align: justify;">
I use Mac OS as my operating system, and for development, I have selected VS Code as my preferred IDE. I highly recommend following this tutorial,which will guide you through the setup process.

Guide:[**Installing VS Code IDE**](https://hackmd.io/SvANKoxnSf-uR_nW76ejxw?both#Mac-OS)

By following this tutorial, you will:

* Install Node.js, which is a prerequisite for the plugin.
* Set up the VS Code IDE on your machine.
* Add the indispensable Pymakr plugin to your VS Code environment.

By completing these steps, you will have a fully equipped development environment that empowers you to work efficiently and effectively.
</div>

## Mac OS
Follow these steps:
+ **Step 1:** Download and install [**Node js (here)**](https://nodejs.org/en/download).

Once installed, verify with (in the terminal)

    which node

and you should get an output similar to:

    /usr/local/bin/node

+ **Step 2:** Download and install [**VS Code (here)**](https://code.visualstudio.com/Download).

If VSCode was already installed on your MAC and running during the nodejs installtion, restart it.
+ **Step 3:** Open VS Code and then the Extensions manager from: the *left panel icon* OR from *`View >> Extensions`* OR by pressing *`Ctrl+Shift+X`*.
+ **Step 4:** Look for **Pymakr** and Install it. (Follow the numbered steps of the following figure)


+ Confirm that the installation of your development environment was successful by clicking on the pymakr plugin icon in the menu to the left.


If you see the `Projects` section and `DEVICE` section, then you're all set!

## Update Firmware on Raspberry Pi Pico W and run a test code
<div style="text-align: justify;">
To proceed, it is necessary to configure your hardware. You can update your framework by following this link for guidance and instructions.

Guide:[Update Firmware on Raspberry Pi Pico W](https://hackmd.io/@lnu-iot/rkFw7gao_)

## Terminology & Project Structure

Before moving forward, it is important to understand the difference between sensors and actuators, learn about the various sensor communication protocols, and the structure of a MicroPython project in VS Code. For detailed instructions, please follow this link.

Guide:[Terminology & Project Structure](https://hackmd.io/_uploads/ByjIQwkYn.jpg)

# Putting everything together
To install a sensor physically onto the board and connect wires to different pins, you can refer to the following guide for detailed instructions on how to proceed:

Guide: [Sensor Connection & Data Reading](https://hackmd.io/@lnu-iot/r1hUdtzI3)

By following this comprehensive guide, you will learn how to properly install sensors onto the board and establish the necessary connections with different pins. It will provide you with step-by-step instructions and ensure that you can successfully complete the installation process.


# Platform

Adafruit.io is a versatile cloud service that enables seamless connectivity over the Internet, facilitating the storage and retrieval of IoT data. With Adafruit IO, you can enjoy the benefits of real-time data visualization online. It empowers you to control devices, access sensor data, and much more through its platform. Additionally, Adafruit IO allows you to establish connections between your projects and various web services such as Twitter, RSS feeds, and more.
I established a Wi-Fi connection to Adafruit.io and successfully sent data over MQTT to my dashboard on the Adafruit IO platform. This allows me to seamlessly transmit and display information on my dashboard, enabling efficient monitoring and visualization of the data.
</div>

## Transmitting the data / connectivity
<div style="text-align: justify;">
To establish a connection between your device and Adafruit.io using Wi-Fi, you can follow the provided instructions:
</div>

* Begin by ensuring that your device is Wi-Fi enabled and capable of connecting to a network.
* Access the Wi-Fi settings on your device and scan for available networks.
* Locate and select the appropriate network to connect to, providing the necessary credentials (such as SSID and password) if prompted.
* Once connected to the Wi-Fi network, navigate to the Adafruit.io platform.
* Create an account on Adafruit.io if you haven't done so already.
* Within your Adafruit.io account, find and access the section for connecting devices or creating feeds.
* Follow the provided instructions for connecting your device to Adafruit.io via Wi-Fi. This typically involves configuring the Wi-Fi settings on your device to connect to Adafruit.io's network.
* Provide any required credentials or authentication details as instructed.
* Test the connection by sending some data or retrieving data from Adafruit.io to ensure the successful integration of your device.
By following these instructions, you will be able to establish a Wi-Fi connection between your device and Adafruit.io, allowing you to exchange data seamlessly through MQTT.

**Guide:**
* [Using WiFi](https://hackmd.io/@lnu-iot/rJVQizwUh)
* [Adafruit IO (MQTT & Webhooks)](https://hackmd.io/@lnu-iot/r1yEtcs55)

## The code

<div style="text-align: justify;">
The provided code demonstrates how to establish a connection between the Raspberry Pi Pico microcontroller and the Adafruit IO MQTT broker using Wi-Fi.

In summary, this code enables the Raspberry Pi Pico to collect sensor data and send it to Adafruit IO, allowing for the monitoring and control of temperature, humidity, and fan speed using the MQTT protocol.
</div>


## key.py
<div style="text-align: justify;">
This code prepares the necessary settings for connecting to a wireless network and establishing a connection with the Adafruit IO platform, allowing for data transmission and interaction.

</div>

import ubinascii      # Conversions between binary data and various encodings
import machine        # To Generate a unique id from processor

# Wireless network
WIFI_SSID =  "Your SSID"
WIFI_PASS = "Your Password"      # No this is not our regular password. :)

# Adafruit IO (AIO) configuration

AIO_SERVER = "io.adafruit.com"
AIO_PORT = 1883
AIO_USER = "aa227fi"
AIO_KEY = "Your AIO_KEY"
AIO_CLIENT_ID = ubinascii.hexlify(machine.unique_id())  # Can be anything

## wifi.py
<div style="text-align: justify;">
This function establishes a Wi-Fi connection to a specified network and returns the IP address upon successful connection
</div>

# Function to connect Pico to the WiFi
import network
from time import sleep
import machine

def do_connect(ssid, password):
    wlan = network.WLAN(network.STA_IF)         # Put modem on Station mode

    if not wlan.isconnected():                  # Check if already connected
        print('Connecting to network...')
        wlan.active(True)                       # Activate network interface
        # set power mode to get WiFi power-saving off (if needed)
        wlan.config(pm = 0xa11140)
        wlan.connect(ssid, password)  # Your WiFi Credential
        print('Waiting for connection...', end='')
        # Check if it is connected otherwise wait
        while not wlan.isconnected() and wlan.status() >= 0:
            print('.', end='')
            sleep(1)
    # Print the IP assigned by router
    ip = wlan.ifconfig()[0]
    print('\nConnected on {}'.format(ip))
    return ip 

## sensors.py
<div style="text-align: justify;">
These functions will be called in the code to retrieve temperature and humidity data from the respective sensors for further processing or display.
</div>

# Functions to read sensors Data
import dht
import machine

# DHT11 sensor pin
DHT_PIN = 15

# DHT22 sensor pin
DHT22_PIN = 16
                                     # Read DHT11 sensor data and return it
def read_dht11():
    d = dht.DHT11(machine.Pin(DHT_PIN))
    d.measure()
    temperature = d.temperature()
    humidity = d.humidity()
    return temperature, humidity
                                     # Read DHT22 sensor data and return it
def read_dht22():
    d = dht.DHT22(machine.Pin(DHT22_PIN))
    d.measure()
    temperature = d.temperature()
    humidity = d.humidity()
    return temperature, humidity

## main.py

<div style="text-align: justify;">
This code enables the Pico to publish sensor data to Adafruit IO. The code starts by importing necessary libraries and defining program settings. Variables are declared and initialized with default values.

After setting up the Wi-Fi connection, an MQTT client object is created and connected to the Adafruit IO MQTT broker. The code subscribes to specific topics such as fan speeds and AC status and publishes initial and updated data to the corresponding feeds on Adafruit IO. Since I didn't have some required additional hardware, in the Adafruit IO dashboard I will create some data for server room and outside temperature data to test the program's functionality.
The primary function in the code is publish_data(), which is repeatedly called in a loop. This function reads temperature and humidity data from DHT11 and DHT22 sensors and publishes it to the corresponding feeds on Adafruit IO. It also controls the air-conditioner and fans based on the inside and outside temperature conditions.
</div>

import time                   # Allows use of time.sleep() for delays
import micropython            # Needed to run any MicroPython code
import ubinascii              # Conversions between binary data and various encodings
import machine                # Interfaces with hardware components
import random                 # Random number generator
from machine import Pin       # Define pin
from mqtt import MQTTClient   # For use of MQTT protocol to talk to Adafruit IO
from wifi import do_connect
from sensors import read_dht11,read_dht22
from key import WIFI_SSID,WIFI_PASS,AIO_CLIENT_ID, AIO_SERVER, AIO_PORT, AIO_USER, AIO_KEY

# BEGIN SETTINGS
# fixed interval -->These need to be change to suit your environment 
FIXED_INTERVAL = 10000    # milliseconds
last_data_sent_ticks = 0  # milliseconds
SR_TEMPERATURE = 0
OS_TEMPERATURE = 0
FAN1_Speed = 10
FAN2_Speed = 0
AC_status = 0

# LED pin initialization for RGB SMD 
LED_PIN_RED=Pin(28, Pin.OUT,value=0)
LED_PIN_GREEN=Pin(27, Pin.OUT,value=0)
LED_PIN_BLUE=Pin(26, Pin.OUT,value=0)

# Adafruit FEED configuration  -->can be in main file
AIO_AC_FEED = "aa227fi/feeds/air-conditioner"
AIO_FAN1_FEED = "aa227fi/feeds/fan1"
AIO_FAN2_FEED = "aa227fi/feeds/fan2"
AIO_MO_TEMPERATURE_FEED = "aa227fi/feeds/mo-temperature"
AIO_MO_HUMIDITY_FEED = "aa227fi/feeds/mo-hiumidity"
AIO_SR_TEMPERATURE_FEED="aa227fi/feeds/server-room-temp"
AIO_OS_TEMPERATURE_FEED="aa227fi/feeds/outside-temperature"

# LED pin initialization for Raspberry Pi Pico W
led = Pin("LED", Pin.OUT)
# END SETTINGS
'''
###########################################################################
# define variables and function for Fans

fan1_pin = machine.Pin(19)
fan1_pwm = machine.PWM(fan1_pin)
fan1_pwm.duty_u16(0)

fan2_pin = machine.Pin(18)
fan2_pwm = machine.PWM(fan2_pin)
fan2_pwm.duty_u16(0)

# Turn Fan 1 on
def fan1_on():
    fan1_pwm.duty_u16(65535)  # Set maximum duty cycle for full speed

# Turn Fan 1 off
def fan1_off():
    fan1_pwm.duty_u16(0)  # Set duty cycle to 0 for off

# Set the speed of Fan 1 (0-100%)
def fan1_speed(speed):
    duty = int(speed * 655.35)  # Map speed to the duty cycle range
    fan1_pwm.duty_u16(duty)

# Turn Fan 2 on
def fan2_on():
    fan2_pwm.duty_u16(65535)  # Set maximum duty cycle for full speed

# Turn Fan 2 off
def fan2_off():
    fan2_pwm.duty_u16(0)  # Set duty cycle to 0 for off

# Set the speed of Fan 2 (0-100%)
def fan2_speed(speed):
    duty = int(speed * 655.35)  # Map speed to the duty cycle range
    fan2_pwm.duty_u16(duty)
#############################################################################
'''
# Connections:
# Try WiFi Connection
try:
    ip = do_connect(WIFI_SSID, WIFI_PASS)
except KeyboardInterrupt:
    print("Keyboard interrupt")

# Set up Adafruit IO MQTT client( Use the MQTT protocol to connect to Adafruit IO)
client = MQTTClient(AIO_CLIENT_ID, AIO_SERVER, AIO_PORT, AIO_USER, AIO_KEY)

# Callback Function to respond to messages from Adafruit IO
def sub_cb(topic, msg):          # sub_cb means "callback subroutine"
    global SR_TEMPERATURE, OS_TEMPERATURE
    print(topic, msg)          # Outputs the message that was received. Debugging use.
    if topic == b"aa227fi/feeds/server-room-temp":             
        SR_TEMPERATURE= int(msg) 
        print("Server Room Temperature is:",SR_TEMPERATURE)               
    elif topic == b"aa227fi/feeds/outside-temperature":          
        OS_TEMPERATURE=int(msg) 
        print("Outside Temperature is:",OS_TEMPERATURE)               
    else:                        # If any other message is received ...
        print("Unknown message") # ... do nothing but output that it happened.
# Subscribed messages will be delivered to this callback
client.set_callback(sub_cb)

# Connect to Adafruit IO MQTT broker
client.connect()
# Subscribe to the feeds
client.subscribe(AIO_SR_TEMPERATURE_FEED)
client.subscribe(AIO_OS_TEMPERATURE_FEED)
print("Connected to %s, subscribed to %s , %s topic" % (AIO_SERVER, AIO_SR_TEMPERATURE_FEED,AIO_OS_TEMPERATURE_FEED))

# initiate some values on Adafruit IO
client.publish(topic=AIO_SR_TEMPERATURE_FEED, msg=b"25")
client.publish(topic=AIO_OS_TEMPERATURE_FEED, msg=b"10")
client.publish(topic=AIO_AC_FEED, msg=str(AC_status))
client.publish(topic=AIO_FAN1_FEED, msg=str(FAN1_Speed))
client.publish(topic=AIO_FAN2_FEED, msg=str(FAN2_Speed))

# Function to publish data to Adafruit IO MQTT server at fixed interval
def publish_data():
    
    global last_data_sent_ticks
    global FIXED_INTERVAL
    global FAN1_Speed,FAN2_Speed,AC_status
    LED_PIN_RED.value(0)
    LED_PIN_GREEN.value(0)
    LED_PIN_BLUE.value(0)
    if ((time.ticks_ms() - last_data_sent_ticks) < FIXED_INTERVAL):
        return; # Too soon since last one sent.

    # Get temperature and humidity from DHT11 sensor
    temperature, humidity = read_dht11()
    # Later for real project!
    #OS_TEMPERATURE, OS_HIUMUDITY = read_dht22()
    #SR_TEMPERATURE, SR_HIUMUDITY = read_dht11()
    print("Publishing: {0} °C and {1} % to {2} {3}... ".format(temperature, humidity, AIO_MO_TEMPERATURE_FEED ,AIO_MO_HUMIDITY_FEED), end='')

    try:
        # Publish temperature values to Adafruit IO
        client.publish(topic=AIO_MO_TEMPERATURE_FEED, msg=str(temperature))
        # Publish humidity values to Adafruit IO
        client.publish(topic=AIO_MO_HUMIDITY_FEED, msg=str(humidity))
        
        # Server room Control System
        if OS_TEMPERATURE<18:
            if (SR_TEMPERATURE-18>0):
                if (FAN1_Speed<100):
                    FAN1_Speed+=10
                    client.publish(topic=AIO_FAN1_FEED, msg=str(FAN1_Speed))
                elif (FAN2_Speed<100):
                    FAN2_Speed+=10
                    client.publish(topic=AIO_FAN2_FEED, msg=str(FAN2_Speed))
                    LED_PIN_BLUE.value(1)
                    time.sleep(1)
                    LED_PIN_BLUE.value(0)
                else:
                    AC_status=1
                    client.publish(topic=AIO_AC_FEED, msg=str(AC_status))
                    print("Server room temperature is {0}°C".format(SR_TEMPERATURE), end='')
                    LED_PIN_RED.value(1)
                    time.sleep(1)
                    LED_PIN_RED.value(0)
                    if (SR_TEMPERATURE>=40):
                        print("Critical Cooling System Alert: The temperature has reached dangerous levels in the server room.\n Temperature is {0}°C!\n Immediate action is required to prevent equipment damage.".format(SR_TEMPERATURE), end='')
                        LED_PIN_RED.value(1)
            else:
                if (AC_status==1):
                    AC_status=0
                    client.publish(topic=AIO_AC_FEED, msg=str(AC_status))
                    LED_PIN_RED.value(0)
                elif (FAN2_Speed>0):
                    FAN2_Speed-=10
                    client.publish(topic=AIO_FAN2_FEED, msg=str(FAN2_Speed))
                    LED_PIN_BLUE.value(1)
                    time.sleep(1)
                    LED_PIN_BLUE.value(0)
                elif (FAN1_Speed>10):
                    FAN1_Speed-=10
                    client.publish(topic=AIO_FAN1_FEED, msg=str(FAN1_Speed))
                    LED_PIN_GREEN.value(1)
                    time.sleep(1)
                    LED_PIN_GREEN.value(0)
                else:
                    client.publish(topic=AIO_FAN1_FEED, msg=str(0)) #server room temperature <18
                    LED_PIN_GREEN.value(1)
                
        elif OS_TEMPERATURE<30:
            if SR_TEMPERATURE-OS_TEMPERATURE>0:
                if FAN1_Speed<100:
                    FAN1_Speed+=10
                    client.publish(topic=AIO_FAN1_FEED, msg=str(FAN1_Speed))
                elif FAN2_Speed<100:
                    FAN2_Speed+=10
                    client.publish(topic=AIO_FAN2_FEED, msg=str(FAN2_Speed))
                    LED_PIN_BLUE.value(1)
                    time.sleep(1)
                    LED_PIN_BLUE.value(0)
                else:
                    AC_status=1
                    client.publish(topic=AIO_AC_FEED, msg=str(AC_status))
                    print("Server room temperature is {0}°C".format(SR_TEMPERATURE), end='')
                    LED_PIN_RED.value(1)
                    time.sleep(1)
                    LED_PIN_RED.value(0)
                    if SR_TEMPERATURE>=40:
                        print("Critical Cooling System Alert: The temperature has reached dangerous levels in the server room.\n Temperature is {0}°C!\n Immediate action is required to prevent equipment damage.".format(SR_TEMPERATURE), end='')
                        LED_PIN_RED.value(1)
            else:
                if FAN2_Speed>0:
                    FAN2_Speed-=10
                    client.publish(topic=AIO_FAN2_FEED, msg=str(FAN2_Speed))
                    LED_PIN_BLUE.value(1)
                    time.sleep(1)
                    LED_PIN_BLUE.value(0)
                elif FAN1_Speed>10:
                    FAN1_Speed-=10
                    client.publish(topic=AIO_FAN1_FEED, msg=str(FAN1_Speed))
                    LED_PIN_GREEN.value(1)
                    time.sleep(1)
                    LED_PIN_GREEN.value(0)
                else:
                    if SR_TEMPERATURE<28:
                        LED_PIN_RED.value(0)
                        LED_PIN_BLUE.value(1)
                        time.sleep(1)
                        LED_PIN_BLUE.value(0)
                    elif SR_TEMPERATURE<20:
                        LED_PIN_GREEN.value(1)
                        time.sleep(1)
                        LED_PIN_GREEN.value(0)
                    else:                            #SR_TEMPERATURE<19
                        AC_status=0
                        client.publish(topic=AIO_AC_FEED, msg=str(AC_status))
                        LED_PIN_GREEN.value(1)   
        else:                                                           #OS_TEMPERATURE>=30
                FAN1_Speed=FAN2_Speed=10
                client.publish(topic=AIO_FAN1_FEED, msg=str(FAN1_Speed))
                client.publish(topic=AIO_FAN2_FEED, msg=str(FAN2_Speed))
                AC_status=1
                client.publish(topic=AIO_AC_FEED, msg=str(AC_status))
                LED_PIN_RED.value(0)
                LED_PIN_BLUE.value(0)
                LED_PIN_GREEN.value(0)
                if SR_TEMPERATURE>=40:
                    LED_PIN_RED.value(1)
                    print("Critical Cooling System Alert: The temperature has reached dangerous levels in the server room.\n Temperature is {0}°C!\n Immediate action is required to prevent equipment damage.".format(SR_TEMPERATURE), end='')
                    
                elif  SR_TEMPERATURE>30:
                    LED_PIN_RED.value(1)
                    time.sleep(1)
                    LED_PIN_RED.value(0)
                elif SR_TEMPERATURE>24:
                    LED_PIN_BLUE.value(1)
                    time.sleep(1)
                    LED_PIN_BLUE.value(0)
                elif SR_TEMPERATURE>18:
                    LED_PIN_GREEN.value(1)
                    time.sleep(1)
                    LED_PIN_GREEN.value(0)
                    
                else:                            #SR_TEMPERATURE<19
                    AC_status=0
                    client.publish(topic=AIO_AC_FEED, msg=str(AC_status))
                    LED_PIN_GREEN.value(1)

        print("DONE")
    except Exception as e:
        print("FAILED")
        print(e)
    finally:
        last_data_sent_ticks = time.ticks_ms()

# Code between try: and finally: may cause an error so ensure the client disconnects the server if that happens.
try:                      
    while True:             # Repeat this loop forever
        client.check_msg()  # Action a message if one is received. Non-blocking.
        publish_data()      # Send Sensors Data to Adafruit IO if it's time.
finally:                    # If an exception is thrown ...
    client.disconnect()     # ... disconnect the client and clean up.
    client = None
    print("Disconnected from Adafruit IO.")

# Presenting the data
<div style="text-align: justify;">
Describe the presentation part. How is the dashboard built? How long is the data preserved in the database?

Provide visual examples on how the dashboard looks. Pictures needed.
How often is data saved in the database.
</div>


# Finalizing the design


## Conclusion
<div style="text-align: justify;">
In summary, this project aims to achieve sustainability and cost-effectiveness by employing outside air for cooling the server room. By utilizing Raspberry Pi Pico W, MQTT, and Adafruit IO, the objective is to effectively control the server room temperature through the use of external air. This implementation holds the promise of energy conservation, increased efficiency, and a more sustainable and economical approach to regulating server room temperatures.
</div>

# References:
* https://hackmd.io/@lnu-iot
* https://www.raspberrypi.com
* https://www.electrokit.com/en
* https://io.adafruit.com
* https://chat.openai.com