|
Tutorial del Internet de las Cosas y Bluetooth con el ESP32
Juan Antonio Villalpando
Volver al índice del tutorial
____________________________
117C.- iot.eclipse.org. También broker.hivemq.com
- Vamos a utilizar el servidor iot.eclipse.org, es gratuito, no hace falta registrarse. No muestra página web como hemos visto con ThingSpeak.
- En vez de poner el servidor de eclipse, podemos poner también: broker.hivemq.com y también: mosquitto.org
- Podemos obtener los valores y enviarlos mediante la aplicación del Android: Linear MQTT Dashboard (Instalamos en nuestro móvil esta aplicación de la Play de Google).
- Los valores se actualizan casi instantáneamente.
- Estos códigos funcionan con el ESP32 y con el ESP8266.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
__________________________________________________________________
1.- ESP8266 Publica un número aleatorio y la aplicación Linear MQTT lo Subscribe.
- La información se ha de enviar en char.
- El número se crea en entero, debemos pasarlo a char.
- Para ello primero pasamos el entero a String y luego el String a char.
int aleatorio = 48
String aleatorioString = "48"
char alea[6]
= 4,8,0,0,0,0
________________________________
- Librería PubSubClient.
- Desde el Gestor de Librerías, instalamos PubSubClient
_________________________________________________________________
- El ESP8266 genera un número aleatorio del 1 al 90 y en la app Linear MQTT observamos ese valor con número y con gráfico.
- Es necesario esta librería: pubsubclient.zip
- De https://vimalb.github.io/IoT-ESP8266-Starter/Lesson_04/lesson.html
- Este programa genera y Publica un número aleatorio del 1 al 90, cada 5 segundos
- Código para enviar desde ESP8266:
- Publicaremos la información mediante: juan/aleatorio
- Para adaptarlo el ESP32 debemos cambiar la librería a <WiFi.h>
- No es necesario registrarse. Puedes poner cualquier nombre en:
MQTT_CLIENT.connect("JuanAntonio"); // Escribe cualquier nombre.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
[Probar también con: broker.hivemq.com]
[Probar también con: mosquitto.org]
ESP8266_eclipse.ino |
// Juan A. Villalpando.
// kio4.com
#include <ESP8266WiFi.h> // Para el ESP8266
// #include <WiFi.h> // Para el ESP32
WiFiClient WIFI_CLIENT;
#include <PubSubClient.h>
PubSubClient MQTT_CLIENT;
// Nombre y contraseña de tu red WiFi.
const char* ssid = "Nombre_de_tu_Red_WiFi";
const char* password = "Clave_WiFi";
void setup() {
Serial.begin(115200);
delay(10);
Serial.println();
Serial.print("Conectando con ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado.");
Serial.println("IP: ");
Serial.println(WiFi.localIP());
}
void loop() {
// Continuamente comprueba si tiene conexión con MQTT,
// en caso de que no tenga, reconecta.
if (!MQTT_CLIENT.connected()) {
reconnect();
}
// Publicar un mensaje. Publish.
// Convierte el entero a char. Debe ser char.
int aleatorio = random(1,90);
String aleatorioString = String(aleatorio);
char alea[6];
aleatorioString.toCharArray(alea, 6);
MQTT_CLIENT.publish("juan/aleatorio", alea);
// Espera antes de Publicar otro aleatorio.
delay(5000);
}
// Reconecta con MQTT broker
void reconnect() {
MQTT_CLIENT.setServer("iot.eclipse.org", 1883);
// MQTT_CLIENT.setServer("broker.hivemq.com", 1883);
// MQTT_CLIENT.setServer("mosquitto.org", 1883);
MQTT_CLIENT.setClient(WIFI_CLIENT);
// Intentando conectar con el broker.
while (!MQTT_CLIENT.connected()) {
Serial.println("Intentando conectar con MQTT.");
MQTT_CLIENT.connect("JuanAntonio"); // Escribe cualquier nombre.
// Espera antes de volver a intentarlo.
delay(3000);
}
Serial.println("Conectado a MQTT.");
}
|
- Recibir en la aplicación Linear MQTT Dashboard.
- Bajamos a nuestro móvil la aplicación Linear MQTT Dashboard de la Play de Google.
- App settings...
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
- Establecemos el servidor: tcp://iot.eclipse.org
- Puerto: 1883
- [También lo podemos hacer con: broker.hivemq.com]
- No hace falta poner usuario ni contraseña ni registrarse. SAVE.
- Luego Pulsamos abajo en TAB #1
- Vamos pulsando en los tres puntitos verticales, Edit...
- Y configurando las pantallas.
- Ponemos Número aleatorio y juan/aleatorio, tal como lo hemos puesto en el código de ESP8266.
- Para arrancar la conexión pulsamos en el icono de la flecha.
- Observa que Subscribimos (Sub.topic).
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
[Probar también con: broker.hivemq.com]
[Probar también con: mosquitto.org]
- Automáticamente irán saliendo los números aleatorios enviado por el ESP8266.
- Debe consultar la TAB #1.
__________________
- Gráfico en el Linear MQTT Dashboard.
- Ve a la TAB #1, para el proceso de datos. Edita el Widget type. Establece Graph.
- La aplicación debe estar en primer plano para que dibuje la gráfica.
__________________
- Comentario.
- La información enviada debe ser de tipo char, para ello pasamos primero el entero aleatorio a aleatorioString y éste luego a char, lo enviamos mediante la variabla char: alea.
_______________________________________________
- El mismo código anterior con ArduinoBlocks.
http://www.arduinoblocks.com
| io.eclipse.org |
mqtt.thingspeak.com |
 |
 |
juanantoniocuarto@gmail.com (clave: laarboleda2019)
Laarboleda2019 (??)
----------------------------
Author: juanantonio4
Channel ID: 746330
-----------------------------
Write API Key: SVRKZNDDNS9TVSIB
Read API Key: LKN1MV3BG2SJ2HJS
https://thingspeak.com/channels/746330
- Con la app Linear Mqtt Dashboard, no podemos conectar porque no nos permite escribir estos datos.
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
2.- Veamos las Notificaciones en la aplicación Linear MQTT Dashboard.
- Vamos a cambiar un poco el código, en este caso estableceremos que cuando el número aleatorio generado sea mayor o igual que 50, enviará la ruta:
juan/notifica acompañada de N= 82, es decir el número que ha superado a 50
MQTT_CLIENT.publish("juan/notifica", grande);
Esta ruta llegará al Linear MQTT Dasboard y provocará una Notificación en la aplicación.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
[Probar también con: broker.hivemq.com]
[Probar también con: mosquitto.org]
ESP8266_notificacion.ino |
// Juan A. Villalpando.
// kio4.com
#include <ESP8266WiFi.h> // Para el ESP8266
// #include <WiFi.h> // Para el ESP32
WiFiClient WIFI_CLIENT;
#include <PubSubClient.h>
PubSubClient MQTT_CLIENT;
// Nombre y contraseña de tu red WiFi.
const char* ssid = "Nombre_de_tu_Red_WiFi";
const char* password = "Clave_WiFi";;
void setup() {
Serial.begin(115200);
delay(10);
Serial.println();
Serial.print("Conectando con ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado.");
Serial.println("IP: ");
Serial.println(WiFi.localIP());
}
void loop() {
// Continuamente comprueba si tiene conexión con MQTT,
// en caso de que no tenga, reconecta.
if (!MQTT_CLIENT.connected()) {
reconnect();
}
// Publicar un mensaje. Publish.
// Convierte el entero a char. Debe ser char.
int aleatorio = random(1,90);
String aleatorioString = String(aleatorio);
char alea[10];
aleatorioString.toCharArray(alea, 10);
MQTT_CLIENT.publish("juan/aleatorio", alea);
// Produce Notificación cuando sea mayor o igual a 50
if(aleatorio >= 50){
String grandeString = "N= " + String(aleatorio);
char grande[6];
grandeString.toCharArray(grande, 6);
MQTT_CLIENT.publish("juan/notifica", grande);
}
// Espera antes de Publicar otro aleatorio.
delay(5000);
}
// Reconecta con MQTT broker
void reconnect() {
MQTT_CLIENT.setServer("iot.eclipse.org", 1883);
// MQTT_CLIENT.setServer("broker.hivemq.com", 1883);
// MQTT_CLIENT.setServer("mosquitto.org", 1883);
MQTT_CLIENT.setClient(WIFI_CLIENT);
// Intentando conectar con el broker.
while (!MQTT_CLIENT.connected()) {
Serial.println("Intentando conectar con MQTT.");
MQTT_CLIENT.connect("JuanAntonio"); // Escribe cualquier nombre.
// Espera antes de volver a intentarlo.
delay(3000);
}
Serial.println("Conectado a MQTT.");
}
|
- En el Linear MQTT Dashboard
- Agregamos juan/notifica como indica la imagen siguiente:
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
[Probar también con: broker.hivemq.com]
[Probar también con: mosquitto.org]
- Cada vez que el número aleatorio sea igual o mayor de 50, saldrá una Notificación en la aplicación del Android.
___________________________________
- Otra forma de hacer las pruebas, con la extensión de Chrome: MQTTlens.
- En vez de hacer las pruebas con la app anterior, podemos instalar como extensión en nuestro navegador Chrome, la extensión: MQTTlens
- Aquí tenemos otras aplicaciones para Windows y Linux similares:
https://www.hivemq.com/blog/seven-best-mqtt-client-tools/
http://www.hivemq.com/demos/websocket-client/
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
3.- ESP8266 Publica el valor de dos pulsadores. Linear MQTT lo Subscribe.
- Conexiones.
- Los terminales D3 y D4 están en PULL-UP, es decir tienen una resistencia conectada a 3,3V, por lo cual no necesitamos poner resistencias externa.
- Al estar en PULL-UP, cuando no pulsamos ningún pulsador, ese terminal está en HIGH, es decir, en reposo está en HIGH y cuando pulsamos se pone en LOW.
- Si utilizamos otros terminales debemos poner o no (según el que sea) resistencia externa cuando conectemos un pulsador. Consulta el patillaje en el tutorial de instalación.
--------------------------------------------------------------------------------------------------------
- Este ejemplo es parecido al anterior.
- Tenemos dos pulsadores, en D3 y D4. Publicamos el estado de esos dos pulsadores y lo Subscribimos en la app Linear MQTT.
- Linear MQTT estará Subscrito a juan/consulta
- Para el ESP32 debemos cambiar la librería a <WiFi.h> y los pulsadores en vez de poner D3 y D4, poner simplemente 3 y 4.
#define pulsa3 3 // Para el ESP32
#define pulsa4 4 // Para el ESP32
- Este código enviará Publicaciones de los pulsadores cada 5 segundos.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
[Probar también con: broker.hivemq.com]
[Probar también con: mosquitto.org]
ESP8266_eclipse_2.ino |
// Modificado por Juan A. Villalpando.
// kio4.com
#include <ESP8266WiFi.h> // Para ESP8266
// #include <WiFi.h> // Para ESP32
WiFiClient WIFI_CLIENT;
#include <PubSubClient.h>
PubSubClient MQTT_CLIENT;
#define pulsa3 D3 // Pulsador en terminal 3.
#define pulsa4 D4 // Pulsador en terminal 4.
int valor3;
int valor4;
String p3;
String p4;
String publicar = "0,0";
char publicacion[30];
// Nombre y contraseña de tu red WiFi.
const char* ssid = "Nombre_de_tu_Red_WiFi";
const char* password = "Clave_WiFi";
void setup() {
Serial.begin(115200);
delay(10);
Serial.println();
Serial.print("Conectando con ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado.");
Serial.println("IP: ");
Serial.println(WiFi.localIP());
}
void loop() {
// Continuamente comprueba si tiene conexión con MQTT.
// en caso de que no tenga, reconecta.
if (!MQTT_CLIENT.connected()) {
reconnect();
}
// Publica el mensaje. Publish.
consulta();
MQTT_CLIENT.publish("juan/consulta", publicacion);
// Espera antes de enviar otra Publicación.
delay(5000);
}
// Reconecta con MQTT broker
void reconnect() {
MQTT_CLIENT.setServer("iot.eclipse.org", 1883);
// MQTT_CLIENT.setServer("broker.hivemq.com", 1883);
// MQTT_CLIENT.setServer("mosquitto.org", 1883);
MQTT_CLIENT.setClient(WIFI_CLIENT);
// Intentando conectar con el broker.
while (!MQTT_CLIENT.connected()) {
Serial.println("Intentando conectar.");
MQTT_CLIENT.connect("JuanAntonio");
// Espera antes de volver a intentarlo.
delay(3000);
}
Serial.println("Conectado a MQTT.");
}
// Consulta el estado de los pulsadores.
void consulta(){
valor3 = digitalRead(pulsa3);
if (valor3 == HIGH) {p3 = "P3 NO";} else {p3 = "P3 PULSADO";}
valor4 = digitalRead(pulsa4);
if (valor4 == HIGH) {p4 = "P4 NO";} else {p4 = "P4 PULSADO";}
publicar = p3 + "," + p4;
Serial.println(publicar);
String publicarString = publicar;
publicarString.toCharArray(publicacion, 30);
delay(10);
}
|
- Recibir en la aplicación Linear MQTT Dashboard.
- Utilizo la TAB #2
- Creamos una Consulta con Sub.topic juan/consulta
- Obtendremos un texto con el estado de los pulsadores.
___________________________________
- Propuesta.
- En vez de obtener un texto, modifica el Widget type para obtener dos RGB LED que se enciendan/apaguen.
- Detector de movimiento. Utiliza este 47detectordemovimiento.htm (consulta aquí un código sencillo).
- Cuando detecte un movimiento que envíe información al Linear MQTT, el código es parecido al de los pulsadores visto anteriormente.
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
Ahora al revés:
4.- La aplicación Linear MQTT Publica un valor. El ESP8266 lo Subscribe.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
- En la aplicación Linear MQTT pondremos dos Botones, al pulsarlos encenderemos/apagaremos el LED4 del ESP8266.
- En este caso Publicaremos en la aplicación y Subscribiremos en ESP8266.
- Podemos utilizar los LEDS D4 o el D5.
- Para adaptarlo al ESP32 debemos poner la librería <WiFi.h> y establecer el ledPin = 2;
- Este código es más complicado que el de Publicar, se basa en la librería PubSubClient. Utiliza la función setCallback que se ejecutará cuando se reciiba un mensaje.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
[Probar también con: broker.hivemq.com]
[Probar también con: mosquitto.org]
ESP8266_eclipse_3.ino |
// Juan A. Villalpando.
// kio4.com
#include <ESP8266WiFi.h> // Para ESP8266
// #include <WiFi.h> // Para ESP32
WiFiClient WIFI_CLIENT;
#include <PubSubClient.h>
PubSubClient MQTT_CLIENT;
// Nombre y contraseña de tu red WiFi.
const char* ssid = "Nombre_de_tu_Red_WiFi";
const char* password = "Clave_WiFi";
const byte led4 = D4; // LED de la placa. ESP8266
// const byte led2 = 2; // Para el ESP32
void setup() {
Serial.begin(115200);
delay(10);
pinMode(led4, OUTPUT);
// Conectar con WiFi.
Serial.println();
Serial.print("Conectando con ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado.");
Serial.print("IP: ");
Serial.println(WiFi.localIP());
// Configuración de la respuesta.
MQTT_CLIENT.setCallback(callback);
}
// Aquí configuramos lo que debe hacer cuando recibe un valor.
void callback(char* recibido, byte* payload, unsigned int length) {
Serial.print("Mensaje recibido: ");
Serial.print(recibido);
Serial.print(" ");
for (int i=0;i<length;i++) {
char receivedChar = (char)payload[i];
Serial.print(receivedChar);
if (receivedChar == '0') {digitalWrite(led4, HIGH);}
if (receivedChar == '1') {digitalWrite(led4, LOW);}
}
Serial.println();
}
void loop() {
if (!MQTT_CLIENT.connected()) {
reconnect();
}
MQTT_CLIENT.loop(); // Chequea lo Subscrito.
}
// Reconecta con MQTT broker
void reconnect() {
MQTT_CLIENT.setServer("iot.eclipse.org", 1883);
// MQTT_CLIENT.setServer("broker.hivemq.com", 1883);
// MQTT_CLIENT.setServer("mosquitto.org", 1883);
MQTT_CLIENT.setClient(WIFI_CLIENT);
// Intentando conectar con el broker.
while (!MQTT_CLIENT.connected()) {
Serial.println("Intentando conectar con MQTT.");
MQTT_CLIENT.connect("JuanAntonio");
MQTT_CLIENT.subscribe("juan/led");
// Espera antes de volver a intentarlo.
delay(3000);
}
Serial.println("Conectado a MQTT.");
}
|
- Enviar en la aplicación Linear MQTT Dashboard.
- Primero configuramos la conexión si no lo hemos realizando anteriormente.
- En este caso he puesto tcp://iot.eclipse.org
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
[Probar también con: broker.hivemq.com]
[Probar también con: mosquitto.org]
Puerto 1883. En estos servidores no es necesario tener cuenta con usuario y contraseña.
- En TAB #2 pulsamos el signo + y luego en Value, pulsamos en Button.
- Pondremos dos Botones: [Podríamos haber puesto un Switch]
- Botón1 juan/led 0 Enciende
- Botón2 juan/led 1 Apaga
- Observa que Publicamos (Pub.topic).
____________________________________
- Otra manera de poner los Botones.
| - En vez de poner dos Botones podemos poner solamente un Botón como indica la imagen de la derecha. |
 |
- También podemos poner un Switch en vez de un Button.
|
 |
https://sg.com.mx/revista/51/hola-mundo-iot
_______________________________________________
- El mismo código anterior con ArduinoBlocks.
http://www.arduinoblocks.com
|
io.eclipse.org |
mqtt.thingspeak.com |
 |
 |
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
5.- Similar el código anterior, pero con dos LED.
- En la aplicación Linear MQTT pondremos dos Botones y un Switch al pulsarlos encenderemos/apagaremos el LED4 o el LED5 del ESP8266.
- En este caso Publicaremos en la aplicación y Subscribiremos en ESP8266.
- Para adaptarlo al ESP32 debemos poner la librería <WiFi.h> y establecer los LED solo con número, no poner la letra D.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
ESP8266_eclipse_4.ino |
// Juan A. Villalpando.
// kio4.com
#include <ESP8266WiFi.h> // Para ESP8266
// #include <WiFi.h> // Para ESP32
WiFiClient WIFI_CLIENT;
#include <PubSubClient.h>
PubSubClient MQTT_CLIENT;
// Nombre y contraseña de tu red WiFi.
const char* ssid = "Nombre_de_tu_Red_WiFi";
const char* password = "Clave_WiFi";
const byte led4 = D4; // LED de la placa.
const byte led5 = D5; // LED de la placa.
// const byte led2 = 2; // Para ESP32
// const byte led5 = 5; // Para ESP32
void setup() {
Serial.begin(115200);
delay(10);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
// Conectar con WiFi.
Serial.println();
Serial.print("Conectando con ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado.");
Serial.print("IP: ");
Serial.println(WiFi.localIP());
// Configuración de la respuesta.
MQTT_CLIENT.setCallback(callback);
}
// Aquí configuramos lo que debe hacer cuando recibe un valor.
void callback(char* recibido, byte* payload, unsigned int length) {
Serial.print("Mensaje recibido: ");
Serial.print(recibido);
Serial.print(" ");
for (int i=0;i<length;i++) {
char receivedChar = (char)payload[i];
Serial.print(receivedChar);
if (receivedChar == 'a'){digitalWrite(led4, LOW);}
if (receivedChar == 'b'){digitalWrite(led4, HIGH);}
if (receivedChar == 'c'){digitalWrite(led5, HIGH);}
if (receivedChar == 'd'){digitalWrite(led5, LOW);}
}
Serial.println();
}
void loop() {
if (!MQTT_CLIENT.connected()) {
reconnect();
}
MQTT_CLIENT.loop(); // Chequea lo Subscrito.
}
// Reconecta con MQTT broker
void reconnect() {
MQTT_CLIENT.setServer("iot.eclipse.org", 1883);
// MQTT_CLIENT.setServer("broker.hivemq.com", 1883);
// MQTT_CLIENT.setServer("mosquitto.org", 1883);
MQTT_CLIENT.setClient(WIFI_CLIENT);
// Intentando conectar con el broker.
while (!MQTT_CLIENT.connected()) {
Serial.println("Intentando conectar con MQTT.");
MQTT_CLIENT.connect("JuanAntonio");
MQTT_CLIENT.subscribe("juan/led4");
MQTT_CLIENT.subscribe("juan/led5");
// Espera antes de volver a intentarlo.
delay(3000);
}
Serial.println("Conectado a MQTT.");
}
|
- Enviar en la aplicación Linear MQTT Dashboard.
- Encenderemos/apagaremos los LED desde esta aplicación utilizando dos Botones y un Switch.
- En TAB #2 pulsamos el signo + y luego en Value, pulsamos en Button.
- Pondremos dos Botones:
- Botón1 juan/led4 a Enciende
- Botón2 juan/led4 b Apaga
- Añadimos un Widget type: Swicth
- En Pub.topic escribimos juan/led5
- En On y Off escribimos c y d.
- Observa en el código del ESP8266 las letras a, b, c y d.
- Publicamos en (Pub.topic).
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
6.- La aplicación Linear MQTT Publica un mensaje. El ESP8266 lo Subscribe en pantalla LCD.
- Escribimos un mensaje en la app Linear MQTT, pulsamos un Botón para Publicar ese mensaje.
- El ESP8266 está Subscrito a ese mensaje, cuando llegue, lo mostrará en la pantalla LCD.
_______________________________________
- Código.
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
ESP8266_eclipse_mensaje.ino |
// Juan A. Villalpando.
// kio4.com
#include <ESP8266WiFi.h> // Para el ESP8266
// #include <WiFi.h> // Para el ESP32
WiFiClient WIFI_CLIENT;
#include <PubSubClient.h>
PubSubClient MQTT_CLIENT;
// Nombre y contraseña de tu red WiFi.
const char* ssid = "Nombre_de_tu_Red_WiFi";
const char* password = "Clave_WiFi";
// Pantalla LCD.
#include <LiquidCrystal_I2C.h>
int columnas = 16;
int filas = 2;
LiquidCrystal_I2C lcd(0x27, columnas, filas);
// LiquidCrystal_I2C lcd(0x3F, columnas, filas);
String mensaje;
void setup() {
Serial.begin(115200);
lcd.init();
lcd.backlight();
// Conectar con WiFi.
Serial.println();
Serial.print("Conectando con ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado.");
Serial.print("IP: ");
Serial.println(WiFi.localIP());
// Configuración de la respuesta.
MQTT_CLIENT.setCallback(callback);
}
// Aquí configuramos lo que debe hacer cuando recibe un valor.
void callback(char* recibido, byte* payload, unsigned int length) {
for (int i=0;i<length;i++) {
mensaje = mensaje + (char)payload[i];
}
Serial.print(mensaje);
lcd.clear(); // Borra pantalla.
lcd.setCursor(0, 0); // Inicio del cursor
lcd.print("Mensaje:");
lcd.setCursor(0,1); // Siguiente renglón.
lcd.print(mensaje);
mensaje = "";
}
void loop() {
if (!MQTT_CLIENT.connected()) {
reconnect();
}
MQTT_CLIENT.loop(); // Chequea lo Subscrito.
}
// Reconecta con MQTT broker
void reconnect() {
MQTT_CLIENT.setServer("iot.eclipse.org", 1883);
// MQTT_CLIENT.setServer("broker.hivemq.com", 1883);
// MQTT_CLIENT.setServer("mosquitto.org", 1883);
MQTT_CLIENT.setClient(WIFI_CLIENT);
// Intentando conectar con el broker.
while (!MQTT_CLIENT.connected()) {
Serial.println("Intentando conectar con MQTT.");
MQTT_CLIENT.connect("JuanAntonio");
MQTT_CLIENT.subscribe("juan/mensaje");
// Espera antes de volver a intentarlo.
delay(3000);
}
Serial.println("Conectado a MQTT.");
}
|
_______________________________________
- Linear MQTT.
- Creamos un Widget type: Button.
- Un Pub. topic: juan/mensaje
- En 'On' value: Hola amigo.
- Cada vez que queramos cambiar el mensaje deberemos volver a editar y modificar el 'On' value.
- Escribe otra frase en 'Off' value. Cuando pulses saldrá un mensaje y cuando sueltes el botón saldrá otro.
_______________________________________________
- Slider. Deslizador.
- Propuesta. Crea un Deslizador Slider en Linear MQTT, cuando deslices debes mover un Servo y mostrar su valor en la pantalla LCD.
- Consulta el tutorial: 346_esp8266_AI2_Servo.htm para estudiar el código del Servo y la pantalla LCD.
- O bien, básate en el código del ejemplo anterior y que solo se muestre el valor de los grados en la pantalla LCD (no conectes el Servo).
- Conexiones.
_____________________________
- Otro MQTT
https://techtutorialsx.com/2017/04/09/esp8266-connecting-to-mqtt-broker/
https://vimalb.github.io/IoT-ESP8266-Starter/Lesson_04/lesson.html
https://pubsubclient.knolleary.net/
IMPORTANTE: Cambia iot.eclipse.org por mqtt.eclipse.org
- tcp://iot.eclipse.org:1883 - connect to iot.eclipse.org on port 1883 using plain TCP
- ws://iot.eclipse.org:1883 - connect to iot.eclipse.org on port 1883 using WebSockets
- tls://iot.eclipse.org:8883 - connect to iot.eclipse.org on port 8883 using TLS (ssl:// and tcps:// are synonyms for tls://)
- address: iot.eclipse.org 80 (websockets)
- Para pasar a char podemos simplificar:
String aleatorioString = String(random(1,90));
char alea[6];
aleatorioString.toCharArray(alea, 6);
_______________________________
|
