Jaula Domótica. Grupo 7

JAULA DOMÓTICA

Grupo 7: MÓSTOLES SEyTR

Diego Jiménez Fernández-Pacheco
Andrea Ortiz González

INDICE
  1. Introducción
  2. Materiales
  3. Funcionamiento
  4. Componentes
  5. Código
  6. Problemas encontrados y soluciones
  7. Mejoras




1.- Introducción

Si estás buscando los mejores cuidados para tu hámster, os
presentamos la jaula perfecta. Está dotada con todos los avances tecnológicos
para que tu hámster sea el mejor cuidado.


2.- Materiales

Elegoo
Conjunto Medio de Iniciación a UNO para Arduino

1
unidad Placa controladora Arduino UNO R3

1 unidad Modulo de LCD1602 (con
conector) 

1 unidad Placa de prototipado


1 unidad Modulo de fuente de alimentación


1 unidad Modulo Joystick (mando
multidireccional)

1 unidad Receptor de infrarrojos

1 unidad Servomotor (SG90)

1 unidad Motor paso a paso

1 unidad Placa controladora ULN2003 para motor
paso a paso

1 unidad Detector ultrasónico

1 unidad Modulo de temperatura y humedad DHT11

1 unidad Pila de 9V

1 unidad 65 cables con conector

1 unidad Cable USB

1 unidad Zumbador activo

1 unidad Zumbador pasivo

1 unidad Potenciómetro

1 unidad Relé de 5V

1 unidad Placa de desarrollo

1 unidad Mando a distancia por infrarrojos

1 unidad Detector de inclinación

5 unidades Pulsador (pequeño)

1 unidad Pantalla de 1 dígito compuesto por 7
segmentos

1 unidad Pantalla de 4 dígitos compuesto por 7
segmentos

5 unidades Diodos LED amarillos

5 unidades Diodos LED azules

5 unidades Diodos LED verdes

5 unidades Diodos LED rojos

1 unidad Diodos LED multicolor

2 unidades Foto-resistores

1 unidad Termistor

2 unidades Diodo Rectificador (1N4007)

2 unidades Transistor NPN (PN2222)

1 unidad Circuito integrado 74HC595

10xResistencias(10R)

10xResistencias(100R)

30xResistencias(220R)

10xResistencias(330R)

10xResistencias(1K)

10xResistencias(2K)

10xResistencias(5K1)

10xResistencias(10K)

10xResistencias (100K)

10xResistencias(1M)

10 unidades Cables con conector hembra a macho
Dupont

32.00€
Registro de Desplazamiento 74HC595


2 unidades
0.45€ cada una
Cables Hembra-Macho

50 unidades
3.60€
Jaula para hámster


1 unidad
6.10€
Cables Hembra-Hembra


25 unidades
5.00€
TOTAL


47.60€


3.-Funcionamiento

Nuestra jaula tiene varias funciones:


  • Para empezar, cuenta con un mando, con él podremos
    activar varios comandos.
  • El botón de POWER
    servirá para encender o apagar todos los LED´s , que se encuentran a lo largo
    de toda la jaula.
  • Cuenta con un sensor de luz, que cuando detecta poca
    luz, hace que unas luces de color blanco se enciendan para que la jaula nunca
    esté a oscuras.
  • También tendremos la opción con los botones, 1,2 y 3 del mando de cambiar los colores de los LED’s a verde, azul y
    amarillo.
  • Con el botón de PLAY/PAUSE
    podemos encender el ventilador que estará en funcionamiento unos segundos.
  • Además, tenemos un localizador en forma de unos LED´s
    que nos indicarán dónde está nuestro hámster en todo momento.
  • Todo ello estará reflejado en una pantalla LCD que se
    encuentra en un lateral de la jaula, y cuando no haya ninguna función en
    marcha, nos estará mostrando la temperatura.



4.-Componentes 
             
Conjunto completo



 

Pantalla LCD (pin: 13,11,10)


Circuito LED’s (pin: 7,6,5)

Ventilador (pin: 3)


Fotorreceptor (pin:
A1), Termómetro (pin: A0), Sensor infrarrojos (pin:4), Sensor Ultrasonidos
(pin: 9, 8).


5.-Código


#include <SPI.h>
#include <LiquidCrystal.h> //Librería de la pantalla LCD. Está modificada para que directamente use el registro de desplazamiento (74hc595)
#include <Servo.h> //Librería del servo. Al final no la utilizaremos ya que no funcionaba correctamente
#include “SR04.h” //sensor ultrasonido
#define TRIG_PIN 9 //pin del ultrasonido
#define ECHO_PIN 8 //El otro pin del ultrasonido
#include “IRremote.h” //Librería del mando
// Ultrasonidos
SR04 sr04 = SR04(ECHO_PIN,TRIG_PIN);
long a;

//Pantalla LCD (Ponemos el número del pin que va al latchPin del 74HC595 (Registro de desplazamiento).
LiquidCrystal lcd(10);
// Servo, porton y motor (Solo dejamos abierto que es el que nos cambiaría el motor de apagado a encendido y si estuviese el servo te diría el estado del portón)
//Servo myservo;  // create servo object to control a servo
//int posSer = 0;    // variable to store the servo position
int motorPin = 3; //Pin del motor.
bool abierto = false;

//Leds {{{
int tDelay = 100;
int latchPin = 6;
int clockPin = 5;
int dataPin = 7;
int colores; //Codigo de los colores. Podrá ser 5, 6 o 7.
bool encendidos = false;
byte leds = 0;
//mando
int receiver = 4;
//termometro
int tempPin = 0;
// Objetos del recibidor del mando.
IRrecv irrecv(receiver);     // Creamos una instancia del recibidor de infrarrojos ‘irrecv’
decode_results results;      // Creamos una instancia de los resultados a recibir ‘decode_results’
// Declaracion de funciones
void updateShiftRegister();
void translateIR();
//Leds }}}
void setup() {
 
  // Ponemos el numero de columnas y filas que tiene el lcd:
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print(“Iniciando…”);
 
  //Leds
  pinMode(latchPin, OUTPUT); // Inicializamos los tres pines de los leds.
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);

  //Inicializamos de los tres colores que se use el primero, 5, 6 o 7
  colores = 5;
  //Mando
  irrecv.enableIRIn(); // Inicializamos el mando

  //Servo
  //myservo.attach(2); // Inicializamos el servo
  pinMode(motorPin, OUTPUT);
  //Inicializamos la pantalla lcd
  lcd.clear();
  lcd.begin(16, 2);
 
}
void loop() {

  //Guardamos la distancia al sensor de ultrasonidos y la imprimimos en el monitor Serial.
  a=sr04.Distance();
  Serial.print(a);
  Serial.print(“cm”);

  //Mando —
  if (irrecv.decode(&results)) {  // Si recibimos una señal del mando
    translateIR(); // La traducimos
    irrecv.resume(); // recibimos el siguiente valor
  }
  //Mando —

  //Leds —
   leds = 0;  //Al ponerlo a 0 reiniciamos el registro de desplazamiento.
  updateShiftRegister();

  // Codigo nuestro de leds
  int reading  = analogRead(1); //Lectura del sensor de luz
  Serial.println(reading);
 
  if(encendidos){ //Si los leds debiesen estar encendidos
  bitSet(leds, colores); //Hacemos que luzca nuestro color elegido.
  updateShiftRegister();
    //Usando el valor recogido del sensor de ultrasonidos calculamos la distancia e iluminamos los leds de esa posicion.
    int ledsEncendidos = (a / 4);
    if(ledsEncendidos > 3)
      ledsEncendidos = 3;
   
    //En caso de que queramos encender todos los leds hasta la posición del hamster
    /*for (int i = 0; i <= ledsEncendidos; i++){
    bitSet(leds, i);
    updateShiftRegister();
    }*/
 
    //En caso de que queramos encender solamente la posición del hamster
    bitSet(leds,ledsEncendidos);
    updateShiftRegister();
   
    //En caso de que haya poca luz que se enciendan las luces blancas
    if(reading < 500){
      bitSet(leds, 4);
      updateShiftRegister();
    }
  }
  //Leds —
  int tempReading = analogRead(tempPin);
 
  double tempK = log(10000.0 * ((1024.0 / tempReading – 1)));
  tempK = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * tempK * tempK )) * tempK );       //  Temp Kelvin
  float tempC = tempK – 273.15;            // Convertimos Kelvin a Celcius
  float tempF = (tempC * 9.0)/ 5.0 + 32.0; // Convertimos Celcius a Fahrenheit
 
  // Imprimimos la temperatura en Celsius
  lcd.setCursor(0, 0);
  lcd.print(“Temp         C  “);
  lcd.setCursor(6, 0);
  lcd.print(tempC);
 
  // Imprimimos la temperatura en Fahrenheit
  lcd.setCursor(0,1);
  lcd.print(“Temp         F  “);
  lcd.setCursor(6,1);
  lcd.print(tempF);
 

  delay(1000);
 
}
// ——————— Funciones ————————–
void translateIR(){
switch(results.value) {
  case 0xFFA25D:
//POWER
        //Botón de encender y apagar luces
        if (!encendidos) {
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print(“Encendiendo”);
          lcd.setCursor(0,1);
          lcd.print(“luces”);
        } else {
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print(“Apagando”);
          lcd.setCursor(0,1);
          lcd.print(“luces”);
        }
encendidos = !encendidos;
break;
  case 0xFFE21D:
//FUNC/STOP
break;
  case 0xFF629D:
//VOL+
break;
  case 0xFF22DD:
  //FAST BACK
  break;
  case 0xFF02FD:
        EncenderMotor();
  //PAUSE
  break;
  case 0xFFC23D:
  //FAST FORWAR
  break;
  case 0xFFE01F:   //DOWN
  break;
  case 0xFFA857:
  //VOL- 
  break;
  case 0xFF906F:
  //UP 
  break;
  case 0xFF9867:
  //EQ 
  break;
  case 0xFFB04F:
  //ST/REPT 
  break;
  case 0xFF6897:
  //0
  break;
  case 0xFF30CF:
  //1 
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print(“Cambiando luces”);
  colores = 5;
   
  break;
  case 0xFF18E7:
//2
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print(“Cambiando luces”);
colores = 6;
break;
  case 0xFF7A85:
//3
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print(“Cambiando luces”);
colores = 7;
break;
  case 0xFF10EF:
//4
break;
  case 0xFF38C7:
//5 
break;
  case 0xFF5AA5:
//6
break;
  case 0xFF42BD:
//7
break;
  case 0xFF4AB5:
//8
break;
  case 0xFF52AD:
//9
break;
  case 0xFFFFFFFF:
//REPEAT
break;
      default:
        Serial.println(” other button   “);
  }

  delay(500);
}
void updateShiftRegister()
{
   digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, LSBFIRST, leds);
   digitalWrite(latchPin, HIGH);
}
void EncenderMotor(){
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Encenciendo”);
lcd.setCursor(0,1);
lcd.print(“motor”);
//Encendemos el motor y esperamos cuatro segundos
    digitalWrite(motorPin, HIGH);
    delay(4000);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(“Finalizado.”);
//Apagamos el motor
    digitalWrite(motorPin, LOW);
    delay(500);
}



6.-Problemas encontrados y soluciones

  • Hemos tenido bastantes
    problemas con el circuito, sobre todo con el uso de los registros de
    desplazamiento 74hc595. Este componente lo hemos usado en
    la pantalla LCD y para reducir en número de pines de la placa usados al
    conectar leds. Los problemas surgieron en el momento de conectarlo todo, ya que
    teníamos que estar atentos a la colocación del componente o la placa arduino se
    calentaba hasta el extremo de apagarse por seguridad.
  • También hemos tenido problemas
    con la alimentación de energía. Al usar en principio un servo nos dimos cuenta
    de que los servos y motores usan tanto amperaje que no podíamos conectarlo al
    arduino, por lo que intentamos conectarlo a la placa adicional de suministro de
    energía, pero no conseguimos de ninguna manera hacer que funcionase
    correctamente.
  • Decidimos usar un motor y
    cambiar el mecanismo de la puerta por un ventilador que se enciende y apaga por
    control del mando. Nos ocurrió el mismo problema al conectarlo a la placa
    Arduino, así que usamos el mismo módulo de energía, pero esta vez sí que
    funcionó.
  • Para el motor usamos un
    circuito con un transistor que actúa como cerradura electrónica y permite o no
    pasar la energía hacia el motor. Esto nos dio problemas ya que al principio no
    conseguíamos hacer que la energía llegase al transistor desde el pin que
    estábamos usando. Esto era debido a que solamente ciertos pines tienen la
    capacidad de transmitir energía (Los que están denominados con PWR) y nosotros
    no estábamos usando uno de esos. Tras cambiarlo conseguimos hacer que
    funcionase.
  • Cuando el motor se enciende, el
    sensor de infrarrojos del mando deja de funcionar, por lo que decidimos que el
    motor se apagase automáticamente pasado un tiempo y mientras bloquea todas las
    acciones.

7.-Mejoras.

Este circuito se puede aplicar a cualquier tipo de jaula,
como mejora, pensamos que una de mayor tamaño y con mejor diseño quedaría mas
vistosa y mas útil, ademas de tener más espacio para cables:





Podríamos añadir alguna función más pero tendríamos que
adquirir una nueva placa de Arduino, ya que ahora tiene muchas funciones y por
ejemplo, en nuestra última incorporación (el ventilador) hemos tenido que
conectar una placa a parte de batería extra. Si tuviéramos que añadir una nueva función pondríamos también un dispensador de agua que llenase
un pequeño tanque mediante una válvula que se abriese y cerrase cuando detecte
que queda poca agua.

También te podría gustar...

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *