Laboratorul 11. NuttX - MQTT

Despre IoT

Internet of Things (IoT, sau “Internetul Lucrurilor”) este domeniul ce studiaza dispozitivele integrate (echipate cu senzori, modul de retea, firmware si software corespunzator etc.) prin prisma conexiunilor dintre acestea si a retelelor pe care le formeaza.

Dispozitivele IoT au ca scopuri principale colectarea si transmiterea de date, dar si efectuarea unor comenzi simple pe baza informatiilor primite. In viata cotidiana, retelele IoT sunt intalnite intr-o multitudine de spatii (orice spatiu poate deveni un spatiu “inteligent”), cateva exemple fiind:

sistemele de semaforizare inteligenta, in care semafoarele isi schimba culoarea in functie de numarul de masini / pietoni in asteptare;
casele si cladirile inteligente, in care putem controla temperatura, umiditatea, lumina ambientala etc. prin aplicatii mobile, asistent vocal, etc.
sere inteligente, ce colecteaza date despre aer si sol si ajusteaza temperatura si frecventa de irigare a plantelor

Fie ca vorbim de senzori sau controllere, dispozitivele ce formeaza o retea IoT au resurse hardware limitate. De aceea, este ideal ca modalitatea de comunicare dintre dispozitive sa tina cont de restrictiile de memorie si alimentare. O modalitate eficienta prin care putem optimiza consumul de resurse este delegarea partii de management a datelor trimise, respectiv primite, cu ajutorul unui broker, ce va gestiona datele.

Aceasta paradigma este cunoscuta sub numele de producator / consumator (sau “publisher / subscriber”), si este implementata de multiple protocoale de comunicatie. In acest laborator vom folosi protocolul MQTT pentru a facilita transmisia de date, fiind unul dintre cele mai utilizate protocoale de comunicatie in retelele IoT.

MQTT

In figura de mai sus putem observa modul de functionare al protocolului MQTT, in cadrul caruia intalnim urmatoarele:

Broker - este reprezentat de un server si este elementul central al retelei, ce se ocupa de gestionarea datelor din reteaua IoT;
Clienti - care sunt de 2 tipuri:
- Producatori (sau “publisheri”) - sunt dispozitivele care publica / trimit date catre broker, precum senzori si butoane
- Consumatori (sau “subscriberi”) - sunt dispozitivele ce primesc date de la broker, precum afisaje electronice sau aplicatii mobile

Mesajele transmise prin acest protocol sunt organizate folosind “topic”-uri, care descriu tipul de date transmise prin retea (de exemplu “temperatura”, “umiditate” etc.). Astfel, un client de tip subscriber se poate abona doar la topic-urile de interes pentru acesta, iar un clienti de tip publisher poate publica date pe anumite topic-uri, in functie de datele pe care le poate colecta.

In cadrul laboratorului, vom folosi broker-ul MQTT public de la adresa broker.hivemq.com.

MQTT in NuttX

Din NuttX, putem publica mesaje prin MQTT folosind aplicatia mqttc_pub, din suita de aplicatii prezente in nuttx-apps. Dupa cum sugereaza si numele, aplicatia este un MQTT publisher, si are mai multe optiuni legate de publicarea mesajelor, printre care urmatoarele:

-t - topic-ul pe care se vor publica date (exemplu: “temperature”)
-m - mesajul ce va fi publicat (exemplu: “28 °C”)

Exercitii

1. Folosind sistemul de build al NuttX, vom compila aplicatia mqttc_pub. Codul sursa a acesteia il puteti gasi in apps/examples/mqttc.

Pentru a compila aplicatia, revizuiti Laboratorul 01. Va trebui sa descarcati toolchain-ul, repository-urile nuttx si nuttx-apps, tabela de partitii si bootloader-ul.

Vom folosi o versiune diferita a toolchain-ului. Adaptati comenzile din primul laborator pentru numele acestui toolchain.

wget https://github.com/espressif/crosstool-NG/releases/download/esp-14.2.0_20240906/xtensa-esp-elf-14.2.0_20240906-x86_64-linux-gnu.tar.xz

De asemenea, vom clona nuttx si nuttx-apps folosind urmatoarele comenzi:

git clone --branch=si-lab-11 https://github.com/andreeaThePenguin/nuttx.git nuttx --depth 1
git clone --branch=releases/12.7 https://github.com/andreeaThePenguin/nuttx-apps.git apps

Pentru a configura NuttX cu suport pentru aplicatia mqttc_pub, vom folosi urmatoarea comanda:
```
./tools/configure.sh esp32-sparrow-kit:mqttc
```
Compilati NuttX, folositi esptool pentru a sterge continutul memoriei flash a placii, si scrieti imaginea pe aceasta (vedeti Laboratorul 1).
Conectati-va la seriala placii folosind utilitarul picocom:
```
picocom /dev/ttyUSB0 -b 115200 
```
Verificati ca aplicatia e instalata, folosind comanda: ?, care va afiseaza toate aplicatiile disponibile pe versiunea de NuttX compilata si incarcata anterior.

2. Pentru a putea testa aplicatia, ne dorim sa cream un setup de tipul Publisher-Subscriber. Pentru aceasta, vom crea un MQTT subscriber care sa primeasca datele trimise de MQTT publisher (reprezentat de placa).

Instalati libraria paho-mqtt pe masina virtuala:
```
pip3 install paho-mqtt
```
Preluati scriptul Python 3 de mai jos, si plasati-l pe masina virtuala; acest script joaca rolul de MQTT subscriber din figura prezentata in laborator. Pregatiti un terminal separat (ideal: pe care sa il puteti vedea in paralel cu primul) din care veti rula la finalul exercitiului acest script.

mqtt_subscriber.py

import paho.mqtt.client as mqtt
import ssl
 
broker = "broker.hivemq.com"
port = 1883
topic = "si-labs"
 
# This is the Subscriber
def on_connect(client, userdata, flags, rc, properties):
    print("Connected with result code: " + str(rc))
    print("Subscribing to topic: ", topic)
    client.subscribe(topic)
 
def on_message(client, userdata, msg):
    print("Received message: ", str(msg.payload.decode("utf-8")))
 
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
 
client.on_connect = on_connect
client.on_message = on_message
 
if port == 8883:
    client.tls_set(tls_version=ssl.PROTOCOL_TLSv1_2)
 
client.connect(broker, port, 60)
 
client.loop_forever()

Pentru a putea trimite mesaje folosind ESP32, vom conecta placa la WiFi. Puteti folosi orice retea WiFi disponibila (ideal: activati un hotspot cu ajutorul telefonului). Folositi urmatorii pasi pentru a conecta placa la reteaua WiFi:
```
ifup wlan0
wapi psk wlan0 <mypasswd> 3
wapi essid wlan0 <myssid> 1
renew wlan0
```

In final, veti avea deschise 2 terminale: unul ce ruleaza scriptul Python (MQTT subscriber), si altul ce afiseaza seriala placii, pe care se afla MQTT publisher-ul. Pentru a publica date, folosim comanda:
```
mqttc_pub -t si-labs -m <message>
```
Trimiteti mai multe date modificand topic-ul si valoarea.

Schimbati numele topic-ului atat in scriptul Python, cat si in comanda de mai sus (altfel, veti primi si mesajele de la ceilalti colegi).

3. Dorim sa trimitem date mai utile catre script-ul nostru de Python, pentru a simula un scenariu real de transmisie a datelor. Mai exact, vom prelua date de la senzorul LTR308, ce capteaza intensitatea luminoasa, apoi vom repeta setup-ul de la exercitiul 2.

Inspectati exemplul apps/examples/ltr308 pentru a vedea cum se utilizeaza senzorul LTR308 (optional, puteti sa il si compilati si testati). Pornind de la acest exemplu, veti modifica aplicatia apps/examples/mqttc_pub.
Pentru a modifica aplicatia, vom folosi scheletul prezent pe branch-ul si-lab-11 din nuttx-apps repo. Din directorul apps, schimbati branch-ul folosind:
```
git checkout si-lab-11
```

Puteti verifica ca lucrati pe branch-ul corect folosind comanda git branch.

Urmati TODO-urile marcate cu (3) din apps/examples/mqttc_pub.
Dupa completarea codului, revenim in directorul nuttx. Pentru a putea folosi senzorul LTR308, aplicam urmatoarele configuratii la rularea make menuconfig, peste configuratia folosita initial, de mqttc:
- CONFIG_SENSORS=y
- CONFIG_SENSORS_LTR308=y
Compilati NuttX si incarcati-l pe placa. Folosind setup-ul de la exercitiul 2, cu cele 2 terminale deschise in paralel, transmiteti date folosind aplicatia mqttc_pub si captati-le folosind scriptul Python.