Cómo hacer un contador de aforo con un ESP32 y un HC-SR04

Un contador de aforo te permite conocer el número de personas que ha entrado en un espacio delimitado. En este tutorial haremos uno con un sensor de distancia que utiliza ultrasonido, el HC-SR04. Los datos se enviarán con un ESP32 a Ubidots, servicio en el cual se mostrará un dashboard.

Anteriormente se hicieron tutoriales para utilizar Ubidots y el HC-SR04.

Tutorial de Ubidots: ESP32 + UBIDOTS : PRIMEROS PASOS – TodoMaker

Tutorial de HC-SR04: MEDICION DE DISTANCIA CON SENSOR DE ULTRASONIDO – TodoMaker

Conexión de componentes

Conecta el ESP32 y el HC-SR04 como en el gráfico.

ESP32	HC-SR04
VIN	VCC
D12	Trig
D13	Echo
GND	GND

Programación

Código

/*
   Contador de aforo con ESP32, HC-SR04 y Ubidots
   www.todomaker.com
*/

#include "UbidotsEsp32Mqtt.h"

/****************************************
  Configuración Ubidots
 ****************************************/
const char *UBIDOTS_TOKEN = "BBFF-L52U8CYjBrk7oM7FgA8GZ8Z8aklz18";  // Token de Ubidots
const char *WIFI_SSID = "Tu SSID";      // SSID de WiFi
const char *WIFI_PASS = "Tu contraseña";      // Contraseña de WiFi
const char *DEVICE_LABEL = "ESP32-TM";   // Device_label Ubidots
const char *VARIABLE_LABEL = "aforo"; // Variable label Ubidots

Ubidots ubidots(UBIDOTS_TOKEN);

int aforo = 0;

/****************************************
   Funciones
 ****************************************/

void callback(char *topic, byte *payload, unsigned int length)
{
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++)
  {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

//Configuraciones HC-SR04
const int Echo = 13;
const int Trigger = 12;

/*Definimos la variable "t" como el tiempo que demora el eco en llegar de retorno al sensor*/
long t;
/*Definimos la variable "d" como la distancia que mide el sensor, en centímetros*/
long d;

void setup() {

  // put your setup code here, to run once:
  Serial.begin(115200);
  // ubidots.setDebug(true);  // uncomment this to make debug messages available
  ubidots.connectToWifi(WIFI_SSID, WIFI_PASS);
  ubidots.setCallback(callback);
  ubidots.setup();
  ubidots.reconnect();

  /*El modo de operación de Trigger se define como una SALIDA*/
  pinMode(Trigger, OUTPUT);
  /*El modo de operación de Echo se define como una ENTRADA*/
  pinMode(Echo, INPUT);
  /*El pin Trigger se inicia en un estado BAJO, con un 0 lógico, sin operar por el momento*/
  digitalWrite(Trigger, LOW);
  /*Imprimimos en el terminal Serial*/
  Serial.print("Iniciando la medición de distancia con sensor HC-04");
  Serial.println("");

}

void loop() {

  digitalWrite(Trigger, HIGH);
  delayMicroseconds(10);
  digitalWrite(Trigger, LOW);
  /*La variable "t" toma como valor, el ancho del pulso de 10 microsegundos que se implementó*/
  t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso
  /*La variable "d" toma el valor del cociente entre el tiempo (en microsegundos) y 59 (ambos se explican en el post)*/
  d = t / 59;
  /*Se imprime en el monitor Serial el valor de la Distancia, y añadimos un retardo de aproximadamente 5 segundos*/
  Serial.print("Distancia medida: ");
  Serial.println(d);
  delay(500);

  //Condición de aforo
  if (d <= 15) { //si la distancia es menor o igual a 15
    aforo += 1;
    Serial.print("Aforo: ");
    Serial.println(aforo);

    if (!ubidots.connected())
    {
      ubidots.reconnect();
    }

    float value = aforo;
    ubidots.add(VARIABLE_LABEL, value); // Insert your variable Labels and the value to be sent
    ubidots.publish(DEVICE_LABEL);

    ubidots.loop();
  }

}

Explicación del código

Iniciamos añadiendo la librería para la comunicación del ESP32 con Ubidots. Recuerda ver el tutorial correspondiente para ver como instalar esta librería.

ESP32 + UBIDOTS : PRIMEROS PASOS – TodoMaker

#include "UbidotsEsp32Mqtt.h"

Posteriormente llenamos los datos necesarios para la comunicación y autentificación del ESP32 con Ubidots. Agregas tu token de Ubidots y los datos de tu red WiFi.

En DEVICE_LABEL agregas el nombre que tendrá el ESP32 en la plataforma y en VARIABLE_LABEL el nombre de la variable que usarás en Ubidots. Estos datos son importantes para que los widgets de Ubidots sepan de donde obtener los datos.

const char *UBIDOTS_TOKEN = "Tu token";  // Token de Ubidots
const char *WIFI_SSID = "MOVISTAR_4760";      // SSID de WiFi
const char *WIFI_PASS = "jzC9zkpTfQs7qd62JE7L";      // Contraseña de WiFi
const char *DEVICE_LABEL = "ESP32-TM";   // Device_label Ubidots
const char *VARIABLE_LABEL = "aforo"; // Variable label Ubidots

Crear una instancia a la que llamaremos ubidots. Se usará el token como argumento. También hay una variable en la que se guardará el dato del aforo.

Ubidots ubidots(UBIDOTS_TOKEN);

int aforo = 0;

Luego se indica al programa que pines del ESP32 se usarán para el sensor HC-SR04. Por ejemplo, el pin digital 13 del ESP32 se usará para el pin Echo del HC-SR04.

También se creará dos variables para la medición con el sensor. En t irá el tiempo que y en d la distancia a la que se encuentra un objeto.

const int Echo = 13;
const int Trigger = 12;

long t;
/*Definimos la variable "d" como la distancia que mide el sensor, en centímetros*/
long d;

En setup() se inicia activando la comunicación serial a una velocidad de 115200.

Posteriormente se conecta el ESP32 a la red WiFi y se establece comunicación con Ubidots.

  Serial.begin(115200);
  // ubidots.setDebug(true);  // uncomment this to make debug messages available
  ubidots.connectToWifi(WIFI_SSID, WIFI_PASS);
  ubidots.setCallback(callback);
  ubidots.setup();
  ubidots.reconnect();

También se indica el modo en el que estarán los pines que se seleccionaron para usar con el sensor.

  /*El modo de operación de Trigger se define como una SALIDA*/
  pinMode(Trigger, OUTPUT);
  /*El modo de operación de Echo se define como una ENTRADA*/
  pinMode(Echo, INPUT);
  /*El pin Trigger se inicia en un estado BAJO, con un 0 lógico, sin operar por el momento*/
  digitalWrite(Trigger, LOW);
  /*Imprimimos en el terminal Serial*/
  Serial.print("Iniciando la medición de distancia con sensor HC-04");
  Serial.println("");

En loop() se inicia tomando la medición de distancia con el sensor e imprimiéndolo en el monitor serie.

digitalWrite(Trigger, HIGH);
  delayMicroseconds(10);
  digitalWrite(Trigger, LOW);
  /*La variable "t" toma como valor, el ancho del pulso de 10 microsegundos que se implementó*/
  t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso
  /*La variable "d" toma el valor del cociente entre el tiempo (en microsegundos) y 59 (ambos se explican en el post)*/
  d = t / 59;
  /*Se imprime en el monitor Serial el valor de la Distancia, y añadimos un retardo de aproximadamente 5 segundos*/
  Serial.print("Distancia medida: ");
  Serial.println(d);
  delay(500);

Se da una condición en la que si un objeto está a 15 o menos centímetros del sensor se procederá a aumentar el valor de aforo en una unidad.

Después de eso se consulta si hay conexión con Ubidots para restablecerla si es necesario. Y para finalizar se procede a enviar el dato de aforo a Ubidots.

if (d <= 15) { //si la distancia es menor o igual a 15
    aforo += 1;
    Serial.print("Aforo: ");
    Serial.println(aforo);

    if (!ubidots.connected())
    {
      ubidots.reconnect();
    }

    float value = aforo;
    ubidots.add(VARIABLE_LABEL, value); // Insert your variable Labels and the value to be sent
    ubidots.publish(DEVICE_LABEL);

    ubidots.loop();
  }

Preparación del dashboard

Cuando hayas conectado el ESP32 y enviado unos datos verás que el dispositivo aparece en tu panel de Ubidots. Entrando al dispositivo puedes entrar al dispositivo y ver la variable con los datos correspondientes.

También puedes borrar los datos.

En la sección de dashboard puedes añadir uno nuevo para posteriormente agregarle los widgets que quieras para visualizar tus datos.

Prueba

Se realizó una prueba para comprobar el funcionamiento. Al pasar cerca al sensor se envía el dato a Ubidots para ser visualizado.

Conclusión

En este tutorial se utilizó el sensor de distancia HC-SR04 para detectar cuando una persona entra a un sitio. El dato sobre el aforo se envía hacia Ubidots usando el ESP32. Cuando el dato haya sido subido se mostrará en un dashboard.

Gracias por haber visto el tutorial. Síguenos para ver más proyectos.