Jaula Domótica. Grupo 7

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

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

Ventilador (pin: 3)

#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);
}

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