Detector de fugas de agua - Proyecto para aprender Arduino

¿Qué utilidad tiene?

Se trata de un proyecto para aprender Arduino que, situado en el suelo, nos enviará un mensaje al móvil a través de Telegram si se detecta que existe la presencia de agua. Desgraciadamente todo el mundo suele tener tarde o temprano una fuga de agua en casa. Mejor enterarse en el momento de que ocurra, sobre todo si estamos fuera. Proyecto Open Source.

¿Qué voy a aprender?

Aprenderás a usar la capacidad del procesador ESP32 para conectarte a Internet por medio de Wifi. Trabajarás con la API de Telegram para enviar mensajes al móvil a través de Arduino. Utilizarás un sensor analógico detector de agua. Utilizarás la memoria interna SPIFFS de la placa con procesador ESP32.

Material necesario

Recuerda que también puedes comprar todo el material necesario en formato kit y con el firmware previamente grabado en la placa.

Comprar el mega kit con todos los proyectos de esta web incluidos

Dificultad 15%

Tiempo de realización: 31 minutos

Gente que lo ha encontrado útil 90%

Te enseñamos a hacerlo por ti mismo

También puedes comprarlo en formato Kit con todo el material necesario y el firmware ya grabado en la placa.

Cableado

Vídeo explicativo

En qué consiste este proyecto

Se trata de un dispositivo que se deja a ras de suelo. Conectado a la corriente. En caso de que el dispositivo detecte agua nos enviará inmediatamente un mensaje al móvil para alertarnos de la situación y que podamos remediarla antes de que el mal llegue a mayores, molestias con los vecinos… etc. Aprender Arduino es fácil con este proyecto.

Aprender Arduino es fácil con este proyecto que ha sido ideado para ello. Se conecta por USB a un cargador de móvil. Va todo metido en una caja estanca de PVC. Es necesario hacer 4 pequeñas soldaduras para garantizar la estanqueidad de la caja a la hora de pasar el cable USB por el prensa estopas metálico. También es posible prescindir de dichas soldaduras y del prensaestopas y emplear cables con pins de conexión (incluidos en el kit) por lo que la soldadura es opcional.

Sensor detector de agua para Arduino

Para poder detectar el agua, este dispositivo incorpora un detector de conductividad. Cuando el agua moja las pistas plateadas del sensor, se produce una conexión entre ellas, variando la resistencia del conjunto.

La placa ESP32 es capaz de medir la variación que produce el sensor en uno de los pins analógicos del sistema, por ello sabe cuando hay agua y cuando no. En el momento de existir agua mojando el sensor, la placa se conectará a Internet por medio de Wifi y nos enviará un mensaje al móvil utilizando para ello la API de Telegram.

Placa ESP32 Lolin32 Lite

Se trata de la placa central de nuestro proyecto. En ella se encuentra el procesador Espressif ESP32 que tiene la capacidad de conectarse a Internet por medio de Wifi. De ésta forma, cuando el sensor detecte agua, la placa podrá enviarnos un mensaje a nuestro teléfono móvil. La placa también incluye conectividad por Bluetooth y circuito de carga de baterías con conector JST, por si deseamos utilizarla en alguno de nuestros futuros proyectos.

Proceso de flasheo del firmware. No es necesario si adquieres el kit.

Instalar el IDE de Arduino. Descarga e instala el IDE de Arduino.

Sigue estos pasos para añadir las dependencias para la placa ESP 32 en el IDE de Arduino.

Añadir las librerías. Accede a estas webs y presiona el botón que pone «Code» y luego en «Download ZIP». Luego descomprime el .ZIP dentro de «Documentos > Arduino >Libraries».

https://github.com/alanswx/ESPAsyncWiFiManager
https://github.com/alanswx/ESPAsyncWiFiManager
https://github.com/bblanchon/ArduinoJson
https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot
https://github.com/jfturcot/SimpleTimer

Ejemplo de como descargar una librería de Arduino

Añadir el programa. Abre el IDE de Arduino. Ve al menú Archivo >Nuevo. Copia y pega el código fuente del programa, situado más abajo. Modificar las líneas 73 y 88 para poner el PIN de Windows y la contraseña para otros programas que tu desees.

Selecciona la placa y el puerto. Conecta la placa al PC. Ve al menú «Herramientas > Placa > Arduino Micro». Luego ve al menu «Herramientas > Puerto > Selecciona el puerto adecuado».

Grabar el firmware en la placa. Ve al menú «Programa > Subir» y espera unos segundos hasta que finalice el proceso.

Proceso de formateo de la memoria interna SPIFFS. No es necesario si adquieres el kit.

Haremos este proceso tan solo la primera vez o bien, si deseamos borrar los datos y dejarlos como estaban originalmente de fábrica.

Para ello localizaremos en el programa la siguiente línea, que está comentada. Ésta instrucción es la que se encarga de hacer el formateo.

//SPIFFS.format();

Borraremos las dos barras «//» del principio (que sirven para comentar la línea y dejarla sin efecto) y grabaremos el firmware. Reiniciaremos la placa y esperaremos unos 30 segundos. Volveremos a grabar el firmware con la línea con las dos barras, es decir, volviendo a comentar la línea.

Proceso de montaje del detector de fugas de agua

Existen dos formas de poder montar este proyecto para aprender Arduino.

Sin soldadura y menor estanqueidad.

Recortar 1 agujero en la parte superior de la caja para poder pasar los cables del sensor y el cable USB. Para ello podemos emplear un cuter.
Conectar el sensor a la placa pasando los cables por el agujero. El pin + lo conectaremos al pin 3V de la placa. El pin S lo conectamos con el pin 33 de la placa. El pin – lo conectamos al GND de la placa.
Conectar el cable USB a la placa pasándolo por el agujero.

Con soldadura y mayor estanqueidad.

Recortar 1 agujero en la parte superior de la caja para poder poner el prensaestopas. Para ello podemos emplear un cuter. Poner el prensaestopas.
Soldar los cables del sensor. Soldarlos a la placa pasando los cables por el agujero. El pin + lo conectaremos al pin 3V de la placa. El pin S lo conectamos con el pin 33 de la placa. El pin – lo conectamos al GND de la placa.
Cortar el cabezal del cable USB que va a la placa, pasar el cable por el prensaestopas. Soldar los cables. Ver el vídeo de la parte superior de esta página para mayor detalle.
Conectar el cable USB a la placa pasándolo por el agujero.

Colocar todo dentro de la caja. Pegar el sensor por fuera usando un trozo de de almohadilla adhesiva.

Proceso de configuración del detector de fugas de agua

El proceso de configuración es muy sencillo. Todo se lleva a cabo a través de un panel de control web. Para que el dispositivo pueda enviarnos mensajes al móvil, vamos a necesitar instalar en el móvil la APP de Telegram.

Una vez hecho, seguiremos estos pasos para obtener 2 datos que necesitamos. El Chat ID y el Bot Token.

Una vez instalada la APP Telegram en nuestro móvil, la abrimos. Presionamos en la lupa y escribimos «BotFather» y entramos.
Escribir /newbot
Escribir un nombre para el bot por ejemplo «guardian»
Escribir lo mismo pero terminado en «bot» por ejemplo «guardianbot»
Se nos proporcionará una clave o token para acceder a la HTTP API, copiar dicha clave que será nuestro BOT token
También veremos un enlace que empieza por «t.me/nombre_del_bot» presionamos para entrar.
Escribimos /start en la ventana de nuestro bot
Volvemos atrás y de nuevo en la lupa escribimos «IDBot». Entramos.
Escribimos /start
Escribimos /getid y apuntamos el número que aparezca que será nuestro CHAT_ID

A partir de aquí, tan solo tienes que seguir los pasos siguientes, que tienes también explicados en el vídeo que hay a continuación. Como podrás ver, este proyecto para aprender Arduino es muy fácil de seguir.

Conectaremos el sensor a un transformador USB de 5V y esperaremos unos segundos. Accederemos desde nuestro PC o móvil a buscar una nueva red wifi a la que conectarnos. El dispositivo habrá creado un punto de acceso wifi llamado Iberotecno AP. Nos conectaremos a esta red wifi. No pedirá contraseña.

Aparecerá automáticamente el panel de control de iberotecno desde el cual podemos configurar nuestro dispositivo. Presionaremos en la opción configurar Wifi.

Ahí pondremos nuestros credenciales de la red Wifi, el chat id y el bot token. Salvamos los datos. ¡Eso es todo! Esperamos que hayas podido aprender Arduino gracias a este proyecto.

Descarga gratis el código fuente

También puedes comprarlo en formato Kit con todo el material necesario y el firmware ya grabado en la placa.

También tienes disponible el código fuente en nuestro GitHub del proyecto.

Copiar código fuente al portapapeles

#include <FS.h>                       //library to access the filesystem
#include <WiFiClientSecure.h>
#include "SPIFFS.h"
#include <WiFi.h>
#include <ESPAsyncWebServer.h>       //https://github.com/alanswx/ESPAsyncWiFiManager
#include <ESPAsyncWiFiManager.h>     //https://github.com/alanswx/ESPAsyncWiFiManager
#include <ArduinoJson.h>             //https://github.com/bblanchon/ArduinoJson
#include <UniversalTelegramBot.h>    //https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot
#include <SimpleTimer.h>             //https://github.com/jfturcot/SimpleTimer

//define custom fields
char chat_id[100];
char bot_token[100];

//flag for saving data
bool shouldSaveConfig = false;

//callback notifying us of the need to save config
void saveConfigCallback () {
  Serial.println("Should save config");
  shouldSaveConfig = true;
}

// variables definitions and initializations
int flag = 0;
int acu = 0;
const int waterSensor = 33;
AsyncWebServer server(80);
DNSServer dns;
SimpleTimer timer;

void setup() {
Serial.begin(115200);
  Serial.println("\n Starting");
  //
  //***clean FS, for testing
  //SPIFFS.format();
 
  //read configuration from FS json
  Serial.println("mounting FS...");
  if (SPIFFS.begin()) {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/config.json")) {
      //file exists, reading and loading
      Serial.println("reading config file");
      File configFile = SPIFFS.open("/config.json", "r");
      if (configFile) {
        Serial.println("opened config file");
        size_t size = configFile.size();
        // Allocate a buffer to store contents of the file.
        std::unique_ptr<char[]> buf(new char[size]);
        configFile.readBytes(buf.get(), size);
        DynamicJsonBuffer jsonBuffer;
        JsonObject& json = jsonBuffer.parseObject(buf.get());
        json.printTo(Serial);
        if (json.success()) {
          Serial.println("\nparsed json");
          strcpy(chat_id, json["chat_id"]);
          strcpy(bot_token, json["bot_token"]);
        } else {
          Serial.println("failed to load json config");
        }
      }
    }
  } else {
    Serial.println("failed to mount FS");
  }
  //end read

//Telegram parameters
  AsyncWiFiManagerParameter custom_chat_id("chat_id", "chat id", chat_id, 100);
  AsyncWiFiManagerParameter custom_bot_token("bot_token", "bot token", bot_token, 100);

//WiFiManager
  //Local intialization. Once its business is done, there is no need to keep it around
  AsyncWiFiManager wifiManager(&server, &dns);

//set config save notify callback
  wifiManager.setSaveConfigCallback(saveConfigCallback);

wifiManager.addParameter(&custom_chat_id);
  wifiManager.addParameter(&custom_bot_token);

//scheduled reset
  int horas = 1; // hours for scheduled reset
  timer.setInterval(horas * 3600000, reinicio);

//WiFiManager

AsyncWiFiManagerParameter custom_text("<p>Seleccione la red WiFi para conectarse.</p>");
  wifiManager.addParameter(&custom_text);
  //reset saved settings
  //wifiManager.resetSettings();
  //set custom ip for portal
  //wifiManager.setAPConfig(IPAddress(10,0,1,1), IPAddress(10,0,1,1), IPAddress(255,255,255,0));
  //fetches ssid and pass from eeprom and tries to connect
  //if it does not connect it starts an access point with the specified name
  //here  "AutoConnectAP"
  //and goes into a blocking loop awaiting configuration
  wifiManager.autoConnect("Iberotecno AP");
  //or use this for auto generated name ESP + ChipID
  //wifiManager.autoConnect();
  //if you get here you have connected to the WiFi
  Serial.println("connected...yeey :)");

//read updated parameters

strcpy(chat_id, custom_chat_id.getValue());
  strcpy(bot_token, custom_bot_token.getValue());

//save the custom parameters to FS
  if (shouldSaveConfig) {
    Serial.println("saving config");
    DynamicJsonBuffer jsonBuffer;
    JsonObject& json = jsonBuffer.createObject();
    json["chat_id"] = chat_id;
    json["bot_token"] = bot_token;
    File configFile = SPIFFS.open("/config.json", "w");
    if (!configFile) {
      Serial.println("failed to open config file for writing");
    }
    json.printTo(Serial);
    json.printTo(configFile);
    configFile.close();
    //end save
  }
  Serial.println("local ip");
  Serial.println(WiFi.localIP());

}

void loop() {
  timer.run();
  int valor = analogRead(waterSensor);
  if (valor >= 5) { // call alert function if water is detected
    if (flag == 0) {
      alerta();
    }
  } else {
    flag = 0;
  }
  delay(100);
}

void alerta() { //alert function
  flag = 1;
  // Initialize Telegram BOT
  WiFiClientSecure client;
  UniversalTelegramBot bot(bot_token, client);
  int Bot_mtbs = 1000; //mean time between scan messages
  long Bot_lasttime;   //last time messages' scan has been done

//Send alert
  String message = "Agua detectada";
  if (bot.sendMessage(chat_id, message, "Markdown")) {
    Serial.println("TELEGRAM Successfully sent");
  } else {
    Serial.println("Fallo TELEGRAM");
    reinicio();
  }
}

// restart function definition
void reinicio() {
  ESP.restart();
}

Las ventajas de adquirir el Kit

Incluye manual de instrucciones en papel y todo lo necesario para montarlo.
El proceso de flasheo no hay que hacerlo ya que el firmware viene pre grabado en la placa.
Soporte y ayuda gratis. Garantía. Envío a España en 24 horas.