Introduzione ad AWS IoT con sensore di temperatura wireless tramite MQTT: 8 passaggi

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

In Instructables precedenti, abbiamo attraversato diverse piattaforme cloud come Azure, Ubidots, ThingSpeak, Losant ecc. Abbiamo utilizzato il protocollo MQTT per inviare i dati del sensore al cloud in quasi tutte le piattaforme cloud. Per ulteriori informazioni su MQTT, i suoi vantaggi e benefici rispetto al protocollo HTTP, puoi fare riferimento a questa istruzione.

In questo tutorial, analizzeremo l'ennesima e più familiare piattaforma cloud Amazon Web Services. Molti di voi potrebbero avere familiarità con AWS, noto anche come Amazon Web Services, e le funzionalità cloud fornite da AWS. È stato il fulcro dello sviluppo web per molti anni. Con la crescente scala delle applicazioni IoT, AWS ha ideato la soluzione di AWSIoT. AWSIoT è una soluzione affidabile per ospitare le nostre applicazioni IoT.

Seguendo questa istruzione:

• Sarai in grado di configurare un account AWS per la tua applicazione IoT
• Sarai in grado di connettere ESP32 al core AWS IoT
• Invia e ricevi messaggi utilizzando il protocollo MQTT e
• Visualizza i dati inviati in AWS

Passaggio 1: configurazione dell'account AWS

La configurazione dell'account AWS è abbastanza semplice. Devi solo caricare un paio di certificati, allegare policy ad esso, registrare il dispositivo e iniziare a ricevere i messaggi di dati del sensore in AWS.

Per configurare l'account AWS segui questo tutorial.

Passaggio 2: specifiche hardware e software

Specifiche del software

Un account AWS

Specifiche hardware

• ESP32
• Sensore di temperatura e vibrazioni wireless
• Ricevitore Zigmo Gateway

Passaggio 3: sensori di vibrazione e temperatura wireless

Si tratta di un sensore di temperatura e vibrazione wireless IoT industriale a lungo raggio, che vanta una portata fino a 2 miglia utilizzando un'architettura di rete mesh wireless. Incorporando un sensore di vibrazione e temperatura a 16 bit, questo sensore trasmette dati di vibrazione estremamente precisi a intervalli definiti dall'utente. Ha le seguenti caratteristiche:

• Sensore di vibrazione a 3 assi di grado industriale con gamma ± 32 g
• Calcola RMS, MAX e MIN g Vibrazione
• Rimozione del rumore utilizzando il filtro passa basso
• Gamma di frequenza (larghezza di banda) fino a 12, 800 Hz
• Frequenza di campionamento fino a 25, 600Hz
• Comunicazione crittografata con portata wireless di 2 miglia
• Intervallo di temperatura di esercizio da -40 a +85 °C
• Enclosure IP65 con montaggio a parete o con magneteEsempi di software per Visual Studio e LabVIEW
• Sensore di vibrazioni con opzione sonda esterna
• Fino a 500.000 trasmissioni da 4 batterie AAMolte opzioni di gateway e modem disponibili

Passaggio 4: firmware AWS ESP32

Per connetterti ad AWS e iniziare a inviare i dati, segui i seguenti passaggi

• Scarica la libreria AWS dal seguente repository Github
• clonare il repository e posizionare il file AWS_IOT nella cartella della libreria della directory Arduino

git clone

Ora passiamo al codice:

• In questa applicazione, abbiamo utilizzato un captive portal per salvare le credenziali WiFi e per passare il mouse sulle impostazioni IP. Per l'introduzione dettagliata sul captive portal, puoi consultare il seguente tutorial.
• Il captive portal ci offre la possibilità di scegliere tra le impostazioni statiche e DHCP. Basta inserire le credenziali come IP statico, Subnet Mask, gateway e Wireless Sensor Gateway verrà configurato su quell'IP.
• Viene ospitata una pagina Web in cui è presente un elenco che mostra le reti WiFi disponibili e RSSI. Seleziona la rete WiFi e la password e inserisci invia. Le credenziali verranno salvate nella EEPROM e l'impostazione IP verrà salvata nello SPIFFS. Maggiori informazioni su questo possono essere trovate in questo istruibile.

Passaggio 5: ottenere i dati del sensore dal sensore di vibrazione e temperatura wireless

Riceviamo un frame da 54 byte dai sensori wireless di temperatura e vibrazione. Questo riquadro viene manipolato per ottenere i dati effettivi di temperatura e vibrazione.

ESP32 ha tre UART disponibili per l'uso seriale

1. RX0 GPIO 3, TX0 GPIO 1
2. RX1 GPIO9, TX1 GPIO 10
3. RX2 GPIO 16, TX2 GPIO 17

e 3 porte seriali hardware

• Seriale
• Seriale1
• Seriale2

Innanzitutto, inizializza il file di intestazione Hardware Serial. Qui useremo RX2 e TX2 alias. Pin GPIO 16 e GPIO 17 della scheda ESP32 per ottenere i dati seriali.

#includere

# definire RXD2 16 # definire TXD2 17

Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2); // pin 16 rx2, 17 tx2, 19200 bps, 8 bit nessuna parità 1 bit di stop

I seguenti passaggi ti porteranno ulteriormente a ottenere i valori reali del sensore

• Crea variabili per memorizzare temperatura, umidità, batteria e altri valori del sensore
• Imposta Rx, tx pin, baud rate e bit di parità per la seriale hardware
• Innanzitutto, controlla che ci sia qualcosa da leggere usando Serial1.available()
• Otterremo il frame di 54 byte.
• Controlla 0x7E che è il byte di inizio.
• I dati di vibrazione sono costituiti da valore RMS per i 3 assi, valori minimi per 3 assi, valori massimi per 3 assi.
• i valori di temperatura e batteria conterranno 2 byte di dati
• ottenere il nome del sensore, il tipo, la versione del sensore conterrà 1 byte di dati e può essere ottenuto dal rispettivo indirizzo

if (Serial2.available()) { Serial.println("Leggi seriale"); data[0] = Serial2.read(); ritardo(k); if(data[0]==0x7E) { Serial.println("Ho ricevuto il pacchetto"); while (!Serial2.available()); for (i = 1; i< 55; i++) { data = Serial2.read(); ritardo(1); } if(data[15]==0x7F) /////// per verificare se i dati ricevuti sono corretti { if(data[22]==0x08) //////// verificare il tipo di sensore è corretto { rms_x = ((uint16_t)(((data[24])<<16) + ((data[25])<<8) + (data[26]))/100); rms_y = ((uint16_t)(((data[27])<<16) + ((data[28])<<8) + (data[29]))/100); rms_z = ((uint16_t)(((data[30])<<16) + ((data[31])<<8) + (data[32]))/100); int16_t max_x = ((uint16_t)(((data[33])<<16) + ((data[34])<<8) + (data[35]))/100); int16_t max_y = ((uint16_t)(((data[36])<<16) + ((data[37])<<8) + (data[38]))/100); int16_t max_z = ((uint16_t)(((data[39])<<16) + ((data[40])<<8) + (data[41]))/100);

int16_t min_x = ((uint16_t)(((data[42])<<16) + ((data[43])<<8) + (data[44]))/100); int16_t min_y = ((uint16_t)(((data[45])<<16) + ((data[46])<<8) + (data[47]))/100); int16_t min_z = ((uint16_t)(((data[48])<<16) + ((data[49])<<8) + (data[50]))/100);

cTemp = ((((data[51]) * 256) + data[52])); batteria tampone = ((data[18] * 256) + data[19]); tensione = 0,00322 * batteria; Serial.print("Numero sensore"); Serial.println(data[16]); numerosenso = dati[16]; Serial.print("Tipo sensore"); Serial.println(data[22]); Serial.print("Versione firmware "); Serial.println(data[17]); Serial.print("Temperatura in gradi Celsius:"); Serial.print(cTemp); Serial.println("C"); Serial.print("Vibrazione RMS nell'asse X:"); Serial.print(rms_x); Serial.println("mg"); Serial.print("Vibrazione RMS nell'asse Y:"); Serial.print(rms_y); Serial.println("mg"); Serial.print("Vibrazione RMS nell'asse Z:"); Serial.print(rms_z); Serial.println("mg");

Serial.print("Vibrazione minima nell'asse X:");

Serial.print(min_x); Serial.println("mg"); Serial.print("Vibrazione minima nell'asse Y:"); Serial.print(min_y); Serial.println("mg"); Serial.print("Vibrazione minima nell'asse Z:"); Serial.print(min_z); Serial.println("mg");

Serial.print("Valore ADC:");

Serial.println (batteria); Serial.print("Tensione batteria:"); Serial.print (tensione); Serial.println("\n"); if (voltaggio < 1) { Serial.println("È ora di sostituire la batteria"); } } } else { for (i = 0; i< 54; i++) { Serial.print(data); Serial.print(", "); ritardo(1); } } } }

Passaggio 6: connessione ad AWS

• Includere i file di intestazione AWS_IOT.h, WiFi.h per configurare una connessione con l'hub AWSIoT
• Inserisci il tuo indirizzo host, l'ID client che sarà il nome della politica e il nome dell'argomento che sarà il nome dell'oggetto

//*********Credenziali AWS*************//char HOST_ADDRESS="a2smbp7clzm5uw-ats.iot.us-east-1.amazonaws.com"; char CLIENT_ID= "ncdGatewayPolicy"; char TOPIC_NAME= "ncdGatewayThing";

Crea una variabile char per memorizzare il tuo JSON, in questo caso, abbiamo creato un formato per memorizzare JSON

const char *format = "{"SensorId\":\"%d\", \"messageId\":%d, \"rmsX\":%d, \"rmsY\":%d, \"rmsZ \":%d, \"cTemp\":%d, \"tensione\":%.2f}";

Crea un'istanza della classe AWS_IOT

AWS_IOT esp; //Istanza della classe AWS_IOT

Ora connettiti all'hub AWSIoT usando il seguente metodo

void reconnectMQTT(){ if(hornbill.connect(HOST_ADDRESS, CLIENT_ID)== 0) { Serial.println("Connesso ad AWS"); ritardo(1000);

if(0==hornbill.subscribe(TOPIC_NAME, mySubCallBackHandler))

{ Serial.println("Sottoscrizione completata"); } else { Serial.println("Subscribe Failed, Check the Thing Name and Certificates"); mentre(1); } } else { Serial.println("Connessione AWS fallita, controllare l'indirizzo HOST"); mentre(1); }

ritardo (2000);

}

pubblicare i dati del sensore ogni 1 minuto

if(tick >= 60) // pubblica nell'argomento ogni 5 secondi { tick=0; char payload[PAYLOAD_MAX_LEN]; snprintf(payload, PAYLOAD_MAX_LEN, formato, senseNumber, msgCount++, rms_x, rms_y, rms_z, cTemp, tensione); Serial.println (carico utile); if(hornbill.publish(TOPIC_NAME, payload) == 0) { Serial.print("Pubblica messaggio:"); Serial.println (carico utile); } else { Serial.println("Pubblicazione fallita"); } } vTaskDelay(1000 / portTICK_RATE_MS); spunta++;

Passaggio 7: visualizzazione dei dati in AWS

• Accedi al tuo account AWS.
• nell'angolo sinistro della barra degli strumenti, troverai la scheda Servizi
• Fare clic su questa scheda e sotto l'intestazione Internet of Things selezionare IoT Core.
• Seleziona QoS e no. di messaggi agli iscritti. Inserisci il nome dell'argomento.

Passaggio 8: codice generale

Puoi trovare il codice generale su questo repository Github.

Titoli di coda

• Arduino Json
• Sensori di temperatura e umidità wireless
• ESP32
• PubSubClient