Detector de actos vandálicos - Proyecto para aprender Arduino -Duino.Pro

¿Qué utilidad tiene?

Se trata de un proyecto para aprender Arduino que es autónomo. Se recarga con energía solar. Cuando detecta una sacudida, golpe o vibración, te envía un mensaje al móvil. Entérate si alguien roba tus pertenencias o invade un perímetro. Detecta accidentes o robos.

¿Qué voy a aprender?

Aprenderás a usar la capacidad de hibernación y modo deep-sleep (ahorro de energía) del procesador ESP32. Trabajarás con una placa solar, un regulador de carga y una batería Li-Po. 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 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

Hacer clic en la imagen para ampliarla.

Vídeo explicativo

En qué consiste este proyecto para aprender Arduino

El dispositivo lleva en su interior un detector pasivo de movimiento que no consume energía alguna a no ser que se detecte una sacudida. Mientras, toda la energía solar se va almacenando en la batería. Por ello puede funcionar sin necesidad de recargarlo. Si se detecta un golpe, la placa se activa y envía un mensaje a Telegram conectándose a Internet por medio de Wifi. Puede experimentarse en diferentes escenarios (se explican más adelante).

Saber si el viento ha tirado muebles de terraza, pérgolas o árboles
Saber si alguien ha tocado nuestras cosas en la playa o en el camping.
Saber si alguien mueve nuestro patinete o bicicleta.
Saber si alguien rebasa una valla o perímetro.

Aprender Arduino es fácil con este proyecto que ha sido ideado para ello. Es completamente autónomo, no es necesario recargar la batería.

Sensor de golpes y sacudidas

Se trata de un pequeño sensor cilíndrico que lleva bolas de metal en su interior y en la parte inferior lleva dos pines. Hacer uso del mismo es muy bueno para aprender Arduino ya que su mecánica es muy sencilla de comprender, te la explicamos.

Cuando se golpea el sensor o se cambia su orientación, las bolas hacen contacto entre los dos pines, abriendo o cerrando el circuito. Si el circuito está abierto, la placa no consumirá apenas energía.

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 del cual vamos a hacer uso en este proyecto.

Batería, placa solar y circuito regulador de carga

El circuito regulador de carga satisface con energía solar la necesidad de carga de la batería. La energía almacenada en ella, servirá para alimentar la placa ESP32. Las tres cosas. Placa solar, batería y placa ESP32 se conectan pues al circuito regulador de carga.

En qué consiste el modo de ahorro extremo de energía o deep spleep de la placa ESP32

Cuando la placa está en este modo consume tan solo muy pocos micro amperios por lo que la carga de la batería puede mantener vivo el sistema durante mucho tiempo. Es cuando se detecta una sacudida y se cierran los pines del sensor cuando la placa despierta y consume más energía para realizar el envío de mensajes a través de Internet.

De esta manera se consigue la eficiencia energética suficiente para que el dispositivo envíe los mensajes pertinentes y el resto del tiempo se dedique a cargar la batería para cuando llegue el momento. Aprender Arduino es fácil con este proyecto. Vamos a ver como proseguir.

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

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.

Selecciona la placa y el puerto. Conecta la placa al PC. Ve al menú «Herramientas > Placa > Wemos Lolin32». 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 actos vandálicos y accidentes

El proceso de montaje y cableado de este proyecto para aprender Arduino, se explica en el vídeo de la parte inicial de este post. Existen dos formas de poder montar el dispositivo. Conectando la placa solar con o sin soldadura.

Sin soldadura

Insertar termo retráctil en los cables de la placa solar.
Retorcer entre si los cables de la placa solar para unirlos con los cables que van al conector del regulador de carga.
Aplicar calor al termo retráctil.

Con soldadura

Insertar termo retráctil en los cables de la placa solar.
Retorcer entre si los cables de la placa solar para unirlos con los cables que van al conector del regulador de carga.
Aplicar estaño con el soldador. De esta manera los cables quedarán mejor unidos.
Aplicar calor al termo retráctil.

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

Proceso de configuración del dispositivo

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.

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 proyecto para aprender Arduino. 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.

Ejemplos de uso en los que se puede experimentar con el dispositivo

Conectando el dispositivo a la red Wifi de nuestra casa, local, bar…

Saber si el viento tira los muebles de la terraza o el mástil de la antena.
Saber si alguien nos abre el maletero del coche que tenemos dentro del garaje.
Saber si alguien abre la puerta del cercado, mueve o sacude la valla del jardín, por ejemplo al saltarla.
Saber si alguien se lleva o mueve las sillas o mesas apiladas en la terraza de un bar.

Conectando el dispositivo a la red Wifi que creemos con nuestro teléfono móvil conectado a Internet…

Saber si alguien mueve o golpea nuestra bicicleta o patinete eléctrico.
Saber si alguien se lleva nuestra nevera, sillas o mochila en la piscina, camping o playa.

¡Esperamos que aprender Arduino te haya sido fácil 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;
}

AsyncWebServer server(80);
DNSServer dns;
SimpleTimer timer;

void setup() {
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_33, 0); //Wake up if movement detected
  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();

// 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 = "Movimiento detectado";
  if (bot.sendMessage(chat_id, message, "Markdown")) {
    Serial.println("TELEGRAM Successfully sent");
  } else {
    Serial.println("Fallo TELEGRAM");
    reinicio();
  }
  Serial.println("Activando modo ahorro... en 15 segundos");
  delay(15000);
  esp_deep_sleep_start();
  Serial.println("Este mensaje nunca saldra");
}

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.