Alarma antirrobo Arduino, compatible con Alexa y Telegram

Esta semana os traemos un proyecto de lo más útil e interesante para darle vidilla a vuestras placas de Arduino o módulos ESP8266. Se trata de una alarma antirrobo para nuestros hogares, la cuál nos mandará notificaciones a nuestro teléfono móvil a través de Telegram si alguien entra en nuestra casa, ¡y además es totalmente compatible con Alexa!

La idea del proyecto es crear un kit de alarma, similar al que venden muchas marcas en la actualidad, los cuales incluyen sensores de puertas y ventanas y sensores de movimiento. Pero añadiendo la integración total con Telegram y Alexa, pero además, lo mejor de todo es que es un proyecto low cost, y podremos crear esta alarma por un precio irrisorio, partiendo de los 20 euros. Muy por debajo del precio de kits como el de Xiaomi, que parte de los 50 euros.

Componentes necesarios

Para nuestro proyecto vamos a crear dos tipos diferentes de sensores, uno para detectar la apertura de puertas/ventanas y otro que detectará el movimiento.

Además para darle conectividad WiFi, vamos a hacer uso de la ya famosa placa ESP8266, la cuál es igual que una placa de Arduino, pero con el añadido de incorporar conexión WiFi. Lo cuál será fundamental para poder mandar notificaciones a Telegram y conectarnos con Alexa.

Sensor de puerta/ventana

Módulo ESP8266. En nuestro caso estamos utilizando el modelo ESP01, ya que gracias a tu reducido tamaño y su bajo consumo, es ideal para este proyecto. Además tiene un coste muy bajo, inferior a los 3 euros la unidad.
Programador para ESP01. Si usáis el módulo ESP01, necesitaréis un programador para cargar el código en el mismo.
Batería a 3,3V. En mi caso estoy usando batería LiPo de 3,7V. Sin embargo hay que tener cuidado al usar estas baterías, ya que su voltaje varía entre los 4,2V y los 3V en función de su carga. El módulo ESP8266, está diseñado para soportar teóricamente como máximo 3,6V, por lo que convendría usar un regulador de voltaje, si no queréis dañar vuestro módulo arduino.
Cargador para la batería. Si usáis una batería de LiPo similar a la que hemos usado nosotros para el proyecto, necesitaréis un módulo que os permita cargar la batería por USB. Por ejemplo el modelo TP4056.
Switch reed. Se trata de un tipo de interruptor que se activa al someterlo al campo eléctrico de un imán.
Imán. Necesitaremos el imán para colocar en el marco de la puerta, y que active nuestro circuito al abrirse la puerta.
Resistencias. En concreto hará falta tener 2 resistencias de 10K Ohm, 1 resistencia de 1k Ohm y una resistencia de 5k Ohm.
Condensador. El que mejor funcionó en nuestras pruebas fue uno de 100uF.
Transistor. Un transistor NPN común, como por ejemplo el famoso 2n2222, es suficiente.
Placa para soldar el circuito y algunos cables.

Sensor movimiento

Módulo ESP8266.
Batería a 3,3V.
Cargador para la batería.
Sensor de movimiento PIR. Se trata de un sensor que lanzará un pequeño pulso eléctrico cuando detecte movimiento.
Resistencias. En concreto hará falta tener 1 resistencia de 10K Ohm, 1 resistencia de 1k Ohm y una resistencia de 5k Ohm.
Condensador de 100uF.
Transistor. Un transistor NPN común, como por ejemplo el famoso 2n2222, es suficiente.
Placa para soldar el circuito y algunos cables.

Circuito

Sensor de puerta/ventana

Sensor movimiento

Ambos circuitos funcionan de modo muy similar.

En el caso del sensor de puerta, cuando el interruptor de la izquierda del circuito (el cuál simula al switch reed), está cerrado, la corriente no circula a través del condensador y por tanto no hay corriente en el transistor, el cuál se comportará como un circuito abierto. Por lo tanto, el pin de reset del ESP01, se mantendrá en estado «ALTO», ya que estará a 3,5V a través de la resistencia de pull-up de 10k Ohm.

En el momento en que el switch se abra (cuando se separa del imán, al abrirse la puerta), la corriente empezará a circular a través del condensador, el cuál se empezará a cargar. Los condensadores en corriente continua, mientras se están cargando, dejan circular la corriente a través de sí mismo y al terminar de cargarse cortan la corriente, por lo que llegará corriente a la base del transistor mientras se cargue el condensador, y por tanto se comportará como un circuito cerrado. Esto supone que el pin de Reset del ESP01, mientras se está cargando el condensador, se pondrá a 0V (tierra), y esto lanzará la señal de reinicio del módulo, el cuál se despertará de su estado de letargo, en el cual estará constantemente, para ahorrar batería. Al dejar de cargarse el condensador, se cortará la corriente y el pin de Reset volverá a 3,5V.

En el caso del sensor de movimiento, la lógica es la misma que en el sensor de puerta, pero en lugar de controlar la entrada de corriente a la base del transistor mediante el switch reed, la corriente la suministrará el sensor de movimiento, el cuál al detectar movimiento, lanzará un pequeño pulso eléctrico, el cuál cargará el condensador y dará corriente a la base del transistor, reiniciando así el módulo ESP01, y ejecutando este su código una vez, antes de volver a dormirse para ahorrar batería.

Fuente circuito: https://www.instructables.com/ESP-01-Motion-Sensor-With-Deep-Sleep/

Cómo funciona la alarma

La alarma estará compuesta por uno o varios sensores de movimiento y uno o varios sensores de puerta/ventana. Cada sensor funcionará de forma totalmente independiente entre sí, teniendo su propio módulo arduino (ESP01) y su propia batería.

Cuando uno de los sensores detecta algo, el pin de RESET del ESP01, se pondrá a tierra durante un breve instante de tiempo, lo cual producirá que el módulo se reinicie. Al reiniciarse, se ejecutará la función setup del código que habremos cargado previamente a nuestra placa, y una vez hecho, volverá a dormirse, para ahorrar batería.

Lo que hará la función setup es lo siguiente:

Comprobará si en el grupo de Telegram que hemos configurado para mandar notificaciones, hay algún mensaje «pineado», y en caso de haberlo, si el mensaje es igual a la cadena de texto «Alarma activada».

Figura 3. Ejemplo de mensaje pineado (alarma activa)

En caso de ser así, mandará un mensaje a nuestro grupo de Telegram a través del bot que hemos creado, y así recibiremos una notificación avisándonos de que la alarma ha sido activada.

Figura 4. Mensaje enviado al grupo de Telegram avisando de movimiento detectado

Además, opcionalmente lanzará una rutina que habremos configurado en Alexa, la cuál reproducirá por sus altavoces sonidos de bocinas y alarmas.

Figura 5. Alexa reproduciendo sonidos de alarma

En caso de que no hubiese un mensaje pineado, no haría nada y se volverá a dormir.

Como podéis ver, utilizaremos el «truco» de pinear mensajes en nuestro grupo de Telegram, para de ese modo, encender o apagar la alarma a nuestro antojo, y no necesitaremos almacenar una variable en un servidor para saber si la alarma está encendida o apagada.

Código

/*
Alarma Arduino compatible con Alexa y Telegram
Creado por Bugeados.com
 */


#include <SPI.h>
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <WiFiClient.h>
#include <ESP8266HTTPClient.h> 
#include <UniversalTelegramBot.h>
#include <ArduinoJson.h>

///////please enter your sensitive data in the Secret tab/arduino_secrets.h
char ssid[] = "XXXXXXXXXXXX";        // your network SSID (name)
char pass[] = "XXXXXXXXXXXXXXXXXXX";    // your network password (use for WPA, or use as key for WEP)
int keyIndex = 0;            // your network key index number (needed only for WEP)

char pinnedMessage[] = "Alarma activada";
String alarm_status = "";

// Initialize Telegram BOT
#define BOTtoken "XXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXX"  // your Bot Token (Get from Botfather)
#define CHAT_ID "XXXXXXXXXXXXX"
#define WEBHOOKSTOKEN "XXXXXXXXXXXXXXXXXX" 

char server[] = "api.telegram.org";    // name address for Google (using DNS)
char server2[] = "maker.ifttt.com"; //URL to trigger alexa routine

// Initialize the Ethernet client library
// with the IP address and port of the server
// that you want to connect to (port 80 is default for HTTP):
X509List cert(TELEGRAM_CERTIFICATE_ROOT);
WiFiClientSecure client;
WiFiClientSecure httpsClient;
UniversalTelegramBot bot(BOTtoken, client);

void setup() {
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  client.setTrustAnchors(&cert); // Add root certificate for api.telegram.org

  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
 
  // attempt to connect to WiFi network:
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, pass);

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

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

  Serial.println("\nStarting connection to server...");
  // if you get a connection, report back via serial:
  if (client.connect(server, 443)) {
    Serial.println("connected to server");
    // Make a HTTP request:
    String part1 = "GET /bot";
    String part2 = "/getChat?chat_id=";
    String part3 = " HTTP/1.1";
    String all = part1 + BOTtoken + part2 + CHAT_ID + part3;
    Serial.println(all);
    client.println(all);
    client.println("Host: api.telegram.org");
    client.println("Connection: close");
    client.println();
  }

  // Check HTTP status
  char status[32] = {0};
  client.readBytesUntil('\r', status, sizeof(status));
  if (strcmp(status, "HTTP/1.1 200 OK") != 0) {
    Serial.println(status);
    Serial.print(F("Unexpected response: "));
    Serial.println(status);
    client.stop();
    return;
  }


    // Skip HTTP headers
  char endOfHeaders[] = "\r\n\r\n";
  if (!client.find(endOfHeaders)) {
    Serial.println(F("Invalid response"));
    client.stop();
    return;
  }

    // Allocate the JSON document
  // Use arduinojson.org/v6/assistant to compute the capacity.
  const size_t capacity = 4096;
  DynamicJsonDocument doc(capacity);

  // Parse JSON object
  DeserializationError error = deserializeJson(doc, client);
  if (error) {
    Serial.print(F("deserializeJson() failed: "));
    Serial.println(error.f_str());
    client.stop();
    return;
  }

  // Extract values
  Serial.println(F("Response:"));
  JsonObject obj = doc["result"]["pinned_message"].as<JsonObject>();
  String alarm_status = obj[String("text")];
  Serial.println(alarm_status);

  // Disconnect
  client.stop();

  // Check alarm status
  if(alarm_status == pinnedMessage){
     bot.sendMessage(CHAT_ID, "Puerta abierta", ""); //Telegram message notification

  httpsClient.setInsecure();

  if (httpsClient.connect(server2, 443)) {
    Serial.println("connected to server");
    // Make a HTTP request:
    String spart1 = "GET /trigger/alexa_alarma/json/with/key/";
    String spart2 = " HTTP/1.1";
    String sall = spart1 + WEBHOOKSTOKEN + spart2;
    Serial.println(sall);
    httpsClient.println(sall);
    httpsClient.println("Host: maker.ifttt.com");
    httpsClient.println("Connection: close");
    httpsClient.println();
    httpsClient.stop();
  }else{
    Serial.println("Problema conectando a servidor");  
  }    
  }

  ESP.deepSleep(0); 
}

void loop() {
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

Alarma Arduino compatible con Alexa y Telegram

Creado por Bugeados.com

#include <SPI.h>

#include <ESP8266WiFi.h>

#include <WiFiClientSecure.h>

#include <WiFiClient.h>

#include <ESP8266HTTPClient.h>

#include <UniversalTelegramBot.h>

#include <ArduinoJson.h>

///////please enter your sensitive data in the Secret tab/arduino_secrets.h

char ssid[] = "XXXXXXXXXXXX"; // your network SSID (name)

char pass[] = "XXXXXXXXXXXXXXXXXXX"; // your network password (use for WPA, or use as key for WEP)

int keyIndex = 0; // your network key index number (needed only for WEP)

char pinnedMessage[] = "Alarma activada";

String alarm_status = "";

// Initialize Telegram BOT

#define BOTtoken "XXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXX" // your Bot Token (Get from Botfather)

#define CHAT_ID "XXXXXXXXXXXXX"

#define WEBHOOKSTOKEN "XXXXXXXXXXXXXXXXXX"

char server[] = "api.telegram.org"; // name address for Google (using DNS)

char server2[] = "maker.ifttt.com"; //URL to trigger alexa routine

// Initialize the Ethernet client library

// with the IP address and port of the server

// that you want to connect to (port 80 is default for HTTP):

X509List cert(TELEGRAM_CERTIFICATE_ROOT);

WiFiClientSecure client;

WiFiClientSecure httpsClient;

UniversalTelegramBot bot(BOTtoken, client);

void setup() {

//Initialize serial and wait for port to open:

Serial.begin(9600);

client.setTrustAnchors(&cert); // Add root certificate for api.telegram.org

while (!Serial) {

; // wait for serial port to connect. Needed for native USB port only

}

// attempt to connect to WiFi network:

WiFi.mode(WIFI_STA);

WiFi.begin(ssid, pass);

while (WiFi.status() != WL_CONNECTED) {

Serial.print(".");

delay(500);

}

Serial.println("");

Serial.println("WiFi connected");

Serial.print("IP address: ");

Serial.println(WiFi.localIP());

Serial.println("\nStarting connection to server...");

// if you get a connection, report back via serial:

if (client.connect(server, 443)) {

Serial.println("connected to server");

// Make a HTTP request:

String part1 = "GET /bot";

String part2 = "/getChat?chat_id=";

String part3 = " HTTP/1.1";

String all = part1 + BOTtoken + part2 + CHAT_ID + part3;

Serial.println(all);

client.println(all);

client.println("Host: api.telegram.org");

client.println("Connection: close");

client.println();

}

// Check HTTP status

char status[32] = {0};

client.readBytesUntil('\r', status, sizeof(status));

if (strcmp(status, "HTTP/1.1 200 OK") != 0) {

Serial.println(status);

Serial.print(F("Unexpected response: "));

Serial.println(status);

client.stop();

return;

}

// Skip HTTP headers

char endOfHeaders[] = "\r\n\r\n";

if (!client.find(endOfHeaders)) {

Serial.println(F("Invalid response"));

client.stop();

return;

}

// Allocate the JSON document

// Use arduinojson.org/v6/assistant to compute the capacity.

const size_t capacity = 4096;

DynamicJsonDocument doc(capacity);

// Parse JSON object

DeserializationError error = deserializeJson(doc, client);

if (error) {

Serial.print(F("deserializeJson() failed: "));

Serial.println(error.f_str());

client.stop();

return;

}

// Extract values

Serial.println(F("Response:"));

JsonObject obj = doc["result"]["pinned_message"].as<JsonObject>();

String alarm_status = obj[String("text")];

Serial.println(alarm_status);

// Disconnect

client.stop();

// Check alarm status

if(alarm_status == pinnedMessage){

bot.sendMessage(CHAT_ID, "Puerta abierta", ""); //Telegram message notification

httpsClient.setInsecure();

if (httpsClient.connect(server2, 443)) {

Serial.println("connected to server");

// Make a HTTP request:

String spart1 = "GET /trigger/alexa_alarma/json/with/key/";

String spart2 = " HTTP/1.1";

String sall = spart1 + WEBHOOKSTOKEN + spart2;

Serial.println(sall);

httpsClient.println(sall);

httpsClient.println("Host: maker.ifttt.com");

httpsClient.println("Connection: close");

httpsClient.println();

httpsClient.stop();

}else{

Serial.println("Problema conectando a servidor");

}

ESP.deepSleep(0);

}

void loop() {

}

En el código simplemente deberemos modificar las variables que aparecen al principio del mismo, añadiendo los valores de nuestra red WiFi, nuestro bot de Telegram, etc. Estos son los valores que deberemos sustituir por los valores reales que tengamos:

char ssid[] = "XXXXXXXXXXXX";        // El nombre de tu red WiFi
char pass[] = "XXXXXXXXXXXXXXXXXXX";    // La contraseña de tu red WiFi

// Initialize Telegram BOT
#define BOTtoken "XXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXX"  // El token de nuestro bot
#define CHAT_ID "XXXXXXXXXXXXX"                         // El ID del chat donde recibiremos las notificaciones
#define WEBHOOKSTOKEN "XXXXXXXXXXXXXXXXXX"              // El token de webhooks

char ssid[] = "XXXXXXXXXXXX"; // El nombre de tu red WiFi

char pass[] = "XXXXXXXXXXXXXXXXXXX"; // La contraseña de tu red WiFi

// Initialize Telegram BOT

#define BOTtoken "XXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXX" // El token de nuestro bot

#define CHAT_ID "XXXXXXXXXXXXX" // El ID del chat donde recibiremos las notificaciones

#define WEBHOOKSTOKEN "XXXXXXXXXXXXXXXXXX" // El token de webhooks

En el siguiente apartado (configuración), explicamos más en detalle cómo obtener estos valores.

Configuración

Bien, ya hemos explicado cómo funcionará la alarma, cuál es el código que necesitamos cargar en nuestras placas de Arduino y cuáles son los circuitos. Pero ahora, tenemos que explicar cómo hacer la configuración para que todas las partes (sensores, Telegram y Alexa) se comuniquen entre sí.

Configuración en Telegram

En primer lugar, necesitaremos crear un bot en Telegram, que será el encargado de mandarnos las notificaciones cuando un sensor es activado. Hace unas semanas hicimos un vídeo y una entrada en la que explicamos detalladamente cómo hacerlo. Echadle un ojo a esta entrada para más detalles.
Una vez tenemos creado nuestro bot. Debemos crear un nuevo grupo en Telegram, y tendremos que invitar a nuestro bot recien creado a este grupo. Opcionalmente, podremos invitar a más personas a este grupo, por ejemplo si hay varias personas viviendo en la casa donde colocaremos la alarma, y queremos que tengan acceso a estos mensajes.
Una vez creado el grupo, debemos dar permisos de administrador a nuestro bot, para que pueda leer mensajes y mensajes pineados. Para ello, abriremos el nuevo grupo, y en las opciones seleccionaremos el bot y lo promocionaremos a administrador.
Lo siguiente que haremos, será escribir el mensaje Alarma activada en el grupo. Es importante que lo escribáis exactamente con las mismas mayúsculas y minúsculas.
A continuación, abriremos un navegador web, y tendremos que ingresar en el siguiente enlace https://api.telegram.org/botXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXX/getUpdates. Donde deberéis sustituir botXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXX por el token de vuestro bot. Este token lo podéis encontrar en la conversación con BotFather, de cuando creasteis el bot.
En ese enlace, encontraréis todas las actualizaciones referentes al bot que habéis creado en formato JSON. Puesto que el bot fue añadido a un nuevo grupo, en este código JSON encontraréis el chat ID del grupo que habéis creado. Además también encontraréis el message ID del mensaje que escribimos anteriormente (Alarma Activada). Tendrán el siguiente aspecto:

"chat":{"id":111111111
"message_id":18

1 2	"chat":{"id":111111111 "message_id":18

Figura 6. JSON getUpdates ejemplo

Por último, en el código de Arduino, debéis modificar el valor de BOTtoken y CHAT_ID por los valores del token de vuestro bot y el valor de chat id respectivamente. Si por ejemplo nuestro BOTtoken es bot1111111:2222222222222 y nuestro CHAT_ID es -12222122, tendremos que poner lo siguiente en nuestro código Arduino:

#define BOTtoken "bot1111111:2222222222222"  // El token de nuestro bot
#define CHAT_ID "-12222122"          // El ID del chat donde recibiremos las notificaciones

1 2	#define BOTtoken "bot1111111:2222222222222" // El token de nuestro bot #define CHAT_ID "-12222122" // El ID del chat donde recibiremos las notificaciones

Configuración comandos de voz para Alexa

Para crear los comandos de voz que usaremos para activar o desactivar la alarma, vamos a usar la herramienta IFTTT. Se trata de un servicio web que permite crear y programar acciones para automatizar diferentes tareas y acciones en Internet.

Accederemos a https://ifttt.com/explore y crearemos una cuenta de usuario gratuita.
Una vez creada la cuenta, iremos a https://ifttt.com/create para crear nuestro primer comando.

En la opción If This, pincharemos en Add y buscaremos y seleccionaremos Amazon Alexa.
Seleccionaremos la primera opción que dice Say a specific phrase.
En el campo Amazon Alexa account vincularemos nuestra cuenta de Amazon Alexa siguiendo las instrucciones. En caso de no tener cuenta de Amazon, la podréis crear de forma gratuita a través de este enlace.
En el campo What phrase?, pondremos la frase que queremos usar para activar la alarma. En nuestro caso, hemos usado la frase Activa la alarma de casa.
Pulsar el botón Create trigger.
En la opción Then That, pincharemos en Add y buscaremos y seleccionaremos Webhooks.
En el campo URL pondremos lo siguiente: https://api.telegram.org/botXXXXXXX:XXXXXXXXXX/pinChatMessage?chat_id=XXXXXX&message_id=XX. Donde tendremos que sustituir botXXXXXXX:XXXXXXXXXX por nuestro BOTtoken, sustituir chat_id=XXXXXX por nuestro chat ID y message_id=XX por nuestro message ID, tal y como os mostramos antes.
En el campo Method seleccionar GET, en Content Type seleccionaremos application/json y dejaremos en blanco el resto de opciones.
Pulsar el botón Update action, y ya tendremos creado el primer comando de voz.

Crear un segundo comando de voz, siguiendo exactamente los mismos pasos, pero en este caso, en el campo What phrase? al configurar el servicio Amazon Alexa, pondremos una frase diferente, por ejemplo Desactiva la alarma de casa. Y en la configuración de Webhooks, en el campo URL usaremos este enlace: https://api.telegram.org/botXXXXXXX:XXXXXXXXXX/unpinAllChatMessages?chat_id=-XXXXXXX. Sustituyendo el BOTtoken y chat ID, por los reales.

Con los pasos que acabamos de describir, ya tendremos creados los dos comandos de voz para activar y desactivar la alarma con Alexa. Por último, de forma opcional, si queremos que Alexa reproduzca sonidos de alarma por sus altavoces al detectar que un sensor se ha activado, deberemos crear un tercer Applet:

En la opción If This, pincharemos en Add y buscaremos y seleccionaremos Webhooks.
En Event Name escribiremos alexa_alarma.
En la opción Then That, pincharemos en Add y buscaremos y seleccionaremos Trigger Monkey (Routine).
En el campo Alexa Voice Monkey account vincularemos nuestra cuenta de Voice Monkey siguiendo las instrucciones. En caso de no tener cuenta, la podréis crear de forma gratuita a través de este enlace.
Una vez creada la cuenta en Voice Monkey, iremos al dashboard principal, y crearemos un nuevo «monkey». Para ello, accederemos al siguiente enlace https://app.voicemonkey.io/dashboard, y pincharemos en la opción Manage Monkeys. A continuación seleccionaremos el botón +Add a Monkey y le pondremos de nombre Alexa.
De vuelta a IFTTT, en el campo Monkey to trigger, seleccionaremos el monkey que acabamos de crear (cuyo nombre es Alexa). Y pincharemos en el botón Create trigger.
Por último, abriremos la aplicación Amazon Alexa en nuestro teléfono móvil (si no la tenéis descargada, la podéis descargar del Google y Apple Store). Y seleccionaremos la opción Más en el menú inferior.
Seleccionaremos Rutinas y seleccionaremos el botón + que se encuentra en la esquina superior derecha.
Pondremos un nombre a nuestra rutina.
En el campo Cúando seleccionaremos Hogar digital y nos debe aparecer un dispositivo llamado Alexa (este es el Monkey que creamos anteriormente).
En el campo Añadir acción podemos seleccionar lo queramos que haga Alexa al detectar que la alarma se ha activado. Por ejemplo podemos seleccionar la opción Skills y usar una skill que reproduzca sonidos de alarma por los altavoces. En nuestro caso hemos usado una skill llamada Alarma.

Precio y valoraciones finales

En lo referente al precio, se trata de un proyecto muy económico, ya que los componentes electrónicos para fabricar los sensores son muy baratos. Os dejamos una lista con los precios aproximados (estos precios pueden variar mucho en función de vuestro país y en qué tienda compréis los materiales) en nuestro caso por unidad. Además puesto que cada sensor funciona de forma totalmente independiente, podremos crear tantos sensores como necesitemos o nos podamos permitir. Por lo que el precio es totalmente personalizable.

MATERIALES

Módulo ESP01 ~2,5€
Switch REED ~0,25€
Sensor movimiento ~1,60€
Batería LiPo 300mah ~2,5€
Cargador batería ~0,35€
Programador ESP01 ~5,49€
COMPONENTES ELECTRÓNICOS RESISTENCIAS, CONDENSADORES, TRANSISTORES, CABLES, ETC ~2€

PRECIO POR SENSOR PUERTA/UNIDAD ~7€
PRECIO POR SENSOR MOVIMIENTO/UNIDAD ~8,5€

TOTAL

Ejemplo alarma con 2 sensores de puerta y 1 sensor de movimiento: 7€+7€+8,5€+5,49€ = 27,99€

1 sensor de puerta y 1 sensor de movimiento: 7€+8,5€+5,49€ = 20,99€

Otro ejemplo con 5 sensores de puerta y 2 sensores de movimiento: 7€x5 + 8,5€x2 + 5,49€ = 57,49€

Como veis el precio es totalmente personalizable a nuestras posibilidades y necesidades.

Esperemos os haya gustado este proyecto, si es así, agradeceríamos que nos dejáis un comentario y os suscribieseis a nuestro canal de Youtube. ¡Gracias por leernos!

Alarma antirrobo Arduino, compatible con Alexa y Telegram

Componentes necesarios

Sensor de puerta/ventana

Sensor movimiento

Circuito

Sensor de puerta/ventana

Sensor movimiento

Cómo funciona la alarma

Código

Configuración

Configuración en Telegram

Configuración comandos de voz para Alexa

Precio y valoraciones finales

Deja una respuesta Cancelar la respuesta

Función Millis de Arduino

Medir la temperatura en una Raspberry Pi

Cómo usar la función «burbujas» de Android 11 en dispositivos Samsung

Creando un Tamagotchi desde cero

Entradas recientes

Archivos

Categorías