Sistem de control al luminilor: 9 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Recent am lucrat la înțelegerea microcontrolerelor și dispozitivelor bazate pe IOT în scopuri de cercetare a securității. Așadar, m-am gândit să construiesc un mic sistem de automatizare a casei pentru practică. Încă nu am finalizat acest lucru, dar pentru pornire voi împărtăși modul în care am folosit Raspberry Pi 2 și alte componente electrice pentru a controla iluminarea camerei mele în această postare. De asemenea, nu voi vorbi despre configurarea inițială pentru Raspberry aici, este posibil să găsiți diverse tutoriale pentru asta.

Dar în acest proiect, vă voi prezenta acest produs din seria docker pi.

Provizii

Lista componentelor:

• 1 x Raspberry Pi 3B + / 3B / Zero / Zero W / 4B /
• 1 x 16 GB Clasa 10 TF card
• 1 x DockerPi seria 4 canale de releu (HAT)
• 1 x [email protected] sursă de alimentare care este de la 52Pi
• 4 x bandă de lumină
• 1 x conector DC
• 1 x sursă de alimentare de 12V pentru benzile de lumină.
• mai multe fire.

Pasul 1: Cunoașterea DockerPi Series 4 Channel Relay Board

Releul DockerPi cu 4 canale este membru al Seriei DockerPi, mai des utilizat în aplicațiile IOT.

Releul DockerPi cu 4 canale poate retransmite AC / DC, în loc de comutatoare tradiționale, pentru a obține mai multe idei. Releul DockerPi 4 canale poate stiva până la 4 și poate fi stivuit cu alte plăci de expansiune DockerPi. Dacă trebuie să rulați mult timp, vă recomandăm să utilizați placa de expansiune DockerPi Power pentru a furniza mai multă energie.

NOTĂ DE ATENȚIE Înainte de a continua, aș dori să vă AVERTIZEZ cu privire la PERICOLUL experimentării cu „Electricitatea rețelei”. Dacă ceva nu merge bine, cea mai gravă consecință poate fi moartea sau cel puțin arderea propriei case. Așadar, vă rugăm să nu încercați să faceți ceva menționat în acest articol dacă nu înțelegeți ce faceți sau mai bine luați ajutorul unui electrician cu experiență. Să începem.

Pasul 2: Caracteristici

• Seria DockerPi
• Programabil
• Control direct (fără programare)
• Extindeți pinii GPIO
• Releu cu 4 canale
• 4 Alt I2C Addr Support
• Suport pentru starea releu Leds
• Suport 3A 250V AC
• 3A 30V DC
• Se poate stiva cu altă placă de stivă Independent de hardware-ul plăcii principale (necesită suport I2C)

Pasul 3: Harta adreselor dispozitivului

Această placă are o adresă de registru separată și puteți controla fiecare releu printr-o singură comandă.

Alte cerinte:

Înțelegerea de bază a Python sau C sau shell sau Java sau orice alt limbaj (voi folosi C, python, shell și java)

• Înțelegerea de bază a sistemelor Linux
• Prezentă de spirit

Acum, înainte de a merge mai departe, va trebui să înțelegeți componentele electrice pe care le vom folosi:

1. Releu:

Un releu este un dispozitiv electric care este utilizat în general pentru a controla tensiuni ridicate folosind o tensiune foarte mică ca intrare. Aceasta constă dintr-o bobină înfășurată în jurul unui stâlp și două clape mici (noduri) metalice care sunt utilizate pentru a închide circuitul. Unul dintre noduri este fix și altul este mobil. Ori de câte ori o electricitate este trecută prin bobină, aceasta creează un câmp magnetic și atrage nodul în mișcare spre nodul static și circuitul este finalizat. Deci, doar prin aplicarea unei tensiuni mici pentru a alimenta bobina, putem efectua circuitul pentru ca tensiunea înaltă să se deplaseze. De asemenea, deoarece nodul static nu este conectat fizic la bobină, există foarte puține șanse ca microcontrolerul care alimentează bobina să fie deteriorat dacă ceva nu merge bine.

Pasul 4: Conectați releul la suportul becului alimentat de sursa electrică principală

Acum, la partea dificilă, vom conecta releul la suportul becului alimentat de sursa principală electrică. Dar, mai întâi vreau să vă dau o scurtă idee despre modul în care luminile sunt pornite și oprite prin sursa de alimentare directă.

Acum, când becul este conectat la sursa principală, de obicei facem acest lucru conectând două fire la bec. unul dintre fire este un fir „Neutru”, iar celălalt este firul „Negativ” care transportă curentul, de asemenea, există un comutator adăugat la întregul circuit pentru a controla mecanismul ON ON OFF. Deci, atunci când swith este conectat (sau pornit) curentul curge prin bec și firul neutru, completând circuitul. Aceasta aprinde becul. Când comutatorul este oprit, acesta întrerupe circuitul și becul se stinge. Iată o schemă mică pentru a explica acest lucru:

Acum, pentru experimentul nostru, va trebui să facem ca „firul negativ” să treacă prin releul nostru pentru a întrerupe circuitul și a controla fluxul de energie folosind comutarea releului. Deci, atunci când releul se va porni, ar trebui să finalizeze circuitul, iar becul să se aprindă și invers. Consultați diagrama de mai jos pentru circuit complet.

Pasul 5: Configurarea I2C (Raspberry Pi)

Rulați sudo raspi-config și urmați instrucțiunile pentru a instala suportul i2c pentru nucleul ARM și nucleul Linux

Accesați Opțiuni de interfață

Pasul 6: Control direct fără programare (Raspberry Pi)

Activați releul canalului 1

i2cset -y 1 0x10 0x01 0xFF

Dezactivați releul canalului 1

i2cset -y 1 0x10 0x01 0x00

Porniți releul canalului 2

i2cset -y 1 0x10 0x02 0xFF

Dezactivați releul canalului 2

i2cset -y 1 0x10 0x02 0x00

Porniți releul canalului 3

i2cset -y 1 0x10 0x03 0xFF

Dezactivați releul canalului 3

i2cset -y 1 0x10 0x03 0x00

Porniți releul canalului nr.4

i2cset -y 1 0x10 0x04 0xFF

Opriți releul canalului nr.4

i2cset -y 1 0x10 0x04 0x00

Pasul 7: Programați în limbajul C (Raspberry Pi)

Creați codul sursă și denumiți-l „relay.c”

#include

#include

#include

#define DEVCIE_ADDR 0x10

#define RELAY1 0x01

#define RELAY2 0x02

#define RELAY3 0x03

#define RELAY4 0x04

#define ON 0xFF

#define OFF 0x00

int main (nul)

{

printf ("Activați releele în C / n");

int fd;

int i = 0;

fd = wiringPiI2CSetup (DEVICE_ADDR);

pentru(;;){

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

{

printf ("activați releul nr. $ d", i);

wiringPiI2CWriteReg8 (fd, i, ON);

somn (200);

printf ("opriți releul nr. $ d", i);

wiringPiI2CWriteReg8 (fd, i, OFF);

somn (200);

}

}

retur 0;

}

Compilați-l

releu gcc.c -lwiringPi -o releu

Exec It

./releu

Pasul 8: Programați în Python (Raspberry Pi)

Se recomandă executarea următorului cod folosind Python 3 și instalarea bibliotecii smbus:

Creați un fișier numit: "relay.py" și lipiți următorul cod:

timp de import ca t

import smbus

import sisteme

DEVICE_BUS = 1

DEVICE_ADDR = 0x10

autobuz = smbus. SMBus (DEVICE_BUS)

în timp ce este adevărat:

încerca:

pentru i în intervalul (1, 5):

bus.write_byte_data (DEVICE_ADDR, i, 0xFF)

t.set (1)

bus.write_byte_data (DEVICE_ADDR, i, 0x00)

t.set (1)

cu excepția KeyboardInterrupt ca e:

print („Ieși din buclă”)

sys.exit ()

* Salvați-l și apoi rulați ca python3:

python3 relay.py

Pasul 9: Program în Java (Raspberry Pi)

Creați un fișier nou numit: I2CRelay.java și lipiți următorul cod:

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;

clasa publica I2CRelay {

// adresa de înregistrare a releului.

public static final int DOCKER_PI_RELAY_ADDR = 0x10;

// canal de releu.

octet public static static DOCKER_PI_RELAY_1 = (octet) 0x01;

octet public static static DOCKER_PI_RELAY_2 = (octet) 0x02;

octet public public static DOCKER_PI_RELAY_3 = (octet) 0x03;

octet public static static DOCKER_PI_RELAY_4 = (octet) 0x04;

// Starea releu

octet final public static DOCKER_PI_RELAY_ON = (octet) 0xFF;

octet public static static DOCKER_PI_RELAY_OFF = (octet) 0x00;

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

Consolă finală = Consolă nouă ();

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

I2CDevice device = i2c.getDevice (DOCKER_PI_RELAY_ADDR);

console.println ("Porniți releu!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

Thread.sleep (500);

console.println ("Opriți releu!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}