RELEVADORES

Objetivo:

Realizar una interface gráfica que me permita encender y apagar una serie de focos desde mi

computadora, introduciendo así al lector a la domótica.

Hacer uso de la paleta Formula Node de LabVIEW.

Introducción:

¿Qué es un relevador?

El relevador, también conocido como relé o relay, es un dispositivo electromecánico que funciona

como un interruptor controlado desde un circuito eléctrico en el que, por medio de una bobina y un

electroimán, se acciona un juego de uno o varios contactos que permiten abrir o cerrar otros

circuitos eléctricos independientes.

Fue inventado en 1835 por Joseph Henry.

¿Cómo funciona un relevador?

Como ya se mencionó, el relevador cuenta con una bobina y un electroimán estos, al ser energizados

accionan el mecanismo de los contactos.

Lo que hace la bobina es crear un campo magnético que lleva a los contactos a establecer una

conexión. El electroimán mueve a la armadura excitada, permitiendo el cierre de los contactos. De

esta forma, el relevador actúa como un interruptor que puede fomentar el paso de la corriente

eléctrica o su interrupción.

Existen dos estados principalmente en un relevador, normalmente abierto (N.A.) o, normalmente

cerrado (N.C.), esto es, si mi relevador es normalmente abierto, quiere decir que sin excitar la bobina

los contactos del relevador están desconectados entre sí y, al introducir un voltaje cierra la conexión

de los contactos, mientras que, si es normalmente cerrado, los contactos del relevador están

conectados entre sí sin necesidad de introducir un voltaje a la bobina, y cuando se excita la bobina,

se abre la conexión de los contactos desconectándolos.

Material:

1 Placa Arduino UNO.

4 Relevadores de un polo, dos tiros y bobina de 5Vcc.

4 Sockets para foco.

4 Focos (Pueden ser incandescentes o fluorescentes).

1 Clavija.

Cable AWG 12.

Desarrollo:

Comenzaremos por realizar las conexiones eléctricas.

Los pines que vamos a usar de nuestra placa Arduino UNO son: 5, 6, 7 y 8 digitales, los cuales vamos

a usar como salidas, estos pines serán los que exciten la bobina y cierren los contactos.

1. Conectamos el cable AWG 12 a la salida de mi clavija.

2. El cable de neutro, proveniente de mi clavija, lo conectaremos a un pin correspondiente al

neutro de los sockets.

3. Nuestro relevador cuenta con cinco pines, dos de ellos son los que excitan la bobina, dos

pines para cerrar el circuito y un pin común. En nuestro relevador se presentan los dos

estados, normalmente abierto y normalmente cerrado, es por eso que necesitamos

identificar los pines a usar, pues el estado normalmente cerrado no se usara.

3.1. Usaremos nuestro multímetro para identificar los pines del relevador. En nuestro

relevador, se tienen, por lo general tres pines continuos, el pin del centro es el común,

mientas que los de los extremos son los pines de la bobina, se puede saber si esto es

verdad, con la opción de resistencia en nuestro multímetro, dándonos como resultado

una resistencia X o, usando la opción de continuidad, visualizaremos en el display de

nuestro multímetro que existe una continuidad.

3.2. Los pines del lado opuesto, son los pines normalmente abierto y normalmente cerrado,

ahora con la opción de continuidad de nuestro multímetro, usaremos el común (pin

sobrante de la prueba anterior) y mediremos continuidad con cada uno de los otros

pines, dándome un pitido en el pin normalmente cerrado y no dándome ningún

resultado con el normalmente abierto.

3.3. Como resultado podemos obtener algo así.

Imagen 1

4. Una vez identificados los pines de nuestro relevador (ver imagen 1), procederemos a

conectarlo a nuestra placa Arduino UNO.

4.1. Del puerto digital número 5 de nuestro Arduino, conectaremos un diodo en dirección

del flujo de corriente (polarizado en directa).

4.2. A la salida del diodo se conectara el pin 1 (pin de la bobina) del relevador.

4.3. El pin 2, de nuestro relé, se conectara a GND de Arduino.

5. El pin 4 del relevador, es conectado al cable de Línea de la clavija.

6. Conectamos el pin 5 (pin normalmente abierto) del relevador a la otra parte del socket.

7. Repetimos los dos pasos anteriores para los otros tres relevadores, teniendo en cuenta que

las salidas digitales a usar para el resto de los relevadores son 6, 7 y 8 de nuestro Arduino

UNO.

A continuación se muestra el diagrama de conexiones.

Imagen 2

Desarrollo de la interface.

1. Abrimos LabVIEW.

2. Damos click en Create Project.

3. Click en Blank VI.

4. Como en todos los programas que hemos creado y usado el microcontrolador Arduino UNO,

cargamos primeramente el archivo LIFA en nuestra placa Arduino.

4.1. Abrir la consola de Arduino, Seleccionar Archivo y Abrir.

4.2. Seleccionar la carpeta LIFA_Base y después el archivo LIFA_Base.ino

4.3. Cargar el archivo para la comunicación entre Arduino y LabVIEW.

5. Configurar Arduino seleccionando el bloque Init al que se le asignan los parámetros:

Puerto de comunicación.

Velocidad de Transmisión.

Tipo de tarjeta Arduino.

Numero de bits de los paquetes de comunicación.

Tipo de puerto de comunicación.

Nota: No olvidar que estos parámetros a excepción del puerto de comunicación los asume

por defecto el sistema, es decir que si no los ponemos el sistema los toma con valores

predefinidos y puede llegar a no funcionar.

6. A continuación se coloca una estructura de tipo “While loop” seleccionando

(Programming -> Structures -> While Loop).

Diagrama de bloques.

7. Colocar la orden para romper el bucle, para ello ir al panel de control y colocar un botón Stop

(Silver -> Boolean –> Stop Button)

Y conectarlo a su correspondiente control.

8. Configurar los pines 5, 6, 7 y 8 de Arduino como salidas, haciendo uso del bloque Set Digital Pin

Mode (Arduino -> Low Level -> Set Digital Pin Mode).

8.1. Se seleccionan cuatro bloques.

8.2. Y les asignamos el número de pin así como la forma en que va a ser usado.

Para asignar el número de pin y el modo de operación basta con ponerse sobre el bloque

con la herramienta de edición en modo “wire” y pulsando el botón derecho del

ratón, podemos seleccionar el número del pin, añadiéndolo con la opción Create ->

Constant.

De manera similar seleccionamos la forma en que va a ser usado, si como salida o como

entrada, en nuestro caso queremos que se use como salida.

9. Conectamos Arduino Init y los pines a usar.

10. En el panel frontal, agregamos cuatro botones y los renombramos. Estos botones serán los que

encenderán y apagaran nuestros focos

Para agregarlos damos click en Silver -> Boolean -> Push Button.

Para renombrarlos basta con darle doble click sobre su nombre por default para poder

modificarlo. Para fines prácticos y por ser una introducción a la domótica se les asigno el nombre

de Hab1, Hab2, Hab3 y Hab4, refiriéndonos a cuatro habitaciones.

Panel Frontal

Diagrama de Bloques

11. En el diagrama de bloques, arrastramos los “Push Button” dentro de la estructura “While”

12. Nuevamente nos posicionamos en el panel frontal e introduciremos cuatro leds, que serán mis

indicadores de que foco estoy encendiendo, por lo que los voy a renombrar como Habitación 1,

Habitación 2, Habitación 3 y Habitación 4.

En la paleta Silver -> Boolean -> LED (Silver.

Panel Frontal

Diagrama de Bloques

13. Al igual que con los botones, colocaremos los leds dentro de la estructura While.

Diagrama de Bloques

14. En el diagrama de bloques, dentro del ciclo While, colocaremos una estructura Formula Node

.

La estructura Formula Node, evalúa fórmulas matemáticas y expresiones similares a lenguaje C,

introduciendo líneas de código.

En la paleta Programming -> Structures -> Formula Node

Diagrama de Bloques

15. Antes de comenzar a introducir las líneas de código dentro de Formula Node, nos

posicionaremos dentro del ciclo While y creamos un arreglo booleano con la función Build Array

y los botones que introducimos anteriormente.

En la paleta Programming -> Array -> Build Array

15.1. Conectamos todos nuestros Push Button a las entradas de Build Array. Inicialmente

Nuestro Build Array aparecerá de la siguiente forma , basta con seleccionarlo y

posicionarnos por debajo de éste, cuando la señalización siguiente aparezca

basta con arrastrarlo hacia abajo para crear más entradas .

15.2. Conectamos los botones a las entradas del Build Array.

Diagrama de bloques

16. Convertiremos la salida del Build Array creado en un dato numérico, para esto haremos uso de

la función Array to Num y conectaremos la salida del Build Array a la entrada de

éste.

Nota: Aquí es importante recordar como pasar de datos binarios a decimales, pues la salida que

obtengo al convertir mi arreglo booleano servirá para crear el programa dentro de Formula

Node, si no lo recordamos, se recomienda visualizar los datos que me esta entregando.

En este caso, tenemos cuatro botones, que lo que hacen en dar un estado Alto (1 binario) o un

estado Bajo (0 binario), podemos hablar entonces de 4bits. Recordamos que:

Binario Decimal

0000 0

0001 1

0010 2

0011 3

0100 4

0101 5

0110 6

0111 7

1000 8

1001 9

1010 10

1011 11

1100 12

1101 13

1110 14

1111 15

Con esta tabla sabemos el dato que se va a obtener al oprimir uno o varios botones.

Si oprimimos el primer botón obtengo un 1 a la salida, si apago ese botón y enciendo el 4,

obtendré un 8 como dato de salida.

17. Nos posicionamos ahora sobre el contorno de la estructura Formula Node, dando click con el

botón derecho del mouse aparecerán una serie de opciones, nosotros le daremos click en Add

Inputs.

17.1. Dando doble click sobre la entrada creada en mi Formula Node, podemos darle

nombre a ésta variable, nosotros le llamaremos a.

17.2. Ahora conectaremos la salida de dato numérico obtenido del arreglo booleano a la

entrada la variable a.

Y vemos que esta cambia de color a azul.

18. De una manera similar ahora agregamos cuatro salidas a mi Formula Node, las cuales

llamaremos o1, o2, o3 y o4.

19. Introducimos el siguiente código dentro de la estructura Formula Node.

int o1;

int o2;

int o3;

int o4;

o1 = 0;

o2 = 0;

o3 = 0;

o4 = 0;

switch(a)

{

case 1: o1 = 255, o2 = o3 = o4 = 0; break;

case 2: o2 = 255, o1 = o3 = o4 = 0; break;

case 3: o1 = o2 = 255, o3 = o4 = 0; break;

case 4: o3 = 255, o1 = o2 = o4 = 0; break;

case 5: o1 = o3 = 255, o2 = o4 = 0; break;

case 6: o2 = o3 = 255, o1 = o4 = 0; break;

case 7: o1 = o2 = o3 = 255, o4 = 0; break;

case 8: o4 = 255, o1 = o2 = o3 = 0; break;

case 9: o1 = o4 = 255, o2 = o3 = 0; break;

case 10: o2 = o4 = 255, o1 = o3 = 0; break;

case 11: o1 = o2 = o4 = 255, o3 = 0; break;

case 12: o3 = o4 = 255, o1 = o2 = 0; break;

case 13: o1 = o3 = o4 = 255, o2 = 0; break;

case 14: o2 = o3 = o4 = 255, o1 = 0; break;

case 15: o1 = o2 = o3 = o4 = 255; break;

default: o1 = o2 = o3 = o4 = 0; break;

}

Descripción del código:

int o1; //Declaramos una variable entera o1.

int o2; //Declaramos una variable entera o2.

int o3; //Declaramos una variable entera o3.

int o4; //Declaramos una variable entera o4.

o1 = 0; //Inicializamos la variable o1 igual a 0.

o2 = 0; //Inicializamos la variable o2 igual a 0.

o3 = 0; //Inicializamos la variable o3 igual a 0.

o4 = 0; //Inicializamos la variable o4 igual a 0.

switch(a) //Realizamos una estructura case donde pregunto, si a es igual a X, has tal cosa, si

es igual a Y, otra cosa, etc.

{

case 1: o1 = 255, o2 = o3 = o4 = 0; break; //Para el caso cuando a es igual a 1, quiere decir

que quiero encender el primer foco, pero mantener apagado los demás, es por eso que o1 es

igual a 255 y o2, o3, o4 es igual a 0. El 255 es porque en el toolkin de Arduino para LabVIEW

podemos tener salidas con un PWM, recordemos que estos pines son 3, 5, 6, 9, 10 y 11, sin

embargo las salidas digitales normales y las PWM se escriben con el mismo bloque, lo que

estoy escribiendo entonces es el total de ancho de pulso para la salida digital de Arduino.

case 2: o2 = 255, o1 = o3 = o4 = 0; break; //Para el caso cuando a es igual a 2, quiere decir

que quiero encender el segundo foco, pero mantener apagado los demás, es por eso que o2 es

igual a 255 y o1, o3, o4 es igual a 0.

case 3: o1 = o2 = 255, o3 = o4 = 0; break; //Para el caso cuando a es igual a 3, quiere decir

que quiero encender el primer y segundo foco, pero mantener apagado los demás, es por eso

que o1 y o2, son iguales a 255 y o3, o4 es igual a 0.

case 4: o3 = 255, o1 = o2 = o4 = 0; break; //Para el caso cuando a es igual a 4, quiere decir

que quiero encender el tercer foco, pero mantener apagado los demás.

case 5: o1 = o3 = 255, o2 = o4 = 0; break; //Para el caso cuando a es igual a 5, quiere decir

que quiero encender el primer y tercer foco, pero mantener apagado los demás.

case 6: o2 = o3 = 255, o1 = o4 = 0; break; //Para el caso cuando a es igual a 6, quiere decir

que quiero encender el segundo y tercer foco, pero mantener apagado los demás.

case 7: o1 = o2 = o3 = 255, o4 = 0; break; //Para el caso cuando a es igual a 7, quiere decir

que quiero encender el primer, segundo y tercer foco, pero mantener apagado el cuarto.

case 8: o4 = 255, o1 = o2 = o3 = 0; break; //Para el caso cuando a es igual a 8, quiere decir

que quiero encender el cuarto foco, pero mantener apagado los demás.

case 9: o1 = o4 = 255, o2 = o3 = 0; break; //Para el caso cuando a es igual a 9, quiere decir

que quiero encender el primer y cuarto foco, pero mantener apagado los demás.

case 10: o2 = o4 = 255, o1 = o3 = 0; break; //Para el caso cuando a es igual a 10, quiere decir

que quiero encender el segundo y tercer foco, pero mantener apagado los demás.

case 11: o1 = o2 = o4 = 255, o3 = 0; break; //Para el caso cuando a es igual a 11, quiere decir

que quiero encender el primer, segudundo y cuarto foco, pero mantener apagado el tercero.

case 12: o3 = o4 = 255, o1 = o2 = 0; break; //Para el caso cuando a es igual a 12, quiere decir

que quiero encender el tercer y cuarto foco, pero mantener apagado los demás.

case 13: o1 = o3 = o4 = 255, o2 = 0; break; //Para el caso cuando a es igual a 13, quiere decir

que quiero encender el primer, tercero y cuarto foco, pero mantener apagado el segundo.

case 14: o2 = o3 = o4 = 255, o1 = 0; break; //Para el caso cuando a es igual a 14, quiere decir

que quiero encender el segundo, tercero y cuarto foco, pero mantener apagado el primero.

case 15: o1 = o2 = o3 = o4 = 255; break; //Para el caso cuando a es igual a 15, quiere decir

que quiero encender todos los focos.

default: o1 = o2 = o3 = o4 = 0; break; //El valor por default es apagar todos los focos.

}

Inmediatamente vemos que las salidas cambian de color a azul.

20. Ahora dentro del ciclo While colocamos el bloque Digital Write Pin , este bloque es el que escribe los valores en las salidas físicas de Arduino. (Arduino –> Low Level –> Digital Write Pin).

En Digital Write Pin se escriben los pines en donde se conectan nuestros relevadores,

así como la Modulación por Ancho de Pulso (PWM), que en nuestro caso será 255.

21. Introducimos el número de pin de se va a usar, los ya declarados al inicio del proyecto, 5, 6, 7 y

8. Y conectamos los bloques entre si y a su respectiva entrada.

22. Las entradas PWM de cada bloque serán las salidas o1, o2, o3 y 04 de la estructura Formula

Node.

23. Conectamos los leds a sus respectivos botones.

24. Ahora debemos cerrar la comunicación con el Arduino, ingresamos el bloque Close

Arduino -> Close.

25. Conectamos los bloques.

26. Como nos damos cuenta, desde el inicio del programa vamos teniendo una línea de error (línea

amarilla), esta línea, la usaremos para detener el programa en caso de error. Para eso usaremos

el bloque Unbundle By Name.

Unbundle By Name, devuelve los elementos de un grupo, cuyo nombre se especifica. No es

necesario que nosotros hagamos un seguimiento de la orden de los elementos dentro un

arreglo. Esta función no requiere el número de elementos para que coincida con el número en

el cluster. Después de cablear un clúster para esta función, se puede seleccionar un elemento

individual de la función.

Programming -> Cluster, Class, & Variant -> Unbundle By Name

27. Conectamos el error que sale del último bloque Write, a la entrada de nuestro Unbundle By

Name.

Veremos que dentro del bloque Unbundle By Name aparece la leyenda status. Status nos dará

un 1 binario en caso de que haya error en el programa.

28. Sabiendo que status me arrojara un 1 lógico cuando el programa cometa error, lo conectaremos

a la entrada del stop, con ayuda de una compuerta OR.

Programming -> Boolean -> Or

29. Desconectamos el botón Stop para conectarlo a la otra entrada de mi compuerta Or y la salida

de ésta al stop del ciclo While.

30. Finalmente nos dirigimos a la paleta Programming -> Dialog & User Interface y seleccionamos

Simple Error.

Simple Error indica si se ha producido un error. Si se produce un error, este VI devuelve una

descripción del error y, opcionalmente, muestra un cuadro de diálogo.

Diagrama de Bloques

Panel Frontal.