En este ejemplo haremos un sistema de encendido lámparas y equipos eléctricos que funcionan con voltaje de red, y los controlaremos con caracteres enviados por línea serie a través del Monitor Serie del IDE de Arduino. Si usted desea leer con más detalle sobre la comunicación serie, le recomendamos el artículo ¿Qué es la comunicación serie? en nuestra página.
Para controlar artefactos con voltaje de red, usaremos las salidas normalmente abiertas de un módulo de relé. Si no conoce los módulos de relé utilizados usualmente en la línea Arduino, recomendamos leer el artículo previo de esta serie Módulos de relé y Arduino: Domótica (1).
Advertencia de seguridad
Antes de continuar con este proyecto, queremos recordarle que está tratando con la tensión de la red. Lea atentamente la siguiente advertencia de seguridad.
Advertencia: cuando realiza proyectos que están conectados a la red eléctrica, realmente debe saber lo que está haciendo, de lo contrario, puede producirse un accidente. Este es un tema serio y queremos que esté seguro. Si no está 100% seguro de lo que va a hacer, por favor no toque nada.
¡Pregúntele a alguien que sepa!
Partes necesarias
■ Módulo de 8 relés (o menos si lo desea, según la necesidad)
■ Arduino UNO
■ Cable USB
■ Cables, portalámparas, lámparas y tomacorrientes
■ Fuente de 5V 2A para alimentación de los relés
Esquemático
El sistema armado como prototipo se ve aproximadamente como en la foto que sigue:
Criterio de control
En este primer experimento hemos elegido como comandos para encender y apagar las salidas un conjunto de letras a enviar por línea serie. Para el relé 1 enviamos la letra “A” para encender, y la letra “a” para apagar. El relé 2 se enciende con la letra “B” y se apaga con la “b”. Y así sucesivamente para los 8 relés. Para apagar todo al mismo tiempo elegimos envíar un “0” (cero).
La lista de comandos es como sigue:
A – Activa el relé 1 / a – Apaga el relé 1
B – Activa el relé 2 / b – Apaga el relé 2
C – Activa el relé 3 / c – Apaga el relé 3
D – Activa el relé 4 / d – Apaga el relé 4
E – Activa el relé 5 / e – Apaga el relé 5
F – Activa el relé 6 / f – Apaga el relé 6
G – Activa el relé 7 / g – Apaga el relé 7
H – Activa el relé 8 / h – Apaga el relé 8
0 – Apaga todos los relés
Programa 1
Copie el siguiente código en su IDE de Arduino y prográmelo en su placa Arduino utilizando la opción «Subir».
Advertencia: no es conveniente cargar código nuevo cuando su Arduino
está conectado al módulo de relés. Siempre quite la alimentación de 5V a este módulo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 |
/* Control de 8 relay */ // definicion de nombres de salidas int rele1 = 2; int rele2 = 3; int rele3 = 4; int rele4 = 5; int rele5 = 6; int rele6 = 7; int rele7 = 8; int rele8 = 9; void setup() { // Pines de rele se definen como salidas pinMode(rele1,OUTPUT); pinMode(rele2,OUTPUT); pinMode(rele3,OUTPUT); pinMode(rele4,OUTPUT); pinMode(rele5,OUTPUT); pinMode(rele6,OUTPUT); pinMode(rele7,OUTPUT); pinMode(rele8,OUTPUT); // Y se inicializan en alto (rele desactivado) digitalWrite(rele1,HIGH); digitalWrite(rele2,HIGH); digitalWrite(rele3,HIGH); digitalWrite(rele4,HIGH); digitalWrite(rele5,HIGH); digitalWrite(rele6,HIGH); digitalWrite(rele7,HIGH); digitalWrite(rele8,HIGH); // Inicio de comunicacion serie para control Serial.begin(9600); } void loop() { /**************************************************************************/ while(Serial.available() == 0); // si llego un caracter por linea serie char val = Serial.read(); // lee el caracter en una variable /**************************************************************************/ // control de las salidas controlEncendido(val); } void controlEncendido(char val) { switch (val) { case 'A': digitalWrite(rele1,LOW); Serial.println("A - ACTIVAR RELAY 1"); break; case 'a': digitalWrite(rele1,HIGH); Serial.println("a - APAGAR RELAY 1"); break; case 'B': digitalWrite(rele2,LOW); Serial.println("B - ACTIVAR RELAY 2"); break; case 'b': digitalWrite(rele2,HIGH); Serial.println("b - APAGAR RELAY 2"); break; case 'C': digitalWrite(rele3,LOW); Serial.println("C - ACTIVAR RELAY 3"); break; case 'c': digitalWrite(rele3,HIGH); Serial.println("c - APAGAR RELAY 3"); break; case 'D': digitalWrite(rele4,LOW); Serial.println("D - ACTIVAR RELAY 4"); break; case 'd': digitalWrite(rele4,HIGH); Serial.println("d - APAGAR RELAY 4"); break; case 'E': digitalWrite(rele5,LOW); Serial.println("E - ACTIVAR RELAY 5"); break; case 'e': digitalWrite(rele5,HIGH); Serial.println("e - APAGAR RELAY 5"); break; case 'F': digitalWrite(rele6,LOW); Serial.println("F - ACTIVAR RELAY 6"); break; case 'f': digitalWrite(rele6,HIGH); Serial.println("f - APAGAR RELAY 6"); break; case 'G': digitalWrite(rele7,LOW); Serial.println("G - ACTIVAR RELAY 7"); break; case 'g': digitalWrite(rele7,HIGH); Serial.println("g - APAGAR RELAY 7"); break; case 'H': digitalWrite(rele8,LOW); Serial.println("H - ACTIVAR RELAY 8"); break; case 'h': digitalWrite(rele8,HIGH); Serial.println("h - APAGAR RELAY 8"); break; case '0': digitalWrite(rele1,HIGH); digitalWrite(rele2,HIGH); digitalWrite(rele3,HIGH); digitalWrite(rele4,HIGH); digitalWrite(rele5,HIGH); digitalWrite(rele6,HIGH); digitalWrite(rele7,HIGH); digitalWrite(rele8,HIGH); Serial.println("TODOS APAGADOS"); break; default: break; } } |
Colocamos entre dos hileras de asteriscos la parte del código donde se obtiene la letra de comando desde la línea serie. Reemplazando ese bloquecito de código es posible utilizar diversos métodos de ingreso de datos para comandar la placa de relés.
Por ejemplo utilizando caracteres llegados desde una placa bluetooth, por I2C o SPI desde otro microcontrolador, un módulo de interfaz RS-485, o diversos sistemas basados en RF (Wi-Fi, 2,4 GHz, etc.) o enlaces de luz infrarroja, láser, etc.
En todos los casos, la comunicación de control se basará en caracteres de control ingresados por TX/RX u otro medio similar de comunicación de caracteres, incluyendo una entrada paralela de 8 bits implementada por un puerto o con el uso de un chip auxiliar, y convertidos en una variable char (cuando es necesario).
El resto del código será siempre el mismo, la función con la estructura Switch…Case.
Por supuesto, usted puede iniciar sus pruebas con un circuito más sencillo, como el que sigue:
Todas las diferentes opciones de control las desarrollamos en detalle en la serie de artículos que siguen en la secuencia de publicación.
Programa 2
En esta modificación de programa utilizamos una opción que nos permite usar una única letra de comando para encender y apagar. El «truco» consiste en alternar el estado del relé de encendido a apagado en cada recepción de la letra, utilizando una operación lógica NOT, que se representa con el símbolo !
Criterio de control
En este caso la lista de comandos es como sigue:
a – Activa el relé 1 / a apaga el relé 1 al pulsar de nuevo
b – Activa el relé 2 / b apaga el relé 2 al pulsar de nuevo
c – Activa el relé 3 / c apaga el relé 3 al pulsar de nuevo
d – Activa el relé 4 / d apaga el relé 4 al pulsar de nuevo
e – Activa el relé 5 / e apaga el relé 5 al pulsar de nuevo
f – Activa el relé 6 / f apaga el relé 6 al pulsar de nuevo
g – Activa el relé 7 / g apaga el relé 7 al pulsar de nuevo
h – Activa el relé 8 / h apaga el relé 8 al pulsar de nuevo
0 – Apaga todos los relés
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 |
/* Control de 8 rele con opcion de alternado */ // definicion de nombres de salidas int rele1 = 2; int rele2 = 3; int rele3 = 4; int rele4 = 5; int rele5 = 6; int rele6 = 7; int rele7 = 8; int rele8 = 9; void setup() { // Pines de rele se definen como salidas pinMode(rele1,OUTPUT); pinMode(rele2,OUTPUT); pinMode(rele3,OUTPUT); pinMode(rele4,OUTPUT); pinMode(rele5,OUTPUT); pinMode(rele6,OUTPUT); pinMode(rele7,OUTPUT); pinMode(rele8,OUTPUT); // Y se inicializan en alto (rele desactivado) digitalWrite(rele1,HIGH); digitalWrite(rele2,HIGH); digitalWrite(rele3,HIGH); digitalWrite(rele4,HIGH); digitalWrite(rele5,HIGH); digitalWrite(rele6,HIGH); digitalWrite(rele7,HIGH); digitalWrite(rele8,HIGH); // Inicio de comunicacion serie para control Serial.begin(9600); } void loop() { /**************************************************************************/ while(Serial.available() == 0); // si llego un caracter por linea serie char val = Serial.read(); // lee el caracter en una variable /**************************************************************************/ // control de las salidas controlEncendido(val); } // mantenemos el comando con letras "a"-"h" por si es necesario controlar // más de 10 reles, como el caso de los modulos de 16. Si usted lo desea // y le resulta practico puede cambiar los caracteres por "1" a "8". void controlEncendido(char val) { int valor = 0; switch (val) { case 'a': valor = !digitalRead(rele1); digitalWrite(rele1,valor); if (valor == HIGH) Serial.println("RELE 1 apagado"); else Serial.println("RELE 1 activo"); break; case 'b': valor = !digitalRead(rele2); digitalWrite(rele2,valor); if (valor == HIGH) Serial.println("RELE 2 apagado"); else Serial.println("RELE 2 activo"); break; case 'c': valor = !digitalRead(rele3); digitalWrite(rele3,valor); if (valor == HIGH) Serial.println("RELE 3 apagado"); else Serial.println("RELE 3 activo"); break; case 'd': valor = !digitalRead(rele4); digitalWrite(rele4,valor); if (valor == HIGH) Serial.println("RELE 4 apagado"); else Serial.println("RELE 4 activo"); break; case 'e': valor = !digitalRead(rele5); digitalWrite(rele5,valor); if (valor == HIGH) Serial.println("RELE 5 apagado"); else Serial.println("RELE 5 activo"); break; case 'f': valor = !digitalRead(rele6); digitalWrite(rele6,valor); if (valor == HIGH) Serial.println("RELE 6 apagado"); else Serial.println("RELE 6 activo"); break; case 'g': valor = !digitalRead(rele7); digitalWrite(rele7,valor); if (valor == HIGH) Serial.println("RELE 7 apagado"); else Serial.println("RELE 7 activo"); break; case 'h': valor = !digitalRead(rele8); digitalWrite(rele8,valor); if (valor == HIGH) Serial.println("RELE 8 apagado"); else Serial.println("RELE 8 activo"); break; case '0': digitalWrite(rele1,HIGH); digitalWrite(rele2,HIGH); digitalWrite(rele3,HIGH); digitalWrite(rele4,HIGH); digitalWrite(rele5,HIGH); digitalWrite(rele6,HIGH); digitalWrite(rele7,HIGH); digitalWrite(rele8,HIGH); Serial.println("TODOS APAGADOS"); break; default: break; } } |
Artículos relacionados:
■ Módulos de relé y Arduino: Domótica (1)
■ Control con relés por interfaz serie: Domótica (2)
■ Control de relés con control remoto IR: Domótica (3)
■ Control de relés por enlace de 2,4 GHz – módulos NRF24L01: Domótica (4)
■ Descripción y funcionamiento del Bus I2C
■ ¿Qué es la comunicación serie?
Pingback: Módulos de relé y Arduino: Domótica (1) | Robots Didácticos
Pingback: Control de relés con control remoto IR: Domótica (3) | Robots Didácticos
Pingback: Control de relés por enlace de 2,4 GHz – módulos NRF24L01 (Domótica 4) | Robots Didácticos