Komma igång med AWS IoT Med trådlös temperatursensor med MQTT: 8 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

I tidigare instruktioner har vi gått igenom olika molnplattformar som Azure, Ubidots, ThingSpeak, Losant etc. Vi har använt MQTT -protokollet för att skicka sensordata till molnet i nästan hela molnplattformen. För mer information om MQTT, dess fördelar och fördelar jämfört med HTTP -protokoll, kan du hänvisa till denna instruerbara.

I detta instruerbara, kommer vi att zooma in i ännu en och mest välkänd molnplattform Amazon Web Services. Många av er kanske känner till AWS aka Amazon Web Services och molnfunktionen från AWS. Det har varit kärnan i webbutveckling i många år. Med den ökande omfattningen av IoT -applikationer har AWS kommit på lösningen av AWSIoT. AWSIoT är en pålitlig lösning för värd för våra IoT -applikationer.

Genom att följa detta instruerbara:

• Du kommer att kunna konfigurera AWS -konto för din IoT -applikation
• Du kommer att kunna ansluta ESP32 till AWS IoT -kärna
• Skicka och ta emot meddelanden med MQTT- och HTTP -protokoll
• Visualisera den skickade data i AWS

Steg 1: Konfigurera AWS -konto

Det är ganska enkelt att skapa ett AWS -konto. Du behöver bara ladda upp ett par certifikat, bifoga policyer, registrera enheten och börja ta emot sensordatameddelanden i AWS.

Följ denna handledning för att konfigurera AWS -kontot.

Steg 2: Hårdvaru- och programvaruspecifikationer

Programvaruspecifikation

Ett AWS -konto

Hårdvaruspecifikation

• ESP32
• Trådlös temperatur- och vibrationssensor
• Zigmo Gateway -mottagare

Steg 3: Trådlösa vibrations- och temperatursensorer

Detta är en Long Range Industrial IoT trådlös vibrations- och temperatursensor med upp till 2 Miles intervall med en trådlös nätverksarkitektur. Denna sensor innehåller en 16-bitars vibrations- och temperatursensor och överför mycket exakta vibrationsdata med användardefinierade intervall. Den har följande funktioner:

• Industriell 3-axlig vibrationssensor med ± 32g räckvidd
• Beräknar RMS, MAX och MIN g vibrationer
• Ljudborttagning med hjälp av lågpassfilter
• Frekvensområde (bandbredd) upp till 12, 800 Hz
• Provhastighet upp till 25, 600Hz
• Krypterad kommunikation med 2 Mile Wireless Range
• Driftstemperatur -40 till +85 ° C
• Väggmonterad eller magnetmonterad IP65-klassad kapslingsexempelprogramvara för Visual Studio och LabVIEW
• Vibrationssensor med extern sondalternativ
• Upp till 500 000 sändningar från 4 AA -batterier Många gateway- och modemalternativ tillgängliga

Steg 4: ESP32 AWS -firmware

För att ansluta till AWS och börja skicka data går du igenom följande steg

• Ladda ner AWS -biblioteket från följande Github -arkiv
• klona repo och placera AWS_IOT -filen i biblioteksmappen i Arduino -katalogen

git-klon

Låt oss nu gå igenom koden:

• I den här applikationen har vi använt en fångad portal för att spara WiFi -uppgifterna och för att sväva genom IP -inställningarna. För en detaljerad introduktion på den fångna portalen kan du gå igenom följande instruerbara.
• Den fångade portalen ger oss möjlighet att välja mellan statiska och DHCP -inställningar. Ange bara autentiseringsuppgifterna som statisk IP, nätmask, gateway och Wireless Sensor Gateway kommer att konfigureras på den IP: n.
• En webbsida är värd där en lista som visar tillgängliga WiFi -nätverk och där RSSI. Välj WiFi -nätverket och lösenordet och skriv in. Uppgifterna sparas i EEPROM och IP -inställningen sparas i SPIFFS. Mer om detta finns i denna instruerbara.

Steg 5: Hämta sensordata från trådlös vibrations- och temperatursensor

Vi får en 54-byte-ram från de trådlösa temperatur- och vibrationssensorerna. Denna ram manipuleras för att få den faktiska temperaturen och vibrationsdata.

ESP32 har tre UART -enheter tillgängliga för seriell användning

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

och 3 seriella portar för hårdvara

• Serie
• Serie 1
• Serie 2

Initiera först hårdvaru -seriehuvudfil. Här kommer vi att använda RX2 och TX2 aka. GPIO 16 och GPIO 17 -stift på ESP32 -kortet för att få seriell data.

#omfatta

# definiera RXD2 16 # definiera TXD2 17

Serial2.begin (115200, SERIAL_8N1, RXD2, TXD2); // stift 16 rx2, 17 tx2, 19200 bps, 8 bitar ingen paritet 1 stoppbit

Följande steg leder dig vidare för att få de verkliga sensorvärdena

• Skapa variabler för lagring av temperatur, luftfuktighet, batteri och andra sensorvärden
• Ställ in bitarna Rx, tx, baud rate och parity för hårdvaruserien
• Kontrollera först att det finns något att läsa med Serial1.available ()
• Vi får ramen på 54 byte.
• Sök efter 0x7E som är startbyte.
• Vibrationsdata består av RMS -värde för 3 -axeln, min -värden för 3 -axel, maxvärden för 3 -axel.
• temperatur och batterivärden kommer att innehålla 2 byte data
• få sensorns namn, typ, sensorversionen kommer att innehålla 1 byte data och kan hämtas därifrån respektive adress

if (Serial2.available ()) {Serial.println ("Read Serial"); data [0] = Serial2.read (); fördröjning (k); if (data [0] == 0x7E) {Serial.println ("Got Packet"); medan (! Serial2.available ()); för (i = 1; i <55; i ++) {data = Serial2.read (); fördröjning (1); } if (data [15] == 0x7F) /////// för att kontrollera om mottagna data är korrekta {if (data [22] == 0x08) //////// se till att sensortypen är korrekt {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])); flottörbatteri = ((data [18] * 256) + data [19]); spänning = 0,00322 * batteri; Serial.print ("Sensornummer"); Serial.println (data [16]); senseNumber = data [16]; Serial.print ("Sensortyp"); Serial.println (data [22]); Serial.print ("firmwareversion"); Serial.println (data [17]); Serial.print ("Temperatur i Celsius:"); Serial.print (cTemp); Serial.println ("C"); Serial.print ("RMS-vibration i X-axeln:"); Serial.print (rms_x); Serial.println ("mg"); Serial.print ("RMS-vibration i Y-axeln:"); Serial.print (rms_y); Serial.println ("mg"); Serial.print ("RMS-vibration i Z-axeln:"); Serial.print (rms_z); Serial.println ("mg");

Serial.print ("Min vibration i X-axeln:");

Serial.print (min_x); Serial.println ("mg"); Serial.print ("Min vibration i Y-axeln:"); Serial.print (min_y); Serial.println ("mg"); Serial.print ("Min vibration i Z-axeln:"); Serial.print (min_z); Serial.println ("mg");

Serial.print ("ADC -värde:");

Serial.println (batteri); Serial.print ("Batterispänning:"); Serial.print (spänning); Serial.println ("\ n"); if (spänning <1) {Serial.println ("Dags att byta batteri"); }}} annat {för (i = 0; i <54; i ++) {Serial.print (data ); Serial.print (","); fördröjning (1); }}}}

Steg 6: Anslutning till AWS

• Inkludera AWS_IOT.h, WiFi.h huvudfiler för att skapa en anslutning med AWSIoT -hubb
• Ange din värdadress, klient -id som kommer att vara policynamnet och ämnesnamn som kommer att vara saknamnet

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

Skapa en char variabel för att lagra din JSON, i det här fallet har vi skapat ett format för att lagra JSON

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

Skapa en instans av klassen AWS_IOT

AWS_IOT esp; // Instans av AWS_IOT -klassen

Anslut nu till AWSIoT -hubben med följande metod

void reconnectMQTT () {if (hornbill.connect (HOST_ADDRESS, CLIENT_ID) == 0) {Serial.println ("Ansluten till AWS"); fördröjning (1000);

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

{Serial.println ("Prenumerera framgångsrikt"); } else {Serial.println ("Prenumerationen misslyckades, kontrollera sakens namn och certifikat"); medan (1); }} else {Serial.println ("AWS -anslutningen misslyckades, kontrollera värdadressen"); medan (1); }

fördröjning (2000);

}

publicera sensordata efter var 1 minut

if (tick> = 60) // publicera till ämnet var 5: e sekund {tick = 0; char nyttolast [PAYLOAD_MAX_LEN]; snprintf (nyttolast, PAYLOAD_MAX_LEN, format, senseNumber, msgCount ++, rms_x, rms_y, rms_z, cTemp, spänning); Serial.println (nyttolast); if (hornbill.publish (TOPIC_NAME, nyttolast) == 0) {Serial.print ("Publicera meddelande:"); Serial.println (nyttolast); } else {Serial.println ("Publiceringen misslyckades"); }} vTaskDelay (1000 / portTICK_RATE_MS); bocka ++;

Steg 7: Visualisera data i AWS

• Logga in på ditt AWS -konto.
• i det vänstra hörnet av verktygsfältet hittar du fliken Tjänster
• Klicka på den här fliken och välj IoT Core under rubriken Internet of Things.
• Välj QoS och nr. meddelanden till prenumeranter. Ange ämnesnamnet.

Steg 8: Övergripande kod

Du kan hitta den övergripande koden på detta Github -arkiv.

Poäng

• Arduino Json
• Trådlösa temperatur- och luftfuktighetssensorer
• ESP32
• PubSubClient