IBM Watson con ESP32 come endpoint: 11 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Pubblico qui oggi il primo video di una serie su come montare un dispositivo Endpoint con ESP32 e poi inviarlo a un servizio cloud. In questo episodio specifico, ti mostrerò come inviare informazioni da un sensore DHT22 utilizzando il protocollo MQTT per IBM Watson.

Per prima cosa introdurremo MQTT, che è un protocollo machine-to-machine utilizzato nell'IoT (Internet of Things). Invieremo anche i dati dal sensore di temperatura e umidità utilizzando questo protocollo, quindi controlleremo il grafico con questi dati su una pagina web.

Passaggio 1: piedinatura ESP32

Ho inserito qui il Pinout di ESP32, che usiamo nel nostro esempio. Tuttavia, voglio chiarire che il progetto funziona anche con ESP8266 e anche con lo stesso codice sorgente.

Passaggio 2: piedinatura NodeMCU

Passaggio 3: MQTT

MQTT è un protocollo machine-to-machine utilizzato nell'IoT. È stato progettato per essere leggero e veloce. Utilizza un sistema di iscrizione/pubblicazione, in cui un dispositivo "si iscrive" a un argomento con le informazioni specifiche di tuo interesse e quindi riceve le informazioni ogni volta che un dispositivo pubblica dati relativi a questo argomento.

Come un programma server, MQTT ha bisogno di software. Questo è chiamato un broker. In questo caso specifico, utilizzeremo il servizio Bluemix IoT di IBM. Questo servizio è gratuito per i test degli endpoint.

Successivamente, dobbiamo avere un telefono cellulare o un tablet con il lato Applicazione, ovvero come client MQTT. Abbiamo anche il lato del dispositivo, che è il lato ESP con un termometro. Questo invia i dati di temperatura e umidità al Bluemix, che quindi invia queste informazioni al lato applicazione.

Passaggio 4: assemblaggio

Il nostro circuito è costituito da un resistore da 4.7k Ohm tra il 3.3v e il pin dati, più un DHT22 collegato al GPIO4 di un ESP32 o NodeMCU. Quindi, questo è il nostro Endpoint.

Passaggio 5: diagramma

Mostro qui i diversi modi per lavorare con il broker locale MQTT. Ho posizionato due modelli di diagrammi. Nel video parlo di una situazione utilizzando un Raspberry Pi per aprire un cancello, ad esempio.

Nell'immagine sopra, abbiamo la prima architettura che utilizza un broker locale con persistenza e una seconda architettura sotto che comunica solo con il broker nel cloud.

Come mostrato nel diagramma, il nostro sensore invia quindi i dati di temperatura e umidità a IBM Watson. È importante sottolineare che IBM Watson non sta scrivendo i dati in questo caso, poiché vengono visualizzati solo nei grafici. Questo perché non affronteremo nessuna operazione di database nell'esempio di oggi, ma indicheremo solo l'accesso alla pagina Quickstart (https://quickstart.internetofthings.ibmcloud.com/), che visualizzerà lo stato dell'Endpoint. Lo schema è semplice e utilizza il WiFi per inviare i dati.

Passaggio 6: biblioteche

Nell'IDE di Arduino, vai al menu Schizzo -> Includi libreria -> Gestisci librerie …

Nella schermata che si apre, entra nella ricerca "DHT" e installa la lib "Libreria sensori DHT"

Quindi, digita "PubSubClient" e installa la lib "PubSubClient".

Passaggio 7: libreria di lettura della temperatura e dell'umidità

Passaggio 8: libreria MQTT

Passaggio 9: MQTT.ino

Avviamo il codice sorgente verificando quale ESP viene utilizzato e importando la libreria e il WiFi corrispondenti. Includiamo ancora le MQTT Libs e il sensore di temperatura e umidità.

//Verifica qual ESP está sendo utilizado//e importa a lib e wifi corrispondenti #ifdefined(ESP8266) #include #else #include #endif //Lib de MQTT #include //Lib do sensor de temperatura e umidode #include

Successivamente, definiamo quanto segue: l'intervallo tra l'invio dei dati, il server MQTT che verrà utilizzato, le informazioni di stampa sul grafico e l'ID. Abbiamo anche indicato come dovrebbe essere la stringa QUICK_START.

//Intervallo entre os envios#define INTERVAL 1000 //Substitua pelo SSID da sua rede #define SSID "TesteESP" //Substitua pela senha da sua rede #define PASSWORD "87654321" //Server MQTT che iremos utlizar #define MQTT_SERVER "quickstart.messaging.internetofthings.ibmcloud.com" //Nome do tópico que devemos enviar os dados //para que eles apareçam nos gráficos #define TOPIC_NAME "iot-2/evt/status/fmt/json" //ID che usaremos para conectar //QUICK_START deve permanecer como está const String QUICK_START = "d:quickstart:arduino:";

In questo passaggio, definiamo un ID univoco. In questo esempio, utilizziamo l'indirizzo MAC del dispositivo che stiamo utilizzando. Questo servirà come identificazione sul sito QuickStart. Qui colleghiamo anche l'ID Quickstart con l'ID del nostro dispositivo.

//No DEVICE_ID você deve mudar para um id único//Aqui nesse exemplo utilizamos o MAC Address //do dispositivo que estamos utilizando //Servirá como identificação no site //https://quickstart.internetofthings.ibmcloud.com const String DEVICE_ID = "240ac40e3fd0"; //Concatemos o id do quickstart com o id do nosso //dispositivo const String CLIENT_ID = QUICK_START + DEVICE_ID;

Configuriamo quindi l'MQTT e il WiFi, nonché gli oggetti e le variabili coinvolte con i valori di temperatura e umidità.

//Cliente WiFi que o MQTT irá utilizar per se conectarWiFiClient wifiClient; //Cliente MQTT, passamos a url do server, a porta //e o cliente WiFi PubSubClient client(MQTT_SERVER, 1883, wifiClient); //Tempo em que o último envio foi feito long lastPublishTime = 0; //Objeto que realiza a leitura da temperatura e da umidode DHT dht(4, DHT22); //Variável para guardarmos o valor da temperatura float temperature = 0; //Variável para guardarmos o valor da umidode float umidità = 0;

MQTT.ino - configurazione

Nel Setup, inizializzeremo il DHT e ci collegheremo alla rete WiFi e al server MQTT.

void setup() { Serial.begin(115200); //Incializamos o dht dht.begin(); //Connettiamoci alla nuova configurazione WiFiWiFi(); //Collegamento al server MQTT connectMQTTServer(); }

MQTT.ino - loop

Nel Loop, raccogliamo i dati del sensore per creare il Json che verrà pubblicato nell'argomento che IBM Watson si aspetta di generare il grafico.

void loop() { //Tempo agora em milisegundos long now = millis(); //Se o tempo desde o último envio for maior que o intervalo de envio if (now - lastPublishTime > INTERVAL) { //Atualizamos o tempo em que ocorreu o último envio lastPublishTime = now; //Fazemos a leitura da temperatura e umiditàde readSensor(); Serial.print("Pubblica messaggio: "); //Criamo o json que enviaremos para o server mqtt String msg = createJsonString(); Serial.println(msg); //Publicamos no tópico onde o servidor espera para receber //e gerar o gráfico client.publish(TOPIC_NAME, msg.c_str()); } }

MQTT.ino - setupWiFi

Qui abbiamo la funzione responsabile della connessione alla rete WiFi.

//Funzione di risposta per connettere WiFivoid setupWiFi() { Serial.println(); Serial.print("Connessione a "); Serial.print(SSID); //Manda o esp se conectar à rede através //do ssid e senha WiFi.begin(SSID, PASSWORD); //Espera até que a conexão com a rede seja stabelecida while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } //Se vuoi sapere come collegare Serial.println(""); Serial.println("WiFi connesso"); }

MQTT.ino - connectMQTTServer

In questo passaggio, utilizziamo la funzione responsabile della connessione al server MQTT.

//Funzione di risposta al collegamento al server MQTTvoid connectMQTTServer() { Serial.println("Connessione al server MQTT…"); //Se conecta ao id que definimos if (client.connect(CLIENT_ID.c_str())) { //Se a conexão foi bem sucedida Serial.println("connected"); } else { //Se ocorreu algum erro Serial.print("error = "); Serial.println(client.state()); } }

MQTT.ino - readSensor

In questa funzione viene definita la lettura dei dati di temperatura e umidità.

//Funzione di risposta per realizare una temperatura //da temperatura e umidità void readSensor(){ float value; //Faz a leitura da temperatura value = dht.readTemperature(); //Se o valor lido é válido if(!isnan(value)){ //Armazena o novo valor da temperatura temperature = value; } //Faz a leitura da umidode value = dht.readHumidity(); //Se o valor for válido if(!isnan(value)){ //Armazena o novo valor da umidode umidità = valore; } }

MQTT.ino - createJsonString

Qui abbiamo la funzione responsabile della creazione di un Json con i dati letti.

//Funzione di risposta per criar//um Json com os dados lidos String createJsonString() { String data = "{"; dati+= "\"d\": {"; dati+="\"temperatura\":"; data+=Stringa(temperatura); dati+=", "; dati+="\"umidità\":"; data+=Stringa(umidità); dati+="}"; dati+="}"; restituire i dati; }

Passaggio 10: grafica

Per visualizzare il grafico del sensore, vai

a

Nel campo ID dispositivo, inserisci il DEVICE_ID che hai definito nel codice.

- È importante modificare questo ID dispositivo in un ID univoco, utilizzato solo per evitare conflitti con i dati inviati da un'altra persona.

Infine, accetta i termini e fai clic su Vai.

In questo progetto, abbiamo testato il nostro Endpoint sul server IBM Watson. Ciò garantisce che il nostro programma Arduino comunichi correttamente con la piattaforma e che i dati che inviamo vengano ricevuti senza problemi da un servizio cloud se creiamo un account.

In un prossimo video di questa serie, ti mostrerò come accedere a IBM Watson, nonché scrivere nella banca dati di questo o di un altro servizio cloud, come Google, Amazon, tra gli altri.

Passaggio 11: file

Scarica i file:

PDF

IO NO