Connecting Things

MQTT, IFTTT, M2M, IBM Watson

Záznam z prednášky

Annoucements

(slide) Hack Kosice 2020
- registrovat sa na stranke podujatia
(slide) Namakaný deň 2020

Introduction

M2M komunikácia - priama komunikácia medzi dvoma zariadeniami pomocou akéhokoľvek komunikačného kanála
komunikačné protokoly IoT
- MQTT
- CoAP
- XMPP
- LWM2M

Networking with ESP32

(slide) Ako sme sa rozprávali, mikrokontrolér ESP32 je vybavený WiFi modulom s podporou štandardu 802.11 b/g/n a so štandardnou podporou bezpečnostných vlastností IEEE 802.11 ako sú WFA, WPA/WPA2_ a WAPI.
Mikrokontrolér vie dokonca pracovať ako Access Point. Tým pádom môže poskytovať pre ostatné zariadenia v sieti rozličné služby. Napríklad môže slúžiť ako webový server, ktorý bude poskytovať webové používateľské rozhranie pre ovládanie pripojených akčných členov alebo môže poskytovať len stavovú stránku s informáciami zozbieranými z pripojených senzorov.

The `network` Module

(slide Pre prácu so sieťou má ESP32 k dispozícii modul network. Pred začiatkom práce ho teda importneme:
```
>>> import network
```
Následne vytvoríme WiFi sieťové rozhranie, ktoré bude pracovať v režime pracovnej stanice (z angl. station interface) a aktivujeme ho:
```
>>> wlan = network.WLAN(network.STA_IF)
>>> wlan.active(True)
```
Následne sa môžeme pozrieť, aké bezdrôtové siete máme v dosahu:
```
>>> wlan.scan()
```
Výsledkom bude zoznam sietí s informáciami ako:
- SSID siete
- MAC adresa rozhrania
- sila signálu
- číslo kanála
Ak sa teda chceme k niektorej z nich pripojiť, potrebujem poznať SSID siete a heslo pre prístup k nej. Samotné pripojenie vykonáme pomocou volania metódy .connect() nad objektom wlan:
```
>>> wlan.connect('SSID', 'password')
```
Po (ne)úspešnom pripojení môžeme overiť stav pripojenia volaním metódy .isconnected(), ktorá vráti hodnotu True, ak sme sa úspešne pripojili alebo hodnotu False, ak nie. Nastavenie pripojenia vieme overiť volaním metódy .ifconfig():
```
>>> wlan.isconnected()
True
>>> wlan.ifconfig()
('192.168.1.128', '255.255.255.0', '192.168.1.1', '192.168.1.1')
```
Len pre úplnosť je možné dodať, že MAC adresu zariadenia môžeme získať takto:
```
>>> wlan.config('mac')
b'`\x01\x94\x1b\xf7\xb1'
```
Od tohto momentu je mikrokontrolér pripojený a môžeme s ním vykonávať sieťové operácie.

Poznámka

Spomínal som, že je možné mikrokontrolér ESP32 použiť aj v režime Access Point-u. To je možné zabezpečiť napríklad týmto fragmentom kódu:

ap = network.WLAN(network.AP_IF)  # create access-point interface
ap.config(essid='ESP-AP')         # set the ESSID of the access point
ap.config(max_clients=10)         # set how many clients can connect to the network
ap.active(True)                   # activate the interface

Setting/Connecting to WiFi

Pripojiť sa k sieti je vhodné počas štartu zariadenia, resp. vzhľadom na šetrenie spotreby sa jemožné pripájať k sieti podľa potreby - napríklad v pravidelných intervaloch niekoľkokrát do dňa. Za tým účelom je možné použiť napr. túto funkciu:

def do_connect(ssid, password):
    import network
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print('connecting to network...')
        wlan.connect(ssid, password)
        while not wlan.isconnected():
            pass
    print('network config:', wlan.ifconfig())

Home Automation with IFTTT

(slide) Pre jednoduchú ukážku sieťovej komunikácie si ukážeme pomocu služby IFTTT. Skratka IFTTT znamená If This Then That.
(slide) Podstatou tejto služby sú tzv. recepty. Princíp je jednoduchý - ak nastane udalosť, na ktorú sa viaže spúšťač (z angl. trigger), vykoná sa požadovaná akcia.
Napr.:
- If I am approaching my house, turn on the living room light, and start playing music.
- If I exit my house, turn off all lights, and set the thermostat to 68 degrees.
- If my plants are dry and they need to be watered, send me a text notification.
- If my client who has Alzheimer’s, goes outside of a specific geographic location, send me a text message.
- If I receive an email from my caregiver, send me a text message.
- If I am on vacation at an exotic place, and I am taking photos there with my phone, upload them automatically to Facebook so my friends and family can see them too.
My túto službu použijeme ako jednoduchú notifikačnú službu. Samozrejme - fantázii sa medze nekladú a naozaj môže byť šikovným pomocníkom v oblasti domácej automatizácie. V tom prípade však potrebujete mať k dispozícii aj zariadenia, ktoré túto službu priamo podporujú.
Recept našej služby bude jednoduchý:

ak sa doručí správa zo zariadenia (odmeranie teploty a vlhkosti v miestnosti), tak sa namerané hodnoty pošlú do kanála Notifications na Slack-u predmetu.
Na realizáciu použijeme senzor DHT11, ktorý vie odmerať teplotu aj vlhkosť.

Creating Service

Z menu používateľa vyberieme položku Create:
Klikneme na slovo This, kde si vyberieme službu, ktorá bude definovať spúšťač (z angl. trigger). Zo zoznamu dostupných služieb si vyberieme Webhooks.
V službe Webhooks máme k dispozícii len spúšťač s názvom Receive a web request. Ten pracuje tak, že keď príde požiadavka na konkrétnu URL adresu, vykoná príslušnú akciu.
Po výbere spúšťača Receive a web request sa nás následne systém pýta na názov udalosti. Nazveme ju dht_data_received a spúšťač vytvoríme.
Následne klikneme na slovo That, kde máme možnosť vybrať službu, ktorá sa spustí po vyvolaní spúšťača. Vyhľadáme službu Slack.
Následne zo zoznamu vyberieme akciu, ktorá je v prípade služby Slack jediná a síce - poslať správu do príslušného kanála. V nasledujúcom okne vyberieme príslušný kanál a napíšeme kostru správy:
```
The temperature in the room is °C and humidity is %.
```
Ostatné položky môžeme zmazať a akciu vytvoríme.
Nakoniec už len potvrdíme vytvorené pravidlo, ktorému ešte môžeme upraviť nadpis. Pravidlo začne pracovať po kliknutí na tlačidlo Finish.

Testing Webhook Service

Keď sa vrátime na zoznam všetkých služieb klikneme na Webhooks. Na stránke klikneme na odkaz Documentation, ktorý zobrazí dokumentáciu opisujúcu spôsob použitia. Na stránke sa nachádza náš osobný kľúč, pomocou ktorého sa vieme autentifikovať pre použitie svojich vytvorených webhook-ov.
Na stránke si môžeme svoj webhook aj vyskúšať. Potrebujeme akurát poznať názov udalosti, ktorú chceme vyvolať. Tá je v našom prípade dht_data_received. Tým dostaneme potrebnú URL adresu, kde môžeme poslať údaje zo senzora:
```
https://maker.ifttt.com/trigger/dht_data_received/with/key/API_KEY
```
Následne môžeme zadať aj hodnoty pre teplotu (value1) a pre vlhkosť (value2).
Po kliknutí na tlačidlo Test It budú údaje odoslané. Výsledok vieme skontrolovať v príslušnom kanáli Slack-u.

Súčasťou dokumentácie je aj ukážka použitia pomocou nástroja curl z príkazového riadku:

curl -X POST -H "Content-Type: application/json" -d '{"value1":"10","value2":"20"}' https://maker.ifttt.com/trigger/dht_data_received/with/key/API_KEY

Tým pádom máme k dispozícii všetky potrebné údaje na vyvolanie webhook-u z prostredia nášej veci v jazyku MicroPython.

Requesting Webhook from the Thing

(slide) V jazyku MicroPython na mikrokontroléri ESP32 použijeme modul urequests, ktorý je úpravou známeho modulu requests.

Za predpokladu, že je vec pripojená do internetu, môže vyzerať výsledné riešenie nasledovne:

import urequests, ujson
from machine import Pin
from dht import DHT11
from time import sleep

url = 'https://maker.ifttt.com/trigger/dht_data_received/with/key/API_KEY'
sensor = DHT11(Pin(33))

while True:
    # measure data from sensor
    sensor.measure()
    print(sensor.temperature(), sensor.humidity())

    # prepare data to send
    data = {'value1': sensor.temperature(), 'value2': sensor.humidity()}
    headers = {
        'Content-Type': 'application/json'
    }

    # send and close the response object
    response = urequests.post(url, headers=headers, json=data)
    response.close()

    sleep(10)

Upozornenie

It’s mandatory to close response objects as soon as you finished working with them. On Pycopy platforms without full-fledged OS, not doing so may lead to resource leaks and malfunction.

MQTT Protocol

(slide) MQTT je jeden z protokolov pre IoT.

MQTT and ESP32

(slide)
k dispozícii máme balík umqtt, ktorý je potrebné importnúť:
```
from umqtt.robust import MQTTClient
```

vytvorenie objektu MQTTClient, resp. prihlásenie sa k MQTT brokerovi:

client = MQTTClient('client-id', 'broker-ip', port)
client.connect()

Sending Data to MQTT Broker

Následne môžeme správu odoslať pomocou metódy .publish():
```
client.publish('messages', 'hello world')
```
Rozprávali sme sa o tom, že nepotrebujeme sa nutne pripájať často, resp. v tomto prípade byť pripojení neustále. V závislosti od použitia sa pripájať stačí napr. len pri odosielaní údajov. Kód teda môže vyzerať nasledovne:
```
client.connect()
client.publish('messages', 'hello world')
client.disconnect()
```

Receiving Data from MQTT Broker

Ak chceme údaje prijímať, musíme vytvoriť callback, ktorý bude objekt MQTTClient volať, keď správu dostane:
```
def on_message(topic, message):
    print('Message "{}" received in topic "{}"'.format(topic, message))
```

Callback sa potom nastaví objektu MQTTClient pomocou volania metódy .set_callback():

client = MQTTClient('client-id', 'broker-ip', port)
client.set_callback(on_message)

Dôležité je, aby ste svojho klienta nezabudli prihlásiť do príslušnej témy (topic). To je však možné až potom, keď je klient pripojený k MQTT brokerovi:
```
client.connect()
client.subscribe('topic')
```
Následne sa môže začať vykonávať hlavná slučka našej veci. Poprípade môžeme explicitne volať metódu .wait_msg(), ak vyslovene čakáme na prijatie správy, čím sa zablokuje akékoveľvek ďalšie vykonávanie. Toto volanie je totiž blokujúce:
```
print('Waiting for message...')
client.wait_msg()  # blocking call
```
Poznámka

Ak potrebujeme v hlavnej slučke vykonávať ešte ďalšiu prácu, neblokujúce volanie zabezpečíme volaním metódy .check_msg():
```
client.check_msg()
```

IBM Watson

(slide) komplexná platforma pre IoT riešenia od IBM
my si ukážeme jednoduchosť použitia v režime Quickstart
do formuláru na stránke zadáme len identifikátor nášho zariadenia (Device ID)
(slide) podpora pre IBM Watson IoT nie je na ESP32 natívna - je potrebné ju doinštalovať
- balík sa volá micropython-watson-iot)
  - balíky pre Micropython je možné vyhľadať cez pypi
  - majú prefix micropython-*
- doinštalovať niečo v Python-e je možné pomocou nástroja pip
- v Micropython-e je možné ďalšie balíky doinštalovať tiež pomocou nástroja pip, ale vo forme príkazov samotného jazyka: python import upip upip.install('micropython-watson-iot')
- balíky sa inštalujú do priečinku lib/ priamo na ESP32
  - po nainštalovaní sú dostupné aj po reštarte ESP32
výhoda - je možné pripraviť kód tak, aby v prípade, že potrebné balíky neexistujú, tak sa najprv nainštalujú

(slide) po nainštalovaní je použitie podobné, ako v prípade MQTT:

from watson_iot import Device

device = Device(device_id='esp32-dht22',
                device_type='my-device-type',
                token='my-device-token')

device.connect()
device.publishEvent('temperature', {'degrees': 30.7, 'unit': 'C'})
device.disconnect()

(slide) Výsledný kód bude vyzerať nasledovne:
```
from dht import DHT11
from machine import Pin
from time import sleep
from watson_iot import Device
```
sensor = DHT11(Pin(23))

device = Device(device_id=‘esp32-with-dht22’, device_type=‘type’, token=‘token’)

while True: sensor.measure() temp = sensor.temperature() device.connect() device.publishEvent(‘temperature’, {‘degrees’: temp, ‘unit’: ‘C’}) device.disconnect()
```
  sleep(10)
```
```

Aditional Resources

Networking - MicroPython ESP32 documentation
CoAP - RFC 7252 Constrained Application Protocol
Assistive Technology with IFTTT (If This Then That) + IoT (Internet of Things): Part 1
urequests
Machine to Machine