Implementación de colas: MQTT

Implementación de colas: MQTT

Para continuar con el desarrollo de la práctica, se va a realizar una implementación de colas por MQTT que llevará el control de plazas disponibles del parking enviando y recibiendo información entre los sensores controlados por la placa ESP8266 y un monitor del sistema.

MQTT es un protocolo usado para la comunicación machine-to-machine (M2M) en el "Internet of Things". Este protocolo está orientado a la comunicación de sensores, debido a que consume muy poco ancho de banda y puede ser utilizado en la mayoría de los dispositivos empotrados con pocos recursos (CPU, RAM, …). La arquitectura de MQTT sigue una topología de estrella, con un nodo central que hace de servidor o "broker". El broker es el encargado de gestionar la red y de transmitir los mensajes, para mantener activo el canal. Al broker se conectan los clientes que mandan periódicamente un paquete (PINGREQ) y esperan la respuesta del broker (PINGRESP). La comunicación en el sistema se basa en unos "topics" (temas), que el cliente que publica el mensaje crea y los nodos que deseen recibirlo deben subscribirse a él.



Para el desarrollo de nuestro subsistema, vamos a utilizar como servidor o broker, un Broker público, en esto caso http://www.mqtt-dashboard.com/

Una vez dentro de la web, creamos un nuevo MQTT Websocket client con los datos:

Implementación de MQTT en ESP8266

Una vez creado el Broker público el siguiente paso es configurarlo en nuestra placa ESP8266 para establecer la comunicación con los sensores. Para poder conectarnos al broker necesitamos darle internet a nuestro ESP8266, para ello utilizamos la librería “#include <ESP8266WiFi.h>” y el código sería el siguiente:

#include <ESP8266WiFi.h>

//Wifi Setup
const char* ssid = "SSID_Proyecto_IoT2018";
const char* password = "password_IoT2018";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

void setup() {
 Serial.begin(9600);
 setup_wifi();
 Serial.print("ESP8266 IP ");
 Serial.println(WiFi.localIP());
}
void loop() {
 …. \\Código del funcionamiento con máquina de estados

 if (!client.connected()) {
    reconnect();
 }
 client.loop();
 delay(100);
}

void reconnect() {
   // Loop until we're reconnected
   while (!client.connected()) {
      Serial.print("Attempting MQTT connection...");
      // Attempt to connect
      if (client.connect("ESP8266Client")) {
          Serial.println("connected");
     client.subscribe("PARKING_IOT_MONITOR");
      } else {
          Serial.print("failed, rc=");
          Serial.print(client.state());
          Serial.println(" try again in 5 seconds");
          // Wait 5 seconds before retrying
          delay(5000);
      }
   }
}

void setup_wifi() {
   delay(10);
   // We start by connecting to a WiFi network
   Serial.println();
   Serial.print("Connecting to ");
   Serial.println(ssid);

   WiFi.begin(ssid, password);

   while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.print(".");
   }

   Serial.println("");
   Serial.println("WiFi connected");
   Serial.println("IP address: ");
   Serial.println(WiFi.localIP());
}

Una vez que ya le hemos dado conexión a nuestro ESP8266, el siguiente paso es conectarnos al broker público. A continuación se va a mostrar el código necesario para realizar dicha conexión:

#include <PubSubClient.h>

//Wifi Setup
const char* ssid = "SSID_Proyecto_IoT2018";
const char* password = "password_IoT2018";

//Broker
const char* mqtt_server = "broker.hivemq.com"; /// MQTT Broker
int mqtt_port = 1883;

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

void setup() {
 Serial.begin(9600);
 setup_wifi();
 client.setServer(mqtt_server, mqtt_port);
 client.setCallback(callback);
 client.subscribe("PARKING_IOT_MONITOR");
 Serial.println("Connected");
 Serial.print("MQTT Server ");
 Serial.print(mqtt_server);
 Serial.print(":");
 Serial.println(String(mqtt_port));
 Serial.print("ESP8266 IP ");
 Serial.println(WiFi.localIP());
}

void loop() {
switch(estado) {
     case inicio:
       if(ValorLDR[0] < limitCoche[0] && PLAZAS_LIBRES > 0) {
         estado = entrando1;
       } else if(ValorLDR[1] < limitCoche[1]) {
         estado = saliendo1;
       }
break; .... 
case entra_coche:
       client.publish("PARKING_IOT", "ENTRA"); /// send char
       Serial.println("Estado: Entra coche");
       estado = inicio;
       break; ....
case sale_coche:
       client.publish("PARKING_IOT", "SALE"); /// send char
       Serial.println("Estado: Sale coche");
       estado = inicio;
       break;
  default:
       estado = inicio;
       break;
 if (!client.connected()) {
    reconnect();
 }
 client.loop();
 delay(100);
}

//Función que se ejecuta cuando se recibe un mensaje nuevo, en este caso, conocer el número de plazas libres
void callback(char* topic, byte* payload, unsigned int length) {
 String s = String((char*)payload);
 PLAZAS_LIBRES = s.toFloat();

 Serial.print("PLAZAS LIBRES => ");
 Serial.println(PLAZAS_LIBRES);
}

void reconnect() {
   // Loop until we're reconnected
   while (!client.connected()) {
      Serial.print("Attempting MQTT connection...");
      // Attempt to connect
      if (client.connect("ESP8266Client")) {
          Serial.println("connected");
     client.subscribe("PARKING_IOT_MONITOR");
      } else {
          Serial.print("failed, rc=");
          Serial.print(client.state());
          Serial.println(" try again in 5 seconds");
          // Wait 5 seconds before retrying
          delay(5000);
      }
   }
}

void setup_wifi() {
   delay(10);
   // We start by connecting to a WiFi network
   Serial.println();
   Serial.print("Connecting to ");
   Serial.println(ssid);

   WiFi.begin(ssid, password);

   while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.print(".");
   }

   Serial.println("");
   Serial.println("WiFi connected");
   Serial.println("IP address: ");
   Serial.println(WiFi.localIP());
}

Comentarios

Publicar un comentario

Entradas populares de este blog

Clasificador Difuso del sistema

Imagen
Clasificador Difuso del sistema ¿Qué es la lógica difusa? La lógica difusa forma parte de la inteligencia artificial, más concretamente se encuentra dentro del Soft Comuting. Las principales características del Soft Computing son: Trata de modelar y estudiar la forma en la que los humanos pensamos o nos comportamos, a través del uso de computadoras u otros dispositivos. Tolera la imprecisión, la incertidumbre, las verdades parciales y la aproximación. En concreto la lógica difusa es considerado el núcleo de la Inteligencia Artificial por algunos autores. La lógica difusa aparece por primera vez en 1965 de la mano de Zadeh en el artículo "Fuzzy sets" , motivado por problemas de control. La lógica difusa (Fuzzy Logic) se basa en una mezcla de teoría de la probabilidad, conjuntos difusos y en la lógica de Lukasiewicz.  La lógica difusa puede considerarse una lógica multievaluada, la cual se diferencia principalmente de la lógica clásica por que un elemento ti...
Leer más

Cliente MQTT del ESP8266

Imagen
Cliente MQTT del ESP8266 En esta entrada se recoge la implementación del cliente MQTT para el ESP8266. Primero es necesario exponer que el protocolo MQTT es un protocolo utilizado en la comunicación máquina a máquina (machine to machine, M2M) en Internet de las cosas. El protocolo está orientado a la comunicación entre sensores o nodos de sensores, debido a que consume pocos recursos.  La arquitectura de MQTT sigue una topología de estrella, en el centro de la estrella se encuentra un nodo llamado Broker, el cuál es el encargado de gestionar la red y transmitir lo mensajes. Para la presente práctica se ha decidido utilizar el Broker público HiveMQ . La comunicación mediante este protocolo se basa en "Topics" , que el cliente puede crear y suscribirse, para enviar un mensaje el cliente debe usar un mensaje tipo publish y para suscribirse se lo comunica al nodo central y lo hace mediante la instrucción o mensaje subscribe.  Los Topics establecen una estructura ...
Leer más

I2C

Imagen
Práctica I2C En esta entrada se recoge la información necesaria para realizar la práctica relacionada con este bus. Para ello, se dará una breve introducción de lo que es este bus y su protocolo de comunicación. Bus I2C Este tipo de bus tiene una comunicación bidireccional basado en dos conductores. El SLC (señal de reloj), y el SDA (transmisión de datos). Los datos que se transmiten por el SDA son de 8 bits. El uso de este tipo de bus viene representado en la siguiente imagen, en la cuál se puede observar que uno de los elementos actúa como maestro, mientras que el resto actúa como esclavos, recibiendo información del maestro o viceversa. Este bus ha sido extendido para soportar velocidades de hasta 3.4 Mbits/s. La velocidad de transmisión es determinada por el reloj. Modos de transferencia: Modo estándar (S-mode) - 100 kbits/s Modo rápido (F-mode) - 400 kbits/s Modo alta velocidad (HS-mode) - más de 3,4 Mbits/s Protocolo I2C El formato del mensaje del...
Leer más