Lichtsteuerungssystem - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

Kürzlich habe ich daran gearbeitet, Mikrocontroller und IOT-basierte Geräte für Sicherheitsforschungszwecke zu verstehen. Also dachte ich daran, ein kleines Hausautomationssystem für die Praxis zu bauen. Ich muss dies noch abschließen, aber zum Start werde ich in diesem Beitrag teilen, wie ich Raspberry Pi 2 und einige andere elektrische Komponenten verwendet habe, um die Beleuchtung meines Zimmers zu steuern. Außerdem werde ich hier nicht über die Ersteinrichtung für Raspberry sprechen, dafür finden Sie möglicherweise verschiedene Tutorials.

Aber in diesem Projekt werde ich Ihnen dieses Produkt der Docker-Pi-Serie vorstellen.

Lieferungen

Komponentenliste:

• 1 x Raspberry Pi 3B+/3B/Zero/Zero W/4B/
• 1 x 16 GB Klasse 10 TF-Karte
• 1 x DockerPi-Serie 4-Kanal-Relaisplatine (HAT)
• 1 x [email protected] Netzteil von 52Pi
• 4 x Lichtleiste
• 1 x DC-Anschluss
• 1 x 12V Netzteil für die Lichtleisten.
• mehrere Drähte.

Schritt 1: Wissenswertes über die 4-Kanal-Relaisplatine der DockerPi-Serie

DockerPi 4 Channel Relay ist ein Mitglied der DockerPi-Serie, die häufiger in IOT-Anwendungen verwendet wird.

DockerPi 4 Channel Relay kann AC/DC anstelle von herkömmlichen Schaltern weiterleiten, um mehr Ideen zu verwirklichen. DockerPi 4 Channel Relay kann bis zu 4 stapeln und kann mit anderen DockerPi-Erweiterungskarten gestapelt werden. Wenn Sie längere Zeit laufen müssen, empfehlen wir Ihnen außerdem, unser DockerPi Power-Erweiterungsboard zu verwenden, um mehr Leistung bereitzustellen.

VORSICHTSHINWEIS Bevor wir fortfahren, möchte ich Sie vor der GEFAHR beim Experimentieren mit dem „Netzstrom“warnen. Wenn etwas schief geht, kann die schlimmste Folge der Tod oder zumindest das Abbrennen des eigenen Hauses sein. Versuchen Sie also NICHT, irgendetwas in diesem Artikel erwähntes zu tun, wenn Sie nicht verstehen, was Sie tun, oder nehmen Sie besser die Hilfe eines erfahrenen Elektrikers in Anspruch. Lass uns anfangen.

Schritt 2: Funktionen

• DockerPi-Serie
• Programmierbar
• Direkte Steuerung (ohne Programmierung)
• Erweitern Sie die GPIO-Pins
• 4-Kanal-Relais
• 4 Unterstützung für alternative I2C-Addr
• Unterstützung von Relaisstatus-LEDs
• 3A 250V AC-Unterstützung
• 3A 30V DC
• Kann mit anderen Stack-Boards gestapelt werden Unabhängig von der Mainboard-Hardware (erfordert I2C-Unterstützung)

Schritt 3: Geräteadressenzuordnung

Diese Karte hat eine separate Registeradresse und Sie können jedes Relais mit einem Befehl steuern.

Andere Vorraussetzungen:

Grundlegendes Verständnis von Python oder C oder Shell oder Java oder einer anderen Sprache (ich werde C, Python, Shell und Java verwenden)

• Grundlegendes Verständnis von Linux-Systemen
• Geistesgegenwart

Bevor Sie fortfahren, müssen Sie die von uns verwendeten elektrischen Komponenten verstehen:

1. Relais:

Ein Relais ist ein elektrisches Gerät, das im Allgemeinen verwendet wird, um hohe Spannungen mit sehr niedriger Spannung als Eingang zu steuern. Dies besteht aus einer um einen Pol gewickelten Spule und zwei kleinen Metallklappen (Knoten), die zum Schließen des Stromkreises verwendet werden. Einer der Knoten ist fest und der andere ist beweglich. Immer wenn Elektrizität durch die Spule geleitet wird, erzeugt sie ein magnetisches Feld und zieht den sich bewegenden Knoten in Richtung des statischen Knotens und der Stromkreis wird geschlossen. Durch Anlegen einer kleinen Spannung zum Einschalten der Spule können wir also den Stromkreis für die Hochspannung vervollständigen. Da der statische Knoten nicht physisch mit der Spule verbunden ist, besteht auch eine sehr geringe Wahrscheinlichkeit, dass der Mikrocontroller, der die Spule versorgt, beschädigt wird, wenn etwas schief geht.

Schritt 4: Schließen Sie das Relais an die Lampenfassung an, die von der Hauptstromversorgung gespeist wird

Nun zum kniffligen Teil, wir verbinden das Relais mit der Lampenfassung, die von der Hauptstromversorgung versorgt wird. Aber zuerst möchte ich Ihnen eine kurze Vorstellung davon geben, wie die Lichter über die direkte Stromversorgung ein- und ausgeschaltet werden.

Wenn die Glühbirne nun an das Stromnetz angeschlossen ist, tun wir dies normalerweise, indem wir zwei Drähte an die Glühbirne anschließen. Einer der Drähte ist ein „Neutral“-Draht und der andere ist der „Negative“-Draht, der tatsächlich den Strom führt. Außerdem ist dem gesamten Stromkreis ein Schalter hinzugefügt, um den EIN- und AUS-Mechanismus zu steuern. Wenn der Schalter angeschlossen (oder eingeschaltet) ist, fließt der Strom durch die Glühbirne und den Neutralleiter und schließt den Stromkreis. Dies schaltet die Glühbirne EIN. Wenn der Schalter ausgeschaltet wird, unterbricht er den Stromkreis und die Glühbirne schaltet sich aus. Hier ein kleiner Schaltplan zur Erläuterung:

Für unser Experiment müssen wir nun den "Negativen Draht" durch unser Relais führen, um den Stromkreis zu unterbrechen und den Stromfluss durch das Schalten des Relais zu steuern. Wenn also das Relais eingeschaltet wird, sollte es den Stromkreis schließen und die Glühbirne sollte sich einschalten und umgekehrt. Beziehen Sie sich auf das folgende Diagramm für den vollständigen Kreislauf.

Schritt 5: Konfigurieren von I2C (Raspberry Pi)

Führen Sie sudo raspi-config aus und folgen Sie den Anweisungen, um die i2c-Unterstützung für den ARM-Kern und den Linux-Kernel zu installieren

Gehen Sie zu Schnittstellenoptionen

Schritt 6: Direkte Steuerung ohne Programmierung (Raspberry Pi)

Schalten Sie das Relais von Kanal Nr. 1 ein

i2cset -y 1 0x10 0x01 0xFF

Schalten Sie das Relais von Kanal Nr. 1 aus

i2cset -y 1 0x10 0x01 0x00

Schalten Sie das Relais von Kanal Nr. 2 ein

i2cset -y 1 0x10 0x02 0xFF

Schalten Sie das Relais von Kanal Nr. 2 aus

i2cset -y 1 0x10 0x02 0x00

Schalten Sie das Relais von Kanal Nr. 3 ein

i2cset -y 1 0x10 0x03 0xFF

Schalten Sie das Relais von Kanal Nr. 3 aus

i2cset -y 1 0x10 0x03 0x00

Schalten Sie das Relais von Kanal Nr. 4 ein

i2cset -y 1 0x10 0x04 0xFF

Schalten Sie das Relais von Kanal Nr. 4 aus

i2cset -y 1 0x10 0x04 0x00

Schritt 7: Programm in Sprache C (Raspberry Pi)

Erstellen Sie den Quellcode und nennen Sie ihn "relay.c".

#enthalten

#enthalten

#enthalten

#define DEVCIE_ADDR 0x10

#define RELAIS1 0x01

#define RELAIS2 0x02

#define RELAY3 0x03

#define RELAY4 0x04

#define EIN 0xFF

#define AUS 0x00

int main(void)

{

printf("Relais in C\n einschalten");

int fd;

int i = 0;

fd = wiringPiI2CSetup(DEVICE_ADDR);

zum(;;){

für (i=1; i<=4; i++)

{

printf("Relais Nr.$d einschalten", i);

wiringPiI2CWriteReg8(fd, i, ON);

Schlaf (200);

printf("Relais Nr.$d ausschalten", i);

wiringPiI2CWriteReg8(fd, i, OFF);

Schlaf (200);

}

}

0 zurückgeben;

}

Kompilieren Sie es

gcc relay.c -lwiringPi -o Relais

Führen Sie es aus

./Relais

Schritt 8: Programmieren in Python (Raspberry Pi)

Es wird empfohlen, den folgenden Code mit Python 3 auszuführen und die smbus-Bibliothek zu installieren:

Erstellen Sie eine Datei mit dem Namen "relay.py" und fügen Sie folgenden Code ein:

Importzeit als t

smbus importieren

Importsystem

DEVICE_BUS = 1

DEVICE_ADDR = 0x10

bus = smbus. SMBus(DEVICE_BUS)

während Wahr:

Versuchen:

für i im Bereich (1, 5):

bus.write_byte_data(DEVICE_ADDR, i, 0xFF)

t.schlaf(1)

bus.write_byte_data(DEVICE_ADDR, i, 0x00)

t.schlaf(1)

außer KeyboardInterrupt als e:

print("Schleife beenden")

sys.exit()

* Speichern Sie es und führen Sie es dann als Python3 aus:

python3 relay.py

Schritt 9: Programm in Java (Raspberry Pi)

Erstellen Sie eine neue Datei mit dem Namen: I2CRelay.java und fügen Sie folgenden Code ein:

import java.io. IOException;

java.util. Arrays importieren;

com.pi4j.io.i2c. I2CBus importieren;

com.pi4j.io.i2c. I2CDevice importieren;

com.pi4j.io.i2c. I2CFactory importieren;

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

import com.pi4j.platform. PlatformAlreadyAssignedException;

com.pi4j.util. Console importieren;

öffentliche Klasse I2CRelay {

// Registeradresse des Relais.

öffentliches statisches finales int DOCKER_PI_RELAY_ADDR = 0x10;

// Kanal des Relais.

öffentliches statisches letztes Byte DOCKER_PI_RELAY_1 = (Byte)0x01;

öffentliches statisches letztes Byte DOCKER_PI_RELAY_2 = (Byte)0x02;

öffentliches statisches letztes Byte DOCKER_PI_RELAY_3 = (Byte)0x03;

öffentliches statisches letztes Byte DOCKER_PI_RELAY_4 = (Byte)0x04;

// Relaisstatus

öffentliches statisches letztes Byte DOCKER_PI_RELAY_ON = (byte)0xFF;

öffentliches statisches letztes Byte DOCKER_PI_RELAY_OFF = (Byte)0x00;

public static void main(String args) löst InterruptedException, PlatformAlreadyAssignedException, IOException, UnsupportedBusNumberException {

letzte Konsolenkonsole = neue Konsole();

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

I2CDevice-Gerät = i2c.getDevice(DOCKER_PI_RELAY_ADDR);

console.println("Relais einschalten!");

device.write(DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

Thread.sleep(500);

console.println("Relais ausschalten!");

device.write(DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}