History

co-op-translator[bot] 67710c800c 🌐 Update translations via Co-op Translator (#554 ) Co-authored-by: leestott <leestott@users.noreply.github.com>		3 weeks ago
..
README.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago
assignment.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago
single-board-computer-commands.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago
single-board-computer-mqtt.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago
single-board-computer-telemetry.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago
wio-terminal-commands.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago
wio-terminal-mqtt.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago
wio-terminal-telemetry.md	🌐 Update translations via Co-op Translator (#554 )	3 weeks ago

README.md

Conectează dispozitivul tău la Internet

Schiță realizată de Nitya Narasimhan. Click pe imagine pentru o versiune mai mare.

Această lecție a fost predată ca parte a seriei Hello IoT de la Microsoft Reactor. Lecția a fost predată în 2 videoclipuri - o lecție de o oră și o sesiune de o oră pentru aprofundarea unor părți ale lecției și răspunsuri la întrebări.

🎥 Click pe imaginile de mai sus pentru a viziona videoclipurile

Chestionar înainte de lecție

Introducere

Litera I din IoT reprezintă Internet - conectivitatea cloud și serviciile care permit multe dintre funcțiile dispozitivelor IoT, de la colectarea măsurătorilor de la senzorii conectați la dispozitiv, până la trimiterea de mesaje pentru a controla actuatoarele. Dispozitivele IoT se conectează de obicei la un singur serviciu cloud IoT folosind un protocol de comunicare standard, iar acel serviciu este conectat la restul aplicației IoT, de la servicii AI pentru a lua decizii inteligente pe baza datelor, până la aplicații web pentru control sau raportare.

🎓 Datele colectate de la senzori și trimise către cloud se numesc telemetrie.

Dispozitivele IoT pot primi mesaje de la cloud. Adesea, aceste mesaje conțin comenzi - adică instrucțiuni pentru a efectua o acțiune fie intern (cum ar fi repornirea sau actualizarea firmware-ului), fie folosind un actuator (cum ar fi aprinderea unei lumini).

Această lecție introduce câteva dintre protocoalele de comunicare pe care dispozitivele IoT le pot folosi pentru a se conecta la cloud și tipurile de date pe care le-ar putea trimite sau primi. Vei avea, de asemenea, ocazia să experimentezi cu acestea, adăugând control prin internet la lampa ta de noapte, mutând logica de control al LED-ului în codul 'server' care rulează local.

În această lecție vom acoperi:

Protocoale de comunicare

Există o serie de protocoale de comunicare populare utilizate de dispozitivele IoT pentru a comunica cu Internetul. Cele mai populare sunt bazate pe mesageria de tip publicare/abonare prin intermediul unui broker. Dispozitivele IoT se conectează la broker și publică telemetrie și se abonează la comenzi. Serviciile cloud se conectează, de asemenea, la broker și se abonează la toate mesajele de telemetrie și publică comenzi fie către dispozitive specifice, fie către grupuri de dispozitive.

MQTT este cel mai popular protocol de comunicare pentru dispozitivele IoT și este acoperit în această lecție. Alte protocoale includ AMQP și HTTP/HTTPS.

Message Queueing Telemetry Transport (MQTT)

MQTT este un protocol de mesagerie ușor, standard deschis, care poate trimite mesaje între dispozitive. A fost conceput în 1999 pentru monitorizarea conductelor de petrol, înainte de a fi lansat ca standard deschis 15 ani mai târziu de IBM.

MQTT are un singur broker și mai mulți clienți. Toți clienții se conectează la broker, iar brokerul direcționează mesajele către clienții relevanți. Mesajele sunt direcționate folosind subiecte denumite, mai degrabă decât să fie trimise direct unui client individual. Un client poate publica pe un subiect, iar orice client care se abonează la acel subiect va primi mesajul.

✅ Fă niște cercetări. Dacă ai multe dispozitive IoT, cum poți asigura că brokerul MQTT poate gestiona toate mesajele?

Conectează dispozitivul IoT la MQTT

Prima parte a adăugării controlului prin Internet la lampa ta de noapte este conectarea acesteia la un broker MQTT.

Sarcină

Conectează dispozitivul tău la un broker MQTT.

În această parte a lecției, vei conecta lampa ta de noapte IoT la Internet pentru a permite controlul de la distanță. Mai târziu în această lecție, dispozitivul tău IoT va trimite un mesaj de telemetrie prin MQTT către un broker MQTT public cu nivelul de lumină, unde va fi preluat de un cod server pe care îl vei scrie. Acest cod va verifica nivelul de lumină și va trimite un mesaj de comandă înapoi către dispozitiv, spunându-i să aprindă sau să stingă LED-ul.

Un caz de utilizare real pentru o astfel de configurație ar putea fi colectarea datelor de la mai mulți senzori de lumină înainte de a decide să aprinzi luminile, într-o locație care are multe lumini, cum ar fi un stadion. Acest lucru ar putea împiedica aprinderea luminilor dacă doar un senzor este acoperit de nori sau de un pasăre, dar ceilalți senzori detectează suficientă lumină.

✅ Ce alte situații ar necesita evaluarea datelor de la mai mulți senzori înainte de a trimite comenzi?

În loc să te ocupi de complexitățile configurării unui broker MQTT ca parte a acestui exercițiu, poți folosi un server de test public care rulează Eclipse Mosquitto, un broker MQTT open-source. Acest broker de test este disponibil public la test.mosquitto.org și nu necesită configurarea unui cont, ceea ce îl face un instrument excelent pentru testarea clienților și serverelor MQTT.

💁 Acest broker de test este public și nesecurizat. Oricine ar putea asculta ceea ce publici, așa că nu ar trebui utilizat cu date care trebuie păstrate private.

Urmează pasul relevant de mai jos pentru a conecta dispozitivul tău la brokerul MQTT:

O privire mai profundă asupra MQTT

Subiectele pot avea o ierarhie, iar clienții se pot abona la diferite niveluri ale ierarhiei folosind caractere wildcard. De exemplu, poți trimite mesaje de telemetrie pentru temperatură pe subiectul /telemetry/temperature și mesaje de umiditate pe subiectul /telemetry/humidity, apoi în aplicația ta cloud te poți abona la subiectul /telemetry/* pentru a primi atât mesajele de telemetrie pentru temperatură, cât și cele pentru umiditate.

Mesajele pot fi trimise cu o calitate a serviciului (QoS), care determină garanția primirii mesajului.

Cel mult o dată - mesajul este trimis doar o dată, iar clientul și brokerul nu iau măsuri suplimentare pentru a confirma livrarea (trimite și uită).
Cel puțin o dată - mesajul este retrimis de către expeditor de mai multe ori până când se primește confirmarea (livrare confirmată).
Exact o dată - expeditorul și receptorul se angajează într-un proces de confirmare în două etape pentru a se asigura că doar o copie a mesajului este primită (livrare garantată).

✅ Ce situații ar necesita un mesaj cu livrare garantată în loc de un mesaj de tip trimite și uită?

Deși numele este Message Queueing (inițialele din MQTT), protocolul nu suportă de fapt cozi de mesaje. Acest lucru înseamnă că, dacă un client se deconectează, apoi se reconectează, nu va primi mesajele trimise în timpul deconectării, cu excepția celor pe care le-a început deja să le proceseze folosind procesul QoS. Mesajele pot avea un flag de retenție setat pe ele. Dacă acest flag este setat, brokerul MQTT va stoca ultimul mesaj trimis pe un subiect cu acest flag și îl va trimite oricărui client care se abonează ulterior la subiect. În acest fel, clienții vor primi întotdeauna cel mai recent mesaj.

MQTT suportă, de asemenea, o funcție de menținere a conexiunii care verifică dacă conexiunea este încă activă în timpul pauzelor lungi între mesaje.

🦟 Mosquitto de la Eclipse Foundation are un broker MQTT gratuit pe care îl poți rula singur pentru a experimenta cu MQTT, împreună cu un broker MQTT public pe care îl poți folosi pentru a testa codul tău, găzduit la test.mosquitto.org.

Conexiunile MQTT pot fi publice și deschise sau criptate și securizate folosind nume de utilizator și parole sau certificate.

💁 MQTT comunică prin TCP/IP, același protocol de rețea de bază ca HTTP, dar pe un port diferit. Poți folosi MQTT și prin websockets pentru a comunica cu aplicații web care rulează într-un browser sau în situații în care firewall-urile sau alte reguli de rețea blochează conexiunile MQTT standard.

Telemetrie

Cuvântul telemetrie provine din rădăcini grecești care înseamnă a măsura de la distanță. Telemetria este actul de a colecta date de la senzori și de a le trimite către cloud.

💁 Unul dintre cele mai vechi dispozitive de telemetrie a fost inventat în Franța în 1874 și trimitea în timp real date despre vreme și adâncimea zăpezii de pe Mont Blanc către Paris. Folosea fire fizice, deoarece tehnologiile wireless nu erau disponibile la acea vreme.

Să ne uităm înapoi la exemplul termostatului inteligent din Lecția 1.

Termostatul are senzori de temperatură pentru a colecta telemetrie. Cel mai probabil ar avea un senzor de temperatură încorporat și s-ar putea conecta la mai mulți senzori de temperatură externi printr-un protocol wireless, cum ar fi Bluetooth Low Energy (BLE).

Un exemplu de date de telemetrie pe care le-ar trimite ar putea fi:

Nume	Valoare	Descriere
`thermostat_temperature`	18°C	Temperatura măsurată de senzorul de temperatură încorporat al termostatului
`livingroom_temperature`	19°C	Temperatura măsurată de un senzor de temperatură extern care a fost denumit `livingroom` pentru a identifica camera în care se află
`bedroom_temperature`	21°C	Temperatura măsurată de un senzor de temperatură extern care a fost denumit `bedroom` pentru a identifica camera în care se află

Serviciul cloud poate apoi folosi aceste date de telemetrie pentru a lua decizii cu privire la ce comenzi să trimită pentru a controla încălzirea.

Trimite telemetrie de la dispozitivul tău IoT

Următorul pas în adăugarea controlului prin Internet la lampa ta de noapte este trimiterea telemetriei nivelului de lumină către brokerul MQTT pe un subiect de telemetrie.

Sarcină - trimite telemetrie de la dispozitivul tău IoT

Trimite telemetrie a nivelului de lumină către brokerul MQTT.

Datele sunt trimise codificate ca JSON - prescurtare pentru JavaScript Object Notation, un standard pentru codificarea datelor în text folosind perechi cheie/valoare.

✅ Dacă nu ai întâlnit JSON până acum, poți afla mai multe despre el în documentația JSON.org.

Urmează pasul relevant de mai jos pentru a trimite telemetrie de la dispozitivul tău către brokerul MQTT:

Primește telemetrie de la brokerul MQTT

Nu are rost să trimiți telemetrie dacă nu există nimic la celălalt capăt care să o asculte. Telemetria nivelului de lumină are nevoie de ceva care să o asculte pentru a procesa datele. Acest cod 'server' este genul de cod pe care îl vei implementa într-un serviciu cloud ca parte a unei aplicații IoT mai mari, dar aici vei rula acest cod local pe computerul tău (sau pe Pi-ul tău dacă lucrezi direct pe acesta). Codul server constă într-o aplicație Python care ascultă mesajele de telemetrie prin MQTT cu niveluri de lumină. Mai târziu în această lecție, vei face ca aceasta să răspundă cu un mesaj de comandă cu instrucțiuni pentru a aprinde sau stinge LED-ul.

✅ Fă niște cercetări: Ce se întâmplă cu mesajele MQTT dacă nu există niciun ascultător?

Instalează Python și VS Code

Dacă nu ai Python și VS Code instalate local, va trebui să le instalezi pe ambele pentru a scrie codul server. Dacă folosești un dispozitiv IoT virtual sau lucrezi pe Raspberry Pi-ul tău, poți sări peste acest pas, deoarece ar trebui să fie deja instalate și configurate.

Sarcină - instalează Python și VS Code

Instalează Python și VS Code.

Instalează Python. Consultă pagina de descărcări Python pentru instrucțiuni despre instalarea celei mai recente versiuni de Python.
Instalează Visual Studio Code (VS Code). Acesta este editorul pe care îl vei folosi pentru a scrie codul dispozitivului virtual în Python. Consultă documentația VS Code pentru instrucțiuni despre instalarea VS Code. 💁 Ești liber să folosești orice IDE sau editor Python preferi pentru aceste lecții, dar instrucțiunile din lecții vor fi bazate pe utilizarea VS Code.
Instalează extensia Pylance pentru VS Code. Aceasta este o extensie pentru VS Code care oferă suport pentru limbajul Python. Consultă documentația extensiei Pylance pentru instrucțiuni despre cum să instalezi această extensie în VS Code.

Configurează un mediu virtual Python

Unul dintre avantajele puternice ale Python este abilitatea de a instala pachete pip - acestea sunt pachete de cod scrise de alte persoane și publicate pe Internet. Poți instala un pachet pip pe computerul tău cu o singură comandă, apoi să folosești acel pachet în codul tău. Vei folosi pip pentru a instala un pachet care permite comunicarea prin MQTT.

În mod implicit, când instalezi un pachet, acesta este disponibil peste tot pe computerul tău, ceea ce poate duce la probleme cu versiunile pachetelor - de exemplu, o aplicație depinde de o versiune a unui pachet care se poate strica atunci când instalezi o versiune nouă pentru o altă aplicație. Pentru a evita această problemă, poți folosi un mediu virtual Python, practic o copie a Python într-un folder dedicat, iar când instalezi pachete pip, acestea sunt instalate doar în acel folder.

Sarcină - configurează un mediu virtual Python

Configurează un mediu virtual Python și instalează pachetele pip pentru MQTT.

Din terminalul sau linia ta de comandă, rulează următoarele comenzi într-o locație la alegerea ta pentru a crea și naviga într-un nou director:
```
mkdir nightlight-server
cd nightlight-server
```
Acum rulează următoarea comandă pentru a crea un mediu virtual în folderul .venv:
```
python3 -m venv .venv
```
💁 Trebuie să apelezi explicit python3 pentru a crea mediul virtual, în cazul în care ai instalat și Python 2 pe lângă Python 3 (cea mai recentă versiune). Dacă ai instalat Python 2, atunci apelarea python va folosi Python 2 în loc de Python 3.
Activează mediul virtual:
- Pe Windows:
  - Dacă folosești Command Prompt sau Command Prompt prin Windows Terminal, rulează:
```
.venv\Scripts\activate.bat
```
  - Dacă folosești PowerShell, rulează:
```
.\.venv\Scripts\Activate.ps1
```
- Pe macOS sau Linux, rulează:
```
source ./.venv/bin/activate
```
💁 Aceste comenzi ar trebui să fie rulate din aceeași locație în care ai rulat comanda pentru a crea mediul virtual. Nu va trebui niciodată să navighezi în folderul .venv, ar trebui întotdeauna să rulezi comanda de activare și orice alte comenzi pentru a instala pachete sau a rula cod din folderul în care te aflai când ai creat mediul virtual.
Odată ce mediul virtual a fost activat, comanda implicită python va rula versiunea de Python care a fost folosită pentru a crea mediul virtual. Rulează următoarea comandă pentru a obține versiunea:
```
python --version
```
Rezultatul va fi similar cu următorul:
```
(.venv) ➜  nightlight-server python --version
Python 3.9.1
```
💁 Versiunea ta de Python poate fi diferită - atâta timp cât este versiunea 3.6 sau mai mare, este în regulă. Dacă nu, șterge acest folder, instalează o versiune mai nouă de Python și încearcă din nou.
Rulează următoarele comenzi pentru a instala pachetul pip pentru Paho-MQTT, o bibliotecă populară pentru MQTT.
```
pip install paho-mqtt
```
Acest pachet pip va fi instalat doar în mediul virtual și nu va fi disponibil în afara acestuia.

Scrie codul serverului

Codul serverului poate fi acum scris în Python.

Sarcină - scrie codul serverului

Scrie codul serverului.

Din terminalul sau linia ta de comandă, rulează următoarele comenzi în interiorul mediului virtual pentru a crea un fișier Python numit app.py:
- Pe Windows rulează:
```
type nul > app.py
```
- Pe macOS sau Linux, rulează:
```
touch app.py
```
Deschide folderul curent în VS Code:
```
code .
```
Când VS Code pornește, acesta va activa mediul virtual Python. Acest lucru va fi raportat în bara de stare de jos:
Dacă terminalul VS Code este deja pornit când VS Code se deschide, mediul virtual nu va fi activat în acesta. Cel mai simplu lucru de făcut este să închizi terminalul folosind butonul Kill the active terminal instance:
Lansează un nou terminal VS Code selectând Terminal -> New Terminal, sau apăsând CTRL+`. Noul terminal va încărca mediul virtual, cu apelul de activare apărând în terminal. Numele mediului virtual (.venv) va apărea și în prompt:
```
➜  nightlight-server source .venv/bin/activate
(.venv) ➜  nightlight 
```
Deschide fișierul app.py din exploratorul VS Code și adaugă următorul cod:
```
import json
import time

import paho.mqtt.client as mqtt

id = '<ID>'

client_telemetry_topic = id + '/telemetry'
client_name = id + 'nightlight_server'

mqtt_client = mqtt.Client(client_name)
mqtt_client.connect('test.mosquitto.org')

mqtt_client.loop_start()

def handle_telemetry(client, userdata, message):
    payload = json.loads(message.payload.decode())
    print("Message received:", payload)

mqtt_client.subscribe(client_telemetry_topic)
mqtt_client.on_message = handle_telemetry

while True:
    time.sleep(2)
```
Înlocuiește <ID> de pe linia 6 cu ID-ul unic pe care l-ai folosit când ai creat codul dispozitivului.

⚠️ Acesta trebuie să fie același ID pe care l-ai folosit pe dispozitivul tău, altfel codul serverului nu se va abona sau publica pe topicul corect.

Acest cod creează un client MQTT cu un nume unic și se conectează la brokerul test.mosquitto.org. Apoi pornește un ciclu de procesare care rulează pe un fir de execuție în fundal, ascultând mesajele de pe orice topicuri la care este abonat.

Clientul se abonează apoi la mesajele de pe topicul de telemetrie și definește o funcție care este apelată când un mesaj este primit. Când un mesaj de telemetrie este primit, funcția handle_telemetry este apelată, afișând mesajul primit în consolă.

În final, un ciclu infinit menține aplicația în funcțiune. Clientul MQTT ascultă mesajele pe un fir de execuție în fundal și rulează tot timpul cât aplicația principală este activă.
Din terminalul VS Code, rulează următoarea comandă pentru a rula aplicația Python:
```
python app.py
```
Aplicația va începe să asculte mesajele de la dispozitivul IoT.
Asigură-te că dispozitivul tău funcționează și trimite mesaje de telemetrie. Ajustează nivelurile de lumină detectate de dispozitivul tău fizic sau virtual. Mesajele primite vor fi afișate în terminal.
```
(.venv) ➜  nightlight-server python app.py
Message received: {'light': 0}
Message received: {'light': 400}
```
Fișierul app.py din mediul virtual nightlight trebuie să fie în execuție pentru ca fișierul app.py din mediul virtual nightlight-server să primească mesajele trimise.

💁 Poți găsi acest cod în folderul code-server/server.

Cât de des ar trebui trimisă telemetria?

O considerație importantă pentru telemetrie este cât de des să măsori și să trimiți datele? Răspunsul este - depinde. Dacă măsori des, poți răspunde mai rapid la schimbări, dar folosești mai multă energie, mai multă lățime de bandă, generezi mai multe date și ai nevoie de mai multe resurse cloud pentru procesare. Trebuie să măsori suficient de des, dar nu prea des.

Pentru un termostat, măsurarea la câteva minute este probabil suficientă, deoarece temperaturile nu se schimbă atât de des. Dacă măsori doar o dată pe zi, ai putea ajunge să încălzești casa pentru temperaturile de noapte în mijlocul unei zile însorite, în timp ce dacă măsori în fiecare secundă vei avea mii de măsurători duplicate inutil care vor consuma viteza și lățimea de bandă a utilizatorilor (o problemă pentru cei cu planuri de lățime de bandă limitată), vor folosi mai multă energie, ceea ce poate fi o problemă pentru dispozitivele alimentate cu baterii, și vor crește costurile resurselor cloud pentru procesare și stocare.

Dacă monitorizezi datele unei mașinării dintr-o fabrică care, dacă se defectează, ar putea cauza daune catastrofale și pierderi de milioane de dolari, atunci măsurarea de mai multe ori pe secundă ar putea fi necesară. Este mai bine să consumi lățime de bandă decât să ratezi telemetria care indică faptul că o mașinărie trebuie oprită și reparată înainte să se strice.

💁 În această situație, ai putea lua în considerare utilizarea unui dispozitiv edge pentru a procesa mai întâi telemetria, reducând astfel dependența de Internet.

Pierderea conectivității

Conexiunile la Internet pot fi nesigure, cu întreruperi frecvente. Ce ar trebui să facă un dispozitiv IoT în aceste circumstanțe - să piardă datele sau să le stocheze până când conectivitatea este restabilită? Din nou, răspunsul este că depinde.

Pentru un termostat, datele pot fi probabil pierdute imediat ce o nouă măsurătoare de temperatură a fost luată. Sistemul de încălzire nu este interesat că acum 20 de minute temperatura era de 20.5°C dacă acum este de 19°C, temperatura actuală determină dacă încălzirea ar trebui să fie pornită sau oprită.

Pentru mașinării, s-ar putea să vrei să păstrezi datele, mai ales dacă sunt folosite pentru a căuta tendințe. Există modele de învățare automată care pot detecta anomalii în fluxurile de date analizând datele dintr-o perioadă definită de timp (cum ar fi ultima oră) și identificând datele anormale. Acest lucru este adesea folosit pentru întreținerea predictivă, căutând indicii că ceva s-ar putea strica în curând, astfel încât să poți repara sau înlocui înainte să se întâmple. Ai putea dori ca fiecare bit de telemetrie pentru o mașinărie să fie trimis pentru a fi procesat pentru detectarea anomaliilor, astfel încât, odată ce dispozitivul IoT se poate reconecta, să trimită toată telemetria generată în timpul întreruperii Internetului.

Designerii dispozitivelor IoT ar trebui să ia în considerare, de asemenea, dacă dispozitivul IoT poate fi utilizat în timpul unei întreruperi a Internetului sau a pierderii semnalului cauzate de locație. Un termostat inteligent ar trebui să poată lua unele decizii limitate pentru a controla încălzirea dacă nu poate trimite telemetrie în cloud din cauza unei întreruperi.

Pentru ca MQTT să gestioneze o pierdere de conectivitate, codul dispozitivului și al serverului va trebui să fie responsabil pentru asigurarea livrării mesajelor, dacă este necesar, de exemplu prin cerința ca toate mesajele trimise să fie răspunse prin mesaje suplimentare pe un topic de răspuns, iar dacă nu, acestea să fie puse în coadă manual pentru a fi retrimise mai târziu.

Comenzi

Comenzile sunt mesaje trimise de cloud către un dispozitiv, instruindu-l să facă ceva. De cele mai multe ori, acest lucru implică oferirea unui fel de ieșire printr-un actuator, dar poate fi și o instrucțiune pentru dispozitivul în sine, cum ar fi să se repornească sau să colecteze telemetrie suplimentară și să o returneze ca răspuns la comandă.

Un termostat ar putea primi o comandă din cloud pentru a porni încălzirea. Pe baza datelor de telemetrie de la toți senzorii, dacă serviciul cloud a decis că încălzirea ar trebui să fie pornită, trimite comanda relevantă.

Trimite comenzi către brokerul MQTT

Următorul pas pentru lampa noastră de noapte controlată prin Internet este ca codul serverului să trimită o comandă înapoi către dispozitivul IoT pentru a controla lumina pe baza nivelurilor de lumină detectate.

Deschide codul serverului în VS Code.
Adaugă următoarea linie după declarația client_telemetry_topic pentru a defini pe ce topic să trimiți comenzi:
```
server_command_topic = id + '/commands'
```
Adaugă următorul cod la sfârșitul funcției handle_telemetry:
```
command = { 'led_on' : payload['light'] < 300 }
print("Sending message:", command)

client.publish(server_command_topic, json.dumps(command))
```
Acesta trimite un mesaj JSON pe topicul de comandă cu valoarea led_on setată la true sau false, în funcție de dacă lumina este mai mică de 300 sau nu. Dacă lumina este mai mică de 300, se trimite true pentru a instrui dispozitivul să aprindă LED-ul.
Rulează codul ca înainte.

Ajustează nivelurile de lumină detectate de dispozitivul tău fizic sau virtual. Mesajele primite și comenzile trimise vor fi afișate în terminal:

(.venv) ➜  nightlight-server python app.py
Message received: {'light': 0}
Sending message: {'led_on': True}
Message received: {'light': 400}
Sending message: {'led_on': False}

💁 Telemetria și comenzile sunt trimise pe un singur topic fiecare. Aceasta înseamnă că telemetria de la mai multe dispozitive va apărea pe același topic de telemetrie, iar comenzile către mai multe dispozitive vor apărea pe același topic de comenzi. Dacă dorești să trimiți o comandă către un dispozitiv specific, ai putea folosi mai multe topicuri, denumite cu un ID unic al dispozitivului, cum ar fi /commands/device1, /commands/device2. În acest fel, un dispozitiv poate asculta doar mesajele destinate acelui dispozitiv.

💁 Poți găsi acest cod în folderul code-commands/server.

Gestionează comenzile pe dispozitivul IoT

Acum că comenzile sunt trimise de la server, poți adăuga cod pe dispozitivul IoT pentru a le gestiona și a controla LED-ul.

Urmează pasul relevant de mai jos pentru a asculta comenzile de la brokerul MQTT:

Odată ce acest cod este scris și în execuție, experimentează schimbând nivelurile de lumină. Urmărește ieșirea de la server și dispozitiv și observă LED-ul pe măsură ce schimbi nivelurile de lumină.

Pierderea conectivității

Ce ar trebui să facă un serviciu cloud dacă trebuie să trimită o comandă către un dispozitiv IoT care este offline? Din nou, răspunsul este că depinde.

Dacă cea mai recentă comandă suprascrie una anterioară, atunci cele anterioare pot fi probabil ignorate. Dacă un serviciu cloud trimite o comandă pentru a porni încălzirea, apoi trimite o comandă pentru a o opri, atunci comanda de pornire poate fi ignorată și nu trebuie retrimisă.

Dacă comenzile trebuie procesate în secvență, cum ar fi mișcarea unui braț robotic în sus, apoi închiderea unui dispozitiv de prindere, atunci acestea trebuie trimise în ordine odată ce conectivitatea este restabilită.

✅ Cum ar putea codul dispozitivului sau al serverului să asigure că comenzile sunt întotdeauna trimise și gestionate în ordine prin MQTT, dacă este necesar?

🚀 Provocare

Provocarea din ultimele trei lecții a fost să enumeri cât mai multe dispozitive IoT pe care le ai acasă, la școală sau la locul de muncă și să decizi dacă sunt construite în jurul microcontrolerelor sau al calculatoarelor pe o singură placă, sau chiar o combinație a acestora, și să te gândești la ce senzori și actuatori folosesc. Pentru aceste dispozitive, gândește-te la ce mesaje ar putea trimite sau primi. Ce telemetrie trimit? Ce mesaje sau comenzi ar putea primi? Crezi că sunt securizate?

Chestionar de după curs

Recapitulare și Studiu Individual

Citește mai multe despre MQTT pe pagina Wikipedia MQTT.

Încearcă să rulezi un broker MQTT pe cont propriu folosind Mosquitto și conectează-te la acesta de pe dispozitivul tău IoT și din codul serverului.

💁 Sfat - implicit, Mosquitto nu permite conexiuni anonime (adică fără un nume de utilizator și o parolă) și nu permite conexiuni din afara calculatorului pe care rulează. Poți rezolva acest lucru cu un fișier de configurare mosquitto.conf care conține următoarele:
listener 1883 0.0.0.0
allow_anonymous true

Temă

Compară și contrastează MQTT cu alte protocoale de comunicare

Declinare de responsabilitate:
Acest document a fost tradus folosind serviciul de traducere AI Co-op Translator. Deși ne străduim să asigurăm acuratețea, vă rugăm să fiți conștienți că traducerile automate pot conține erori sau inexactități. Documentul original în limba sa natală ar trebui considerat sursa autoritară. Pentru informații critice, se recomandă traducerea profesională realizată de un specialist uman. Nu ne asumăm responsabilitatea pentru eventualele neînțelegeri sau interpretări greșite care pot apărea din utilizarea acestei traduceri.