Sistema de controle de luzes: 9 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Recentemente, eu estava trabalhando na compreensão de microcontroladores e dispositivos baseados em IOT para fins de pesquisa de segurança. Então, pensei em construir um pequeno sistema de automação residencial para praticar. Ainda estou para concluir isso, mas para começar, compartilharei como usei o Raspberry Pi 2 e alguns outros componentes elétricos para controlar a iluminação da minha sala neste post. Além disso, não vou falar sobre a configuração inicial do Raspberry aqui, você pode encontrar vários tutoriais para isso.

Mas, neste projeto, apresentarei este produto da série docker pi a você.

Suprimentos

Lista de componentes:

• 1 x Raspberry Pi 3B + / 3B / Zero / Zero W / 4B /
• 1 x cartão de 16GB classe 10 TF
• 1 x DockerPi série 4 Channel Relay Board (HAT)
• Fonte de alimentação 1 x [email protected] que é de 52 Pi
• 4 x tira de luz
• 1 x conector DC
• Fonte de alimentação 1 x 12V para as faixas de luz.
• vários fios.

Etapa 1: Saber sobre a placa de relé de canal DockerPi Série 4

DockerPi 4 Channel Relay é um membro da série DockerPi, mais comumente usado em aplicativos IOT.

O DockerPi 4 Channel Relay pode retransmitir AC / DC, em vez de interruptores tradicionais, para obter mais ideias. DockerPi 4 Channel Relay pode empilhar até 4, e pode ser empilhado com outra placa de expansão DockerPi. Se precisar funcionar por muito tempo, também recomendamos que você use nossa placa de expansão DockerPi Power para fornecer mais energia.

NOTA DE CUIDADO Antes de prosseguirmos, gostaria de AVISAR sobre o PERIGO de fazer experiências com a "eletricidade principal". Se algo der errado, a pior consequência pode ser morte ou pelo menos queimar sua própria casa. Portanto, NÃO TENTE fazer nada mencionado neste artigo se você não entender o que está fazendo ou melhor, peça ajuda de algum eletricista experiente. Vamos começar.

Etapa 2: Recursos

• DockerPi Series
• Programável
• Controle diretamente (sem programação)
• Estenda os pinos GPIO
• Relé de 4 canais
• 4 Alt I2C Addr Support
• Suporte de leds de status de relé
• Suporte 3A 250 V AC
• 3A 30 V DC
• Pode empilhar com outra placa de pilha independente do hardware da placa-mãe (requer suporte I2C)

Etapa 3: Mapa de endereço do dispositivo

Esta placa tem endereço de registro separado, e você pode controlar cada relé por meio de um comando.

Outros requerimentos:

Noções básicas de Python ou C ou shell ou Java ou qualquer outra linguagem (estarei usando C, python, shell e java)

• Compreensão básica de sistemas Linux
• Presença de espírito

Agora, antes de prosseguir, você precisará entender os componentes elétricos que usaremos:

1. Relé:

Um relé é um dispositivo elétrico que geralmente é usado para controlar altas tensões usando uma tensão muito baixa como uma entrada. Ele consiste em uma bobina enrolada em um poste e duas pequenas abas de metal (nós) que são usadas para fechar o circuito. Um dos nós é fixo e o outro é móvel. Sempre que uma eletricidade é passada pela bobina, ela cria um campo magnético e atrai o nó móvel em direção ao nó estático e o circuito é concluído. Então, apenas aplicando uma pequena tensão para energizar a bobina, podemos realmente completar o circuito para que a alta tensão viaje. Além disso, como o nó estático não está fisicamente conectado à bobina, há muito menos chance de que o microcontrolador que alimenta a bobina seja danificado se algo der errado.

Etapa 4: Conecte o relé ao porta-lâmpada alimentado pela fonte elétrica principal

Agora, a parte complicada, vamos conectar o relé ao porta-lâmpada alimentado pela fonte elétrica principal. Mas, primeiro, quero dar uma breve ideia sobre como as luzes são ligadas e desligadas por meio da fonte de alimentação direta.

Agora, quando a lâmpada está conectada à fonte principal, geralmente fazemos isso conectando dois fios à lâmpada. um dos fios é um fio “Neutro” e o outro é o fio “Negativo” que realmente carrega a corrente, também há uma chave adicionada a todo o circuito para controlar o mecanismo LIGADO e DESLIGADO. Assim, quando o interruptor é conectado (ou LIGADO) a corrente flui através da lâmpada e do fio neutro, completando o circuito. Isso liga a lâmpada. Quando o interruptor é desligado, ele interrompe o circuito e a lâmpada se apaga. Aqui está um pequeno diagrama de circuito para explicar isso:

Agora, para nosso experimento, precisaremos fazer o "fio negativo" passar por nosso relé para interromper o circuito e controlar o fluxo de energia usando a comutação do relé. Assim, quando o relé acender, deverá completar o circuito e a lâmpada acenderá e vice-versa. Consulte o diagrama abaixo para circuito completo.

Etapa 5: Configurar I2C (Raspberry Pi)

Execute sudo raspi-config e siga as instruções para instalar o suporte i2c para o núcleo ARM e kernel do Linux

Vá para Opções de Interface

Etapa 6: Controle direto sem programação (Raspberry Pi)

Ligue o relé do canal No.1

i2cset -y 1 0x10 0x01 0xFF

Desligue o relé do canal No.1

i2cset -y 1 0x10 0x01 0x00

Ligue o relé do canal No.2

i2cset -y 1 0x10 0x02 0xFF

Desligue o relé do canal No.2

i2cset -y 1 0x10 0x02 0x00

Ligue o relé do canal No.3

i2cset -y 1 0x10 0x03 0xFF

Desligue o relé do canal No.3

i2cset -y 1 0x10 0x03 0x00

Ligue o relé do canal No.4

i2cset -y 1 0x10 0x04 0xFF

Desligue o relé do canal No.4

i2cset -y 1 0x10 0x04 0x00

Etapa 7: programe na linguagem C (Raspberry Pi)

Crie o código-fonte com o nome "relay.c"

#incluir

#incluir

#incluir

#define DEVCIE_ADDR 0x10

#define RELAY1 0x01

#define RELAY2 0x02

# define RELAY3 0x03

# define RELAY4 0x04

#define ON 0xFF

#define OFF 0x00

int main (vazio)

{

printf ("Ligar relés em C / n");

int fd;

int i = 0;

fd = wiringPiI2CSetup (DEVICE_ADDR);

para(;;){

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

{

printf ("ligar o relé nº $ d", i);

wiringPiI2CWriteReg8 (fd, i, ON);

sono (200);

printf ("desligar relé nº $ d", i);

wiringPiI2CWriteReg8 (fd, i, OFF);

sono (200);

}

}

return 0;

}

Compile-o

gcc relay.c -lwiringPi -o relay

Exec It

./retransmissão

Etapa 8: programar em Python (Raspberry Pi)

Recomenda-se que o código a seguir seja executado usando Python 3 e instale a biblioteca smbus:

Crie um arquivo chamado: "relay.py" e cole o seguinte código:

tempo de importação como t

import smbus

import sys

DEVICE_BUS = 1

DEVICE_ADDR = 0x10

bus = smbus. SMBus (DEVICE_BUS)

enquanto verdadeiro:

Experimente:

para i no intervalo (1, 5):

bus.write_byte_data (DEVICE_ADDR, i, 0xFF)

t.sleep (1)

bus.write_byte_data (DEVICE_ADDR, i, 0x00)

t.sleep (1)

exceto KeyboardInterrupt como e:

print ("Sair do Loop")

sys.exit ()

* Salve-o e execute como python3:

python3 relay.py

Etapa 9: programar em Java (Raspberry Pi)

Crie um novo arquivo chamado: I2CRelay.java e cole o seguinte código:

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;

public class I2CRelay {

// endereço de registro do relé.

público estático final int DOCKER_PI_RELAY_ADDR = 0x10;

// canal de retransmissão.

byte final estático público DOCKER_PI_RELAY_1 = (byte) 0x01;

byte final estático público DOCKER_PI_RELAY_2 = (byte) 0x02;

byte final estático público DOCKER_PI_RELAY_3 = (byte) 0x03;

byte final estático público DOCKER_PI_RELAY_4 = (byte) 0x04;

// Relay status

byte final estático público DOCKER_PI_RELAY_ON = (byte) 0xFF;

byte final estático público DOCKER_PI_RELAY_OFF = (byte) 0x00;

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

console final do console = novo console ();

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

Dispositivo I2CDevice = i2c.getDevice (DOCKER_PI_RELAY_ADDR);

console.println ("Ativar relé!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

Thread.sleep (500);

console.println ("Desligue o Relay!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}