Introducción a AWS IoT con sensor de temperatura inalámbrico mediante MQTT: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En Instructables anteriores, hemos pasado por diferentes plataformas en la nube como Azure, Ubidots, ThingSpeak, Losant, etc. Hemos estado utilizando el protocolo MQTT para enviar los datos del sensor a la nube en casi toda la plataforma en la nube. Para obtener más información sobre MQTT, sus ventajas y beneficios sobre el protocolo HTTP, puede consultar este instructivo.

En este instructivo, nos acercaremos a otra plataforma en la nube más familiar, Amazon Web Services. Es posible que muchos de ustedes estén familiarizados con AWS, también conocido como Amazon Web Services, y la funcionalidad en la nube proporcionada por AWS. Ha sido el núcleo del desarrollo web durante muchos años. Con la escala cada vez mayor de las aplicaciones de IoT, AWS ha creado la solución de AWSIoT. AWSIoT es una solución confiable para alojar nuestras aplicaciones de IoT.

Siguiendo este instructable:

• Podrá configurar una cuenta de AWS para su aplicación de IoT
• Podrá conectar el ESP32 al núcleo de AWS IoT
• Envíe y reciba mensajes utilizando el protocolo HTTP y MQTT
• Visualice los datos enviados en AWS

Paso 1: configuración de la cuenta de AWS

Configurar una cuenta de AWS es bastante fácil. Solo necesita cargar un par de certificados, adjuntar políticas, registrar el dispositivo y comenzar a recibir los mensajes de datos del sensor en AWS.

Para configurar la cuenta de AWS, siga este tutorial.

Paso 2: Especificaciones de hardware y software

Especificación de software

Una cuenta de AWS

Especificación de hardware

• ESP32
• Sensor inalámbrico de temperatura y vibración
• Receptor Zigmo Gateway

Paso 3: Sensores inalámbricos de temperatura y vibración

Se trata de un sensor de temperatura y vibración inalámbrico IoT industrial de largo alcance, con un alcance de hasta 2 millas utilizando una arquitectura de red de malla inalámbrica. Al incorporar un sensor de temperatura y vibración de 16 bits, este sensor transmite datos de vibración de alta precisión a intervalos definidos por el usuario. Tiene las siguientes características:

• Sensor de vibración de 3 ejes de grado industrial con rango de ± 32 g
• Calcula la vibración RMS, MAX y MIN g
• Eliminación de ruido mediante filtro de paso bajo
• Rango de frecuencia (ancho de banda) hasta 12, 800 Hz
• Frecuencia de muestreo de hasta 25, 600 Hz
• Comunicación cifrada con alcance inalámbrico de 2 millas
• Rango de temperatura de funcionamiento -40 a +85 ° C
• Caja con clasificación IP65 para montaje en pared o imán Software de ejemplo para Visual Studio y LabVIEW
• Sensor de vibración con opción de sonda externa
• Hasta 500, 000 transmisiones desde 4 baterías AA Muchas opciones de gateway y módem disponibles

Paso 4: firmware ESP32 AWS

Para conectarse a AWS y comenzar a enviar los datos, siga los siguientes pasos

• Descargue la biblioteca de AWS desde el siguiente repositorio de Github
• clone el repositorio y coloque el archivo AWS_IOT en la carpeta de la biblioteca del directorio de Arduino

clon de git

Ahora repasemos el código:

• En esta aplicación, hemos hecho uso de un portal cautivo para guardar las credenciales de WiFi y pasar el cursor por la configuración de IP. Para obtener una introducción detallada sobre el portal cautivo, puede seguir las siguientes instrucciones.
• El portal cautivo nos da la opción de elegir entre configuraciones estáticas y DHCP. Simplemente ingrese las credenciales como IP estática, máscara de subred, puerta de enlace y la puerta de enlace del sensor inalámbrico se configurará en esa IP.
• Se aloja una página web en la que aparece una lista que muestra las redes WiFi disponibles y el RSSI. Seleccione la red WiFi y la contraseña e ingrese enviar. Las credenciales se guardarán en EEPROM y la configuración de IP se guardará en SPIFFS. Se puede encontrar más sobre esto en este instructivo.

Paso 5: Obtener los datos del sensor del sensor inalámbrico de temperatura y vibración

Estamos obteniendo un marco de 54 bytes de los sensores inalámbricos de temperatura y vibración. Este marco se manipula para obtener los datos reales de temperatura y vibración.

ESP32 tiene tres UART disponibles para el uso en serie

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

y 3 puertos seriales de hardware

• De serie
• Serial1
• Serial2

Primero, inicialice el archivo de encabezado de serie de hardware. Aquí usaremos RX2 y TX2 aka. GPIO 16 y GPIO 17 pines de la placa ESP32 para obtener los datos en serie.

#incluir

# definir RXD2 16 # definir TXD2 17

Serial2.begin (115200, SERIAL_8N1, RXD2, TXD2); // pines 16 rx2, 17 tx2, 19200 bps, 8 bits sin paridad 1 bit de parada

Los siguientes pasos lo llevarán más lejos para obtener los valores reales del sensor

• Cree variables para almacenar temperatura, humedad, batería y otros valores del sensor
• Configure los bits de Rx, tx pin, velocidad en baudios y paridad para la serie de hardware
• Primero, verifique que haya algo para leer usando Serial1.available ()
• Obtendremos la trama de 54 bytes.
• Compruebe si hay 0x7E, que es el byte de inicio.
• Los datos de vibración consisten en el valor RMS para los 3 ejes, los valores mínimos para los 3 ejes y los valores máximos para los 3 ejes.
• Los valores de temperatura y batería contendrán 2 bytes de datos.
• obtener el nombre del sensor, el tipo, la versión del sensor contendrá 1 byte de datos y se puede obtener desde la dirección respectiva

if (Serial2.available ()) {Serial.println ("Leer serie"); datos [0] = Serial2.read (); retraso (k); if (datos [0] == 0x7E) {Serial.println ("Paquete recibido"); while (! Serial2.available ()); para (i = 1; i <55; i ++) {datos = Serial2.read (); retraso (1); } if (data [15] == 0x7F) /////// para verificar si los datos recibidos son correctos {if (data [22] == 0x08) //////// asegúrese de que el tipo de sensor es correcto {rms_x = ((uint16_t) (((datos [24]) << 16) + ((datos [25]) << 8) + (datos [26])) / 100); rms_y = ((uint16_t) (((datos [27]) << 16) + ((datos [28]) << 8) + (datos [29])) / 100); rms_z = ((uint16_t) (((datos [30]) << 16) + ((datos [31]) << 8) + (datos [32])) / 100); int16_t max_x = ((uint16_t) (((datos [33]) << 16) + ((datos [34]) << 8) + (datos [35])) / 100); int16_t max_y = ((uint16_t) (((datos [36]) << 16) + ((datos [37]) << 8) + (datos [38])) / 100); int16_t max_z = ((uint16_t) (((datos [39]) << 16) + ((datos [40]) << 8) + (datos [41])) / 100);

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

cTemp = ((((datos [51]) * 256) + datos [52])); batería flotante = ((datos [18] * 256) + datos [19]); voltaje = 0.00322 * batería; Serial.print ("Número de sensor"); Serial.println (datos [16]); senseNumber = datos [16]; Serial.print ("Tipo de sensor"); Serial.println (datos [22]); Serial.print ("Versión de firmware"); Serial.println (datos [17]); Serial.print ("Temperatura en grados Celsius:"); Serial.print (cTemp); Serial.println ("C"); Serial.print ("Vibración RMS en el eje X:"); Serial.print (rms_x); Serial.println ("mg"); Serial.print ("Vibración RMS en el eje Y:"); Serial.print (rms_y); Serial.println ("mg"); Serial.print ("Vibración RMS en el eje Z:"); Serial.print (rms_z); Serial.println ("mg");

Serial.print ("Vibración mínima en el eje X:");

Serial.print (min_x); Serial.println ("mg"); Serial.print ("Vibración mínima en el eje Y:"); Serial.print (min_y); Serial.println ("mg"); Serial.print ("Vibración mínima en el eje Z:"); Serial.print (min_z); Serial.println ("mg");

Serial.print ("valor ADC:");

Serial.println (batería); Serial.print ("Voltaje de la batería:"); Serial.print (voltaje); Serial.println ("\ n"); if (voltaje <1) {Serial.println ("Tiempo para reemplazar la batería"); }}} else {for (i = 0; i <54; i ++) {Serial.print (datos ); Serial.print (","); retraso (1); }}}}

Paso 6: Conexión a AWS

• Incluya archivos de encabezado AWS_IOT.h, WiFi.h para configurar una conexión con AWSIoT hub
• Ingrese su dirección de host, ID de cliente, que será el nombre de la política, y el nombre del tema, que será el nombre de la cosa.

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

Cree una variable char para almacenar su JSON, en este caso, hemos creado un formato para almacenar JSON

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

Cree una instancia de la clase AWS_IOT

AWS_IOT esp; // Instancia de la clase AWS_IOT

Ahora conéctese al concentrador AWSIoT utilizando el siguiente método

void reconnectMQTT () {if (hornbill.connect (HOST_ADDRESS, CLIENT_ID) == 0) {Serial.println ("Conectado a AWS"); retraso (1000);

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

{Serial.println ("Suscripción exitosa"); } else {Serial.println ("Falló la suscripción, verifique el nombre de la cosa y los certificados"); mientras (1); }} else {Serial.println ("Falló la conexión AWS, verifique la dirección del HOST"); mientras (1); }

retraso (2000);

}

publique los datos del sensor cada 1 minuto

if (tick> = 60) // publicar en el tema cada 5 segundos {tick = 0; carga útil char [PAYLOAD_MAX_LEN]; snprintf (carga útil, PAYLOAD_MAX_LEN, formato, senseNumber, msgCount ++, rms_x, rms_y, rms_z, cTemp, voltaje); Serial.println (carga útil); if (hornbill.publish (TOPIC_NAME, payload) == 0) {Serial.print ("Publicar mensaje:"); Serial.println (carga útil); } else {Serial.println ("Error de publicación"); }} vTaskDelay (1000 / portTICK_RATE_MS); garrapata ++;

Paso 7: Visualización de datos en AWS

• Inicie sesión en su cuenta de AWS.
• en la esquina izquierda de la barra de herramientas, encontrará la pestaña Servicios
• Haga clic en esta pestaña y, debajo del encabezado Internet de las cosas, seleccione IoT Core.
• Seleccione la QoS y no. de mensajes a suscriptores. Ingrese el nombre del tema.

Paso 8: Código general

Puede encontrar el código general en este repositorio de Github.

Créditos

• Arduino Json
• Sensores inalámbricos de temperatura y humedad
• ESP32
• PubSubClient