Cuaderno de Bitácora
Fecha: 8 de enero de 2018
Hora: 19:00 Zulu
Antes de empezar a diseñar nuestra solución para el desafío Hydro Dynamics, nos planteamos los imprescindibles que queríamos que tuviese. Estos eran: que estuviera programada con Arduino y diseñada e impresa en 3D, así se ahorrarían costes de materiales ya que no son excesivamente caros; además, debería ser sencilla de utilizar y eficaz para solucionar el problema, al igual que internacional, es decir, que se pudiera usar en cualquier lugar del mundo.
Fecha: 8 de enero de 2018
Hora: 19:00 Zulu
Antes de empezar a diseñar nuestra solución para el desafío Hydro Dynamics, nos planteamos los imprescindibles que queríamos que tuviese. Estos eran: que estuviera programada con Arduino y diseñada e impresa en 3D, así se ahorrarían costes de materiales ya que no son excesivamente caros; además, debería ser sencilla de utilizar y eficaz para solucionar el problema, al igual que internacional, es decir, que se pudiera usar en cualquier lugar del mundo.
Teniendo en cuenta todos estos imprescindibles, hemos diseñado y realizado aFLOOD, un prototipo de la solución para el problema de la detección de inundaciones por fugas de agua en el interior de las casas y que consta de dos partes: una caja hecha con impresión 3D, que cierra herméticamente toda la parte electrónica; y una placa de Arduino que va dentro de la caja unida a sensores externos, que se encarga de avisarnos cuando tenemos una inundación de agua en casa.
La caja está hecha de plástico PLA, que es el material que usa la impresora 3D. El grosor del filamento de PLA es de 1,75 mm. Está separada en dos partes: la caja y su tapa. Las dos encajan y cierran herméticamente para que el agua no entre dentro.
La razón de por qué el prototipo no es una pieza es que hay que meter de alguna forma la placa de Arduino en el interior y para cambiar las baterías, aunque no es frecuente porque hemos usado una librería de Arduino que aporta un modo de ahorro de batería y con esto se podría alargar su duración hasta los 10 años con unas buenas pilas.
El prototipo de aFLOOD mide 85 mm de largo, 60 mm de ancho y 145 mm de alto, el grosor de las paredes es de 1,5 mm. La tapa mide 82 mm de largo, 57 mm de ancho y 5 mm de alto. Esas dimensiones son las justas para que dentro quepan todos los componentes electrónicos unidos a la placa de Arduino.
Aquí se pueden descaragar los archivos de impresión diseñados en Tinkercad de la caja y la tapa del prototipo.
Para la parte electrónica hemos utilizado diferentes componentes: un sensor de gotas de lluvia, que sirve para detectar gotas de agua, pero que hemos utilizado para detectar las inundaciones. Tiene dos modos de funcionamiento: analógico y digital. El digital indica el valor entre 0 (mojado) y 1 (seco). El analógico indica el valor entre 0 (mojado) y 1023 (seco), este es el que hemos utilizado en nuestro prototipo porque da más información sobre lo mojado que está el sensor.
También tiene un zumbador que emite una serie de pitidos según se haya programado: en nuestro caso emite tres pitidos en serie cuando detecta agua y dos pitidos más cortos cuando envía el mensaje. Una batería que se compone de dos pilas Duracel AA de 1´5 alimenta al módulo SigFox de Arduino. Una placa board sirve para apoyar los componentes y dar una mayor conexión con la placa de Arduino.
Y por último, un módulo de Arduino SigFox que viene con una antena facilita las comunicaciones. Es una placa de Arduino que tiene instalado un microchip para las comunicaciones de la empresa SigFox.
Las ventajas de aFLOOD son las siguientes y están relacionadas con el módulo programado de comunicaciones SigFox: no necesita alimentación ya que solo con las pilas es suficiente; tampoco necesita configuración por lo que no hay que meter contraseñas, que se pueden olvidar fácilmente o cuando se cambia en el caso del wifi; no hace falta que el dueño de la casa permita el acceso al módulo de comunicaciones; tiene una excelente cobertura; el coste de comunicaciones es muy bajo y puede ser llevado dónde se quiera cuándo se quiera.
Para terminar, este es el código de programación que hemos desarrollado para que aFLOOD funcione realmente. El programa usa la librería que da SigFox para simplificar el envío de mensajes a través de su red. Además, se usan funciones para que el código sea más sencillo de entender y modificar.
¿Qué significan los colores de este código?
¿Qué significan los colores de este código?
- Verde: comentario para entender el programa
- Azul: instrucciones que sólo realiza la placa si está conectada al ordenador
- Negro: instrucciones que va a realizar la placa siempre
// Comentar esta línea cuando se va a usar el programa sin estar
conectado al ordenador
//#define Conectado_Ordenador
// Añadir la librería de Sigfox
#include
<SigFox.h>
// Inicializar las variables
boolean LED_Estado;
int Pin_Out_Zumbador = 5;
int
Comprobar_Cada = 1000;
// Inicio del bloque Setup
void
setup()
{
// Si estamos conectados
al ordenar podemos usar el cable USB para enviar mensajes a la pantalla del
ordenador
// Si no estamos conectados no hay pantalla
por lo que no se puede enviar mensaje
#ifdef Conectado_Ordenador
// Inicializa la
comunicación con el ordenador
Serial.begin(9600);
// Esperar a que la
comunicación esté OK
while (!Serial) {};
#endif
// Inicializa el pin
digital LED_BUILTIN como salida
pinMode(LED_BUILTIN,
OUTPUT);
// Comprobar que la placa Sigfox responde
if
(SigFox.begin())
{
// Si Sigfox funciona
OK
// Si estamos
conectados al ordenador enviamos el mensaje a la pantalla
#ifdef Conectado_Ordenador
Serial.println("La placa MKRFox1200
funciona OK!");
#endif
// Estés o no
conectado al ordenador suenan 2 pitidos agudos y cortos para indicar que todo
va bien usando la función Emitir_Zumbido que se define fuera del bucle
Emitir_Zumbido(4000, 100, 2);
}
else
{
// Si Sigfox no
funciona
// Si estamos conectados al ordenador enviamos
el mensaje a la pantalla
#ifdef Conectado_Ordenador
Serial.println("La placa MKRFox1200
no se encuentra!");
#endif
// Estés o no conectado
al ordenador suena emitimos 1 pitido largo para indicar que algo ha ido mal
Emitir_Zumbido(100, 2000, 1);
// Si ha fallado cerramos
el programa
return;
}
// Si se comenta esta
línea no parpadeará el LED cuando se está enviando el mensaje
SigFox.debug();
// Apagar el módulo de
Sigfox para ahorrar batería
SigFox.end();
}
// Fin del bloque Setup
// Inicio del bloque Loop (bucle que se repite continuamente)
void
loop()
{
// Cada vez que pasa por
el bucle cambia el estado del LED y así sabemos que está funcionando usando la
función Parpadeo que definimos fuera del bucle
Parpadeo();
// Comprobar si hay fuga
usando la función Comprobar_Fuga que definimos fuera del bucle
Comprobar_Fuga();
// Esperamos el tiempo
que indica la variable Comprobar_Cada definida al inicio
//De esta manera
decidimos cada cuanto comprobamos si hay una inundación y ahorramos batería
delay(Comprobar_Cada);
}
// Fin del bloque Loop
// Funciones
// Inicio Función Comprobar_Fuga
void
Comprobar_Fuga()
{
// Lee el valor de la
entrada analógica A2 del sensor y lo asigna a la variable Valor_Seco
int Valor_Seco = analogRead(A2);
// Si estamos
conectados al ordenador enviamos el mensaje a la pantalla
#ifdef Conectado_Ordenador
// Escribe en pantalla
el valor de la lectura
Serial.print("Valor analógico:
");
Serial.print(Valor_Seco);
#endif
// Decidir si está seco
o mojado comparando el valor leído con el límite establecido en la variable
Limite_Mojado definida al inicio
if (Valor_Seco < Limite_Mojado)
{
// Hemos detectado la
inundación
// Si estamos
conectados al ordenador enviamos el mensaje a la pantalla indicando que está
mojado
#ifdef Conectado_Ordenador
Serial.println(" Mojado");
#endif
// Sonar Alarma: Estés o
no conectado al ordenador suenan 3 pitidos graves y largos como Alarma usando
la función Emitir_Zumbido que se define más adelante
Emitir_Zumbido(262, 500, 3);
// Enviar mensaje a la
red de Sigfox usando la función Enviar_Alarma_Sigfox definida más adelante
Enviar_Alarma_Sigfox();
}
// Si estamos conectados al
ordenador enviamos el mensaje a la pantalla indicando que está seco
#ifdef Conectado_Ordenador
else {Serial.println(" Seco");};
#endif
}
// Fin Función Comprobar_Fuga
// Inicio Función Parpadeo
void
Parpadeo()
{
// Invertir el valor de
la variable LED_Estado
LED_Estado = !LED_Estado;
// Enciende o apaga el
LED escribiendo en el pin de la placa
digitalWrite(LED_BUILTIN,
LED_Estado);
}
// Fin Función Parpadeo
// Inicio Función Enviar_Alarma_Sigfox
void
Enviar_Alarma_Sigfox()
{
String Mensaje;
// Define el mensaje que
se va enviar
Mensaje
= "Alarma......";
#ifdef Conectado_Ordenador
Serial.println("Enviando mensaje
" + Mensaje);
#endif
// Enviar mensaje a la
red de Sigfox usando la función Enviar_Mensaje_Sigfox
Enviar_Mensaje_Sigfox(Mensaje);
}
// Fin Función Enviar_Alarma_Sigfox
// Inicio Función Enviar_Mensaje_Sigfox
void
Enviar_Mensaje_Sigfox(String MensajeSigfox)
{
// Encendemos el módulo
de Sigfox
SigFox.begin();
// Esperar 100mS para
dar tiempo a que arranque
delay(100);
// Limpiar todas las
interrupciones pendientes
SigFox.status();
delay(1);
// Enviar el mensaje a
la red de SIGFOX
SigFox.beginPacket();
SigFox.print(MensajeSigfox);
int Envio_OK =
SigFox.endPacket();
//Comprobar
si el mensaje se ha enviado correctamente
if (Envio_OK > 0)
{
// Ha habido problemas
con el envío
// Si estamos conectados al ordenador
enviamos el mensaje a la pantalla indicando que ha habido problemas
#ifdef Conectado_Ordenador
Serial.println("Sin transmisión");
#endif
// Estés o no
conectado al ordenador suena 1 pitido muy largo para indicar que algo ha ido
mal
Emitir_Zumbido(100, 2000, 1);
}
else
{
// El envío ha sido
correcto
// Si estamos conectados al ordenador enviamos
el mensaje a la pantalla indicando que se ha enviado correctamente
#ifdef Conectado_Ordenador
Serial.println("Transmisión
OK");
#endif
// Estés o no
conectado al ordenador suenan 2 pitidos agudos y cortos para indicar que todo
va bien
Emitir_Zumbido(4000, 100, 2);
}
// Apagar el módulo de
Sigfox para ahorrar batería
SigFox.end();
}
// Fin Función Enviar_Mensaje_Sigfox
// Inicio Función Emitir_Zumbido
void
Emitir_Zumbido(int Zumbido_Tono, int Zumbido_Duracion, int
Zumbido_NumRepeticiones)
{
// Bucle que se repite las veces que indica
la variable Zumbido_NumRepeticiones
for (int i=1; i <=
Zumbido_NumRepeticiones; i++)
{
// Suena un pitido con el tono que indica la
variable Zumbido_Tono y de duración que indica la variable
Zumbido_Duracion
tone(Pin_Out_Zumbador, Zumbido_Tono,
Zumbido_Duracion);
// Espera 1.5 veces la
duración para dar tiempo al tono a sonar y a que haya medio silencio
delay(Zumbido_Duracion * 1.5);
}
}
// Fin Función Emitir_Zumbido
En resumen, nuestro equipo ha diseñado un prototipo de aFLOOD que es muy sencillo y eficaz para detectar inundaciones en las casas. La carcasa está diseñada con impresión 3D y está programado con Arduino, pero este Arduino es algo especial porque tiene instalado un microchip de comunicaciones SigFox más baratas a las habituales. Esperamos vuestros comentarios indicándonos qué os parece nuestra solución. ¡Muchas gracias!
Juntos, somos UNO!
Sara Núñez, Julen Pérez y Naíra Arratibel