Système de contrôle des lumières : 9 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

Récemment, je travaillais sur la compréhension des microcontrôleurs et des appareils basés sur l'IOT à des fins de recherche en sécurité. J'ai donc pensé à construire un petit système domotique pour m'entraîner. Je n'ai pas encore terminé cela, mais pour le démarrage, je partagerai comment j'ai utilisé Raspberry Pi 2 et d'autres composants électriques pour contrôler l'éclairage de ma pièce dans cet article. De plus, je ne parlerai pas de la configuration initiale pour Raspberry ici, vous pouvez trouver divers tutoriels pour cela.

Mais dans ce projet, je vais vous présenter ce produit de la série docker pi.

Fournitures

Liste des composants:

• 1 x Raspberry Pi 3B+/3B/Zéro/Zéro W/4B/
• 1 carte TF classe 10 de 16 Go
• 1 x carte de relais DockerPi série 4 canaux (HAT)
• 1 x alimentation [email protected] qui est de 52Pi
• 4 x bande lumineuse
• 1 x connecteur CC
• 1 x alimentation 12V pour les bandes lumineuses.
• plusieurs fils.

Étape 1: Connaître la carte de relais DockerPi Series 4 canaux

DockerPi 4 Channel Relay est un membre de la série DockerPi, plus couramment utilisé dans les applications IOT.

DockerPi 4 Channel Relay peut relayer AC/DC, au lieu des commutateurs traditionnels, pour réaliser plus d'idées. DockerPi 4 Channel Relay peut empiler jusqu'à 4 et peut être empilé avec d'autres cartes d'extension DockerPi. Si vous devez fonctionner pendant longtemps, nous vous recommandons également d'utiliser notre carte d'extension DockerPi Power pour fournir plus de puissance.

NOTE D'ATTENTIONAvant d'aller plus loin, je voudrais vous AVERTIR du DANGER d'expérimenter avec « l'électricité sur secteur ». Si quelque chose ne va pas, la pire des conséquences peut être la mort ou au moins l'incendie de votre propre maison. Alors, s'il vous plaît, N'ESSAYEZ PAS de faire quoi que ce soit mentionné dans cet article si vous ne comprenez pas ce que vous faites ou mieux faites appel à un électricien expérimenté. Commençons.

Étape 2: Fonctionnalités

• Série DockerPi
• Programmable
• Contrôle directement (sans programmation)
• Étendre les broches GPIO
• Relais 4 canaux
• Prise en charge de l'adresse 4 Alt I2C
• Prise en charge des LED d'état du relais
• Prise en charge 3A 250V CA
• 3A 30V CC
• Peut s'empiler avec d'autres cartes Stack Indépendant du matériel de la carte mère (nécessite la prise en charge I2C)

Étape 3: Mappage d'adresses de l'appareil

Cette carte a une adresse de registre distincte et vous pouvez simplement contrôler chaque relais par une seule commande.

Autres exigences:

Compréhension de base de Python ou C ou shell ou Java ou tout autre langage (j'utiliserai C, python, shell et java)

• Compréhension de base des systèmes Linux
• Présence d'esprit

Maintenant, avant d'aller de l'avant, vous devez comprendre les composants électriques que nous utiliserons:

1. Relais:

Un relais est un appareil électrique qui est généralement utilisé pour contrôler des hautes tensions en utilisant une très basse tension comme entrée. Il s'agit d'une bobine enroulée autour d'un pôle et de deux petits volets métalliques (nœuds) qui sont utilisés pour fermer le circuit. L'un des nœuds est fixe et l'autre est mobile. Chaque fois qu'une électricité passe à travers la bobine, elle crée un champ magnétique et attire le nœud mobile vers le nœud statique et le circuit est terminé. Ainsi, en appliquant simplement une petite tension pour alimenter la bobine, nous pouvons en fait compléter le circuit pour que la haute tension circule. De plus, comme le nœud statique n'est pas physiquement connecté à la bobine, il y a très peu de chances que le microcontrôleur alimentant la bobine soit endommagé en cas de problème.

Étape 4: Connectez le relais au support d'ampoule alimenté par l'alimentation électrique principale

Passons maintenant à la partie délicate, nous allons connecter le relais au support d'ampoule alimenté par l'alimentation électrique principale. Mais, je veux d'abord vous donner une brève idée de la façon dont les lumières sont allumées et éteintes via une alimentation électrique directe.

Maintenant, lorsque l'ampoule est connectée à l'alimentation principale, nous le faisons généralement en connectant deux fils à l'ampoule. l'un des fils est un fil "neutre" et l'autre est le fil "négatif" qui transporte réellement le courant, il y a aussi un interrupteur ajouté à l'ensemble du circuit pour contrôler le mécanisme ON et OFF. Ainsi, lorsque l'interrupteur est connecté (ou allumé), le courant traverse l'ampoule et le fil neutre, complétant le circuit. Cela allume l'ampoule. Lorsque l'interrupteur est éteint, il coupe le circuit et l'ampoule s'éteint. Voici un petit schéma de circuit pour expliquer cela:

Maintenant, pour notre expérience, nous devrons faire passer le "fil négatif" à travers notre relais pour couper le circuit et contrôler le flux d'énergie à l'aide de la commutation du relais. Ainsi, lorsque le relais s'allumera, il devrait terminer le circuit et l'ampoule devrait s'allumer et vice-versa. Reportez-vous au schéma ci-dessous pour le circuit complet.

Étape 5: Configuration d'I2C (Raspberry Pi)

Exécutez sudo raspi-config et suivez les instructions pour installer le support i2c pour le noyau ARM et le noyau Linux

Aller aux options d'interfaçage

Étape 6: Contrôle direct sans programmation (Raspberry Pi)

Allumez le relais du canal n°1

i2cset -y 1 0x10 0x01 0xFF

Désactiver le relais du canal n°1

i2cset -y 1 0x10 0x01 0x00

Allumez le relais du canal n°2

i2cset -y 1 0x10 0x02 0xFF

Désactiver le relais du canal n°2

i2cset -y 1 0x10 0x02 0x00

Allumez le relais du canal n°3

i2cset -y 1 0x10 0x03 0xFF

Désactiver le relais du canal n°3

i2cset -y 1 0x10 0x03 0x00

Allumez le relais du canal n°4

i2cset -y 1 0x10 0x04 0xFF

Désactiver le relais du canal n°4

i2cset -y 1 0x10 0x04 0x00

Étape 7: Programmez en langage C (Raspberry Pi)

Créez le code source et nommez-le "relay.c"

#comprendre

#comprendre

#comprendre

#define DEVCIE_ADDR 0x10

#définir RELAIS1 0x01

#définir RELAIS2 0x02

#définir RELAIS3 0x03

#définir RELAIS4 0x04

#define ON 0xFF

#define OFF 0x00

int main(void)

{

printf("Activer les relais en C\n");

int fd;

entier je = 0;

fd = câblagePiI2CSetup(DEVICE_ADDR);

pour(;;){

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

{

printf("activer le relais n°$d", i);

câblagePiI2CWriteReg8(fd, i, ON);

sommeil(200);

printf("éteindre le relais n°$d", i);

câblagePiI2CWriteReg8(fd, i, OFF);

sommeil(200);

}

}

renvoie 0;

}

Compilez-le

gcc relay.c -lwiringPi -o relay

Exécutez-le

./relais

Étape 8: Programmer en Python (Raspberry Pi)

Il est recommandé d'exécuter le code suivant à l'aide de Python 3 et d'installer la bibliothèque smbus:

Créez un fichier nommé: "relay.py" et collez le code suivant:

temps d'importation en t

importer smbus

importer le système

DEVICE_BUS = 1

DEVICE_ADDR = 0x10

bus = smbus. SMBus(DEVICE_BUS)

tant que vrai:

essayer:

pour i dans la plage (1, 5):

bus.write_byte_data(DEVICE_ADDR, i, 0xFF)

t.sommeil(1)

bus.write_byte_data(DEVICE_ADDR, i, 0x00)

t.sommeil(1)

sauf KeyboardInterrupt en tant que e:

print("Quitter la boucle")

sys.exit()

* Enregistrez-le puis exécutez-le en tant que python3:

python3 relay.py

Étape 9: Programmez en Java (Raspberry Pi)

Créez un nouveau fichier nommé: I2CRelay.java et collez le code suivant:

importer java.io. IOException;

importer java.util. Arrays;

importer com.pi4j.io.i2c. I2CBus;

importer com.pi4j.io.i2c. I2CDevice;

importer com.pi4j.io.i2c. I2CFactory;

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

importer com.pi4j.platform. PlatformAlreadyAssignedException;

importer com.pi4j.util. Console;

classe publique I2CRelay {

// adresse du registre du relais.

public statique final int DOCKER_PI_RELAY_ADDR = 0x10;

// canal de relais.

octet final statique public DOCKER_PI_RELAY_1 = (octet)0x01;

octet final statique public DOCKER_PI_RELAY_2 = (octet)0x02;

octet final statique public DOCKER_PI_RELAY_3 = (octet)0x03;

octet final statique public DOCKER_PI_RELAY_4 = (octet)0x04;

// Etat du relais

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

octet final statique public DOCKER_PI_RELAY_OFF = (octet)0x00;

public static void main(String args) lève InterruptedException, PlatformAlreadyAssignedException, IOException, UnsupportedBusNumberException {

console finale console = nouvelle console();

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

Périphérique I2CDevice = i2c.getDevice(DOCKER_PI_RELAY_ADDR);

console.println("Activez le relais !");

device.write(DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

Thread.sleep(500);

console.println("Désactivez le relais !");

device.write(DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}