Está en la página 1de 24

Realizado por: José del Rey y Álvaro Vigueras         D.P.E.

 2SEL 

Página 1 de 24 
Controlador de acuario 
INDICE 
‐ Descripción del proyecto…………………………………………………………..      1 
‐ Funcionamiento del proyecto……………………………………………………      2 
‐ Materiales y presupuesto………………………………………………………….      8 
‐ Construcción del proyecto…………………………………………………………    12 
‐ Programa…………………………………………………………………………………..    17 

   

Página 2 de 24 
Controlador de acuario 
DESCRIPCIÓN DEL PROYECTO: 
Mediante este proyecto, podemos controlar todas las funciones de un 
acuario. 

Se controla mediante una placa con 3 botones y un interruptor. El 
interruptor te lleva a los dos menús que hay en el programa: 

‐ En el primer menú, nos muestra en la pantalla LCD el nivel del agua 
en cm, la hora, la temperatura actual del agua y la temperatura 
actual que hay entre la tapa y  el agua. 
‐ Con el segundo menú determinamos las medidas a las que 
queremos que se active el ventilador, para enfriar la temperatura 
entre la tapa y el agua, el calentador de agua, para calentar la 
temperatura del agua, la hora a la que queremos que la tira de leds 
simule el amanecer, que cambiaría de azul oscuro a blanco, 
gradualmente , en horas y minutos, la hora a la que queremos que 
la tira de leds simule el atardecer, que cambiaría de blanco a azul 
oscuro, gradualmente, en horas y minutos. 

El programa consta también de un sistema automático de llenado y de 
vaciado del acuario. Cuando el sensor de ultrasonidos detecte que el nivel 
del agua llega a un mínimo en cm, la electroválvula se activará y empezará 
el llenado del acuario. Cuando el sensor de ultrasonidos detecte que el 
nivel de agua ha alcanzado el deseado, la electroválvula se cerrará y no 
dejará paso al agua. 

Para vaciar el agua del acuario para proceder a su limpieza, la bomba se 
activará y empezara el proceso de vaciado, por el cual el agua saldrá a 
través de una manguera instalada en la bomba. Cuando el sensor de 
ultrasonidos detecte que el nivel de agua ha llegado a su mínimo, la 
electroválvula se activará y comenzará el proceso de llenado, explicado 
anteriormente, hasta llegar a un máximo de cm.     
   

Página 3 de 24 
Controlador de acuario 
FUNCIONAMIENTO DEL PROYECTO 
Iluminación led de colores con DMX 

En este tutorial vamos a ver cómo podemos cambiar los colores de una 
tira de leds utilizando el protocolo DMX. 

  

¿Cómo conecto los equipos? 

La conexión de los equipos es muy sencilla, tengo que conectar el puerto 
RS485 (A y B) del WK0100 al controlador DMX y éste a la tira de leds tal 
como se muestra en el siguiente esquema: 

  

  

 
  

  

Página 4 de 24 
Controlador de acuario 
 

1. Direccionamiento de los controladores DMX 

Cada  controlador  DMX  que  conecto  en  el  bus  lleva  una  dirección  que  se 
configura en los switches que situados en la carcasa. En este caso, como 
solamente  tenemos  un  controlador  y  una  tira  de  leds,  su  dirección  debe 
ser el 1 ponemos en posición ON el switch número 1 y el resto en posición 
OFF. Si tenemos más de un controlador DMX en el bus, hay que tener en 
cuenta que en el protocolo DMX se direcciona por canal. Un canal es cada 
uno de los colores que vamos a controlar. De este modo, cada controlador 
DMX  que  quiera  conectar  al  bus  ocupa  tres  canales,  por  lo  tanto  el 
segundo  DMX  lleva  la  dirección  4,  el  siguiente  la  dirección  7  y  así 
sucesivamente.  La  dirección  se  codifica  en  binario  en  los  switches  de  la 
carcasa de cada controlador DMX. 

  

2. Programa 

Vamos a hacer el programa en el IDE de Arduino, puedes descargártelo de 
su página oficial: http://arduino.cc. 

Ahora necesitsas añadir la librería DMXSerial, la puedes encontrar en la 
web http://www.mathertel.de/Arduino/DMXSerial.aspx, Además de los 
archivos .cpp y .h propios de la librería, también trae unos ejemplos pero 
aquí vamos a hacer un programa más sencillo. 

Página 5 de 24 
Controlador de acuario 
 

El código es el siguiente: 

  

#include <DMXSerial.h> 

void setup() { 

DMXSerial.init(DMXController); 

void loop() { 

DMXSerial.write(1, 255); 

DMXSerial.write(2, 0);  

DMXSerial.write(3, 0);  

delay(5000);  
   
DMXSerial.write(1, 255); 

DMXSerial.write(2, 255); 

DMXSerial.write(3, 0); 

delay(5000); 

DMXSerial.write(1, 0); 

DMXSerial.write(2, 0); 

DMXSerial.write(3, 150); 

delay(5000); 

  

Página 6 de 24 
Controlador de acuario 
  

Puedes  modificar  el  código  para  que  los  leds  muestren  los  colores  que 
quieras: 

 
Página 7 de 24 
Controlador de acuario 
MATERIALES: 
PRODUCTO  CANTIDAD  IMAGEN  PRECIO  PRECIO 
C/U  TOTAL 
Arduino UNO  1  26,56€  26,56€ 

 
Acuario 30  1  33,95€  33,95€ 
litros 

 
Rele 5v  1  2,30€  2,30€ 

 
Rele 5v Finder  3  6,50€  19,5€ 

 
Calentador de  1  18,90€  18,90€ 
agua 

 
Ventilador 12v  1  9,90€  9,90€ 

Página 8 de 24 
Controlador de acuario 
DMX  1  59€  59€ 

 
Tira de leds  1  7,33€  7,33€ 

 
Pantalla LCD  1  17,26€  17,26€ 

 
Interruptor  1  1,38€  1,38€ 

 
Pulsador  3  0,42€  1,26€ 

 
Electroválvula  1  15€  15€ 

 
Filtro del agua  1  8,10€  8,10€ 

 
Bomba de  1  6,50€  6,50€ 
agua 

Página 9 de 24 
Controlador de acuario 
Cables  1  4,50€  4,50€ 

 
LM35  2  0,60€  1,20€ 

 
Conector  1  0,50€  0,50€ 
hembra 

 
Conector  1  0,50€  0,50€ 
macho 

LED rojo  4  0,15€  0,60€ 

 
BC547B  4  1,24€  4,96€ 

 
1N4148  4  0,62€  2,48€ 

 
Regleta  1  0,87€  0,87€ 
conexión 

Página 10 de 24 
Controlador de acuario 
Resistencia  2  0,06€  0,12€ 
10K 

 
Resistencia 1K  4  0,06€  0,24€ 

 
Sensor  1  6,67€  6,67€ 
ultrasonidos 

 
Manguera  1  5,99€  5,99€ 

 
 

   

Página 11 de 24 
Controlador de acuario 
CONSTRUCCIÓN DEL PROYECTO 
CONSTRUCCIÓN 

Para la construcción de nuestro proyecto hemos utilizado diversos 
materiales y componentes. 

Podemos dividir el proyecto en 4 partes, el acuario, la tapa, la caja done se 
encuentran todas la conexiones y la placa de control. 

Empezamos por la caja donde se encuentran todas las conexiones del 
proyecto. 

Aquí nos encontramos con lo que es el nucleo del proyecto, en ella se 
encuentra nuestro arduino y la placa que hemos diseñado con todas las 
conexiones que hemos utilizado.  

Podemos encontrar: 

.‐Salida para conectar 4 reles, con sus correspondientes pines IN,VCC y 
GND. 

.‐Salida para conectar los dos sensores de temperatura para la tapa y 
agua, también con IN ( pin analógico), GND y VCC. En el caso de del sensor 
de temperatura hemos elegido el pin A0, y para la tapa A1. 

.‐Salida para reloj GND,VCC ,SCL y SDA. 

.‐Salida para LCD GND, VCC, SCL y SDA. 

.‐SCL y SDA van para ambas conexiones conectadas a A4 y A5 
consecutivamente. 

.‐Salida para sensor ultrasonidos, pines: 

GND, VCC, TRIG y ECHO. 

.‐Salida de 12V con su correspondiente GND, 3 pines cada uno. 

.‐Salida para conexión TX y RX que utilizamos para el DMX. 

Página 12 de 24 
Controlador de acuario 
 
 
 
 
 
 
 
 
 
 
 
 
 
   

En la foto se visualiza la placa 
comentada anteriormente.  
 

Placa de control. 

Es una placa pequeña y sencilla, formada por un interruptor de dos 
posiciones y 3 pulsadores, esta placa se encuentra a la vista y esta 
conectada a la placa anterior. 

 
Página 13 de 24 
Controlador de acuario 
 

Tapa 

La tapa es de madera y en ella se encuentran varios componenetes, en la 
parte exterior, se encuentra atornillado el DMX y la pantalla LCD, en el 
interior, tenemos la tira de leds RGB , el sensor de temperatura, el 
ventilador y el de ultrasonidos atornillados. 

A la tapa se le han hecho unos agujeros en los laterales para facilitar el 
paso tanto de cables como de gomas por donde circulara el agua. 

Página 14 de 24 
Controlador de acuario 
 

El acuario 

En el acuario se encuentra el calentador de temperatura, la bomba de 
agua, el filtro, la sonda de temperatura. 

 
Resumen de construcción. 

En un principio realizamos todas las conexiones en una placa protoboard 
para comprobar su correcto funcionamiento. 

Una vez que comprabamos el funcionamiento, diseñamos la placa que iria 
conectada al arduino y donde se realizarían todas las conexiones, esa 
placa la introducimos en una caja de carton a la que hicimos un agujero en 
la parte frontal y otro más grande en el lateral, por el frotal sacamos todos 
las cables que irían a todos los componentes conectados, reles, dmx, 
sondas, pantalla lcd etc. 

Página 15 de 24 
Controlador de acuario 
Y por el frontal sacamos las cables que irían a la placa de control que se 
encontraría a la vista y en el exterior para poder utilizarla con facilidad. 

A la tapa, pegamos la tira RGB y atornillamos el sensor de ultrasonidos, y 
el de temperatura. 

Practicamos los agujeros necesarios para adaptar el ventilador y la 
pantalla LCD. 

En el exterior atornillamos en la parte de arriba el DMX que controlará las 
tiras RGB. 

Muchos de los elementos que utilizamos funcionan con 220V en alterna, 
para ello hemos conectado los reles y una regleta para conseguir la 
alimentación necesaria. 

NOTA: 

Los diferentes diseños de placas que hemos utilizados, serán adjuntados 
con toda la documentación. 
Página 16 de 24 
Controlador de acuario 
PROGRAMA 
PROGRAMA 

El programa ha sido realizado con la versión Arduino 1.0.1 para Arduino 
UNO SMD. 

Las librerías que hemos utilizado son: 

LiquidCrystal_I2C.h> 

.‐Wire.h. Permite comunicar con dispositivos I2C 

.‐Ultrasonic.h  Necesaria para utilizar el sensor de ultrasonidos 

.‐DMXSerial.h Es la librería que permite el correcto funcionamiento del 
DMX. 

.‐RTClib.h Librería del reloj 

El programa consta de dos cuerpos, uno que se ejecuta una vez y otro que 
es cíclico, en el primero inicializamos y establecemos nuestros parámetros 
fijos. 

El programa nos muestra por pantalla una cosa u otra según la posición 
del interruptor, según el programa si el interruptor está en la posición 1 el 
sistema estará en funcionamiento y nos mostrará por pantalla los valores 
reales. 

Si está en posición 2 entrará en modo configuración, llamara a la función  

Fon_Configuracion(datos); 

En ella a través de otra función Fon_Pulsador_Soltar(datos) podremos 
visualizar los parámetro a establecer y modificarlos con los pulsadores. 

Página 17 de 24 
Controlador de acuario 
  int estadopulsadorMenu = LOW; 
#include <LiquidCrystal_I2C.h>  int const 
#include <Wire.h>  numeroElementosMenu = 8; 
#include <Ultrasonic.h>  byte 
#include <DMXSerial.h>  datos[numeroElementosMenu]; 
#include <RTClib.h>  char* 
  datos1[numeroElementosMenu] 
Ultrasonic ultrasonic(3,4);  = { 
RTC_DS1307 RTC;    ".‐ Temperatura", ".‐ 
  Temperatura", ".‐ Amanecer", ".‐ 
/*‐‐‐‐‐( Declarar Constantes )‐‐‐‐‐*/  Amanecer", ".‐ Anochecer",".‐ 
// Entradas del conmutador  Anochecer",".‐ Nivel Agua",".‐ 
int ledpin=13;  Nivel Agua"}; 
int conmutador_1 = 6;  char* 
int conmutador_2 = 5;  datos2[numeroElementosMenu] 
int Sonda=A0;  = { 
int LM35= A3;    "Agua", "Tapa", "Hora", 
float temp;  "Minuto", "Hora", "Minuto", 
float temp1;  "Maximo","Minimo"}; 
int Ta;   
int Tt;  void setup()   /*‐‐‐‐( SETUP: Se 
int AH;  ejecuta una vez )‐‐‐‐*/ 
int AM;  { 
int AnH;    DMXSerial.init(DMXController); 
int AnM;    lcd.init(); // initialize the lcd 
int  NaM;    lcd.backlight(); 
int NaMi;    Wire.begin(); 
int bomba;    RTC.begin(); 
int ventilador;    if (! RTC.isrunning())  
int calentador;    { 
int filtro;      
  RTC.adjust(DateTime(__DATE__, 
// Los 3 pulsadorMenues  __TIME__)); 
int pulsadorMenu = 12;    } 
int pulsadorSubir_1 = 11;    pinMode(filtro,OUTPUT); 
int pulsadorSubir_10 = 10;    pinMode(bomba,OUTPUT); 
    pinMode(calentador,OUTPUT); 
/*‐‐‐‐‐( Declarar Objetos )‐‐‐‐‐*/    pinMode(ventilador,OUTPUT); 
LiquidCrystal_I2C lcd(0x27,16,2); // set    pinMode(ledpin,OUTPUT); 
the LCD address to 0x27    pinMode(pulsadorMenu, 

Página 18 de 24 
Controlador de acuario 
  INPUT); 
/*‐‐‐‐‐( Declarar Variables )‐‐‐‐‐*/    pinMode(pulsadorSubir_1, 
// usados con el conmutador para que  INPUT);   
la pantalla permanezca sin parpadear    pinMode(pulsadorSubir_10, 
boolean c1 = true;  INPUT);  
boolean c2 = true;    pinMode(conmutador_1, 
boolean c3 = true;  INPUT);   
    pinMode(conmutador_2, 
  AH=datos[2];  INPUT);  
  AM=datos[3];  }/*‐‐(end setup )‐‐‐*/ 
  AnH=datos[4];   
  AnM=datos[5];   
  NaM=datos[6];  void loop()   /*‐‐‐‐( LOOP: Ciclico 
  NaMi=datos[7];  )‐‐‐‐*/ 
  { 
  DateTime now = RTC.now();    digitalWrite(filtro,HIGH); 
  if (digitalRead(conmutador_1))   
  {    Ta=datos[0]; 
    lcd.setCursor(0,1);    Tt=datos[1]; 
    lcd.print(now.hour());      { 
    lcd.print(":");        DMXSerial.write(1, 255); 
    lcd.print(now.minute());        DMXSerial.write(2, 255); 
        DMXSerial.write(3, 255); 
         } 
temp1=(5*analogRead(A0)*100/1023.0     if(now.hour()==AnH && 
);  now.minute()==AnM) 
         {   
temp=(5*analogRead(A3)*100/1023.0)       for(int baja= 255 ; baja >= 0;  
;  ‐‐baja) 
    lcd.setCursor(9,0);        {  
    lcd.print("T:");          DMXSerial.write(1, baja); 
    lcd.print(temp);          DMXSerial.write(2, baja);  
    lcd.setCursor(9,1);          DMXSerial.write(3, 150);  
    lcd.print("A:");         } 
    lcd.print (temp1);      } 
    delay(500);      else if(now.hour()>AnH && 
    lcd.setCursor(3,0);  now.minute()>AnM && 
    lcd.print(ultrasonic.Ranging(CM)); //  now.hour()!=AH && 
CM or INC  now.minute()!=AM) 
    lcd.print("cm" );      { 

Página 19 de 24 
Controlador de acuario 
        DMXSerial.write(1, 0); 
    if(now.hour()==AH &&        DMXSerial.write(2, 0); 
now.minute()==AM)        DMXSerial.write(3, 150); 
    {         } 
      for(int sube = 0 ; sube <= 255; sube       if(ultrasonic.Ranging(CM)<15) 
++)       { 
      {       digitalWrite(bomba,HIGH);   
        DMXSerial.write(1, sube);       } 
        DMXSerial.write(2, sube);        else 
        DMXSerial.write(3, sube);       { 
        delay(235);       digitalWrite(bomba,LOW); 
      }       } 
    }       if (temp > 25) 
    else if(now.hour()>AH &&       { 
now.minute()>AM &&       digitalWrite(ventilador,HIGH);   
now.hour()!=AnH &&       } 
now.minute()!=AnM )       else 
     }       { 
     else       digitalWrite(ventilador,LOW);   
     {       } 
     digitalWrite(calentador,LOW);          
     }       if (temp1 < 22) 
            { 
            
       digitalWrite(calentador,HIGH);   
   
    if (c1)   
    {   
      lcd.clear();   
      lcd.print("ON");   
      c1 = false;     
      c2 = true;   
      c3 = true;      
   
    }   
   
  }   
  else   
    if (digitalRead(conmutador_2))   
    {   

Página 20 de 24 
Controlador de acuario 
      if (c2)   
      {   
        lcd.clear();   
        lcd.print("Modo");   
        lcd.setCursor(0,1);   
        lcd.print("Configuracion");   
        c2 = false;   
        c1 = true;   
        c3 = true;   
        Fon_Configuracion(datos);   
      }   
    }     
   
  //delay(1000);   
   
}/* ‐‐(end main loop )‐‐ */   
   
/*‐‐‐‐‐( Declare User‐written Functions   
)‐‐‐‐‐*/   
   
   
   
   
/* ( THE END ) */   
   
   
   
FUNCION FON_CONFIGURACION   
   
// Creamos en menu donde iremos   
introduciendo dato a dato   
// lo iremos guardando en *datos   
(datos[0], datos[1], etc)   
void Fon_Configuracion(byte *datos)   
{      datos[numeroMenu] = 
    Fon_Lee_Dato(datos[numeroMe
  int numeroMenu = 0;  nu]); 
  boolean ver = true;   
   
  // Mientras esta en Modo   

Página 21 de 24 
Controlador de acuario 
Configuracion      delay(150); 
  while (digitalRead(conmutador_2))     
  {  }} 
    // Si pulso y suelto el boton Menu   
incremento el numero de menu   
    if   
(Fon_Pulsador_Soltar(pulsadorMenu))   
    { 
      numeroMenu++; 
      if (numeroMenu > 
numeroElementosMenu‐1) 
      { 
        numeroMenu = 0;  
      } 
      ver = true; 
    } 
    // Muestro y mantengo fijos. 
    if (ver) 
    { 
      lcd.clear(); 
      lcd.setCursor(0,0); 
      lcd.print(numeroMenu); 
      lcd.print(datos1[numeroMenu]); 
      lcd.setCursor(0,1); 
      lcd.print(datos2[numeroMenu]); 
    } 
    ver = false; 
    // En pantalla solo parpadea el valor 
a introducir 
    lcd.setCursor(13,1); 
    lcd.print("   "); 
    lcd.setCursor(13,1); 
    lcd.print(datos[numeroMenu]); 
 
 
 
 
 
 
 

Página 22 de 24 
Controlador de acuario 
FUNCION FON_PULSADOR_SOLTAR 
 
// Incrementa en 1 y se queda en un 
bucle sin hacer nada hasta que se suelt 
int Fon_Pulsador_Soltar(int pulsador) 

  if (digitalRead(pulsador)) 
  { 
    while (digitalRead(pulsador)) ;  
    return 1;  
  } 
  return 0; 

// incrementa el contador mientras se 
mantiene pulsado. 
int Fon_Pulsador_Mantenido(int 
pulsador, int contador, int incremento) 

  if (digitalRead(pulsador)) 
  { 
    contador = contador + incremento;  
  } 
  if (contador > 100) 
  { 
    contador = 0; 
  } 
  return contador; 

// Lee un dato mediante los pulsadores 
int Fon_Lee_Dato(int valorElegido) 

  valorElegido = 
Fon_Pulsador_Mantenido(pulsadorSub
ir_1, valorElegido,1); 
  valorElegido = 
Fon_Pulsador_Mantenido(pulsadorSub
ir_10, valorElegido,10); 
  //delay(100); 
  return valorElegido; 

Página 23 de 24 
Controlador de acuario 
 
 

Página 24 de 24 
Controlador de acuario