IBM Watson con ESP32 como punto final: 11 pasos

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

Hoy publico aquí el primer video de una serie sobre cómo montar un dispositivo Endpoint con ESP32 y luego enviarlo a un servicio en la nube. En este episodio específico, le mostraré cómo enviar información desde un sensor DHT22 utilizando el protocolo MQTT para IBM Watson.

Primero presentaremos el MQTT, que es un protocolo de máquina a máquina que se usa en IoT (Internet de las cosas). También enviaremos datos del sensor de temperatura y humedad usando este protocolo, y luego verificaremos el gráfico con estos datos en una página web.

Paso 1: Pinout ESP32

Coloqué aquí el Pinout de ESP32, que usamos en nuestro ejemplo. Sin embargo, quiero dejar claro que el proyecto también funciona con ESP8266, e incluso con el mismo código fuente.

Paso 2: Pinout de NodeMCU

Paso 3: MQTT

MQTT es un protocolo de máquina a máquina que se utiliza en IoT. Fue diseñado para ser ligero y rápido. Utiliza un sistema de suscripción / publicación, donde un dispositivo se "suscribe" a un tema con la información específica de su interés, y luego recibe la información cada vez que un dispositivo publica datos relacionados con este tema.

Como un programa de servidor, MQTT necesita software. A esto se le llama Broker. En este caso específico, utilizaremos el servicio Bluemix IoT de IBM. Este servicio es gratuito para pruebas de terminales.

A continuación, necesitamos tener un teléfono celular o tableta con el lado de la Aplicación, es decir, como un cliente MQTT. También tenemos el lado del dispositivo, que es el lado del ESP con un termómetro. Esto envía los datos de temperatura y humedad al Bluemix, que luego envía esta información al lado de la aplicación.

Paso 4: Montaje

Nuestro circuito consta de una resistencia de 4.7k Ohms entre 3.3vy el pin de datos, más un DHT22 conectado al GPIO4 de un ESP32 o NodeMCU. Por lo tanto, este es nuestro punto final.

Paso 5: diagrama

Aquí muestro las diversas formas de trabajar con el Broker local MQTT. Coloqué dos modelos de diagrama. En el video, hablo de una situación en la que se usa una Raspberry Pi para abrir una puerta, por ejemplo.

En la imagen de arriba, tenemos la primera arquitectura que usa un Broker local con persistencia y una segunda arquitectura debajo que solo se comunica con el broker en la nube.

Como se muestra en el diagrama, nuestro sensor envía los datos de temperatura y humedad a IBM Watson. Es importante enfatizar que IBM Watson no está escribiendo los datos en este caso, ya que solo se muestran en gráficos. Esto se debe a que no abordaremos ninguna operación de base de datos en el ejemplo de hoy, sino que solo indicaremos el acceso a la página de inicio rápido (https://quickstart.internetofthings.ibmcloud.com/), que mostrará el estado del Endpoint. El esquema es simple y usa WiFi para enviar datos.

Paso 6: Bibliotecas

En el IDE de Arduino, vaya al menú Sketch -> Incluir biblioteca -> Administrar bibliotecas …

En la pantalla que se abre, ingrese en la búsqueda "DHT" e instale la lib "Biblioteca de sensores DHT"

Luego, escriba "PubSubClient" e instale la biblioteca "PubSubClient".

Paso 7: Biblioteca de lectura de temperatura y humedad

Paso 8: Biblioteca MQTT

Paso 9: MQTT.ino

Comenzamos el código fuente verificando qué ESP se está utilizando e importando la biblioteca y el WiFi correspondientes. Seguimos incluyendo los MQTT Libs y el sensor de temperatura y humedad.

// Verifica qual ESP está sendo utilizado // e importa a lib e wifi corresponnte #if defined (ESP8266) #include #else #include #endif // Lib de MQTT #include // Lib do sensor de e umidade #include

A continuación, definimos lo siguiente: el intervalo entre envíos de datos, el servidor MQTT que se utilizará, la información de impresión en el gráfico y el ID. También señalamos cómo debería ser la cadena QUICK_START.

// Intervalo 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 que iremos utlizar #define MQTT_SERVER "quickstart.messaging.internetofthings.ibmcloud.com "// Nome do tópico que devemos enviar os dados // para que aparezcan los gráficos #define TOPIC_NAME" iot-2 / evt / status / fmt / json "// ID que usaremos para conectar // QUICK_START deve permanecer como está const String QUICK_START = "d: quickstart: arduino:";

En este paso, definimos una identificación única. En este ejemplo, usamos la dirección MAC del dispositivo que estamos usando. Esto servirá como identificación en el sitio QuickStart. Aquí, también conectamos la ID de inicio rápido con la ID de nuestro 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;

Luego configuramos el MQTT y WiFi, así como los objetos y variables involucrados con los valores de temperatura y humedad.

// Cliente WiFi que o MQTT irá utilizar para conectarWiFiClient wifiClient; // Cliente MQTT, pasamos una url al servidor, un 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 una lectura de temperatura e umidade DHT dht (4, DHT22); // Variável para guardarmos o valor da temperatura float temperature = 0; // Variável para guardarmos o valor da umidade flotador humedad = 0;

MQTT.ino - configuración

En la configuración, inicializaremos el DHT y nos conectaremos a la red WiFi y al servidor MQTT.

configuración vacía () {Serial.begin (115200); // Incializamos o dht dht.begin (); // Conectamos a red wifi setupWiFi (); // Conectamos ao servidor MQTT connectMQTTServer (); }

MQTT.ino - bucle

En el Loop, recopilamos los datos del sensor para crear el Json que se publicará en el tema que IBM Watson espera que genere el gráfico.

void loop () {// Tempos 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 umidade readSensor (); Serial.print ("Publicar mensaje:"); // Criamos 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 - configuraciónWiFi

Aquí tenemos la función encargada de conectarnos a la red WiFi.

// Função responsável para conectar à rede WiFivoid setupWiFi () {Serial.println (); Serial.print ("Conectando 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 estabelecida while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } // Se chegou aqui é porque conectou Serial.println (""); Serial.println ("WiFi conectado"); }

MQTT.ino - connectMQTTServer

En este paso, usamos la función responsable de conectarnos al servidor MQTT.

// Función de respuesta para conectar un servidor MQTTvoid connectMQTTServer () {Serial.println ("Conectando al servidor MQTT…"); // Se conecta ao id que definimos if (client.connect (CLIENT_ID.c_str ())) {// Se a conexão foi bem sucedida Serial.println ("conectado"); } else {// Se ocorreu algum erro Serial.print ("error ="); Serial.println (client.state ()); }}

MQTT.ino - readSensor

La lectura de los datos de temperatura y humedad se define en esta función.

// Função responsável para realizar una lectura // da temperatura e umidade 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 = valor; } // Faz a leitura da umidade value = dht.readHumidity (); // Se o valor para válido if (! Isnan (valor)) {// Armazena o novo valor da umidade humedad = valor; }}

MQTT.ino - createJsonString

Aquí, tenemos la función responsable de crear un Json con los datos leídos.

// Função responsável por criar // um Json com os dados lidos String createJsonString () {String data = "{"; datos + = "\" d / ": {"; datos + = "\" temperatura / ":"; datos + = Cadena (temperatura); datos + = ","; datos + = "\" humedad / ":"; datos + = String (humedad); datos + = "}"; datos + = "}"; devolver datos; }

Paso 10: Gráfico

Para ver el gráfico del sensor, vaya

a

En el campo ID de dispositivo, ingrese el DEVICE_ID que definió en el código.

- Es importante cambiar esta ID de dispositivo a una ID única, que se usa solo para evitar conflictos con los datos enviados por otra persona.

Finalmente, acepte los términos y haga clic en Ir.

En este proyecto, probamos nuestro Endpoint en el servidor IBM Watson. Esto asegura que nuestro programa Arduino se esté comunicando correctamente con la plataforma, y que los datos que enviamos serán recibidos sin problemas por un servicio en la nube si creamos una cuenta.

En un próximo video de esta serie, te mostraré cómo iniciar sesión en IBM Watson, así como escribir en el banco de datos de este u otro servicio en la nube, como Google, Amazon, entre otros.

Paso 11: Archivos

Descarga los archivos:

PDF

INO