Sistema de control de llums: 9 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

Recentment treballava en la comprensió de microcontroladors i dispositius basats en IOT amb finalitats d’investigació de seguretat. Per tant, vaig pensar en construir un petit sistema domòtic per a la pràctica. Encara no he completat això, però, per iniciar-lo, compartiré com he utilitzat Raspberry Pi 2 i alguns altres components elèctrics per controlar la il·luminació de la meva habitació en aquesta publicació. A més, no parlaré de la configuració inicial per a Raspberry aquí, és possible que hi trobeu diversos tutorials.

Però en aquest projecte us presentaré aquest producte de la sèrie docker pi.

Subministraments

Llista de components:

• 1 x Raspberry Pi 3B + / 3B / Zero / Zero W / 4B /
• 1 targeta TF classe 16 x 16 GB
• 1 x placa de retransmissió de 4 canals (HAT) de la sèrie DockerPi
• 1 x [email protected] font d'alimentació que és de 52Pi
• 4 x tira de llum
• 1 x connector DC
• 1 alimentació de 12V per a les tires de llum.
• diversos cables.

Pas 1: conèixer el tauler de retransmissió de canals de la sèrie 4 de DockerPi

DockerPi 4 Channel Relay és membre de la sèrie DockerPi, més utilitzat en aplicacions IOT.

El relé DockerPi de 4 canals pot retransmetre AC / DC, en lloc dels commutadors tradicionals, per aconseguir més idees. El relé de 4 canals DockerPi es pot apilar fins a 4 i es pot apilar amb una altra placa d’expansió DockerPi. Si necessiteu córrer durant molt de temps, també us recomanem que utilitzeu la nostra placa d’expansió DockerPi Power per proporcionar més energia.

NOTA DE PRECAUCIÓ Abans de continuar, voldria advertir-vos del PERILL d’experimentar amb l’“electricitat de xarxa”. Si alguna cosa surt malament, la pitjor conseqüència pot ser la mort o, almenys, la crema de casa vostra. Per tant, NO INTENTEU fer res esmentat en aquest article si no enteneu què feu o, millor, ajudeu algun electricista experimentat. Comencem.

Pas 2: funcions

• Sèrie DockerPi
• Programable
• Control directament (sense programació)
• Amplieu els pins GPIO
• Relé de 4 canals
• 4 Suport d'Add I2C Alt
• Suport Leds d’estat de relés
• Suport de CA 3A 250V
• 3A 30V CC
• Es pot apilar amb una altra placa de pila independent del maquinari de la placa base (requereix suport I2C)

Pas 3: Mapa d'adreces del dispositiu

Aquest tauler té una adreça de registre independent i només podeu controlar cada relé mitjançant una ordre.

Altres requisits:

Comprensió bàsica de Python o C o shell o Java o qualsevol altre llenguatge (utilitzaré C, python, shell i java)

• Coneixement bàsic dels sistemes Linux
• Presència de la ment

Ara, abans de seguir endavant, haureu d’entendre els components elèctrics que farem servir:

1. Relleu:

Un relé és un dispositiu elèctric que s'utilitza generalment per controlar altes tensions utilitzant molt baixa tensió com a entrada. Consisteix en una bobina embolicada al voltant d’un pal i dues petites solapes metàl·liques (nodes) que s’utilitzen per tancar el circuit. Un dels nodes és fix i l’altre és mòbil. Sempre que es passa una electricitat a través de la bobina, crea un camp magnètic i atrau el node en moviment cap al node estàtic i el circuit es completa. Per tant, només amb l’aplicació d’un petit voltatge per encendre la bobina, podem completar el circuit perquè l’alt voltatge circuli. A més, com que el node estàtic no està físicament connectat a la bobina, hi ha molt menys possibilitats que el microcontrolador que alimenta la bobina es faci malbé si alguna cosa surt malament.

Pas 4: connecteu el relé al portalàmpades alimentat per la font d'alimentació elèctrica principal

Ara, a la part complicada, connectarem el relé al suport de la bombeta alimentat per l’alimentació de Main Electric. Però, primer, vull fer-vos una breu idea de com s’encenen i apaguen els llums mitjançant una font d’alimentació directa.

Ara, quan la bombeta està connectada al subministrament principal, normalment ho fem connectant dos cables a la bombeta. un dels cables és un cable "neutre" i un altre és el cable "negatiu" que realment transporta el corrent, també hi ha un commutador afegit a tot el circuit per controlar el mecanisme ON ON OFF. Per tant, quan el swith està connectat (o activat) el corrent flueix a través de la bombeta i el cable neutre, completant el circuit. Això engega la bombeta. Quan es commuta l’interruptor, trenca el circuit i la bombeta s’APAGA. Aquí teniu un petit diagrama de circuits per explicar-ho:

Ara, per al nostre experiment, haurem de fer passar el "fil negatiu" pel nostre relé per trencar el circuit i controlar el flux d'energia mitjançant la commutació del relé. Per tant, quan el relé s’encengui, hauria de completar el circuit i la bombeta s’ha d’encendre i viceversa. Consulteu el diagrama següent per veure el circuit complet.

Pas 5: Configuració de l'I2C (Raspberry Pi)

Executeu sudo raspi-config i seguiu les instruccions per instal·lar el suport i2c per al nucli ARM i el nucli linux

Aneu a Opcions d’interfície

Pas 6: control directe sense programació (Raspberry Pi)

Activeu el relé número 1 del canal

i2cset -y 1 0x10 0x01 0xFF

Desactiveu el relé del número 1 del canal

i2cset -y 1 0x10 0x01 0x00

Activeu el relé número 2 del canal

i2cset -y 1 0x10 0x02 0xFF

Desactiveu el relé número 2 del canal

i2cset -y 1 0x10 0x02 0x00

Activeu el relé número 3 del canal

i2cset -y 1 0x10 0x03 0xFF

Desactiveu el relé número 3 del canal

i2cset -y 1 0x10 0x03 0x00

Activeu el relé número 4 del canal

i2cset -y 1 0x10 0x04 0xFF

Desactiveu el relé del número 4 del canal

i2cset -y 1 0x10 0x04 0x00

Pas 7: programa en llenguatge C (Raspberry Pi)

Creeu el codi font i anomeneu-lo "relay.c"

#incloure

#incloure

#incloure

#define DEVCIE_ADDR 0x10

#define RELAY1 0x01

#define RELAY2 0x02

#define RELAY3 0x03

#define RELAY4 0x04

#define ON 0xFF

#define OFF 0x00

int main (buit)

{

printf ("Activa els relés a C / n");

int fd;

int i = 0;

fd = wiringPiI2CSetup (DEVICE_ADDR);

per a (;;) {

per a (i = 1; i <= 4; i ++)

{

printf ("activa el relé núm. $ d", i);

wiringPiI2CWriteReg8 (fd, i, ON);

dormir (200);

printf ("apaga el relé núm. $ d", i);

wiringPiI2CWriteReg8 (fd, i, OFF);

dormir (200);

}

}

retorn 0;

}

Compila-ho

relé gcc.c -lwiringPi -o relé

Exec It

./ relé

Pas 8: programa a Python (Raspberry Pi)

Es recomana executar el codi següent mitjançant Python 3 i instal·lar la biblioteca smbus:

Creeu un fitxer anomenat: "relay.py" i enganxeu el codi següent:

temps d'importació com a t

importar smbus

importar sistemes

DEVICE_BUS = 1

DEVICE_ADDR = 0x10

bus = smbus. SMBus (DEVICE_BUS)

mentre que és cert:

provar:

per a l'interval (1, 5):

bus.write_byte_data (DEVICE_ADDR, i, 0xFF)

dormir (1)

bus.write_byte_data (DEVICE_ADDR, i, 0x00)

dormir (1)

excepte KeyboardInterrupt com e:

print ("Surt del bucle")

sys.exit ()

* Deseu-lo i, a continuació, executeu-lo com a python3:

python3 relay.py

Pas 9: programa a Java (Raspberry Pi)

Creeu un fitxer nou anomenat: I2CRelay.java i enganxeu el codi següent:

importació java.io. IOException;

importa 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;

importació com.pi4j.platform. PlatformAlreadyAssignedException;

importació com.pi4j.util. Console;

classe pública I2CRelay {

// adreça de registre del relé.

public static final int DOCKER_PI_RELAY_ADDR = 0x10;

// canal de relé.

byte final estàtic públic DOCKER_PI_RELAY_1 = (byte) 0x01;

byte final estàtic públic DOCKER_PI_RELAY_2 = (byte) 0x02;

byte final estàtic públic DOCKER_PI_RELAY_3 = (byte) 0x03;

byte final estàtic públic DOCKER_PI_RELAY_4 = (byte) 0x04;

// Estat del relé

byte final estàtic públic DOCKER_PI_RELAY_ON = (byte) 0xFF;

byte final estàtic públic DOCKER_PI_RELAY_OFF = (byte) 0x00;

public static void main (String args) llança InterruptedException, PlatformAlreadyAssignedException, IOException, UnsupportedBusNumberException {

Consola final Consola = Consola nova ();

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

I2CDevice device = i2c.getDevice (DOCKER_PI_RELAY_ADDR);

console.println ("Activa el relé!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

Thread.sleep (500);

console.println ("Desactiva el relé!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}