Sistema di controllo delle luci: 9 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Recentemente stavo lavorando alla comprensione dei microcontrollori e dei dispositivi basati su IOT per scopi di ricerca sulla sicurezza. Così, ho pensato di realizzare un piccolo impianto domotico per esercitarmi. Devo ancora completarlo, ma per l'avvio condividerò come ho usato Raspberry Pi 2 e alcuni altri componenti elettrici per controllare l'illuminazione della mia stanza in questo post. Inoltre, non parlerò della configurazione iniziale per Raspberry qui, potresti trovare vari tutorial per questo.

Ma in questo progetto, ti presenterò questo prodotto della serie docker pi.

Forniture

Elenco dei componenti:

• 1 x Raspberry Pi 3B+/3B/Zero/Zero W/4B/
• 1 scheda TF di classe 10 da 16 GB
• 1 x scheda relè a 4 canali serie DockerPi (HAT)
• 1 x alimentatore [email protected] che proviene da 52Pi
• 4 x striscia luminosa
• 1 x connettore CC
• 1 x alimentatore 12V per le strisce luminose.
• diversi fili.

Passaggio 1: conoscere la scheda relè a 4 canali della serie DockerPi

DockerPi 4 Channel Relay è un membro della serie DockerPi, più comunemente utilizzata nelle applicazioni IOT.

DockerPi 4 Channel Relay può trasmettere AC/DC, invece dei tradizionali interruttori, per realizzare più idee. DockerPi 4 Channel Relay può essere impilato fino a 4 e può essere impilato con altre schede di espansione DockerPi. Se hai bisogno di funzionare a lungo, ti consigliamo anche di utilizzare la nostra scheda di espansione DockerPi Power per fornire più potenza.

NOTA DI ATTENZIONE Prima di procedere oltre, vorrei AVVERTIRTI circa il PERICOLO di sperimentare con la "rete elettrica". Se qualcosa va storto, la peggiore conseguenza potrebbe essere la morte o almeno bruciare la tua stessa casa. Quindi, per favore, NON TENTARE di fare qualsiasi cosa menzionata in questo articolo se non capisci cosa stai facendo o meglio farti aiutare da qualche elettricista esperto. Iniziamo.

Passaggio 2: caratteristiche

• Serie DockerPi
• Programmabile
• Controllo diretto (senza programmazione)
• Estendere i pin GPIO
• Relè a 4 canali
• 4 Supporto per l'indirizzo I2C alternativo
• Supporto LED di stato relè
• Supporto CA 3A 250V
• 3A 30V CC
• Può essere impilato con un'altra scheda Stack Indipendente dall'hardware della scheda madre (richiede il supporto I2C)

Passaggio 3: mappa degli indirizzi del dispositivo

Questa scheda ha un indirizzo di registro separato e puoi semplicemente controllare ciascun relè con un comando.

Altri requisiti:

Comprensione di base di Python o C o shell o Java o qualsiasi altro linguaggio (utilizzerò C, python, shell e java)

• Comprensione di base dei sistemi Linux
• Presenza di spirito

Ora, prima di andare avanti dovrai capire i componenti elettrici che utilizzeremo:

1. Relè:

Un relè è un dispositivo elettrico che viene generalmente utilizzato per controllare tensioni elevate utilizzando una tensione molto bassa come ingresso. Questo consiste in una bobina avvolta attorno ad un palo e due piccoli lembi metallici (nodi) che vengono utilizzati per chiudere il circuito. Uno dei nodi è fisso e l'altro è mobile. Ogni volta che un'elettricità viene fatta passare attraverso la bobina, crea un campo magnetico e attira il nodo in movimento verso il nodo statico e il circuito viene completato. Quindi, semplicemente applicando una piccola tensione per alimentare la bobina, possiamo effettivamente completare il circuito per far viaggiare l'alta tensione. Inoltre, poiché il nodo statico non è fisicamente collegato alla bobina, ci sono poche possibilità che il microcontrollore che alimenta la bobina si danneggi se qualcosa va storto.

Passaggio 4: collegare il relè al portalampada alimentato dall'alimentazione elettrica principale

Ora alla parte difficile, collegheremo il relè al portalampada alimentato dall'alimentazione elettrica principale. Ma prima voglio darvi una breve idea di come le luci si accendono e si spengono tramite alimentazione diretta.

Ora, quando la lampadina è collegata all'alimentazione principale, di solito lo facciamo collegando due fili alla lampadina. uno dei fili è un filo "Neutro" e l'altro è il filo "Negativo" che porta effettivamente la corrente, inoltre c'è un interruttore aggiunto all'intero circuito per controllare il meccanismo ON e OFF. Quindi, quando l'interruttore è collegato (o acceso) la corrente scorre attraverso la lampadina e il filo neutro, completando il circuito. Questo accende la lampadina. Quando l'interruttore è spento, interrompe il circuito e la lampadina si spegne. Ecco un piccolo schema elettrico per spiegarlo:

Ora, per il nostro esperimento, dovremo far passare il "filo negativo" attraverso il nostro relè per interrompere il circuito e controllare il flusso di potenza utilizzando la commutazione del relè. Quindi, quando il relè si accenderà, dovrebbe completare il circuito e la lampadina dovrebbe accendersi e viceversa. Fare riferimento allo schema seguente per Circuito completo.

Passaggio 5: configurazione di I2C (Raspberry Pi)

Esegui sudo raspi-config e segui le istruzioni per installare il supporto i2c per il core ARM e il kernel linux

Vai a Opzioni di interfaccia

Passaggio 6: controllo diretto senza programmazione (Raspberry Pi)

Attiva il relè del canale n.1

i2cset -y 1 0x10 0x01 0xFF

Spegni il relè del canale n.1

i2cset -y 1 0x10 0x01 0x00

Attiva il relè del canale n.2

i2cset -y 1 0x10 0x02 0xFF

Spegni il relè del canale n.2

i2cset -y 1 0x10 0x02 0x00

Attiva il relè del canale n.3

i2cset -y 1 0x10 0x03 0xFF

Spegni il relè del canale n.3

i2cset -y 1 0x10 0x03 0x00

Attiva il relè del canale n.4

i2cset -y 1 0x10 0x04 0xFF

Spegni il relè del canale n.4

i2cset -y 1 0x10 0x04 0x00

Passaggio 7: programma in lingua C (Raspberry Pi)

Crea il codice sorgente e chiamalo "relay.c"

#includere

#includere

#includere

#define DEVCIE_ADDR 0x10

#define RELAY1 0x01

#define RELAY2 0x02

#define RELAY3 0x03

#define RELAY4 0x04

#define ON 0xFF

#define OFF 0x00

int main (vuoto)

{

printf("Attiva i relè in C\n");

int fd;

int i = 0;

fd = cablaggioPiI2CSetup(DEVICE_ADDR);

per(;;){

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

{

printf("accendi il relè n.$d", i);

cablaggioPiI2CWriteReg8(fd, i, ON);

dormire(200);

printf("spegni il relè n.$d", i);

cablaggioPiI2CWriteReg8(fd, i, OFF);

dormire(200);

}

}

restituisce 0;

}

Compilalo

gcc relay.c -lwiringPi -o relay

Eseguilo

./relè

Passaggio 8: programma in Python (Raspberry Pi)

Si consiglia di eseguire il codice seguente utilizzando Python 3 e installare la libreria smbus:

Crea un file chiamato: "relay.py" e incolla il seguente codice:

importa il tempo come t

import smbus

sistema di importazione

BUS_DISPOSITIVO = 1

DEVICE_ADDR = 0x10

bus = smbus. SMBus(DEVICE_BUS)

mentre vero:

Tentativo:

per i nell'intervallo (1, 5):

bus.write_byte_data(DEVICE_ADDR, i, 0xFF)

t.sonno(1)

bus.write_byte_data(DEVICE_ADDR, i, 0x00)

t.sonno(1)

tranne KeyboardInterrupt come e:

print("Esci dal ciclo")

sys.exit()

* Salvalo ed esegui come python3:

python3 relay.py

Passaggio 9: programma in Java (Raspberry Pi)

Crea un nuovo file chiamato: I2CRelay.java e incolla il seguente codice:

import java.io. IOException;

import java.util. Array;

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;

classe pubblica I2CRelay {

// indirizzo di registro del relè.

public static final int DOCKER_PI_RELAY_ADDR = 0x10;

// canale del relè.

byte finale statico pubblico DOCKER_PI_RELAY_1 = (byte)0x01;

byte finale statico pubblico DOCKER_PI_RELAY_2 = (byte)0x02;

byte finale statico pubblico DOCKER_PI_RELAY_3 = (byte)0x03;

byte finale statico pubblico DOCKER_PI_RELAY_4 = (byte)0x04;

// Stato del relè

byte finale statico pubblico DOCKER_PI_RELAY_ON = (byte)0xFF;

byte finale statico pubblico DOCKER_PI_RELAY_OFF = (byte)0x00;

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

console finale console = new Console();

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

I2CDevice device = i2c.getDevice(DOCKER_PI_RELAY_ADDR);

console.println("Attiva il relè!");

device.write(DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

Thread.sleep(500);

console.println("Disattiva relè!");

device.write(DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}