Sensor ultrasonico con servidor mqtt

cerca del proyecto

En este post vamos a usar el sensor hcsr04 para medir la distancia y este dato lo vamos a enviar a un servidos mqtt para poderlo procesar y gráfica en una web, para ello nos guiaremos con el montaje de este sensor de post pasados y de la conexión de la placa wemos d1 a mosquitto.

Conocimiento previo

Para realizar este proyecto se requiere conocimiento previo de los siguientes temas, si aun no has trabajado con lo que se menciona en la siguiente tabla, allí están los links a los post para que puedas dar un repaso adicional o puedas recordar el conocimiento necesario para poder realizar este proyecto.

Materiales

Lo que necesitamos para este proyecto va a ser básicamente la placa wemos D1 con el sensor de distancia, adicional vamos a mencionar todo el software y todas las librerías que requerimos para poder hacer funcionar y visualizar en la web este proyecto. En el siguiente apartado tenemos los programas necesitamos instalar y configurar para poder montar el servidor mosquito.

Software

Para el desarrollo de este proyecto vamos a requerir los siguientes programas, librerías e instaladores, a continuación encontrara los link para que los descargue y los post donde podrá realizar la instalación.

Componentes electrónicos

Pasos de conexión wemos D1 a mqtt

Para poder trabajar con el servidor mosquito y recibir datos, lo primero que tenemos que hacer el servidor y configurar el servidor mosquito con el protocolo mqtt, este paso lo voy a a pasar por alto en esta explicación ya que como menciono en los conocimientos previos se encuentran los links para instalarlo en Windows y en Linux, allí van a encontrar el detalle de cómo se debe hacer la instalación.

Una vez instalado y configurado el servidor mqtt procederemos a hacer los siguientes pasos.

Configurar mosquitto

Para poder trabajar con mosquitto mqtt debemos realizar una configuración sobre el archivos mosquitto.conf el cual se encuentra en windows en la ruta "C:\Program Files\mosquitto" o linux "etc/mosquitto", donde se instalo el mosquitto.

En este archivo vamos a buscar y descomentar las siguientes lineas, si no estan las puede agregar al final:

allow_anonymous true
listener 1883

Estas lienas permiten habilitar las conexiones externas al servidor, en otros post explicamos como generar conexiones seguras.

Vamos a validar los siguiente antes de continuar, todo esto esta en los post de instalación del entorno.

• Verificar que el firewall acepte conexiones de salida ye entrada en el puerto 1883
• Despues de hacer la configuración reiniciar el servidor
• Realizar los ejemplos que menciono en el post Mosquitto enviar y recibir mensajes.

Ahora vamos a crear el topic en donde recibiremos las conexiones, para ello abrimos una terminal de comandos y colocamos lo siguiente:

mosquitto_sub -h localhost -t distancia -v

El topic donde recibimos los datos es distancia, puede colocar cualquier nombre.

Circuito

En el siguiente circuito esta la forma de conectar el sensor al wemos d1, aunque en la imagen se muestra la placa arduino la conexión es la misma.

Sí necesitamos más detalles sobre esta conexión, en el post arduino hc sr04 explico a detalle Cómo se debe realizar la conexión la configuración y el paso a paso en el código para poder entender el funcionamiento y de Cómo podemos obtener la distancia con este sensor.

Código

Expliquemos el código paso a paso, para poderlo analizar mejor antes de entrar a verlo al detalle.

• Primero vamos a incluir las librerías necesarias para realizar la comunicación, el link de descarga son los mencionados en los materiales, estas librerías se deben cargar al programa arruino.
• Vamos a declarar una serie de variables en donde guardaremos el nombre de la red, contraseña y nombre del servidor.
• Después inicializaremos los objetos correspondientes WiFiEspClient, PubSubClient, y softwareserial.
• Ahora la primera acción que vamos a realizar es iniciar con el wifi, en donde validaremos si esta conectado y comunicándose el modulo, luego vamos a realizar la conexión al modulo con el nombre de la red y la contraseña.
• Después de tener conexión al wifi indicamos cual es el servidor en donde esta mosquitto con el fin de abrir una conexión permanente para poder enviar información al topic.
• Finalmente enviamos la cadena de texto con el dato que necesitamos enviar.

//Cargamos las librerias
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

//Creamos las variables para el acceso al WIFI 
//y al servidor mosquitto
const char* ssid = "NOMBRE_DE_LA_RED";
const char* password = "CONTRASEÑA";
const char* mqtt_server = "192.168.20.21";

//Inicializamos los objetos el cliente y el publicador
WiFiClient espClient;
PubSubClient client(espClient);

long lastMsg = 0;
char msg[50];
int value = 0;

//Se declaran los pines para el sensor
int const TRIG = D9;
int const ECHO = D8;

//Variables de calculo
float _distance;
float _time;

//Creamos la función que nos permitira realizar
//la conexión del wifi
void setup_wifi() {
    delay(10);
    Serial.println();
    Serial.print("Conectado a: ");
    Serial.println(ssid);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    }
    randomSeed(micros());
    Serial.println("");
    Serial.println("WiFi conectado");
    Serial.println("Direccion IP: ");
    Serial.println(WiFi.localIP());
}

//Creamos la función que permite realizar la conexión
//al servidor mosquitto
void reconnect() {
    Serial.println("reconnect");
    //Validamos si existe una conexión al servidor, 
    //de lo contrario intentamos conectarlo de nuevo
    while (!client.connected()) {
        Serial.print("Attempting MQTT connection...");
        //Creamos un clinete ID ramdon
        String clientId = "ESP8266Client-";
        clientId += String(random(0xffff), HEX);
        //Intentamos conectarnos
        if (client.connect(clientId.c_str())) {
            Serial.println("connected");
            //Enviamos un mensaje de prueba
            client.publish("outTopic", "hello world");
        } else {
            //Si la conexión fallo, intentamos de nuevo
            Serial.print("failed, rc=");
            Serial.print(client.state());
            Serial.println(" try again in 5 seconds");
            // Wait 5 seconds before retrying
            delay(5000);
        }
    }
}

void setup() {
    //Activación del pin como salida: para el pulso ultrasónico
    pinMode(TRIG, OUTPUT); 
    //Activación del pin como entrada: tiempo del rebote del ultrasonido
    pinMode(ECHO, INPUT); 
    Serial.begin(9600);
    Serial.println("setup");
    //Iniciamos la conexión del wifi
    setup_wifi();
    //Indicamos a que servidor nos conectamos
    client.setServer(mqtt_server, 1883);
}

void loop() {
    //Validamos la conexión si esta correcta
    if (!client.connected()) {
        reconnect();
    }
    
    //Dejamos el cliente el loop para que no cierre 
    //la conexión actual
    client.loop();

    float distanceSensor = readDistance();
    Serial.println("distancia");
    Serial.println(distanceSensor);
    snprintf (msg, 50, "%4.2f", distanceSensor);
    Serial.print("Publish message: ");
    Serial.println(msg);
    //Enviamos el mensaje
    client.publish("distancia", msg);

    delay(2000);
}

//Leemos la distancia del sensor
float readDistance(){
    digitalWrite(TRIG,LOW); 
    delayMicroseconds(5);
    //Envío del pulso ultrasónico
    digitalWrite(TRIG, HIGH); 
    delayMicroseconds(10);

    //Obtenemos el tiempo de rebote
    _time = pulseIn(ECHO, HIGH); 

    //Calculamos la distancia
    _distance = _time / 2 / 29.1;
    return _distance;
}

Prueba funcionamiento

Por último lo que vamos a hacer es compilar el código lo vamos a cargar a la wemos d1 pero ya Métete Nilo conectado lo que es el sensor, luego vamos a verificar por consola si tenemos inicializado el servidor mqtt a la escucha del topic quedamos en apartados anteriores, y lo que vamos a hacer es abrir la terminal serial de arduino para poder visualizar el loca que no se está generando el programa, con esto podemos observar que la tarjeta podemos de uno está conectándose a la red y luego se conecta al servidor mqtt Y por último le dé la distancia que obtiene desde el centro y la envía al topic correspondiente que creamos.

Con este proyecto lo que queremos hacer es poder combinar dos tecnologías diferentes para poder utilizarla según un propósito que necesitamos, en este caso de poder obtener la distancia y enviarla a un servidor mqtt, ese ya lo podemos Conectar a algún programa como por ejemplo node red y poder visualizar la distancia en un entorno gráfico más agradable