Resumen


Diagramá y armá un sistema de abastecimiento de agua domiciliario de dos tanques, el cual se controla el ingreso del agua a los dos tanques a través una electroválvula, una bomba sumergible y un sensor ultrasónico que mide el nivel de llenado, conectados a una placa Arduino. Podrás monitorear a distancia, a través de IoT Internet de las cosas, su funcionamiento y el nivel de llenado de los tanques.
 

Objetivos

Se propone armar una maqueta/prototipo a escala de un sistema de tanques interconectados, que simule el sistema de suministro de agua que existe en las casas y los edificios. El llenado de los tanques y las bombas se controlará midiendo el nivel del agua presente en cada tanque con sensores de ultrasonido. En el nivel más avanzado se propone incorporar Internet de la Cosas (IoT) para generar un registro sobre el llenado de los tanques. 

Al final de esta guía se puede encontrar un glosario donde se provee la información técnica necesaria para poder poner el proyecto en funcionamiento. El mismo cuenta con aclaraciones sobre los diversos elementos electrónicos involucrados así como también conceptos claves.

Objetivos

  • Aproximarse al conocimiento y al manejo de distintos componentes electrónicos, mediante la construcción de una maqueta de un sistema de tanques en el que se regulen el ingreso y el egreso de agua.
  • Introducirse en el armado de circuitos utilizando placas Arduino, sensores de ultrasonido y actuadores.
  • Analizar la programación de estructura secuencial de un programa que permita el ingreso de agua y el pasaje de agua de un tanque a otro (nivel intermedio) cuando sea necesario.
  • Utilizar Internet de la Cosas (IoT) para registrar los datos de llenado de los tanques (nivel avanzado).

Ficha técnica

Nivel educativo

Secundario. Ciclo Básico.

 

Descripción general

Diseño y construcción de una maqueta/prototipo de un sistema de abastecimiento de agua domiciliario.

Niveles de complejidad

Nivel inicial: controlar el ingreso del agua al tanque a través una electroválvula (que regule el ingreso) y un sensor ultrasónico (que mida el nivel de llenado) conectados a una placa Arduino.

Nivel intermedio: agregar un segundo tanque y una bomba sumergible que envíe agua del primer tanque al segundo.

Nivel avanzado: informar los datos obtenidos a un dispositivo móvil a través de internet de las cosas (IoT).

 

Insumos

  • 2 x Módulo relé de 5V
  • 1 x Bomba de agua sumergible
  • 2 x Sensores de distancia ultrasónicos
  • 1 x Arduino UNO R3
  • 1 x OBLOQ Módulo IoT
  • 1 x Fuente de 9V 1A (plug centro positivo, 5.5 x 2.1mm)
  • 1 x Cable USB tipo B
  • 20 x Cables dupont macho hembra
  • Cables eléctricos.
  • 2 x Recipientes para agua con canillas de desagote
  • Mangueras

Equipamiento

  • Computadora
  • Soldador
  • Estaño
  • Alicate
  • Pinza de punta
  • Brusela

 

Otros requisitos

  • Conexión a internet
  • Descargar el programa “mblock3”

http://www.mblock.cc/software-1/mblock/mblock3/

 

Temas


Paso 1: Preparar el tanque
Paso 2: Instalar el sensor ultrasónico y conectar la electroválvula
Paso 3: Establecer la altura de corte
Paso 4: Conectar sensor, válvula y relé a la placa Arduino
Paso 5: Programar el funcionamiento del dispositivo    
Paso 6 - Programación IoT

Camilo está construyendo una casa para su familia que tendrá una sola planta con una terraza. Para hacerlo tiene que, entre muchas otras cosas, realizar la conexión de agua. El agua llega a su casa por el sistema corriente que la distribuye a toda la zona desde la planta potabilizadora local. Todas las edificaciones deben contar con uno o más tanques de almacenamiento, que se llenan con el agua que proviene de la red y a partir de allí suministran el consumo local. Estos se ubican en el nivel más alto de cada construcción y se utilizan para garantizar la disponibilidad de agua en el edificio o casa en que se encuentren. Entonces, Camilo debe instalar un tanque en su terraza, que recibirá directamente el agua que viene desde la calle y que proveerá desde allí agua para toda la casa. También debe instalar un sistema de válvulas que controle el ingreso del agua, para evitar que se rebalse el tanque. Para esto, normalmente se usa una válvula o interruptor de flotador. Camilo, en este caso, decidió controlar el ingreso de agua utilizando un sensor de distancia ultrasónico que mide el nivel de llenado del tanque. En esta instancia del proyecto se construirá la maqueta de un tanque de agua en la que se regule el ingreso de la misma al tanque a través de un sensor ultrasónico que mida el nivel de llenado del tanque y una electroválvula.

Paso 1: Preparar el tanque

Para comenzar, es necesario conseguir un recipiente que cumpla la función del tanque. Este debe tener una tapa, un agujero en la parte superior para el ingreso del agua, y otro en la parte inferior donde se colocará la llave de paso que controlará la distribución del agua.

 

Paso 2: Instalar el sensor ultrasónico y conectar la electroválvula

En este proyecto la ubicación de los distintos elementos en el prototipo es fundamental para el buen funcionamiento del mismo. Por lo tanto, organizamos la disposición de todos los componentes antes de realizar la conexión a la placa Arduino. Esta placa puede recibir datos de un sensor, así como enviar datos a un actuador, por medio de sus pines analógicos y digitales.

 

Para controlar el ingreso de agua y evitar que el tanque rebalse, colocamos en su entrada una electroválvula (válvula controlada electrónicamente, del tipo que suelen encontrarse en los lavarropas). Esta se abrirá cuando queramos llenar el tanque y se cerrará cuando el agua haya alcanzado un nivel determinado por nosotros.

Electroválvula, es un actuador que permite o interrumpe el paso de un fluido a través del mismo. Existen versiones que trabajan con 12 V así como también los que trabajan directamente con 220 V, permitiendo trabajar en un sistema de mayor nivel de caudal.

 

Sujetamos el sensor ultrasónico en la parte interior de la tapa del tanque. Es importante que este apunte de manera perpendicular al fondo del tanque para que las paredes no interfieran en la medición. Además, hay que asegurarnos de que el sensor no se moje cuando ingresa el agua. El sensor medirá la distancia a la que se encuentra el agua y en función de eso activará o no la electroválvula.

Sensor ultrasónico, es un tipo de sensor que se utiliza para medir distancias. El principio de funcionamiento del mismo se basa en emitir un pulso de sonido ultrasónico y medir el tiempo que pasa hasta registrar que dicho pulso regresó a la fuente tras rebotar en un obstáculo.

 

Paso 3: Establecer la altura de corte

Para evitar que el tanque rebalse, el agua no puede superar la altura de ingreso. Por lo tanto, debemos detener la entrada de agua antes de que se alcance dicho nivel. Para asegurarnos de que eso suceda, es recomendable que el tanque se deje de llenar cuando el agua esté a unos 5 o 10 cm del ingreso. Una vez determinado este nivel hay que medir la distancia desde este punto a la tapa donde se encuentra el sensor y establecer este valor como la distancia mínima de desactivación de la válvula.

 

Paso 4: Conectar sensor, válvula y relé a la placa Arduino

Una vez que tengamos ubicados los distintos elementos del sistema, conectaremos el sensor ultrasónico, la electroválvula y el relé a una placa Arduino como indica la figura.

 

 

¡Atención! Para construir este dispositivo trabajaremos con una tensión de 220V. En caso de utilizar protoboard, se recomienda no incluir en el mismo las conexiones a relé y  220V.

La electroválvula funciona con una tensión de 220V. Por este motivo, para realizar la conexión necesitamos usar dos cables de 2,5 mm de diámetro y una ficha de enchufe para conectar a la red. Debemos soldar uno de los cables a un borne de la electroválvula y el otro conectarlo a la bornera “COM” del relé. Usar un tercer cable para unir el otro borne de la electroválvula con la bornera “NO” del relé.

Ahora solo queda conectar el relé a la placa Arduino. Para esto usaremos cables dupont macho hembra ya que estaremos trabajando con 5V. Conectar el pin “+” a 5V, el pin “-” a GND y el pin “S” al pin digital“4” de la placa Arduino.

 

Para conectar el sensor de posición ultrasónico necesitamos cuatro cables dupont hembra-macho. Conectar los pines “Vcc”,  “GND”, “Trig” y “Echo” del sensor a los pines “5V“ “GND”, “8” y “9” del Arduino respectivamente.

 

Paso 5: Programar el funcionamiento del dispositivo

La programación la realizaremos con mBlock3, un entorno de programación basado en Scratch2, que permite programar proyectos de Arduino utilizando bloques. Se puede descargar siguiendo este enlace: http://www.mblock.cc/software-1/mblock/mblock3/

 

Cuando abrimos mBlock3, veremos una pantalla como la siguiente:

 

Para programar un proyecto de Arduino con mBlock3 debemos seleccionar el “Modo Arduino” desde el menú.

 

Al seleccionar este modo, el programa cambiará de aspecto. Se verá un área en el centro que es la que utilizaremos para programar con bloques. A la derecha se verá un campo donde aparecerá el código escrito que le corresponde a los bloques que están en el centro. Este código se irá escribiendo automáticamente a medida que se vaya armando el programa con los bloques.

 

 

Los bloques están agrupados por categorías. En este caso, se usarán las siguientes:Robots”, “Control”, “Operadores” y “Datos y Bloques”. Cuando seleccionamos una de estas categorías, se pueden visualizar todos los bloques que pertenecen a ese grupo.

 

Escribimos el programa que controlará la apertura de la válvula. Lo haremos de modo que permita que se cargue el tanque siempre que la distancia entre la superficie del agua y el sensor sea menor que la distancia mínima medida anteriormente. Tomando como ejemplo que la distancia mínima es de 40 cm, el código en bloques nos queda como sigue:

 

 

Veremos que a continuación se muestra el código escrito generado por mBlock, que corresponde a este programa:

 

#include
#include
#include

double angle_rad = PI/180.0;
double angle_deg = 180.0/PI;
float getDistance(int trig,int echo){
    pinMode(trig,OUTPUT);
    digitalWrite(trig,LOW);
    delayMicroseconds(
2);
    digitalWrite(trig,HIGH);
    delayMicroseconds(
10);
    digitalWrite(trig,LOW);
    pinMode(echo, INPUT);
   
return pulseIn(echo,HIGH,30000)/58.0;
}


void setup(){
    pinMode(
4,OUTPUT);
}


void loop(){
   
if((getDistance(8,9)) < ( 40 )){
        digitalWrite(
4,0);
    }
else{
        digitalWrite(
4,1);
    }
    _delay(
1);
    _loop();
}


void _delay(float seconds){
   
long endTime = millis() + seconds * 1000;
   
while(millis() < endTime)_loop();
}


void _loop(){
}

                                                   Fragmento de código 1

 

Paso 6 - Programación IoT

Para subir el código de nuestro programa a la placa Arduino, necesitamos:

  1. Conectar la placa Arduino a la entrada USB.
  2. Chequear que en el menú “Placas” esté seleccionado “Arduino Uno”.
  3. Seleccionar el puerto serie al que está conectada la placa.

  1. Cliquear el botón  que se encuentra en la parte derecha superior de la interfaz.

Al terminar de subir nuestro código, veremos este mensaje:

 

Temas


Paso 1: Preparar la instalación del segundo tanque
Paso 2: Realizar las conexiones a la placa Arduino

La prima de Camilo, Melina, quiere instalar un sistema como el de su primo, que también mida y regule el nivel del tanque de agua con un sensor ultrasónico. Ella vive en el mismo barrio que Camilo, pero no en una casa sino en un edificio de 6 pisos que tiene 12 departamentos, y que recibe agua desde la misma planta potabilizadora. La presión y el caudal de agua entregados desde la planta a cada construcción dependen de la altura de la edificación, de la distancia a la que se encuentre de la planta, y del consumo que haya en la red. La presión suministrada por esta red es suficiente para abastecer el tanque de una casa como la de Camilo, pero no para llenar los tanques ubicados en los pisos superiores de los edificios más altos, como el de Melina. En estos casos se utiliza un tanque extra llamado cisterna que se ubica en el sótano. El agua de la red llega a este tanque que luego envía el agua al tanque de arriba por medio de una bomba. El desafío en este caso será construir un sistema de tanques para el edificio de Melina. En esta instancia del proyecto, habrá que agregar un segundo tanque con una bomba sumergible que reciba el agua y la envíe al tanque principal.

Paso 1: Preparar la instalación del segundo tanque

Para simular el sistema de tanque cisterna y elevado tomaremos la maqueta realizada en la etapa anterior y agregaremos un tanque extra con otro sensor de distancia y una bomba sumergible. Las bombas sumergibles no pueden funcionar si no están por debajo del nivel del agua, por lo tanto es muy importante asegurarnos de que el tanque cisterna sea lo suficientemente grande como para que el agua tape la bomba.

 

Además programaremos el Arduino de modo que, cuando el nivel del agua sea inferior al de la bomba, no envíe agua al tanque elevado y espere hasta que se haya llenado lo suficiente para enviar el agua.

 

 

Paso 2: Realizar las conexiones a la placa Arduino

 

¡Atención! Para construir este dispositivo trabajaremos con una tensión de 220V. En caso de utilizar protoboard, se recomienda no incluir en el mismo las conexiones a relé y  220V.

Conectamos los componentes como indica la figura, agregando el sensor ultrasónico del segundo tanque y la bomba de agua con el relé. Para conectar el sensor necesitamos 4 cables dupont hembra-macho. Conectamos los pines “Vcc”, “GND”, “Trig” y “Echo” del sensor a los pines “5V“ “GND”, “10” y “11” del Arduino.

 

Conectamos la bomba de agua a un relé ya que, al igual que la electroválvula, funciona con 220V. Para ello necesitamos usar dos cables de 2,5 mm de diámetro y una ficha de enchufe para conectar a la red.

Conectamos uno de los cables de la ficha a la bornera “COM” del relé. El otro cable que nos queda de la ficha lo conectamos a la bomba de agua. Utilizamos, por último, un tercer cable para unir la bomba de agua con la bornera “NO” del relé.

 

Luego, conectamos el relé a la Placa Arduino. Para esto, usamos cables dupont macho hembra ya que estamos trabajando con 5V. Conectar el pin “+” a 5V, el pin “-” a GND y el pin “S” al pin digital “5” del Arduino.

 

El armado de este circuito tiene como función conseguir que el sensor de posición del tanque elevado (A) envíe una señal al Arduino para activar la bomba sumergible del tanque cisterna cuando el nivel de llenado sea inferior al máximo. Si en el tanque cisterna hay agua suficiente, se activará la bomba para enviar agua al tanque elevado. La activación se mantendrá hasta que se llene el tanque elevado o hasta que el nivel de agua del tanque cisterna sea inferior al mínimo.

 

 

Paso 3 - Programar el funcionamiento del dispositivo

Editamos nuestro programa para que contemple este tanque extra, así como su llenado, siempre que el primer tanque esté en condiciones de activar la bomba. Supongamos que la distancia mínima de ambos tanques es de 40 cm, y la máxima del primero, de 140 cm. El programa debe ser similar al siguiente modelo:

 

Veremos que a continuación se muestra el código escrito generado por mBlock, que corresponde a este programa:

#include
#include
#include

double angle_rad = PI/180.0;
double angle_deg = 180.0/PI;
float getDistance(int trig,int echo){
    pinMode(trig,OUTPUT);
    digitalWrite(trig,LOW);
    delayMicroseconds(
2);
    digitalWrite(trig,HIGH);
    delayMicroseconds(
10);
    digitalWrite(trig,LOW);
    pinMode(echo, INPUT);
   
return pulseIn(echo,HIGH,30000)/58.0;
}


void setup(){
    pinMode(
4,OUTPUT);
    pinMode(
5,OUTPUT);
}


void loop(){
   
if((getDistance(8,9)) < ( 40 )){
        digitalWrite(
4,0);
    }
else{
        digitalWrite(
4,1);
    }
   
if((getDistance(10,11)) < ( 40 )){
        digitalWrite(
5,0);
    }
else{
       
if((getDistance(8,9)) > (140)){
            digitalWrite(
5,0);
        }
else{
            digitalWrite(
5,1);
        }
    }
    _delay(
1);
    _loop();
}


void _delay(float seconds){
   
long endTime = millis() + seconds * 1000;
   
while(millis() < endTime)_loop();
}


void _loop(){
}

                                                   Fragmento de código 2

 

Temas


Paso 1 - Introducción a Internet de las Cosas (IoT) 
Paso 2 - Crear un Panel de Control 
Paso 3 - Agregar Módulo OBLOQ 
Paso 4 - Arduino IDE 
Paso 5 - Programar sin código bloqueante 
Paso 6 - Programar IoT

Luego de haber terminado la instalación del tanque y la bomba, los vecinos de Melina le plantearon que sería muy útil poder tener acceso a la información que toma el sensor respecto al nivel del agua. Hoy en día, si quisieran saber cuánta agua hay en el tanque, deberían subir al techo, acceder al tanque y sacarle la tapa, lo cual resulta muy complicado. Si pudieran registrar los datos que toma el sensor y monitorearlos desde sus casas, podrían saber cuánta agua hay disponible en el tanque para cuidar este recurso entre todo el consorcio. En esta tercera instancia se programará el envío de datos obtenidos a un dispositivo móvil a través de internet (IoT).


Paso 1 - Introducción a Internet de las Cosas (IoT)

Internet de las Cosas (en inglés Internet of Things, abreviado IoT) es un concepto que refiere a la interconexión digital de objetos cotidianos con internet. Esta interconexión puede tener diversas funciones. Por ejemplo, puede utilizarse para monitorear la temperatura de un ambiente, enviando los datos obtenidos por un sensor a una central donde se recopile la información. De esta manera podría visualizarse en un dispositivo móvil la temperatura de un laboratorio, de un invernadero o de una sala de un hospital.

 

Para poder incorporar IoT a nuestro proyecto es necesario:

 

  1. Un dispositivo capaz de conectarse a internet.
  2. Un servidor que reciba y aloje los datos.

 

Existen diversas formas de lograr el cometido de registrar y almacenar los datos del sistema de tanques construido. En este caso, habrá que detallar cómo hacerlo con un módulo OBLOQ de DFRobot, y con los servidores de Adafruit.

 

El módulo UART OBLOQ es un dispositivo WiFi a serie pensado para desarrolladores no profesionales. Permite enviar y recibir datos mediante los protocolos HTTP y MQTT.

 

 

Paso 2 - Crear un Panel de Control

En primer lugar, se explicará cómo crear un Panel de Control en Adafruit. Luego, se verá cómo vincular los controles del Panel con los datos que se intercambian con el dispositivo. Primero debemos crear una cuenta de usuario en io.adafruit.com.

Una vez que ingresamos con nuestro usuario, creamos un nuevo panel haciendo click en “Create a New Dashboard”.

 

 

Luego designamos un nombre y una descripción. Y al finalizar presionamos el botón “Create”.

 

Seguidamente hacemos click en el nuevo panel creado y veremos una pantalla vacía. Podemos comenzar a agregar bloques haciendo click en .

Veremos una serie de controles posibles como en la siguiente imagen:

 

Para nuestro sistema de tanques podríamos ubicar dos Gauge para mostrar el nivel de los tanques y dos Indicator para indicar el estado de la válvula y el relé.

 

Cuando agregamos un control al panel debemos asociarlo a un “feed”.

Un feed es una fuente de datos en la que uno puede publicar así como también se puede suscribir para recibir los datos de cierto feed.

Llamamos al primer feed “tanque1” y le damos al botón “Create”. En él publicaremos, desde nuestro dispositivo, la información sobre el nivel de llenado del primer tanque.

 

Luego de crearlo, seleccionamos el feed creado y hacemos click en “Next step” (paso siguiente) para configurar nuestro control.

Ajustamos los parámetros del bloque como se ve en la imagen.

 

 

Luego, hacemos click en “Create block” (crear bloque) para completar la operación.

Si se quiere, podemos modificar el tamaño y ubicación de los bloques haciendo click en “la rueda de configuración”.

 

Repetimos este procedimiento para “tanque2”, quedando algo similar a lo siguiente:

 

Ahora creamos “valvula” (sin tilde) y ajustamos los parámetros del bloque como se ve en la imagen:

 

Si se quiere, podemos modificar el tamaño y ubicación de los bloques haciendo click en “la rueda de configuración”.

Repetimos este procedimiento para “bomba”, quedando algo similar a lo siguiente:

 

Una vez realizado el panel, publicaremos en nuestros feeds los estados de nuestros tanques para poder monitorearlos de manera remota.

 

Paso 3 - Agregar Módulo OBLOQ

Conectamos el módulo OBLOQ como se muestra en el esquema siguiente:

 

 

Paso 4 - Arduino IDE

La programación por bloques tiene sus ventajas desde un punto de vista didáctico, pero tiene sus límites. Cuando el programa comienza a ser más complejo, hay ciertas operaciones que no se pueden resolver con bloques, o bien que intentar hacerlo resulta algo mucho más engorroso y difícil de leer que el código escrito.

Hasta ahora hemos visto cómo al realizar nuestra programación en bloques se generaba simultáneamente un código escrito en el área lateral derecha. Para esta sección de la actividad se propone trabajar directamente sobre el código, para ello vamos a recurrir a el entorno nativo de Arduino que llamamos Arduino IDE (entorno de desarrollo integrado).

Para ello descarga el Arduino IDE desde el siguiente enlace y luego procede con la instalación del mismo: www.enfoco.net.ar/sd

 

Veremos que se nos presenta la siguiente interfaz:

 

A continuación,  se presenta una estructura mínima de un sketch (un programa) de Arduino:

 

void setup() {
 
// Código de inicialización. Se ejecuta una sola vez.
}

void loop() {
 
// Código principal. Se ejecuta repetidamente.
}

 

En líneas generales, un programa de Arduino es:

 

  1. Un bloque de código que se ejecuta por única vez al inicializarse el dispositivo. Este bloque de código está contenido dentro de la función “setup” (se coloca dentro de void setup() { y } ).
  2. Un bloque de código que se ejecuta repetidamente luego de la función “setup”. Este bloque de código está contenido dentro de la función “loop” (se coloca dentro de void loop() { y } ).

 

Después de   //  se incluyen comentarios para el lector que no tienen ningún efecto en el programa. Estos comentarios sirven para clarificar el código y que sea más fácil de interpretar para otras personas.

Los pasos para subir el código a través del Arduino IDE son similares a los que hemos visto para mBlock3:

  1. Conectar la placa a la entrada USB.
  2. Chequear que estén seleccionados la placa “Arduino/Genuino Uno” y el puerto serie al que está conectada la placa.

 

  1. Clickear el botón de “Subir”   para comprobar los paso anteriores.

Sabremos que nuestro código subió correctamente si en la barra de estado se escribe “Subido”.

 

Paso 5 - Programar sin código bloqueante

Antes de comenzar a utilizar IoT debemos hacer una aclaración con respecto a la función _delay() que figura en el código que usamos hasta ahora. Esta función brinda un tiempo de espera al sistema que puede utilizarse con varios fines. Suele utilizarse bastante en las primeras aproximaciones a la programación ya que su comportamiento resulta fácil de comprender y su programación no requiere más que una línea de código. Sin embargo, esta función tiene una complicación, dado que genera un “código bloqueante”. Esto significa que, cuando el programa entra en esa función, se detiene todo el procesamiento hasta que se cumpla el tiempo indicado. En otras palabras, cuando el programa entra al delay queda “colgado” por el período de tiempo establecido.

 

Al utilizar IoT, es conflictivo utilizar código “bloqueante” ya que, al detenerse el procesamiento, se impide también que el sistema realice otras operaciones que funcionan en simultáneo. Por ejemplo, las tareas de publicación y el mantenimiento constante de la conexión a internet.

 

Para evitar estos problemas, se puede utilizar una alternativa de código “no bloqueante”, como la función  millis(). Esta función arroja un valor sobre un conteo de tiempo, que se realiza desde el momento en que se inicia el sistema. Es decir, funciona como un cronómetro (en milisegundos) que, cada vez que es consultada desde el código, “devuelve” el valor en el que se encuentra. De esta manera podemos pedirle al sistema que informe cuánto tiempo transcurrió desde el inicio de las operaciones para dar indicaciones temporales sobre una tarea, sin detener todas las demás.

 

A continuación se presenta un ejemplo de cómo se puede programar la intermitencia de un LED que se prenda y apague cada un segundo (expresado en 1000 milisegundos) sin utilizar código bloqueante. Lo haremos utilizando la función millis para consultar cuánto tiempo pasó.

 

int estado = LOW;

// Se declara "millisAnterior" con valor inicial igual a cero.
long millisAnterior = 0;

void setup() {
 
// Inicializa el pin digital 13 como una salida.
  pinMode(13, OUTPUT);
}


void loop() {
 
 
long millisActual = millis();

 
if (millisActual - millisAnterior >= 1000) {
   
// Conmuta el estado del led.
    if (estado == LOW) {
      estado =
HIGH;
    }
else {
      estado =
LOW;
    }


    // Setea el estado del led.
    digitalWrite(13, estado);
   
   
// Guarda la última vez que conmutamos el led.
    millisAnterior = millisActual;
  }

 
// Y en este punto nuestro procesador queda libre
  // para realizar otras tareas.
 
}

                                                   Fragmento de código 3


En el ejemplo se puede observar que para tomar el valor de millis se define un valor inicial, al que llamamos “millisAnterior”, que es igual a cero. Luego, para consultar el tiempo transcurrido desde el inicio del sistema, se calcula la diferencia entre el valor de “millisActual” y el de “millisAnterior”. En el caso de nuestro ejemplo, cómo queremos generar una intermitencia de 1 segundo, necesitamos evaluar si esta diferencia es mayor o igual a 1000. En caso de que haya transcurrido más de un segundo, el sistema modifica el estado de la luz. Si ha transcurrido menos tiempo, el estado se mantiene estable.

 

En última instancia, se establece que, si esta diferencia es mayor o igual a 1000, se le asigne a “millisAnterior” el valor de “millisActual”. De esta manera, la diferencia entre “millisActual” y “millisAnterior” vuelve a ser cero hasta que vuelva a transcurrir otro segundo.

 

Paso 6 - Programar IoT

Utilizaremos la librería ObloqAdafruit para informar a Adafruit los niveles de los tanques. Podremos monitorear estos niveles desde el Panel de Control que hemos creado.

 

En primer lugar debemos instalar la librería en el Arduino IDE. Para esto debemos ingresar al menú Programa > Incluir Librería > Gestionar Librerías.

 

Fig. 28

 

Se abrirá una ventana con un buscador en margen superior. Debemos escribir Obloq, seleccionar la librería ObloqAdafruit y apretar el botón Instalar.

 

 

En general, las librerías traen códigos de ejemplo como referencia. Abrimos el ejemplo “Publicar” ubicado en Archivo -> Ejemplo -> OBLOQADAFRUIT-master.

 

Debemos reemplazar el SSID de la WiFi, su password, el IO_USERNAME e IO_KEY por los que copiamos de Adafruit. Pare ello maximizamos la pantalla de Adafruit y hacemos click en el ícono de la “llave”.

Copiamos el código que nos ofrece para Arduino, con nuestro usuario y key.

​​​​​​​

 

Estos datos aparecen en el código de la siguiente manera:

#define IO_USERNAME    "usuario_adafruit"

#define IO_KEY         "key_adafruit"

 

Se deberán reemplazar en esas dos líneas el usuario y key que se hayan obtenido en Adafruit. Por ejemplo:

#define IO_USERNAME  "usuario_aio"
#define IO_KEY       "1234cfdd29a244b6b049abb07727c117"

 

También modificaremos softSerial(10,11) por softSerial(6,7) ya que así es como lo conectamos en nuestra placa, quedándonos el siguiente código:

 

 

 

#include "SoftwareSerial.h"
#include "ObloqAdafruit.h"

// Indicamos conexión de wifi.

#define WIFI_SSID      "SSID_de_Wifi"
#define WIFI_PASSWORD  "PWD_de_WIFI"

// Copiamos las credenciales obtenidas anteriormente en Adafruit.

#define IO_USERNAME    "usuario_adafruit"
#define IO_KEY         "key_adafruit"

SoftwareSerial softSerial(6,7);
ObloqAdafruit
olq(&softSerial,WIFI_SSID,WIFI_PASSWORD,IO_USERNAME,IO_KEY);

 

 

El setup debe incluir la línea de inicialización del softwareSerial:

 

void setup()
{
    softSerial.
begin(9600);
}

 

Se debe agregar también la función de actualización o “update”: olq.update(). Por esto es importante que nuestro código no sea bloqueante.

 

void loop()
{
    olq.update();
  
// ..
   // ..
}

 

Para publicar un feed, utilizaremos la función publish del objeto olq :

 

// informar que el nivel del tanque1 es de 92 cm

olq.publish("tanque1", 92);

 

Finalmente, nuestro programa de tanques con IoT queda como sigue:

 

// Incluimos las librerías que usaremos.
#include "SoftwareSerial.h"
#include "ObloqAdafruit.h"


// Indicamos conexión de wifi.
#define WIFI_SSID      "SSID_de_Wifi"
#define WIFI_PASSWORD  "PWD_de_WIFI"

// Copiamos las credenciales obtenidas anteriormente en Adafruit.
#define IO_USERNAME    "usuario_adafruit"
#define IO_KEY         "key_adafruit"


// Indicamos a qué distancia debe cortar la válvula.
#define DISTANCIA_MINIMA1 40
#define DISTANCIA_MAXIMA1 140
#define DISTANCIA_MINIMA2 40
#define VALVULA 4
#define BOMBA 5


// Definimos la función que calcula la distancia
// del sensor ultrasónico (en cm).
float getDistance(int trig,int echo){
    pinMode(trig,OUTPUT);
    digitalWrite(trig,LOW);
    delayMicroseconds(
2);
    digitalWrite(trig,HIGH);
    delayMicroseconds(
10);
    digitalWrite(trig,LOW);
    pinMode(echo, INPUT);
   
return pulseIn(echo,HIGH,30000)/58.0;
}


// Indicamos a qué pines se conecta el módulo OBloq.
SoftwareSerial softSerial(6,7);
// Declaramos nuestro objeto IoT.
ObloqAdafruit olq(&softSerial,WIFI_SSID,WIFI_PASSWORD,IO_USERNAME,IO_KEY);

long millisAnterior = 0;

void setup() {
  pinMode(VALVULA, OUTPUT);
// Seteamos VALVULA como salida.
  pinMode(BOMBA , OUTPUT); // Seteamos BOMBA como salida.

  //  Inicializamos la comunicación con el módulo OBloq.
  softSerial.begin(9600);
}


void loop() {
 
 
long millisActual = millis();



 
//Ejecutamos solo cada 3 segundos.
  if (millisActual - millisAnterior >= 3000) {


   
// Leemos la distancia del agua en cm en el primer tanque.
    int distancia1 = getDistance(8,9);
   
if(distancia1 < DISTANCIA_MINIMA1){
     
// Si la distancia medida es menor que
      // la distancia mínima, apagamos la válvula.
      digitalWrite(VALVULA, LOW);
      olq.publish(
"valvula", 0);  // Publicar en Adafruit.
    }else{
     
// Si no, la encendemos para que cargue el tanque.
      digitalWrite(VALVULA, HIGH);
      olq.publish(
"valvula", 1);  // Publicar en Adafruit.
    }

   
// Leemos la distancia del agua en cm en el segundo tanque.
    int distancia2 = getDistance(10,11);
   
if(distancia2 < DISTANCIA_MINIMA2){
     
// Si la distancia medida es menor que
      // la distancia mínima, apagamos la bomba.
      digitalWrite(BOMBA, LOW);
      olq.publish(
"bomba", 0);  // publicar en adafruit
    }else{
     
// Si no, primero debemos verificar que el primer
      // tanque no esté demasiado vacío, ya que la
      // bomba se arruina si se enciende y no está
      // completamente sumergida.
  
     
if(distancia1 > DISTANCIA_MAXIMA1){
       
// El nivel de agua está muy bajo.
        // Apago la bomba.
        digitalWrite(BOMBA, LOW);
        olq.publish(
"bomba", 0);  // Publicar en Adafruit.
      }else{
       
// Hay suficiente agua en el primer tanque.
        // Enciendo la bomba.
        digitalWrite(BOMBA, HIGH);
        olq.publish(
"bomba", 1);  // Publicar en Adafruit.
      }
    }


   
// Publicar en Adafruit los niveles de los tanques.
    olq.publish("tanque1", distancia1);
    olq.publish(
"tanque2", distancia2);


    millisAnterior = millisActual; 
// guarda millisAnterior

  }

 
// Llamamos a que la librería actualice lo que necesite.
  olq.update();
}

                                                   Fragmento de código 4

 

 

Cierre - Glosario


Cierre

Una vez finalizado este proyecto, si se quiere continuar, es posible extenderlo. Una opción sugerida es:

 

  • Calcular, teniendo en cuenta la capacidad total del tanque y la distancia que lee el sensor ultrasónico, cuánta capacidad disponible queda en el tanque, es decir, cuánto falta para que se llene el tanque (en litros). Luego, se puede amar un programa que recupere esa información y la publique a través de IoT.

 

El proceso de resolución de problemas, como los que se han planteado aquí, permite la movilización y la integración de distintos saberes en la búsqueda de soluciones posibles a una situación dada. Si bien la información fue presentada a modo de instructivo, se espera que sean los estudiantes organizados en pequeños grupos quienes vayan encontrando las mejores formas para construir los dispositivos. Esto implica preparar los materiales para que cada grupo cuente con todo lo necesario para la construcción del proyecto. Además, en el interior de cada grupo, los estudiantes deben distribuirse los roles y las tareas de acuerdo a las demandas que van teniendo en las actividades.

 

Es importante que los docentes acompañen las producciones de cada grupo monitoreando los avances de todos los estudiantes y presentando la información que se considere necesaria para continuar la tarea. Pero, al mismo tiempo, es necesario que habiliten espacios para que los alumnos realicen hipótesis, planteen interrogantes, indaguen, prueben y realicen ajustes de acuerdo a lo que ellos mismo van pensando sobre cómo llevar a cabo el proyecto. 

 

En este sentido, registrar lo que se va haciendo, las preguntas de los alumnos, las pruebas, los errores y cómo se fueron construyendo los dispositivos, permite reflexionar sobre la propia práctica, reforzar los aprendizajes construidos a lo largo de este proceso y poder volver a ese material disponible para próximos proyectos que se realicen.

 

Una vez terminado el proyecto, se sugiere reunir y organizar con el grupo el registro que se hizo del proceso realizado. Esta instancia de sistematización también permite movilizar capacidades vinculadas a la comunicación porque implica tomar decisiones respecto a cómo se quiere mostrar el proyecto a otros (otros grupos, otras escuelas, otros docentes, a la comunidad, etc.).

 

Te recomendamos pasar por el repositorio de saberes Digitales para obtener más materiales y otros ejemplos: www.enfoco.net.ar/sd

 

 

Glosario

Electrónica y Arduino

 

Arduino: Placa electrónica que contiene un microcontrolador programable y sistema de comunicación (USB y serial) que permite al usuario cargarle diversos programas así como también comunicarse con la misma. Del lado de la computadora se utiliza un IDE (entorno de desarrollo integrado) para generar el código, compilarlo y quemarlo en la placa. Existen múltiples IDE compatibles con las placas Arduino.

 

El microcontrolador posee entradas analógicas y digitales así como salidas digitales, PWM y servo. Las entradas y salidas digitales son las que permiten leer o escribir estados del tipo binarios. Pueden adoptar la forma de 0 ó 1, alto o bajo, verdadero o falso. Para prender y apagar los LED del semáforo utilizamos salidas digitales, las mismas están nomencladas con números desde el 0 al 13.

 

Las entradas analógicas permiten leer información que puede adoptar diferentes niveles de tensión, tal como la lectura de un termómetro analógico, la posición de un potenciómetro, etc. Las mismas están identificadas en la placa como A0 a A5.

 

Puerto COM: Es el puerto de comunicaciones a través del cual un sistema operativo informático se comunica con un dispositivo externo tal como una placa Arduino. La asignación de los mismos suele realizarse de forma automática al conectar la placa via USB. Dicha asignación suele ser dinámica, lo que significa que a veces cambia el número al conectar una misma placa en otro puerto USB o al conectar varias placas. En todos los IDE de programación es necesario especificar el puerto COM a través del cual nos comunicaremos con la placa Arduino.

 

Protoboard: Es una placa experimental que permite el prototipado rápido de circuitos electrónicos. Tiene orificios para insertar las patas de los componentes permitiendo que se conecten sin tener que recurrir a la soldadura.

 

El mismo posee una grilla de orificios que se encuentran conectados entre sí siguiendo el esquema de la imágen. Las líneas de conexión superior e inferior recorren la placa de punta a punta y suelen utilizarse para la alimentación del circuito, mientras que las líneas verdes se suelen utilizar para interconectar componentes. Tomar en cuenta que las líneas verdes se interrumpen en el centro de la placa. Generalmente se utilizan cables del tipo dupont para realizar conexiones en la protoboard.

 

 

 

Sensor de distancia ultrasónico: Es un tipo de sensor que se utiliza para medir distancias. El principio de funcionamiento del mismo se basa en emitir un pulso de sonido ultrasónico y medir el tiempo que pasa hasta registrar que dicho pulso regresó a la fuente tras rebotar en un obstáculo. El tiempo transcurrido es directamente proporcional a la distancia que se encuentra el objeto, esto se debe a que la velocidad de propagación del sonido en el aire es lineal. Este tipo de sensor tiene cuatro pines de conexión, de estos se utilizan dos para la alimentación eléctrica del mismo (VCC y GND). Los dos pines restantes se utilizan para generar el pulso (Trigger) y para detectar la llegada del mismo (Echo).

 

La utilización del mismo requiere programar el mecanismo de disparo, medición de tiempo y sensado de la llegada del rebote. En general la mayoría de los entornos de programación facilitan alguna librería que resuelva de manera simple la gestión de estos procesos, pudiendo acceder como usuario directamente a la información en Centímetros de la medición realizada.

 

Electroválvula: Se trata de un actuador que permite o interrumpe el paso de un fluido a través del mismo. Existen versiones que trabajan con 12 V así como también los que trabajan directamente con 220 V, permitiendo trabajar en un sistema de mayor nivel de caudal. El accionamiento del mismo se realiza directamente a través de la alimentación de la misma, por lo que tiene únicamente 2 pines para la conexión. Los estados posibles son activado o no, por lo que se puede controlar mediante una salida digital y un relé.

 

Relé: Dispositivo electromagnético que funciona como un interruptor controlado por un circuito eléctrico. Por medio de un electroimán se acciona uno o varios contactos que permiten abrir o cerrar otros circuitos eléctricos independientes. Se utiliza comúnmente para aislar eléctricamente dos circuitos así como también permitir controlar con bajo voltaje a dispositivos que utilizan mayor voltaje. Arduino trabaja con señales de 5 V que mediante un relé permiten controlar la activación o desactivación de dispositivos de 220 V.

 

Internet de las cosas

Panel de Control Adafruit: Los sistemas IoT trabajan apoyándose en un servidor que se encarga de gestionar la información que reportan los diversos sensores así como responder a las consultas de los dispositivos que buscan acceder a esta información (mostrarla en pantalla, tomar decisiones, etc). Adafruit es una plataforma online con posibilidad de uso gratuito que ofrece el servicio de gestión de esta información. La misma ofrece un alto grado de compatibilidad con diversos estándares de trabajo IoT, principalmente orientada al uso educativo.

Feed: Fuente de datos en la que uno puede publicar y a la que puede suscribirse. Es decir, permite enviar datos, para que estos sean almacenados en el tiempo así como también leerlos, recibiendo las actualizaciones de quienes estén publicando allí. Es una forma de almacenar información en una gran base de datos de forma ordenada, utilizando el concepto de etiquetas tanto al momento de escribirla como el de leerla.