28 outubro 2013

Módulo RF Transmissor + Receptor 433 Mhz

Fui convidado a escrever um artigo para o blog do site FILIPEFLOP, mostrando a utilização de módulos RF 433 Mhz.

Montei um circuito para transmissão de dados, com os módulos RF 433 Mhz (Transmissor e Receptor), e também o LCD Nokia 5110. O resultado você confere no vídeo abaixo :




Gostou ? Então veja todos os detalhes, circuito e programa neste link :


Leia lá, comente lá ou aqui, que eu respondo do mesmo jeito. Abraço !


19 outubro 2013

Contador Display 7 segmentos - Video

Olá ! Conforme comentei, segue abaixo vídeo demonstrando o funcionamento do contador com display 7 segmentos de 3 dígitos, que abordei no artigo anterior :



15 outubro 2013

Contador Display 7 segmentos - 3 dígitos

Quem quer iniciar com o Arduino geralmente fica em dúvida sobre quais componentes comprar. Eu mesmo comprei algumas coisas que não usei até hoje... :-)

Pensando nisso, a FILIPEFLOP , parceira aqui do site, criou kits de componentes com tudo o que você precisa para montar seus primeiros experimentos. O kit básico, por exemplo, vem com o Arduino Uno, sensor ultrasonico, relé, push-button, leds, protoboard, jumpers, display LCD, fonte, potenciômetro, display 7 segmentos...e muito mais. Dê uma olhada nesse link e veja todos os kits disponíveis.

E falando em kit, no último artigo eu abordei o sensor óptico TCRT5000, mostrando o acionamento de um led com a aproximação de um objeto do sensor óptico, e hoje vou usar esse mesmo sensor óptico, mas juntamente com o display 7 segmentos 3 dígitos, que também vem no kit básico, para criar um contador.

O display 7 segmentos - 3 dígitos CPS03631BR é um display de anodo comum com 12 pinos, conforme mostrado no esquema abaixo (6 pinos na parte superior, 5 pinos na parte inferior, o pino 6 não é utilizado), e que você pode conferir no datasheet. São sete pinos para os segmentos A, B, C, D, E, F, G, um pino para o ponto decimal (DP), e um pino para cada dígito :

contador display 7 segmentos

Em um display 7 segmentos de apenas um dígito, é possível deixar o anodo sempre em estado alto, e ir acionando os segmentos conforme a necessidade, formando os  números. Nesse display de 3 dígitos, se eu deixar todos os anodos em estado alto, vou mostrar os mesmo números em todos os dígitos.

Como eu evito isso ? Usando um procedimento chamado multiplexação, que consiste no seguinte : aciono o anodo do dígito 1, e ligo os segmentos desejados, desligo o anodo do digito 1, ligo o anodo do digito 2 e aciono os segmentos desejados, e faço o mesmo procedimento com o digito 3, e depois repito o processo. Desta forma, uso os mesmo pinos do Arduino para a ativação dos segmentos de todos os dígitos. Dê uma olhada nessa animação abaixo, que mostra como isso acontece :

Animação multiplexação display 7 segmentos
Mostrando assim, parece que o display vai "piscar", não é mesmo ? Mas o segredo é fazer isso numa frequencia tão alta que o olho humano nem vai perceber, devido à um fenômeno conhecido como persistência da visão.

Antes de entrar na parte do circuito e do programa, gostaria de fazer um parênteses sobre a parte eletrônica. Eu verifiquei vários tutoriais e artigos diferentes, que mostram displays com 2 ou mais dígitos. Em alguns deles , são usadas resistências para ligar os pinos do Arduino diretamente ao anodo dos dígitos. Outros utilizam transistores, para não sobrecarregar e/ou ultrapassar a corrente máxima suportada pelo Arduino. Eu utilizei apenas um resistor de 1K em cada ligação dos anodos. Também liguei diretamente os pinos do Arduino aos pinos dos segmentos do display. Isso talvez reduza a vida útil do display, então recomendo que, dependendo da aplicação, esse procedimento seja revisto.

Vamos então à lista de materiais que utilizei :
  • 3 resistores de 1 K (um para cada dígito/anodo)
  • 1 resistor de 220 ohms (led IR do sensor óptico)
  • 1 resistor de 10 k (ligado ao sensor óptico - receptor)
  • Display 7 segmentos de 3 dígitos CPS03631BR
  • Sensor óptico reflexivo TCRT5000
Circuito contador com sensor óptico

Achei na internet vários exemplos de códigos usando multiplexação, e até criei um próprio (que não funcionou muito bem, diga-se de passagem), mas no final acabei utilizando a biblioteca SevSeg , que faz todo o serviço pesado : basta definir qual informação você quer mandar para o display (nesse programa exemplo, a varíavel CONTADOR), e a biblioteca faz o resto :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// Programa : Contador utilizando display 7 segmentos e TCRT5000  
// Alterações e adaptações : Arduino e Cia  
//  
// Baseado no exemplo da biblioteca SevSeg, de Dean Reading  
// deanreading@hotmail.com  
   
#include "SevSeg.h" //Carrega a biblioteca SevSeg  
   
SevSeg sevseg;  
   
//Cria variaveis globais  
int contador = 0;  

//Ligado ao pino "coletor" do sensor óptico - Porta A5 ao Arduino  
int pinosensor = 19; 
int leitura; //Armazena o valor lido pelo sensor  
   
void setup() 
{  
  //Utilizando display de anodo comum, pinos dos digitos : 10 a 13  
  //Pino dos segmentos : 2 a 9  
  sevseg.Begin(1,13,10,11,12,2,3,4,5,6,7,8,9);  
  //Controla a luminosidade - 0 a 100  
  sevseg.Brightness(20);  
  //Define o pino do sensor optico como entrada 
  pinMode(pinosensor, INPUT);  
}  
   
void loop() 
{  
  //Produce an output on the display  
  sevseg.PrintOutput();  
  sevseg.NewNum(contador,(byte) 2);

  //Le as informações do pino do sensor  
  leitura = digitalRead(pinosensor);   
  if (leitura != 1) //Verifica se o objeto foi detectado  
  {  
    contador = contador++; //Incrementa o valor do contador  

    //Loop caso o objeto pare sobre o sensor 
    while(digitalRead(pinosensor) != 1)  
    {  
      sevseg.PrintOutput();  
     sevseg.NewNum(contador,(byte) 2);  
    }  
  }   
}  

Se você precisa de um botão de reset para zerar o contador, veja o artigo Contador com botão de reset, aqui mesmo no Arduino e Cia.

Em breve publicarei um vídeo mostrando o funcionamento desse circuito. Até lá !

Atualizado : Contador Display 7 segmentos - Vídeo


08 outubro 2013

Sensor óptico reflexivo TCRT5000 - Vídeo

Pequeno vídeo mostrando o funcionamento do sensor óptico reflexivo TCRT5000 como um "interruptor óptico", conforme circuito e programa mostrados no post anterior :




07 outubro 2013

Sensor óptico reflexivo TCRT5000

Outro sensor da série "bom e barato" é esse Sensor Óptico Reflexivo TCRT5000 que chegou recentemente da FilipeFlop. É um daqueles sensores que eu considero essenciais na gaveta de qualquer "Arduinomaníaco".

Por menos de 5 reais, ou seja, por menos do que você pagaria por duas xícaras de café, você tem um sensor óptico reflexivo que você pode usar em sensores de movimento, interruptores, alarmes, contadores e robôs, apenas para citar alguns exemplos.

"- Ah, mas eu não sei o que é um sensor óptico reflexivo"

Tudo bem, eu também não sabia, pelo menos não com esse nome. Para entender como ele funciona, vamos dar uma olhada na estrutura do sensor, cujo datasheet você encontra neste link :

Sensor Óptico Reflexivo TCRT5000

Esse sensor tem 2 componentes no mesmo suporte : um led infravermelho (cor azul) e um transistor IR (fototransistor - cor preta), separados por uma pequena "parede". Quando algum objeto se aproxima do sensor, a luz infravermelha é refletida no objeto, "passa" para o outro lado e ativa o transistor :

Sensor Óptico TCRT5000 - Esquema e funcionamento


Perceba que o tipo de objeto que você quer detectar vai influenciar diretamente na operação do sensor, já que, quanto mais reflexivo o material, maior a distância que o sensor vai alcançar. Como exemplo, fiz um teste (sem precisão), onde o sensor foi acionado com um pedaço de papel (branco) à 23 mm, uma régua de metal foi detectada à 30 mm e, com um pedaço de madeira escura, o sensor nem foi acionado.

Para testar esse sensor óptico com o Arduino Uno R3, vamos primeiramente montar este circuito. Utilizei um resistor de 330 ohms para o led infravermelho e de 10K para o transistor :

Circuito teste sensor óptico TCRT5000
Carregue este programa, abra o serial monitor e aproxime objetos do sensor até que o objeto seja detectado. No serial monitor, o status muda de "Ausente" para "Detectado" :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Programa : Teste sensor óptico reflexivo  
// Autor : Arduino e Cia  
   
int objeto = 0;  
   
void setup()  
{  
  pinMode(7, INPUT); //Pino ligado ao coletor do fototransistor  
  Serial.begin(9600);  
}  
   
void loop()  
{  
  objeto = digitalRead(7);  
  if (objeto == 0)  
  {  
    Serial.println("Objeto : Detectado");  
  }  
  else  
  {  
    Serial.println("Objeto : Ausente !");  
  }  
} 

Com o sensor devidamente testado e funcionando, vamos acrescentar um led ao circuito, e teremos um "interruptor óptico", que altera o estado do led (ligado/desligado), cada vez que um objeto é detectado :

Circuito interruptor óptico com TCRT5000 Arduino



 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Programa : Acionamento de led utilizando sensor óptico reflexivo  
// Autor : Arduino e Cia  
   
int sinalparaoled = 8; //Pino do led  
int pinosensor = 7;   //Ligado ao pino "coletor" do sensor óptico  
int leitura;      //Armazena informações sobre a leitura do sensor  
int estadoled = 0;   //Armazena o estado do led (ligado/desligado)  
   
void setup()  
{  
  pinMode(sinalparaoled, OUTPUT); //Define o pino do led como saida   
  pinMode(pinosensor, INPUT);   //Define o pino do sensor como entrada
}  
   
void loop()  
{  
  //Le as informações do pino do sensor
  leitura = digitalRead(pinosensor);   
  if (leitura != 1) //Verifica se o objeto foi detectado  
  {  
    while(digitalRead(pinosensor) != 1)  
    {  
     delay(100);  
    }  

    //Inverte o estado do led (ligado / desligado) 
    estadoled = !estadoled; 

    //Liga ou desliga o led conforme "estadoled" 
    digitalWrite(sinalparaoled, estadoled); 
  }   
}  
     

Como você pôde ver, este é um sensor barato e que pode ser usado nas mais variadas aplicações. Em um dos próximos artigos, vou utilizar este sensor juntamente com um display 7 segmentos para construir um contador.

Até lá !

04 outubro 2013

Módulo relé 4 canais e controle remoto IR

Dias atrás um colega leitor do blog escreveu, com dúvidas sobre como programar o Arduino para utilizar um controle remoto IR e acionar relés.

O projeto dele consiste em utilizar o Arduino Uno, uma placa com 4 relés e um controle remoto IR da marca/fornecedor Open Jumper, para o controle de 4 lâmpadas. São lâmpadas de cores diferentes : vermelha, amarela, verde e azul, que devem ser acionadas ao apertar o botão correspondente no controle remoto. Por fim, a tecla ON acende todas as lâmpadas de uma vez, e a tecla OFF apaga todas, como mostrado nesse vídeo, utilizando leds no lugar das lâmpadas :


Na foto abaixo, a placa de relés utilizada :

Módulo relé 4 canais Arduino



Eu já havia escrito um artigo sobre Controle Remoto IR aqui no site, e apesar do controle IR da Open Jumper ser um pouco diferente, podemos usar a mesma biblioteca IRremote que usamos no outro artigo. O que muda são apenas alguns códigos hexadecimais das teclas. Montei uma tabela mostrando o controle remoto utilizado, e seus respectivos códigos :

Tabela codigos controle remoto IR
Para testar o programa, montei um circuito com leds no lugar das lâmpadas. O comum de cada relé (pino central) eu liguei em 5 Volts, e o contato NO (Normal Open/Normal Aberto) de cada relê, eu liguei no anodo do led correspondente. Note que na placa há um jumper entre o pino JD-Vcc e Vcc. O JD-Vcc é utilizado quando há necessidade de uma fonte externa para ativar os relés. Como vamos utilizar os 5 volts do próprio Arduino, mantenha o jumper na placa.

Circuito modulo rele 4 canais e controle remoto IR
Por fim, o programa, que eu tentei manter o mais simples possível, não só para facilitar o entendimento, mas também tornar qualquer modificação mais tranquila. Se necessário, troque algumas definições e acionamento de portas por rotinas utilizando FOR, por exemplo, ou use o comando IF no lugar de SWITCH. São várias as opções.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
// Programa : Relé 4 Canais com controle IR  
// Autor : Arduino e Cia  
  
#include <IRremote.h>  
   
int RECV_PIN = 11; //Ligado ao pino do receptor IR (pino S)  
int armazenavalor = 0;  
int pinorele1 = 2; //Pino do Arduino ligado ao IN1 da placa de relés  
int pinorele2 = 3; //Pino do Arduino ligado ao IN2 da placa de relés  
int pinorele3 = 4; //Pino do Arduino ligado ao IN3 da placa de relés  
int pinorele4 = 5; //Pino do Arduino ligado ao IN4 da placa de relés  
int estadorele1 = HIGH; //Armazena o estado do relé 1  
int estadorele2 = HIGH; //Armazena o estado do relé 2  
int estadorele3 = HIGH; //Armazena o estado do relé 3  
int estadorele4 = HIGH; //Armazena o estado do relé 4  
  
IRrecv irrecv(RECV_PIN);  
decode_results results;  
  
void setup()  
{  
  pinMode(pinorele1, OUTPUT);  //Define os pino dos reles como saída  
  pinMode(pinorele2, OUTPUT);    
  pinMode(pinorele3, OUTPUT);  
  pinMode(pinorele4, OUTPUT);  
  digitalWrite(pinorele1, estadorele1); //Coloca os pinos dos reles em
  digitalWrite(pinorele2, estadorele2); //estado alto (rele desligado)  
  digitalWrite(pinorele3, estadorele3);  
  digitalWrite(pinorele4, estadorele4);  
    
  Serial.begin(9600); //Inicializa a serial  
  irrecv.enableIRIn(); // Inicializa o receptor IR  
}  
   
void loop()  
{  
  //Verifica se o sensor IR recebeu algum sinal
  if (irrecv.decode(&results))   
  {  
    //Mostra na serial o valor lido pelo sensor IR
    Serial.print("Valor lido : "); 
    Serial.println(results.value, HEX);
    //Armazena o sinal recebido pelo sensor IR  
    armazenavalor = (results.value);   
    switch (armazenavalor)  
    {  
     case 0xFF22DD: //Verifica se a tecla vermelha foi acionada  
      estadorele1 = !estadorele1;  
      //Aciona rele 1 e liga led vermelho
      digitalWrite(pinorele1, estadorele1);   
      break;  
      
     case 0xFFE01F: //Verifica se a tecla amarela foi acionada  
      estadorele2 = !estadorele2;  
      //Aciona rele 2 e liga led amarelo  
      digitalWrite(pinorele2, estadorele2); 
      break;  
      
     case 0xFF02FD: //Verifica se a tecla verde foi acionada  
      estadorele3 = !estadorele3;  
      //Aciona rele 3 e liga led Verde  
      digitalWrite(pinorele3, estadorele3); 
      break;  
      
     case 0xFF906F: //Verifica se a tecla azul foi acionada  
      estadorele4 = !estadorele4;  
      //Aciona rele 4 e liga led azul  
      digitalWrite(pinorele4, estadorele4); 
      break;  
      
     case 0xFFE21D: //Verifica se a tecla OFF foi acionada  
      //Desliga todos os reles, colocando as portas em nivel alto  
      digitalWrite(pinorele1, HIGH);   
      digitalWrite(pinorele2, HIGH);  
      digitalWrite(pinorele3, HIGH);  
      digitalWrite(pinorele4, HIGH);  
      //Seta o estado de todos os reles para alto (desligados)  
      estadorele1 = HIGH;  
      estadorele2 = HIGH;  
      estadorele3 = HIGH;  
      estadorele4 = HIGH;  
      break;  
     
     case 0xFFA25D: //Verifica se a tecla ON foi acionada  
      //Liga todos os reles, colocando as portas em nivel baixo  
      digitalWrite(pinorele1, LOW);  
      digitalWrite(pinorele2, LOW);  
      digitalWrite(pinorele3, LOW);  
      digitalWrite(pinorele4, LOW);  
      //Seta o estado de todos os reles para baixo (ligados)  
      estadorele1 = LOW;  
      estadorele2 = LOW;  
      estadorele3 = LOW;  
      estadorele4 = LOW;  
      break;  

     case 0xFF42BD: //Verifica se a tecla 7 foi acionada  
      //Desliga todos os reles, colocando as portas em nivel alto  
      digitalWrite(pinorele1, HIGH);  
      digitalWrite(pinorele2, HIGH);  
      digitalWrite(pinorele3, HIGH);  
      digitalWrite(pinorele4, HIGH);  
      delay(1000); //Aguarda 1 segundo   
      digitalWrite(pinorele1, LOW); //Aciona o rele 1   
      delay(500); //Aguarda 500 ms   
      digitalWrite(pinorele2, LOW); //Aciona o rele 2  
      delay(500); //Aguarda 500 ms  
      digitalWrite(pinorele3, LOW); //Aciona o rele 3  
      delay(500); //Aguarda 500 ms   
      digitalWrite(pinorele4, LOW); //Aciona o rele 4  
      delay(2000); //Aguarda 2 segundos  
      //Desliga todos os reles, colocando as portas em nivel alto  
      digitalWrite(pinorele1, HIGH);  
      digitalWrite(pinorele2, HIGH);  
      digitalWrite(pinorele3, HIGH);  
      digitalWrite(pinorele4, HIGH);  
      //Seta o estado de todos os reles para alto (desligados)   
      estadorele1 = HIGH;  
      estadorele2 = HIGH;  
      estadorele3 = HIGH;  
      estadorele4 = HIGH;  
      break;  
    }  
  irrecv.resume(); //Le o próximo valor  
  }  
} 

Como mostrado no vídeo no início deste artigo, teste o programa acionando o botão vermelho do controle remoto para acender o led vermelho, amarelo para o amarelo e assim por diante. Para acender todos os leds de uma vez utilize a tecla ON, e para desligar, a tecla OFF.  A tecla com o número 7 do controle remoto apaga todos os leds, depois os acende em sequencia.

O programa ainda exibe no Serial Monitor o valor em hexadecimal das teclas que foram acionadas. Desta forma, você consegue adaptar o programa ao seu controle remoto (dependendo do modelo), apenas alterando esses valores.