Acionamento de Cargas por Controle Remoto e,ou Sensor de Movimento

Prévia do material em texto

ADALBERTO CARVALHO CAMARA 
EUDES APARECIDO ROLA 
MARCELO JOSÉ PARIS 
MOACIR JUNIOR OMIZZOLLO 
 
 
 
 
 
 
 
ACIONAMENTO DE CARGAS POR 
CONTROLE REMOTO E/OU SENSOR DE 
MOVIMENTO 
 
 
 
 
Relatório de projeto desenvolvido, apresentado com 
o intuito de obtenção de nota parcial na disciplina 
de Circuitos Elétricos I, do curso de Engenharia 
Elétrica, UNEMAT, campus Sinop. 
 
Docente: Reginne Michelle Silva Iocca. 
 
 
 
 
 
 
SINOP - MT 
Julho / 2017 
 
 
SUMÁRIO 
1. FUNDAMENTAÇÃO TEÓRICA ................................................................ 3 
1.1. Arduino UNO .......................................................................................... 3 
1.2. Controle Remoto por Infravermelho .......................................................... 3 
1.3. Relé mecânico ......................................................................................... 4 
1.4. Sensor PIR .............................................................................................. 4 
2. OBJETIVOS .............................................................................................. 5 
3. MATERIAIS UTILIZADOS ........................................................................ 5 
4. METODOLOGIA ....................................................................................... 6 
4.1. Esquemático, Circuito e Componentes ....................................................... 6 
4.2. Código Fonte ........................................................................................... 7 
5. RESULTADOS E DISCUSSÃO ................................................................ 10 
6. CONCLUSÃO .......................................................................................... 10 
7. REFERÊNCIAS ....................................................................................... 10 
 
 
Página 3 de 10 
 
1. FUNDAMENTAÇÃO TEÓRICA 
 
1.1. Arduino UNO 
O Arduino é uma placa de desenvolvimento de código aberto para hardware, ou 
seja, é um pequeno dispositivo microcontrolador que possibilita sua programação para o 
funcionamento do sistema que for necessário ser desenvolvido. 
Baseado no microcontrolador ATmega328, possui 14 pinos para entrada e saída 
digital, 6 entradas analógicas, uma conexão 
USB, uma entrada para alimentação, 
conexão ICSP e botão de reset. 
Para programá-lo é necessário 
utilizar o software de programação especial 
para o Arduino chamado ArduinoIDE, com 
esse programa é possível o acesso livre 
sobre o código aberto do mesmo, fazendo 
possível a programação para qualquer 
objetivo. 
 
1.2. Controle Remoto por Infravermelho 
O controle remoto infravermelho funciona da seguinte 
maneira, ao apertar um botão em um controle remoto, pulsos de 
luz infravermelha, invisíveis a olho nu são emitidos com 
intervalos longos ou curtos que compõem códigos binários, que 
ao chegar no aparelho destinado converte estes códigos em 
comandos. Cada botão deste controle possui um código binário, 
ao apertar este botão um sinal é enviado a um microprocessador 
dentro deste controle, este por sua vez, aciona um gerador de 
frequência, enviando os sinais para o LED infravermelho que 
emite os sinais sob a forma luminosa para então serem 
decodificados no receptor, que pode ser um fototransistor, por 
exemplo. 
O fototransistor é um de dispositivo que recebe e decodifica os pulsos luminosos 
emitidos pelo controle remoto, no seu formato mais comum possui três pinos, assim como 
um transistor convencional, porém o pino base de um fototransistor serve unicamente 
Imagem 1 – Arduino Uno 
Fonte: http://ninjadolinux.com.br 
Imagem 2 – Controle 
Remoto Infravermelho. 
Fonte: AliExpress. 
 
Página 4 de 10 
 
para enviar os pulsos elétricos convertidos 
pelo dispositivo para algum microcontrolador 
que irá interpretar estes pulsos e executar os 
comandos associados. Existe uma biblioteca 
para a IDE do Arduino chamada IRremote, que 
é responsável por fazer com que o 
microcontrolador consiga interpretar os pulsos 
gerados pelo fototransistor, gerando assim 
códigos hexadecimais. 
 
1.3. Relé mecânico 
E uma chave eletromecânica onde, sua bobina é o principal componente, 
responsável por abrir ou fechar a chave. Em torno dela que é gerado um campo 
eletromagnético quando o relé é energizado. Este campo eletromagnético gera uma força 
que movimenta um conjunto mecânico (armadura fixa) com contatos móveis, desse modo 
altera seu estado de normalmente aberto para fechado ou de normalmente fechado para 
aberto. 
Dentro das suas vantagens 
podemos destacar, a operação do circuito 
de carga e de controle estão 
completamente isolados galvanicamente, 
também a bobina pode ser controlada com 
uma tensão muito menor do que a dos 
contatos da carga. 
É muito utilizado na indústria em 
geral, automação predial e residencial, por 
conseguir acionar cargas relativamente 
grandes através de circuitos eletrônicos 
 
1.4. Sensor PIR 
Sensor PIR é um tipo de sensor infravermelho que funciona de forma passiva, ou 
seja, apenas faz a análise da radiação infravermelha que está presente em seu campo de 
atuação. 
Imagem 3 – Fototransistor. 
Fonte: Internet. 
Imagem 4 – Representação de um Relé 
Fonte: www.findernet.com. 
 
Página 5 de 10 
 
Em aplicações com Arduino Uno é mais comum a 
utilização do Módulo Sensor PIR DYP-ME003, este módulo 
permite o ajuste da sensibilidade do sensor e do tempo de 
acionamento do mesmo quando há variação da radiação 
infravermelho. A cúpula esbranquiçada em seu exterior é uma 
Lente de Fresnel, utilizada para aumentar o campo do sinal 
infravermelho convergindo as ondas luminosas para o centro 
do sensor. 
 
 
 
 
 
 
 
 
 
2. OBJETIVOS 
 
 Demonstrar a aplicação do Arduino Uno no acionamento de cargas utilizando 
controle remoto e/ou sensor de movimento. 
 
3. MATERIAIS UTILIZADOS 
 
01 Arduino UNO. 
01 Módulo Sensor PIR DYP-ME003,. 
01 Fototransistor TSOP1836. 
02 Relés 12V. 
02 Transistores NPN BC547. 
02 Diodos Retificadores 1N4001. 
02 Resistores 10 𝑘Ω. 
01 Resistor 330 Ω 
01 Led difuso 5mm vermelho 
01 Protoboard 
02 Receptáculos E27 
02 Lâmpadas LED 7W E27 
01 Plug macho tipo flecha 
 Fios jumpers e cabo cordão paralelo 2,5mm2 
 
 
 
 
Imagem 5 – Módulo PIR 
DYP-ME003 
Fonte: Arduino e Cia. 
Imagem 6 – Funcionamento da Lente 
de Fresnel 
Fonte: Arduino e Cia. 
Imagem 7 – Detalhe Módulo PIR DYP-ME003 
Fonte: Arduino e Cia. 
 
Página 6 de 10 
 
4. METODOLOGIA 
 
A ideia inicial deste projeto era facilitar o acionamento remoto de cargas 
utilizando um microcontrolador, no caso Arduino UNO, mas usando um módulo Wireless 
ESP8266, porém não conseguimos encontrar a venda na cidade tal módulo, sendo 
necessário fazer a aquisição em uma loja online e aguardar sua chegada, o que atrasaria 
o desenvolvimento do projeto, sendo até possível que não chegasse no prazo necessário, 
nos forçando então a buscar outras alternativas, que não comprometessem a ideia 
principal do projeto, logo, acabamos por optar usar a comunicação remota por 
infravermelho. 
 
4.1. Esquemático, Circuito e Componentes 
Através de estudos de artigos e tutoriais disponíveis na internet, podemos 
desenvolver nosso próprio esquema, como mostrado a seguir: 
Para alimentação elétrica do circuito foram necessárias duas fontes de energia 
elétrica, sendo uma de 12 Vcc e outra de 5 Vcc, pois os relés utilizados foram reciclados, 
operando com tensão diferente do Arduino, isso tem um lado positivo, pois com uma 
fonte exclusiva para os relés o Arduino não corre o risco de ser prejudicado por algum 
Imagem8 – Esquemático do projeto 
Fonte: Autoria própria. 
 
Página 7 de 10 
 
curto circuito ou sobrecorrente, oriundas dos solenoides presentes nos relés, outra grande 
vantagem também é que, com uma maior tensão, pode-se também utilizar de fios e cabos 
mais compridos, sem prejudicar a eficiência do circuito. 
O sensor Infravermelho também foi reciclado, passou por algumas etapas de testes 
para verificar seu funcionamento, uma vez aprovado, pode ser empregado no circuito. 
 
4.2. Código Fonte 
O código foi inteiramente escrito utilizando a IDE ARDUINO 1.8.2, tendo 
algumas linhas baseadas nos tutoriais e artigos estudados, passando por várias edições e 
revisões, buscando o máximo de eficiência e velocidade na sua execução, resultando no 
código a seguir. 
 
//**Acionamento de Cargas por Controle Remoto e/ou Sensor de Movimento**// 
//Adalberto, Eudes, Marcelo, Moacir 
//Source By Eudes 
 
#include <IRremote.h> 
#include <IRremoteInt.h> 
 
int RECV_PIN = 11; //pino ligado ao infravermelho 
float armazenavalor; 
int pinorele1 = 5; //pino ligado ao rele1 
int pinorele2 = 6; //pino ligado ao rele2 
int pinoledvermelho = 7; //Pino ligado ao led vermelho 
int pinopir = 3; //Pino ligado ao sensor PIR 
int acionamento; //Variavel para guardar valor do sensor PIR 
 
int rele1 = 0; //Mantém as saídas em LOW ao inicializar 
int rele2 = 0; 
int ledvermelho = 0; 
int acionamento_old = 0; 
 
IRrecv irrecv(RECV_PIN); 
decode_results results; 
 
void setup() 
{ 
 pinMode(pinorele1, OUTPUT); //Define o pino do rele1 como saida 
 pinMode(pinorele2, OUTPUT); //Define o pino do rele2 como saida 
 pinMode(pinoledvermelho, OUTPUT); //Define o pino do led vermelho como saida 
 pinMode(pinopir, INPUT); //Define pino sensor como entrada 
 Serial.begin(9600); // Inicializa o serial 
 irrecv.enableIRIn(); // Inicializa o receptor IR 
} 
 
void loop() 
{ 
 acionamento = digitalRead(pinopir); //Le o valor do sensor PIR 
 if (acionamento == LOW) 
 { 
 digitalWrite(pinoledvermelho, LOW); //Sem movimento, apaga o LED 
 } 
 else 
 
Página 8 de 10 
 
 { 
 digitalWrite(pinoledvermelho, HIGH); //Com movimento, acende o LED 
 } 
 if (acionamento == acionamento_old) //Verifica se houve mudança do sensor 
 { 
 
 } 
 else 
 { 
 if (acionamento == HIGH) 
 { 
 Serial.println("Movimento detectado!!!"); 
 } 
 else 
 { 
 Serial.println("Sem movimento!!!"); 
 } 
 } 
if (irrecv.decode(&results)) 
 { 
 Serial.print("Valor lido : "); 
 Serial.println(results.value, HEX); 
 armazenavalor = (results.value); 
 if (armazenavalor == 0xFF30CF) //Verifica se a tecla 1 foi acionada 
 { 
 rele1 = 1; 
 } 
 if (armazenavalor == 0xFF18E7) //Verifica se a tecla 2 foi acionada 
 { 
 rele1 = 0; 
 } 
 if (armazenavalor == 0xFF7A85) //Verifica se a tecla 3 foi acionada 
 { 
 rele1 = 2; 
 } 
 if (armazenavalor == 0xFF10EF) //Verifica se a tecla 4 foi acionada 
 { 
 rele2 = 1; 
 } 
 if (armazenavalor == 0xFF38C7) //Verifica se a tecla 5 foi acionada 
 { 
 rele2 = 0; 
 } 
 if (armazenavalor == 0xFF5AA5) //Verifica se a tecla 6 foi acionada 
 { 
 rele2 = 2; 
 } 
 if (armazenavalor == 0xFF6897) //Verifica se a tecla 0 foi acionada 
 { //Desativa todos os relés 
 rele1 = 0; 
 rele2 = 0; 
 } 
 irrecv.resume(); //Lê o próximo valor 
 } 
 //Verifica quais as teclas acionadas e muda o estado dos relés 
 if (rele1 == 1) //Verifica se a tecla 1 foi acionada 
 { 
 digitalWrite(pinorele1, HIGH); //Ativa o relé1 
 } 
 if (rele1 == 0) //Verifica se a tecla 2 foi acionada 
 { 
 digitalWrite(pinorele1, LOW); //Desativa o relé1 
 } 
 
Página 9 de 10 
 
 if (rele1 == 2) //Verifica se a tecla 3 foi acionada 
 { 
 if (acionamento == LOW) //Verifica se há movimento 
 { 
 digitalWrite(pinorele1, LOW); //Desativa o relé1 
 } 
 else 
 { 
 digitalWrite(pinorele1, HIGH); //Ativa o relé1 
 } 
 } 
 if (rele2 == 1) //Verifica se a tecla 4 foi acionada 
 { 
 digitalWrite(pinorele2, HIGH); //Ativa o relé2 
 } 
 if (rele2 == 0) //Verifica se a tecla 5 foi acionada 
 { 
 digitalWrite(pinorele2, LOW); //Desativa o relé2 
 } 
 if (rele2 == 2) //Verifica se a tecla 6 foi acionada 
 { 
 if (acionamento == LOW) //Verifica se há movimento 
 { 
 digitalWrite(pinorele2, LOW); //Desativa o relé2 
 } 
 else 
 { 
 digitalWrite(pinorele2, HIGH); //Ativa o relé2 
 } 
 } 
 acionamento_old = acionamento; 
} 
Após o código ser compilado, foi carregado no microcontrolador utilizando o cabo 
USB que o acompanha, após ser carregado com sucesso, desligou-se o microcontrolador, 
logo dando início a montagem do projeto na protoboard, o resultado final foi o seguinte: 
 
Imagem 9 – Projeto montado em protoboard 
Fonte: Acervo pessoal. 
 
Página 10 de 10 
 
5. RESULTADOS E DISCUSSÃO 
 
Após o projeto totalmente montado pode-se observar o mesmo em funcionamento 
da forma como esperado. 
Referente ao acionamento das cargas por controle remoto, o projeto apresentou 
uma ótima eficiência, podendo-se realizar o acionamento de duas cargas de forma 
independente ao pressionar os botões do controle referentes a cada uma das cargas, 
acionar as duas ao mesmo tempo também pelo controle remoto e também ativar o modo 
autônomo do sistema, acionando as cargas sempre que for detectado algum movimento 
pelo Sensor PIR. 
 
6. CONCLUSÃO 
 
Conclui-se que a utilização da placa de desenvolvimento Arduino Uno para o 
acionamento de cargas por controle remoto e/ou sensor de presença demonstrou-se muito 
eficiente. 
No nosso projeto, foram utilizadas apenas duas cargas independentes, mas com 
poucas modificações no esquemático e no código fonte pode-se acionar até nove cargas 
com apenas um Arduino Uno, também é possível o acréscimo de mais sensores, como 
luminosidade, temperatura, umidade, por exemplo, para que o mesmo faça os 
acionamentos de forma mais automatizada e inclusive temporizada. 
 
7. REFERÊNCIAS 
 
Sensor de presença com módulo PIR DYP-ME003 – Arduino e Cia. Disponível em: 
<http://www.arduinoecia.com.br/2014/06/sensor-presenca-modulo-pir-dyp-
me003.html>. 
Acesso em 29 de julho de 2017. 
 
Controle Remoto IR no Arduino – Arduino e Cia. Disponível em: 
<http://www.arduinoecia.com.br/2013/09/controle-remoto-ir-no-arduino.html>. 
Acesso em 29 de julho de 2017.