"La ciencia es una empresa cooperativa que se transmite de generación en generación. Es una antorcha que se pasa de profesores a alumnos y viceversa. Una comunidad de mentes capaces de regresar hasta la antigüedad y viajar más allá de las estrellas. ¡Nuestro viaje solo acaba de empezar!". (Neil deGrasse Tyson)


"El trabajo en equipo convierte los sueños en realidades". (Scott Kelly)

lunes, 8 de enero de 2018

Presentamos... ¡aFLOOD!

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.
    
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. 

Prototipo de aFLOOD

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.

Esquema de montaje de los componentes electrónicos
   
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?
  • 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;
int Limite_Mojado = 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