Sistema de encendido de luces dual de 8 canales, por infrarrojos y pulsadores

En este tutorial armaremos un sistema de encendido de luces dual, ya que podemos controlar el encendido y pagado mediante un control remoto por infrarrojos, y también por medio de 8 pulsadores. Usaremos un módulo relay de 8 canales, un arduino nano, un módulo receptor infrarrojos, un pcb fabricado en pcbway, y otros componentes electrónicos. Armaremos el circuito, analizaremos paso a paso el código fuente y finalmente probaremos todo el funcionamiento del sistema.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas

Materiales

Un Arduino nano

El Arduino Nano es una placa pequeña, completa y compatible con la placa de pruebas basada en el ATmega328 (Arduino Nano 3.x). Tiene más o menos la misma funcionalidad del Arduino Duemilanove, pero en un paquete diferente. Solo carece de un conector de alimentación de CC y funciona con un cable USB Mini-B en lugar de uno estándar.

Diagrama de pines

Pines hembra

Un zócalo para el arduino nano

Módulo relay de 8 canales

Características

Permite controlar el encendido/apagado de equipos de alta potencia (electrodomésticos). Funciona perfectamente con Arduino, Pic o cualquier otro sistema digital.

Dentro de la gran variedad de proyectos que podemos realizar con Arduino, podemos llegar a desear controlar componentes de alto voltaje o alto amperaje, como bombillas o bombas de agua, los cuales no pueden ser manejados directamente con Arduino. En estos casos es necesario utilizar Relays o Reles, estos dispositivos permiten controlar cargas de alto voltaje con una señal pequeña.

El modulo posee 8 Relays de alta calidad, capaces de manejar cargas de hasta 250V/10A. Cada canal posee aislamiento eléctrico por medio de un optoacoplador y un led indicador de estado. Su diseño facilita el trabajo con Arduino, al igual que con muchos otros sistemas como Raspberry Pi, ESP8266 (NodeMCU y Wemos), Teensy y Pic. Este modulo Relay activa la salida normalmente abierta (NO: Normally Open) al recibir un “0” lógico (0 Voltios) y desactiva la salida con un “1” lógico (5 voltios). Para la programación de Arduino y Relays se recomienda el uso de timers con la función “millis()” y de esa forma no utilizar la función “delay” que impide que el sistema continue trabajando mientras se activa/desactiva un relay.

Entre las cargas que se pueden manejar tenemos: bombillas de luz, luminarias, motores AC (220V), motores DC, solenoides, electroválvulas, calentadores de agua y una gran variedad de actuadores más. Se recomienda realizar y verificar las conexiones antes de alimentar el circuito, también es una buena práctica proteger el circuito dentro de un case.

Datos técnicos

8 canales independientes

8 Relevadores (Relays) de 1 polo 2 tiros

El voltaje de la bobina del relé es de 5 VDC

Led indicador para cada canal (enciende cuando la bobina del relé esta activa)

Activado mediante corriente: el circuito de control debe proveer una corriente de 15 a 20 mA

Puede controlado directamente por circuito lógicos

Terminales de conexión de tornillo (clemas)

Terminales de entrada de señal lógica con headers macho de 0.1″.

Puede controlado directamente por circuito lógicos

Alimentación y consumo

La forma mas sencilla de alimentar este módulo es desde Vcc y GND de la placa Arduino, manteniendo el Jumper en su lugar, con lo que JD-Vcc = Vcc. Esta conexión tiene dos limitaciones importantes:

Se pierde la aislación eléctrica que brindan los optoacopladores, lo que aumenta la posibilidad de daño al Arduino si hay algún problema con las cargas de los relés.

La corriente consumida por las bobinas de los relés debe ser provista por la placa Arduino. Cada bobina consume unos 90 mA y las cuatro juntas suman 360 mA. Si a esto le sumamos los consumos que pueden tener otras salidas, estamos muy cerca de los 500 mA que puede suministrar un puerto USB. En este caso se debería alimentar al Arduino con una fuente externa, lo que aumenta el limite de corriente a 1 A (en el caso de la Arduino UNO).

La forma mas segura es remover el jumper y alimentar la placa de relés con dos fuentes: la de la placa Arduino conectada a Vcc y una segunda fuente, con el positivo a JD-Vcc y el negativo a GND, sin estar éste unido a la placa Arduino. Esta conexión tiene como ventajas:

Hay completa aislación entre la carga y el Arduino.

Todo el consumo de los relés es tomado de la segunda fuente y no del Arduino o el puerto USB.

Entradas

Las entradas a la placa pueden conectarse directamente a las salidas digitales de la placa Arduino. La única precaución a tener en cuenta es que cuando Arduino arranca al ser alimentado, los pines se configuran como entradas automáticamente y puede ocurrir que, por un brevísimo lapso de tiempo entre el arranque y la correcta configuración de estos pines como salidas, las entradas de control al módulo de relé queden en un estado indeterminado. Esto se puede evitar conectando en cada entrada un pull-up con una resistencia de 10K a Vcc, lo que asegura un estado ALTO durante el arranque.

Pines macho

Módulo receptor infrarrojo ky-022

Tamaño: 6.4 * 7.4 * 5.1MM, ángulo de aceptación 90 °, voltaje de trabajo 2.7-5.5V.
Frecuencia 37.9KHZ, recibiendo la distancia 18 m.

Rechazo de luz diurna hasta 500LUX, capacidad de interferencia electromagnética, IC dedicado de infrarrojos incorporado.
Ampliamente utilizado: estéreo, TV, VCR, CD, decodificadores, marco de fotos digital, audio para el automóvil, juguetes de control remoto, receptores de satélite, disco duro, aire acondicionado, calefacción, ventiladores, iluminación y otros electrodomésticos.

Pinout:

1 …. GND (-)

2 …. + 5V

3 …. Salida (S)

Ocho pulsadores

Un pcb

Descargar –> Control de luces de 8 canales por infrarrojo

Código Fuente

//Más proyectos en www.rogerbit.com
#include <IRremote.h>
#define RECV_PIN 2 //indicamos el pin por el que recibimos los datos del 
//sensor TSOP1838
IRrecv irrecv(RECV_PIN);
decode_results results;
int estadoBoton11 = 0;
int estadoBoton12 = 0;
int estadoBotonA5 = 0;
int estadoBotonA0 = 0;
int estadoBotonA1 = 0;
int estadoBotonA2 = 0;
int estadoBotonA3 = 0;
int estadoBotonA4 = 0;

int estado11 = 0;
int estado12 = 0;
int estadoA5 = 0;
int estadoA0 = 0;
int estadoA1 = 0;
int estadoA2 = 0;
int estadoA3 = 0;
int estadoA4 = 0;
//Pulsadores
int botonPin11 =11; 
int botonPin12 =12;
int botonPinA5 =A5;
int botonPinA0 =A0;
int botonPinA1 =A1;
int botonPinA2 =A2;
int botonPinA3 =A3;
int botonPinA4 =A4;
void setup()
{
     Serial.begin(9600);//Velocidad del puerto
     //Definimos estos pines como salidas
     pinMode(3,OUTPUT);  
     pinMode(4,OUTPUT);  
     pinMode(5,OUTPUT); 
     pinMode(6,OUTPUT); 
     pinMode(7,OUTPUT); 
     pinMode(8,OUTPUT); 
     pinMode(9,OUTPUT); 
     pinMode(10,OUTPUT);
     //Ponemos en estado Alto todas las salidas 
     digitalWrite(3,HIGH);
     digitalWrite(4,HIGH);
     digitalWrite(5,HIGH);
     digitalWrite(6,HIGH);
     digitalWrite(7,HIGH);
     digitalWrite(8,HIGH);
     digitalWrite(9,HIGH);
     digitalWrite(10,HIGH);
     //Definimos estos pines como entrdas para los pulsadores
     pinMode(botonPin11, INPUT_PULLUP);
     pinMode(botonPin12, INPUT_PULLUP);
     pinMode(botonPinA5, INPUT_PULLUP);
     pinMode(botonPinA0, INPUT_PULLUP);
     pinMode(botonPinA1, INPUT_PULLUP);
     pinMode(botonPinA2, INPUT_PULLUP);
     pinMode(botonPinA3, INPUT_PULLUP);
     pinMode(botonPinA4, INPUT_PULLUP);
     irrecv.enableIRIn(); // Iniciamos la recepcion
}
void loop()
{
//Si tenemos datos de lectura debido a que se pulsa una tecla en el mando
   if (irrecv.decode(&results))
    {
//Mostramos por puerto serie dicho codigo en Hexadecimal(para depuracion)
   Serial.print("Codigo: 0x") ;
   Serial.println(results.value,HEX) ;
//Pin 3 arduino IN1 en módulo relay de 8 canales
if(results.value==0x2B||results.value==0x82B)//Apagado
   {
 digitalWrite(3,HIGH);
 estado11 = 0;
        }
        
if(results.value==0x2A||results.value==0x82A)//Encendido
   {
 digitalWrite(3, LOW);
 estado11 = 1;
        }   
//Pin 4 arduino IN2 en módulo relay de 8 canales
if(results.value==0x23||results.value==0x823)//Apagado
   {
 digitalWrite(4,HIGH);
 estado12 = 0;
        }
        
if(results.value==0x27||results.value==0x827)//Encendido
   {
 digitalWrite(4, LOW);
 estado12 = 1;
        }
//Pin 5 arduino IN3 en módulo relay de 8 canales
if(results.value==0xB||results.value==0x80B)//Apagado
   {
 digitalWrite(5,HIGH);
 estadoA5 = 0;
   }   

if(results.value==0x3D||results.value==0x83D)//Encendido
   {
 digitalWrite(5,LOW);
 estadoA5 = 1;
   }
//Pin 6 arduino IN4 en módulo relay de 8 canales
if(results.value==0x30||results.value==0x830)//Apagado
   {
 digitalWrite(6,HIGH);
  estadoA0 = 0;
   }   

if(results.value==0x2F||results.value==0x82F)//Encendido
   {
 digitalWrite(6,LOW);
  estadoA0 = 1;
   }
//Pin 7 arduino IN5 en módulo relay de 8 canales
if(results.value==0x33||results.value==0x833)//Apagado
   {
 digitalWrite(7,HIGH);
  estadoA1 = 0;
   }   

if(results.value==0x31||results.value==0x831)//Encendido
   {
 digitalWrite(7,LOW);
   estadoA1 = 1;
   }   
//Pin 8 arduino IN6 en módulo relay de 8 canales
if(results.value==0x21||results.value==0x821)//Apagado
   {
 digitalWrite(8,HIGH);
  estadoA2 = 0;
   }   

if(results.value==0x20||results.value==0x820)//Encendido
   {
 digitalWrite(8,LOW);
  estadoA2 = 1;
   } 
//Pin 9 arduino IN7 en módulo relay de 8 canales
if(results.value==0x24||results.value==0x824)//Apagado
   {
 digitalWrite(9,HIGH);
  estadoA3 = 0;
   }   

if(results.value==0xE||results.value==0x80E)//Encendido
   {
 digitalWrite(9,LOW);
  estadoA3 = 1;
   } 
//Pin 10 arduino IN8 en módulo relay de 8 canales
if(results.value==0x11||results.value==0x811)//Apagado
   {
 digitalWrite(10,HIGH);
  estadoA4 = 0;
   }   

if(results.value==0x10||results.value==0x810)//Encendido
   {
 digitalWrite(10,LOW);
  estadoA4 = 1;
   } 
irrecv.resume(); // Recibimos el siguiente valor del sensor
}
delay(100);//Retardo antirrebote para los pulsadores
estadoBoton11 = digitalRead(botonPin11);//Leemos el pulsador para ver su estado
estadoBoton12 = digitalRead(botonPin12);//Leemos el pulsador para ver su estado
estadoBotonA5 = digitalRead(botonPinA5);//Leemos el pulsador para ver su estado
estadoBotonA0 = digitalRead(botonPinA0);//Leemos el pulsador para ver su estado
estadoBotonA1 = digitalRead(botonPinA1);//Leemos el pulsador para ver su estado
estadoBotonA2 = digitalRead(botonPinA2);//Leemos el pulsador para ver su estado
estadoBotonA3 = digitalRead(botonPinA3);//Leemos el pulsador para ver su estado
estadoBotonA4 = digitalRead(botonPinA4);//Leemos el pulsador para ver su estado
  //Llama a una función
if (estadoBoton11 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luz11();
 }
 //Llama a una función
if (estadoBoton12 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luz12();
 }

 //Llama a una función
if (estadoBotonA5 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luzA5();
 }
 //Llama a una función
if (estadoBotonA0 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luzA0();
 }

 //Llama a una función
if (estadoBotonA1 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luzA1();
 } 

 //Llama a una función
if (estadoBotonA2 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luzA2();
 }

 //Llama a una función
if (estadoBotonA3 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luzA3();
 } 

 //Llama a una función
if (estadoBotonA4 == LOW) {//Si el pulsador está precionado se cumple esta condición
  luzA4();
 } 
 
}
//Función para encender la luz con el botón
void luz11(){
if(estado11 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(3, LOW);// Encendemos el relay
estado11 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(3, HIGH);//Apagamos el relay
 estado11 = 0;
  }
while(estadoBoton11 == LOW){
estadoBoton11 = digitalRead(11);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }

//Función para encender la luz con el botón
void luz12(){
if(estado12 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(4, LOW);// Encendemos el relay
estado12 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(4, HIGH);//Apagamos el relay
 estado12 = 0;
  }
while(estadoBoton12 == LOW){
estadoBoton12 = digitalRead(12);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }

//Función para encender la luz con el botón
void luzA5(){
if(estadoA5 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(5, LOW);// Encendemos el relay
estadoA5 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(5, HIGH);//Apagamos el relay
 estadoA5 = 0;
  }
while(estadoBotonA5 == LOW){
estadoBotonA5 = digitalRead(A5);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }

void luzA0(){
if(estadoA0 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(6, LOW);// Encendemos el relay
estadoA0 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(6, HIGH);//Apagamos el relay
 estadoA0 = 0;
  }
while(estadoBotonA0 == LOW){
estadoBotonA0 = digitalRead(A0);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }

//Función para encender la luz con el botón
void luzA1(){
if(estadoA1 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(7, LOW);// Encendemos el relay
estadoA1 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(7, HIGH);//Apagamos el relay
 estadoA1 = 0;
  }
while(estadoBotonA1 == LOW){
estadoBotonA1 = digitalRead(A1);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }  

//Función para encender la luz con el botón
void luzA2(){
if(estadoA2 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(8, LOW);// Encendemos el relay
estadoA2 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(8, HIGH);//Apagamos el relay
 estadoA2 = 0;
  }
while(estadoBotonA2 == LOW){
estadoBotonA2 = digitalRead(A2);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }

//Función para encender la luz con el botón
void luzA3(){
if(estadoA3 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(9, LOW);// Encendemos el relay
estadoA3 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(9, HIGH);//Apagamos el relay
 estadoA3 = 0;
  }
while(estadoBotonA3 == LOW){
estadoBotonA3 = digitalRead(A3);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }

//Función para encender la luz con el botón
void luzA4(){
if(estadoA4 ==0){//Si la variable estado es igual a 0 se cumple esta condición
digitalWrite(10, LOW);// Encendemos el relay
estadoA4 = 1;//Asignamos el valor 1 a la variable "estado"
} else{
 digitalWrite(10, HIGH);//Apagamos el relay
 estadoA4 = 0;
  }
while(estadoBotonA4 == LOW){
estadoBotonA4 = digitalRead(A4);//Se cumple esta condición mientras esté precionado el botón   
  }  
  }

PROYECTO RECOMENDADO