Sistema de control de luces: 9 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Recientemente estuve trabajando en la comprensión de microcontroladores y dispositivos basados en IOT para fines de investigación de seguridad. Entonces, pensé en construir un pequeño sistema de automatización del hogar para practicar. Todavía tengo que completar esto, pero para el inicio compartiré cómo usé Raspberry Pi 2 y algunos otros componentes eléctricos para controlar la iluminación de mi habitación en esta publicación. Además, no hablaré sobre la configuración inicial para Raspberry aquí, puede encontrar varios tutoriales para eso.

Pero en este proyecto, les presentaré este producto de la serie Docker Pi.

Suministros

Lista de componentes:

• 1 x Raspberry Pi 3B + / 3B / Zero / Zero W / 4B /
• 1 tarjeta TF de 16 GB clase 10
• 1 x placa de relé de 4 canales de la serie DockerPi (HAT)
• Fuente de alimentación 1 x [email protected] que es de 52Pi
• 4 x tira de luz
• 1 x conector DC
• Fuente de alimentación 1 x 12V para las tiras de luz.
• varios alambres.

Paso 1: Conocer la placa de relé de 4 canales de la serie DockerPi

DockerPi 4 Channel Relay es un miembro de la serie DockerPi, más comúnmente utilizado en aplicaciones IOT.

El relé de 4 canales DockerPi puede retransmitir CA / CC, en lugar de los interruptores tradicionales, para lograr más ideas. El relé de 4 canales DockerPi se puede apilar hasta 4 y se puede apilar con otra placa de expansión DockerPi. Si necesita funcionar durante mucho tiempo, también le recomendamos que utilice nuestra placa de expansión DockerPi Power para proporcionar más potencia.

NOTA DE PRECAUCIÓN Antes de continuar, me gustaría advertirle sobre el PELIGRO de experimentar con la "Red eléctrica". Si algo sale mal, la peor consecuencia puede ser la muerte o al menos el incendio de su propia casa. Por lo tanto, NO INTENTE hacer nada de lo mencionado en este artículo si no comprende lo que está haciendo o, mejor, recurra a la ayuda de un electricista experimentado. Empecemos.

Paso 2: características

• Serie DockerPi
• Programable
• Control directo (sin programación)
• Extienda los pines GPIO
• Relé de 4 canales
• Soporte de 4 Alt I2C Addr
• Soporte de LED de estado de relé
• Soporte 3A 250V AC
• 3 A 30 V CC
• Puede apilarse con otra placa Stack independientemente del hardware de la placa base (requiere soporte I2C)

Paso 3: mapa de direcciones del dispositivo

Esta placa tiene una dirección de registro separada, y puede controlar cada relé con un comando.

Otros requerimientos:

Comprensión básica de Python o C o shell o Java o cualquier otro lenguaje (usaré C, python, shell y java)

• Comprensión básica de los sistemas Linux
• Presencia de la mente

Ahora, antes de seguir adelante, deberá comprender los componentes eléctricos que usaremos:

1. Relevo:

Un relé es un dispositivo eléctrico que generalmente se usa para controlar altos voltajes usando muy bajo voltaje como entrada. Consiste en una bobina enrollada alrededor de un poste y dos pequeñas solapas metálicas (nodos) que se utilizan para cerrar el circuito. Uno de los nodos es fijo y el otro es móvil. Siempre que se pasa electricidad a través de la bobina, crea un campo magnético y atrae el nodo en movimiento hacia el nodo estático y el circuito se completa. Entonces, con solo aplicar un pequeño voltaje para encender la bobina, podemos completar el circuito para que viaje el alto voltaje. Además, como el nodo estático no está conectado físicamente a la bobina, hay muy pocas posibilidades de que el microcontrolador que alimenta la bobina se dañe si algo sale mal.

Paso 4: conecte el relé al portalámparas alimentado por suministro eléctrico principal

Ahora a la parte complicada, conectaremos el relé al portalámparas alimentado por suministro eléctrico principal. Pero, primero quiero darle una breve idea sobre cómo se encienden y apagan las luces a través de la fuente de alimentación directa.

Ahora, cuando la bombilla está conectada al suministro principal, generalmente lo hacemos conectando dos cables a la bombilla. uno de los cables es un cable "Neutral" y el otro es el cable "Negativo" que en realidad transporta la corriente, también hay un interruptor agregado a todo el circuito para controlar el mecanismo de ENCENDIDO y APAGADO. Entonces, cuando el interruptor está conectado (o encendido), la corriente fluye a través de la bombilla y el cable neutro, completando el circuito. Esto enciende la bombilla. Cuando se apaga el interruptor, se interrumpe el circuito y la bombilla se apaga. Aquí hay un pequeño diagrama de circuito para explicar esto:

Ahora, para nuestro experimento, tendremos que hacer que el "cable negativo" pase a través de nuestro relé para romper el circuito y controlar el flujo de energía mediante la conmutación del relé. Entonces, cuando el relé se enciende, debe completar el circuito y la bombilla debe encenderse y viceversa. Consulte el diagrama a continuación para el circuito completo.

Paso 5: Configurar I2C (Raspberry Pi)

Ejecute sudo raspi-config y siga las instrucciones para instalar el soporte i2c para el núcleo ARM y el kernel de linux

Ir a Opciones de interfaz

Paso 6: Control directo sin programación (Raspberry Pi)

Encienda el relé del canal n. ° 1

i2cset -y 1 0x10 0x01 0xFF

Apague el relé del canal n. ° 1

i2cset -y 1 0x10 0x01 0x00

Encienda el relé del canal n. ° 2

i2cset -y 1 0x10 0x02 0xFF

Apague el relé del canal n. ° 2

i2cset -y 1 0x10 0x02 0x00

Encienda el relé del canal n. ° 3

i2cset -y 1 0x10 0x03 0xFF

Apague el relé del canal n. ° 3

i2cset -y 1 0x10 0x03 0x00

Encienda el relé del canal n. ° 4

i2cset -y 1 0x10 0x04 0xFF

Apague el relé del canal n. ° 4

i2cset -y 1 0x10 0x04 0x00

Paso 7: Programa en Lenguaje C (Raspberry Pi)

Cree el código fuente y asígnele el nombre "relay.c"

#incluir

#incluir

#incluir

#define DEVCIE_ADDR 0x10

#define RELAY1 0x01

#define RELAY2 0x02

#define RELAY3 0x03

#define RELAY4 0x04

#define ON 0xFF

#define OFF 0x00

int main (vacío)

{

printf ("Activar relés en C / n");

int fd;

int i = 0;

fd = cableadoPiI2CSetup (DEVICE_ADDR);

por(;;){

para (i = 1; i <= 4; i ++)

{

printf ("enciende el relé No. $ d", i);

cableadoPiI2CWriteReg8 (fd, i, ON);

dormir (200);

printf ("apagar el relé No. $ d", i);

cableadoPiI2CWriteReg8 (fd, i, APAGADO);

dormir (200);

}

}

return 0;

}

Compílelo

relé gcc. c -lwiringPi -o relé

Exec It

./relé

Paso 8: Programa en Python (Raspberry Pi)

Se recomienda ejecutar el siguiente código con Python 3 e instalar la biblioteca smbus:

Cree un archivo con el nombre "relay.py" y pegue el siguiente código:

importar tiempo como t

importar smbus

importar sys

DEVICE_BUS = 1

DEVICE_ADDR = 0x10

bus = smbus. SMBus (DEVICE_BUS)

mientras que es cierto:

tratar:

para i en el rango (1, 5):

bus.write_byte_data (DEVICE_ADDR, i, 0xFF)

dormir (1)

bus.write_byte_data (DEVICE_ADDR, i, 0x00)

dormir (1)

excepto KeyboardInterrupt como e:

print ("Salir del bucle")

sys.exit ()

* Guárdelo y luego ejecútelo como python3:

python3 relay.py

Paso 9: Programa en Java (Raspberry Pi)

Cree un nuevo archivo llamado: I2CRelay.java y pegue el siguiente código:

import java.io. IOException;

import java.util. Arrays;

import com.pi4j.io.i2c. I2CBus;

import com.pi4j.io.i2c. I2CDevice;

import com.pi4j.io.i2c. I2CFactory;

import com.pi4j.io.i2c. I2CFactory. UnsupportedBusNumberException;

import com.pi4j.platform. PlatformAlreadyAssignedException;

import com.pi4j.util. Console;

public class I2CRelay {

// dirección de registro del relé.

public static final int DOCKER_PI_RELAY_ADDR = 0x10;

// canal de relevo.

byte final estático público DOCKER_PI_RELAY_1 = (byte) 0x01;

byte final estático público DOCKER_PI_RELAY_2 = (byte) 0x02;

byte final estático público DOCKER_PI_RELAY_3 = (byte) 0x03;

byte final estático público DOCKER_PI_RELAY_4 = (byte) 0x04;

// Estado del relé

byte final estático público DOCKER_PI_RELAY_ON = (byte) 0xFF;

byte final estático público DOCKER_PI_RELAY_OFF = (byte) 0x00;

public static void main (String args) lanza InterruptedException, PlatformAlreadyAssignedException, IOException, UnsupportedBusNumberException {

consola final consola = nueva consola ();

I2CBus i2c = I2CFactory.getInstance (I2CBus. BUS_1);

Dispositivo I2CDevice = i2c.getDevice (DOCKER_PI_RELAY_ADDR);

console.println ("¡Enciende el relé!");

dispositivo.escribir (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

Hilo.sueño (500);

console.println ("¡Apaga el relé!");

dispositivo.escribir (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}