O modulo sensor de presença infravermelho trata-se de um conjunto compacto de componentes que permitem o acionamento de um sensor de presença, e o usuário tem controle de ajustes sobre tempo e a sensibilidade do dispositivo.
fonte: https://learn.adafruit.com
No ajuste de sensibilidade do sensor o usuário pode determinar à qual distância o objeto deve ser detectado, dentro de distâncias entre 3 a 7 metros e o tempo acionamento que pode variar de 5 a 200 segundos. Esses ajustes podem se conseguidos por meio de potenciômetros localizados na base do sensor.
fonte: próprio autor
O modulo deve receber alimentação entre 4,5V e 20V em CC. De simples ligação, conta com somente um pino que envia ao microcontrolador um sinal Alto (HIGH) ao detectar movimento e sinal Baixo (LOW) quando nenhum movimento é detectado.
fonte: https://www.robotics.org.za
Utilizando o modulo PIR
Para a realização dos projetos apresentados, deve-se ter a mão os seguintes componentes:
1 Arduino Uno (ou compatível)
1 Sensor PIR
2 Leds coloridos
1 Buzzer 5Vcc
3 resistores 220 ohms
cabos jumpers protoboard (matriz de contatos)
Esquema de montagem
fonte: próprio autor
fonte: próprio autor
Com a montagem feita, copie e cole o código abaixo e verifique o funcionamento.
O código fonte
/** Código **/
// Elaborado por Tony Emerson Marim em 17/12/2016.
/** mecatronizando@gmail.com **/
/** Alarme com sensor PIR e LEDs**/
//Variáveis digitais.
int pinBuzzer = 3;
int pinSensorPIR = 7;
int pinLedvm = 8;
int pinLedam = 9;
int SensorPIR = 0;
void setup() {
Serial.begin(9600); //Inicializando o serial monitor
//Definido pinos como de entrada ou de saída
pinMode(pinBuzzer,OUTPUT);
pinMode(pinSensorPIR,INPUT);
pinMode(pinLedvm,OUTPUT);
pinMode(pinLedam,OUTPUT);
}
void loop() {
//Lendo o valor do sensor PIR.
SensorPIR = digitalRead(pinSensorPIR);
Serial.print("Valor do Sensor PIR: "); //1 quando detecta algum movimento e 0 quando não detecta.
Serial.println(SensorPIR);
//Verificando detecção de movimentos
if (SensorPIR == 1) {
Alarmeacionado();
} else {
Alarmedesligado();
}
}
void Alarmeacionado() {
//Ligando o led
digitalWrite(pinLedvm, HIGH);
delay(500);
digitalWrite(pinLedvm, LOW);
delay(500);
digitalWrite(pinLedam, HIGH);
delay(500);
digitalWrite(pinLedam, LOW);
delay(500);
//Ligando o buzzer com uma frequencia de 600 hz.
tone(pinBuzzer,600);
delay(2000); //tempo que o led fica acesso e o buzzer toca
Alarmedesligado();
}
void Alarmedesligado() {
//Desligando o led
digitalWrite(pinLedvm, LOW);
digitalWrite(pinLedam, LOW);
//Desligando o buzzer
noTone(pinBuzzer);
}
No código é possível observar o comportamento do sensor pro meio do monitor serial da IDE do Aduino.
fonte: próprio autor
No vídeo abaixo é demonstrado o funcionamento do nosso projeto.
Curtiu? Compartilhe, comente, use nossa FanPage! Assine o canal!
Caso seja necessário o projeto completo pode ser baixado por esse LINK!
Anteriormente vimos no site uma postagem de como acionar um motor de passo utilizando um drive Ponte H L298N, hoje vamos conhecer um pouco sobre o drive A4988 para motor de passo bipolar.
fonte: https://www.pololu.com
Esse pequeno drive permite um controle por meio de "micropassos", permitindo assim que o usuário obtenha em seu projeto posicionamentos mais exatos onde exige uma melhor precisão.
fonte: https://www.pololu.com
O módulo Drive A4988 trabalha utilizando tensões de 3V e 5V e para o acionamento dos motores permitem tensões aplicadas que podem variar de 8 à 35V.
fonte: https://www.pololu.com
O controle básico do motor é realizado por dois pinos do modulo, o STEP (passo) e DIR (direção).
Abaixo é possível observar a função dos pinos localizados no modulo.
fonte: https://www.pololu.com
Controlando motor com drive A4988 e Arduino
Para a realização desse projeto é necessário que você tenha em mãos:
1 motor de passo (na demostração estou utilizando um nema 17 PM-K047-02V)
fonte externa 12V 1A
fios jumpers
O controle do motor em questão foi a pedido de um leitor do blog para testar os motores que serão usados em uma impressora 3D.
Esquema de ligação
Vamos conectar o drive A4988 ao Arduino e controlar o movimento direcional do motor por meio do potenciômetro.
Além dos pinos STEP e DIR, utilizei também os pinos MS1 e MS2 para utilizar o recurso de micropassos que o modulo oferece possibilitando ao acionar esses pino os modos full-step, half-step, quarter-step, eight-step e sixteenth-step.
Observar que na alimentação externa que é necessário para que o motor funcione corretamente foi inserido um capacitor de 100uF, onde pelas especificações do fabricante é indicado para compensar a sensibilidade do modulo em relação a picos de tensão.
fonte: próprio autor
Atenção ao capacitor entre os pinos VMOT e GND, e ao jumper entre os pinos SLEEP e RESET.
O código fonte
Copie e cole o código na IDE do seu Arduino e observe o funcionamento.
/** Código para Projeto DRIVE A4988 com potenciometro_Tony Emerson Marim **/
// Elaborado por Tony Emerson Marim em 11/12/2016.
/** mecatronizando@gmail.com **/
/** Controle de Motor de passo Nema17 com drive A4988 por potenciometro(direcionamento) **/
#define STEP 6 // Pino 6 conectado ao pino STEP no drive
#define DIR 7 // Pino 7 conectador ao pino Direction no drive
#define MS1 10 // Pino 10 conectado ao pino MS1 no drive
#define MS2 9 // Pino 9 conectado ao pino MS2 no drive
#define SLEEP 8 // Pino 8 conectado ao pino SLEEP no drive
#define POT A5 // Pino A5 analogico conectado ao pino de controle do potenciometro
int direction; // Variavel para setar a rotação (CW-CCW) do motor
int steps = 1025; // Posição de centro assumida
void setup() {
pinMode(MS1, OUTPUT);
pinMode(MS2, OUTPUT);
pinMode(DIR, OUTPUT);
pinMode(STEP, OUTPUT);
pinMode(SLEEP, OUTPUT);
digitalWrite(SLEEP, HIGH); // "Desperta" drive
delay(5);
digitalWrite(MS1, LOW); // Configuração dos Passos
digitalWrite(MS2, LOW); // Configuração dos Passos
}
void loop() {
while (analogRead(POT) >= 0 && analogRead(POT) <= 100) {
if (steps > 0) {
digitalWrite(DIR, HIGH); // (HIGH = anti- horário / LOW = horário)
digitalWrite(STEP, HIGH);
delay(1);//Tempo do passo ( quanto maior mais lento)
digitalWrite(STEP, LOW);
delay(1);
steps--;
}
}
while (analogRead(POT) > 100 && analogRead(POT) <= 400) {
if (steps < 512) {
digitalWrite(DIR, LOW);
digitalWrite(STEP, HIGH);
delay(1);
digitalWrite(STEP, LOW);
delay(1);
steps++;
}
if (steps > 512) {
digitalWrite(DIR, HIGH);
digitalWrite(STEP, HIGH);
delay(1);
digitalWrite(STEP, LOW);
delay(1);
steps--;
}
}
while (analogRead(POT) > 401 && analogRead(POT) <= 600) {
if (steps < 1025) {
digitalWrite(DIR, LOW);
digitalWrite(STEP, HIGH);
delay(1);
digitalWrite(STEP, LOW);
delay(1);
steps++;
}
if (steps > 1025) {
digitalWrite(DIR, HIGH);
digitalWrite(STEP, HIGH);
delay(1);
digitalWrite(STEP, LOW);
delay(1);
steps--;
}
}
while (analogRead(POT) > 601 && analogRead(POT) <= 900) {
if (steps < 1535) {
digitalWrite(DIR, LOW);
digitalWrite(STEP, HIGH);
delay(1);
digitalWrite(STEP, LOW);
delay(1);
steps++;
}
if (steps > 1535) {
digitalWrite(DIR, HIGH);
digitalWrite(STEP, HIGH);
delay(1);
digitalWrite(STEP, LOW);
delay(1);
steps--;
}
}
while (analogRead(POT) > 900 && analogRead(POT) <= 1024) {
if (steps < 2050) {
digitalWrite(DIR, LOW);
digitalWrite(STEP, HIGH);
delay(1);
digitalWrite(STEP, LOW);
delay(1);
steps++;
}
}
}
No Vídeo abaixo é possível ver o funcionamento do controle elaborado utilizando o potenciômetro como direcional.
O Light Dependent Resistor (LDR) trata-se de um componente que tem sua resistência variada em função da luminosidade do ambiente. Em situações onde a quantidade de luz aumenta sobre o componente menor torna-se sua resistência.
Para encontramos esse tipo de sensores no dia a dia, basta no entardecer observarmos o comportamento da iluminação urbana, com o por do sol a quantidade de iluminação natural baixa e consequentemente sua resistência também permitido de maneira automática o acender das luzes. N estrutura de um relé fotoelétrico que compõe o acionamento de iluminação dos postes, existe uma estrutura mais elaborada eletro mecanicamente do que a que vamos apresentar a seguir, mas o mesmo componente se encontra lá para o perfeito funcionamento.
Nesse projeto de nível bem simples e prático, vamos elaborar uma situação onde na ausência de luz, um LED de emergência deve ser aceso e uma mensagem de estado deve ser demonstrada pelo monitor serial do Arduino.
Para isso você deve ter em mãos:
1 Arduino Uno (ou compatível)
1 LDR
1 resistor de 220 ohm
1 resistor de 10k
fios jumpers
1 protoboard (matriz de contatos)
Esquema de ligação
Seguir a montagem conforme a figura abaixo.
fonte: próprio autor
O código fonte
Sem a necessidade de nenhuma biblioteca, copie e cole na IDE do seu Arduino e execute para entender se funcionamento.
/** Código para Projeto LDR_Tony Emerson Marim **/
// Elaborado por Tony Emerson Marim em 10/12/2016.
/** mecatronizando@gmail.com **/
/** Controle de LED dependente da iluminação ambiente **/
const int ledPin = 10;
const int ldrPin = A1;
void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
pinMode(ldrPin, INPUT);
}
void loop() {
int ldrStatus = analogRead(ldrPin);
if (ldrStatus <=100) {
digitalWrite(ledPin, HIGH);
Serial.println("LDR BLOQUEADA, LED LIGADO");
}
else {
digitalWrite(ledPin, LOW);
Serial.println("LDR LIVRE, LED DESLIGADO");
}
}
fonte: próprio autor
fonte: próprio autor
No vídeo abaixo é demonstrado o funcionamento do circuito.
Esse display possibilita que seja escrito números decimais de 0 a 9, além de outros símbolos comumente utilizados como sinais ou letras.
entre as tecnologias de fabricação existentes para fabricação desses componentes, o mais comum é o display a LED, onde cada segmento é composto por um LED e dividi-se em dois tipos denominados catodo comum e anodo comum.
Como o próprio nome diz, o display catodo comum é aquele que possui todos os catodos dos LEDs interligados, em comum, onde para o acionamento (acender), é necessário aplicar o nível lógico 1 no anodo. No anodo comum todos os anodos dos LEDs estão interligados, sendo necessário o nível lógico 0 para ser acionado.
Então para fazer funcionar alguns comando com Arduino basta acionar um led por saída do e combinar os acionamentos.
fonte: www.physics.udel.edu
Vamos precisar para esse simples tutorial:
1 Arduino Uno (ou compatível) 1 Display 7 segmentos 8 resistores de 220 ohms 1 resistor de 330 ohm 1 resistor de 10 k 1 chave pushbutton 1 protoboard fios jumpers
Projeto 1
Na primeira montagem vai ser demonstrado led a led acionando no display, testando as saídas digitais dos pinos 2 a 9.
*Atenção: em todos os projetos os estados altos (HIGH) ou baixos (LOW), vai depender do tipo de display que foi escolhido, catodo ou anodo em comum, alterações em algumas linhas dos códigos podem ser necessárias.
fonte: próprio autor
Utilize o código fonte para testar o programa, lembre-se de que a escolha do display anodo comum ou catodo comum fica conforme a disponibilidade do usuário, atentando-se sempre para a ligação.
/*-----------------------------------------------------------------------
Display LED 7 segmentos
Teste das portas
baseado no original de Just4Fun Media
*************************************************************************
www.mecatronizando.com.br
**************************************************************************
*/
void setup() {
for(int x = 2; x < 10; x++) {
pinMode(x,OUTPUT);
}
}
void loop() {
for(int x = 2; x < 10; x++) {
digitalWrite(x,HIGH);
delay(1000);
digitalWrite(x, LOW);
}
for(int x = 2; x < 10; x++) {
digitalWrite(x,HIGH);
}
delay(1000);
for(int x = 2; x < 10; x++) {
digitalWrite(x,LOW);
}
}
Projeto 2
Utilizando a mesma montagem do projeto anterior, carregue o código para ver valores crescentes de 0 a 9 no display.
O próximo projeto faz uma integração do usuário com o display por meio do monitor serial do Arduino. O numero digital no teclado é exibido no display.
As ligações do circuito permanecem as mesmas anteriores.
/*-----------------------------------------------------------------------
Teste display 7 segmentos serial
Interface com monitor serial
baseado no original de Just4Fun Media
por Tony Emerson Marim 26/11/2016
*************************************************************************
www.mecatronizando.com.br
**************************************************************************
*/
void setup() {
// put your setup code here, to run once:
for(int x = 2; x < 10; x++) {
pinMode(x,OUTPUT);
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
}
}
}
void loop() {
if (Serial.available()) {
char Num = (Serial.read());
switch (Num) {
case '0':
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, LOW);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '1':
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
digitalWrite(5, LOW);
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(8, LOW);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '2':
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, LOW);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '3':
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '4':
digitalWrite(2, HIGH);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
digitalWrite(5, LOW);
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '5':
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, LOW);
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '6':
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, LOW);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '7':
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, LOW);
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(8, LOW);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '8':
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.write(Num);
break;
case '9':
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.write(Num);
break;
default:
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);
digitalWrite(5, LOW);
digitalWrite(6, LOW);
digitalWrite(7, LOW);
digitalWrite(8, LOW);
digitalWrite(9, LOW);
Serial.write(Num);
break;
}
}
}
Projeto 4
Nesse quarto e último projeto, o display vai exibir números de 0 a 9 em ordem crescente. Conforme a necessidade do usuário um botão tipo pushbutton deve ser adotado e a velocidade de troca dos valores dos números exibidos dependem do toque no botão.
Nesse circuito vamos mudar as ligações em relação aos últimos circuitos e criar um esquema mais "enxuto". Basta seguir o desenho abaixo e copiar e colar o código na IDE do seu Arduino.
No vídeo abaixo é possível ver todos os projetos da página funcionando conforme os passos apresentados. Caso seja necessário, todos os arquivos podem ser baixados por esse LINK.
Gostou?
Curta nossa página no Facebook!
Assine o nosso canal no Youtube, curta e compartilhe para podermos estar sempre trazendo um pouco de programação.
A identificação por rádio frequência ou Radio Frequency Identification, consiste em uma tecnologia que utiliza sinais de radio para leitura/gravação de uma tag (etiqueta). Dentro dessa tag uma série de informações estão gravadas e relacionadas com o serviço ou produto, para identificação ou acesso ou outras aplicações. Para ter uma ideia, hoje em dia é comum o uso do RFID no controle à acesso no sistema de transporte público ("Bilhete Único") e no controle sobre acesso em rodovias ("Sem Parar") e logística.
fonte: Wikipedia
No modulo RFID RC522, consegue ler e gravar tag em cartões tipo Mifare que operam na frequência 13,56 Mhz. Utiliza interfaec SPI para comunicação com o Arduino e sua ligação por meio dos pinos digitais de 9 a 13.
Para cada tag do leitor RFID existe uma identificação única que pode ser inserido na programação para definir acessos e prioridades.
fonte:http://rfidblog.com.br/tag/rfid
A pinagem para uma correta ligação do RFID com Arduino deve obedecer a seguinte ordem:
3,3V: Deve ser ligada ao pino de tensão 3,3V do Arduino RST: Deve ser conectado ao pino 9 do Arduino GND: GND IRQ: Não Conectar MISO: Conectar ao pino 12 MOSI: Conectar ao pino 11 SCK: Conectar ao pino 13 SDA: Conectar ao pino 10
Controle de nível de acesso RFID
O projeto consiste em um controle de acesso para simular uma situação onde as tags relacionadas determinam ao usuário se existe uma atribuição relacionada ao seu número.
Primeiro vamos elaborar um circuito que possibilite ao usuário descobrir os dados que estão gravados no seu cartão, assim poderemos identificar as tags que devem ser inseridas no código e definir as prioridades.
O esquema de ligação
Para começar demos realizar uma montagem conforme o esquema abaixo:
fonte: próprio autor
A ligação de alimentação do módulo deve ser de 3,3V para evitar efeitos prejudiciais à placa!
O código
Antes de copiar e colar o código, é importante ressaltar que a biblioteca que estou usando pode ser baixado por este Link.
Agora copie e cole o código para ler as tags do seu cartão ou chaveiro RFID.
#include <SPI.h>
#include <MFRC522.h>
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);
void setup()
{
Serial.begin(9600); // Inicia a serial
SPI.begin(); // Inicia SPI bus
mfrc522.PCD_Init(); // Inicia MFRC522
}
void loop()
{
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
delay(500);
String conteudo= "";
for (byte i = 0; i < mfrc522.uid.size; i++)
{
conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.print("TAG LIDA: ");
conteudo.toUpperCase();
Serial.println(conteudo.substring(1));
}
fonte: próprio autor
O valor da Tag deve ser exibido por meio do monitor serial e informado a sequencia que pode ser utilizada no código de acesso ou não no projeto.
O projeto
Agora depois de descoberto as tags do cartão (ou chaveiro) vamos alterar o Código que vai executar o nosso projeto.
O projeto consiste na seguinte lógica, os cartões autorizados devem acessar o sistema indicando por meio de leds os funcionários que têm acesso e um pulso informa via internet, em um browser se o funcionário deu entrada no local.
Para o projeto você deve ter em mãos:
1 Arduino Uno (ou compatível) 1 módulo RFID MC522 1 display LCD 16x2 1 protoboard 1 potenciômetro 10k 2 leds (vermelho e verde) 2 resistores 220 ohm
Primeiro vamos montar o esquema abaixo em uma protoboard.
fonte: próprio autor
O código fonte do projeto
Feito toda a montagem, é hora de carregar o código no seu Arduino e testar, o projeto deve dar acesso às tags previamente autorizadas informando ao usuário a liberação por mensagem na LCD e acendendo um sinal visual por meio de um led verde, caso sua tag não esteja autorizada o usuário também recebe uma mensagem e um led vermelho pisca alertando-o.
Copie e cole o código para testar em seu circuito.
**a biblioteca utilizada pode ser baixada no link ao final do post!
// Programa : RFID - Controle de acesso / cancela
// Autor : Tony Emerson Marim
//basedo no original de Arduino e CIA
//www.mecatronizando.com.br
#include <SPI.h>
#include <MFRC522.h>
#include <LiquidCrystal.h> //Carrega a biblioteca LCD
#define SS_PIN 10
#define RST_PIN 9
// Definicoes pino modulo RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);
//Define os pinos que serão ligados ao LCD
LiquidCrystal lcd(6, 7, 5, 4, 3, 2);
// Leds indicadores acesso liberado ou negado
int led_liberado = 8;
int led_negado = 16;
char st[20];
void setup()
{
Serial.begin(9600); //Inicializa a serial
pinMode (led_liberado, OUTPUT);
pinMode (led_negado, OUTPUT);
lcd.begin(16,2); //Inicializa LCD
lcd.clear(); //Limpa o LCD
// Inicia a serial
Serial.begin(9600);
// Inicia SPI bus
SPI.begin();
// Inicia MFRC522
mfrc522.PCD_Init();
// Mensagens iniciais no serial monitor
Serial.println("Aproxime o seu cartao do leitor...");
Serial.println();
lcd.begin(16,2);
mensageminicial();
}
void loop()
{
// Aguarda a aproximacao do cartao
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
// Seleciona um dos cartoes
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
// Mostra UID na serial
Serial.print("UID da tag :");
String conteudo= "";
byte letra;
for (byte i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
Serial.print("Mensagem : ");
conteudo.toUpperCase();
// Testa se o cartao1 foi lido
if (conteudo.substring(1) == "A5 76 7A 25")
{
digitalWrite(led_liberado, HIGH);
Serial.println("Cartao1 - Acesso liberado !");
Serial.println();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Ola USUARIO 1!");
lcd.setCursor(0,1);
lcd.print("ACESSO PERMITIDO !");
delay(2000);
digitalWrite(led_liberado, LOW);
mensageminicial();
}
// Testa se o cartao2 foi lido
if (conteudo.substring(1) == "3A 42 0F BB")
{
digitalWrite(led_liberado, HIGH);
Serial.println("Cartao2 - Acesso liberado !");
Serial.println();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Ola USUARIO 2!");
lcd.setCursor(0,1);
lcd.print("ACESSO PERMITIDO !");
delay (2000);
digitalWrite(led_liberado, LOW);
mensageminicial();
}
// Testa se o cartao3 foi lido
if (conteudo.substring(1) == "E5 77 17 53")
{
Serial.println("Cartao2 - Acesso negado !!!");
Serial.println();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("DESCONHECIDO !");
lcd.setCursor(0,1);
lcd.print("Acesso Negado !");
delay (2000);
// Pisca o led vermelho
for (int i= 1; i<5 ; i++)
{
digitalWrite(led_negado, HIGH);
delay(200);
digitalWrite(led_negado, LOW);
delay(200);
}
mensageminicial();
}
delay(500);
}
void mensageminicial()
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("MECATRONIZANDO");
delay(2000);
lcd.clear();
lcd.print(" Aproxime o seu");
lcd.setCursor(0,1);
lcd.print("cartao do leitor");
}
No vídeo abaixo é possível ver o funcionamento do projeto.
Nesse artigo abordaremos uma integração entre três componentes abordando um conceito de IoT (Internet of Things). Um acionamento de uma saída onde um módulo ESP8266 conectado na rede mundial (Internet) via wi-fi deve acender um led, como demonstração, mas antes devemos conhecer os principais equipamentos usados no projeto.
fonte: próprio autor
ESP8266
Desenvolvido pela Espressif, desde seu lançamento destaca-se pelo seu tamanho reduzido e pelo seu baixo custo (é possível encontrá-lo por menos que $5,00 dólares). Para explorar o conceito de Internet das Coisas - IoT, existem disponíveis no mercado um grande número de diferentes módulos, mas oque vamos utilizar é o modelo ESP8266 ESP-01.
Com a função primordial de receber comando via Serial (UART) interagindo com a rede Wi-Fi por meio de conexões TCP/UDT, inclusive operando em modo standalone, como microcontroladores no Wi-Fi.
No modelo que destaca-se nesse projeto vamos utilizá-lo como uma ponte Serial/Wi-fi e para isso necessita-se de um Arduino ou qualquer outro microcontrolador que tenha uma porta de comunicação serial.
fonte: http://www.keywordhut.com/cnN0IGZvcm0/
Pinagem básica:
VCC: Tensão de alimentação 3,3V;
GND: sinal de ddp;
Tx: sinal transmissor do módulo;
Rx: sinal recepstor do módulo;
RST: sinal de restart do módulo;
CH_PD: usado para gravação de firmware ou atualização, mantido em alto nível para operação normal;
GPIO0: pode ser controlado pelo firmware, nível baixo para update ou nível alto para operação normal;
GPIO2: I/O controlada pelo firmware
Leds indicadores: vermelho para indicar funcionamento e azul para atividade.
Como citado anteriormente, o módulo pode ser usado em modo standalone, onde pode utilizar o GPIO0 e GPIO2 controlando entrada e saída, podendo ser configurado para leitura de sinais, acionamentos entre outras funções, e é aí que entra nosso projeto.
fonte: próprio autor
FTDI 232
O conversor FTDI ( Future Technology Devices International) é um módulo conversor USB para TTL que foi baseado em FT232RL e permite a interface de dispositivos TTL via USB.
fonte: http://br-arduino.org
fonte: próprio autor
Blink
Consiste em um conjunto de ferramentas disponíveis para o mundo da IoT (internet of things - internet das coisas), onde os usuários podem elaborar uma aplicação conforme sua necessidade. O Blynk é uma plataforma desenvolvida para realizar controle sobre as placas comerciais mais usadas atualmente por inventores, professores, estudantes e hobbistas em todos os níveis de conhecimento, do básico ao avançado em qualquer tipo de projeto eletroeletrônico microcontrolado.
Proveniente de uma iniciativa financiada pela Kickstarter, foi um sucesso durante a campanha de criação.
O Blynk integra um aplicativo "montado" pelo usuário com hardwares, por meio da internet permitindo o controle das saídas digitais.
De funcionamento simples e sem a necessidade de programação, o usuário só tem que inserir uma chave (token) gerada pelo aplicativo para o reconhecimento em seu código fonte.
O aplicativo utilizado para que seu projeto seja executado pode ser encontrado na loja do seu sistema, seja Android ou iOS.
fonte: http://docs.blynk.cc/
O projeto
Então conhecidos os principais componentes do projeto vamos começar a montagem.
Para esse projeto vai ser necessário ter me mãos:
1 módulo FTDI 232
1 módulo ESP8266-01
1 fonte externa com tensão de 3,3V
1 protoboard
1 Led
1 resistor 220 ohm
fios Jumpers
fonte: próprio autor
Passo 1
O primeiro passo para realização do projeto é conectar o ESP8266-01 com o FTDI comforme o esquema abaixo.
fonte: próprio autor
CUIDADO!!! Tanto o módulo ESP8266 quanto o FTDI trabalham com tensão de 3,3V!
O módulo FTDI não fornece corrente suficiente para o módulo ESP8266 sendo necessário o uso de uma fonte externa de 3,3V
Passo 2
Na IDE do Arduino vá para: Arquivos > Exempos > Blynk > Boards Wi_Fi > ESP8266_Standalone.
fonte: próprio autor
fonte: próprio autor
Abra agora no seu celular o aplicativo Blynk e vá para: Criar um novo projeto (Create new project) > Dê um nome ao projeto e escolha a placa ESP8266 > clique em enviar auth token por email > Create.
fonte: próprio autor
Agora ao clicar no aplicativo Blynk no ícone parecido com uma porca sextavada, é possível nomear seu projeto como preferir.
fonte: próprio autor
Passo 3
Feito isso, o próximo passo é alterar o código que vamos usar, é necessário que em char auth [ ], o usuário insira o auth token gerado pelo Blynk e enviado por email, em char ssid [ ] = " Inserir o nome de sua rede wi-fi" e em char pass [ ] = " Inserir a senha de sua rede wi-fi".
fonte: próprio autor
Na IDE do Arduino escolha, Ferramentas > placa Generic ESP8266 moule e mantenha as opções padrão.
fonte: próprio autor
Conecte o FTDI e ligue a fonte externa, feito isso é só descarregar o código, não esqueça de especificar a COM utilizada.
fonte: próprio autor
Depois de carregar o código, vamos colocar o ESP em Standalone e inserir um botão de controle no Blynk.
Passo 4
Pode-se tirar a ligação do FTDI, pois não vamos mais precisar do módulo nas próximas etapas.
Então agora faremos as ligações a seguir.
fonte: próprio autor
Passo 5
Abrir o projeto iniciado no Blynk e inserir um botão. Clique no sinal de mais no alto á direita e escolha button, toque no botão para inserir as configurações necessárias. Em PIN selecione Digital e gp2 PWM > Continue.
fonte: próprio autor
Toque o círculo ao lado do button para selecionar a cor do seu led > Altere o mode de PUSH para SWITCH.
fonte: próprio autor
Volte para a página principal e inicie o "play" do aplicativo.
fonte: próprio autor
No vídeo abaixo é possível ver uma demonstração do projeto em funcionamento.
Assim como costumo dizer, se acendo um led, inserindo uma eletrônica de potência posso acionar qualquer coisa....
Breve estarei postando um acionamento de dispositivos com diferentes tensões via Blynk/ Wi-Fi.
