28 setembro 2013

Controle de luz utilizando LDR

Algumas pessoas me escreveram perguntando sobre sensores de luz, e como poderia ser montado um dispositivo que acendesse uma lâmpada ao escurecer.

Esse é um circuito bem simples de montar, e que utiliza pouquíssimos componentes, entre eles, um componente barato e fácil de encontrar : o LDR (Light Dependent Resistor, ou Resistor Dependente de Luz), componente disponível no Kit Arduino Iniciante da loja FILIPEFLOP.


Arduino LDR

O LDR, como o próprio nome diz, é um resistor cuja resistência varia em função da luminosidade que incide sobre ele, devido ao material fotossensível que cobre o componente.

Ao iluminarmos um LDR, a sua resistência apresenta valores muito baixos. Ao cortarmos a iluminação, a resistência sobe. Observe isso na prática, nas fotos abaixo, onde eu aplico luz ao LDR (imagem da esquerda), e a resistência medida é baixa, e na imagem da direita, cubro parcialmente o LDR e ocorre o aumento da resistência :

Comparativo resistência LDR

Conhecendo os princípios básicos do componente, podemos montar um circuito onde, com incidência de luz, o led se apaga, e ao cobrirmos o LDR, o led se acende :

Circuito LDR Led - Arduino Uno
O programa para este circuito lê o valor da porta analógica (que deve estar na faixa de 0 a 1024), verificando se o valor é maior do que 800 (LDR encoberto) e consequentemente acendendo o led. Usei no meu circuito um resistor de 330 ohms para o led e de 10K para o LDR. Caso o seu circuito não funcione adequadamente, ajuste esses valores :

 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
// Programa : LDR - Sensor de Iluminação  
// Autor : Arduino e Cia  
   
int portaLed = 10; //Porta a ser utilizada para ligar o led  
int portaLDR = A5; //Porta analógica utilizada pelo LDR  
  
void setup()  
{  
  pinMode(portaLed, OUTPUT); //Define a porta do Led como saída  
}  
   
void loop()  
{  
  int estado = analogRead(portaLDR);  //Lê o valor fornecido pelo LDR  
    
  // Caso o valor lido na porta analógica seja maior do que 
  // 800, acende o LED  
  // Ajuste o valor abaixo de acordo com o seu circuito  
  if (estado > 800)    
  {  
    digitalWrite(portaLed, HIGH);  
  }  
  else  //Caso contrário, apaga o led  
  {  
    digitalWrite(portaLed, LOW);  
  }  
}  

E você lembra deste post sobre dimmer usando potenciômetro ? Pois bem, podemos utilizar o mesmo circuito, trocando o potenciometro pelo LDR, e obtendo o mesmo efeito, sem mexer no programa :

Circuito LDR Dimmer - Arduino Uno


 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
// Projeto : Controle de luminosidade de led com LDR  
// Autor : Arduino e Cia  
   
int pinoled = 10; //Pino ligado ao anodo do led  
int pinopot = 5;  //Pino ligado ao LDR  
int valorpot = 0; //Armazena valor lido do LDR, entre 0 e 1023  
float luminosidade = 0; //Valor de luminosidade do led  
   
void setup()  
{  
  Serial.begin(9600);    //Inicializa a serial  
  pinMode(pinoled, OUTPUT); //Define o pino do led como saída  
  pinMode(pinopot, INPUT);  //Define o pino do LDR como entrada  
}  
   
void loop()  
{  
  // Le o valor - analogico - do LDR  
  valorpot = analogRead(pinopot);  

  // Converte o valor lido do LDR
  luminosidade = map(valorpot, 0, 1023, 0, 255); 
  Serial.print("Valor lido do LDR : ");   

  // Mostra o valor lido do LDR no monitor serial  
  Serial.print(valorpot);  
  Serial.print(" = Luminosidade : ");  

  // Mostra o valor da luminosidade no monitor serial  
  Serial.println(luminosidade); 
  
  // Acende o led com luminosidade variável
  analogWrite(pinoled, luminosidade); 
 }  

Se necessário, ajuste os valores das resistências do led e do LDR, como no circuito anterior, e tenha agora um dimmer regulado por luz (ou pela falta dela).

25 setembro 2013

Display gráfico LCD 128x64 - ST7920

Displays LCD, na minha opinião, são itens indispensáveis para quem mexe com Arduíno. São componentes relativamente baratos e oferecem, dependendo do uso, uma forma mais eficaz do que o serial monitor para acompanhamento de dados.

Já utilizei displays LCD em muitos artigos aqui no Arduino e Cia, seja mostrando indicadores de temperatura e umidade em um LCD Nokia 5110, ou as distâncias lidas por um sensor ultrasônico, em um LCD 16x2.

Tenho agora a oportunidade de mostrar um outro display LCD gráfico, este com resolução de 128x64, baseado no chip ST7920, que adquiri na FILIPEFLOP.

Display gráfico LCD 128x64 Arduino

Este display tem backlight azul e escrita branca, e com ele (e a biblioteca certa) você consegue efeitos gráficos muito legais como rotação de tela, mudança de fontes de texto, rotação de texto e, claro, desenhar. Publiquei um pequeno vídeo no Youtube mostrando algumas dessas funções :


O display tem 20 pinos, numerados da direita para a esquerda, conforme podemos ver na foto abaixo. Ele pode ser utilizado para se comunicar com o Arduino tanto de forma serial como paralela. Neste artigo, onde a velocidade de atualização do LCD não é um ponto crítico, vamos utilizar a comunicação serial, ocupando apenas 4 portas do Arduino :

display grafico lcd 128x64

Informações mais detalhadas sobre a pinagem do LCD podem ser encontradas no datasheet do produto.

Atualizado: Veja como ligar este display em modo paralelo no artigo Display gráfico LCD 128x64 ST7920 em modo 8 bits.

Atualizado: Monte um relógio analógico/digital com esse display. Veja no post Relógio com Display LCD 128x64 e módulo RTC DS3231

O circuito usa um potenciômetro (utilizei um de 50K) para regulagem do contraste do display, e a alimentação é feita pelos 5v do Arduino. Para alimentar o backlight, eu usei os 3.3v do Arduino Uno R3 (mas segundo as especificações, também pode ser  ligado em 5v):

Ligação Arduino - Display LCD 128x64 - ST7920



















Tabela conexão LCD 128x64 - Arduino














A biblioteca que vamos usar é a U8Glib , uma biblioteca bem completa (e complexa, às vezes), com muitos exemplos de utilização. Recomendo uma visita à página da u8glib (em inglês) , onde você vai encontrar instruções sobre o funcionamento da biblioteca e também informações detalhadas sobre a utilização de cada comando. Vale a pena explorar.

O programa abaixo é baseado no exemplo "GraphicsTest", que já vem com a biblioteca. Conforme as instruções do desenvolvedor, conservei o cabeçalho com as informações de direitos autorais :

  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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/*  
GraphicsTest.pde  
>>> Before compiling: Please remove comment from the constructor of the   
>>> connected graphics display (see below).  
  
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/  
  
Copyright (c) 2012, olikraus@gmail.com  
All rights reserved.  
 
Redistribution and use in source and binary forms, with or without 
modification, are permitted provided that the following conditions 
are met:  
 
* Redistributions of source code must retain the above copyright notice, 
  this list of conditions and the following disclaimer.  
     
* Redistributions in binary form must reproduce the above copyright 
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution.  
  
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND   
  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,   
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF   
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE   
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR   
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,   
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT   
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;   
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER   
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,   
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF   
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   
*/  
   
#include "U8glib.h"  
// A linha abaixo define as ligacoes e deve ser 
// ajustada conforme o display utilizado. 
U8GLIB_ST7920_128X64_1X u8g(6, 5, 4 ,7); //Enable, RW, RS, RESET  
int display = 1;  
   
void u8g_prepare() 
{  
  u8g.setFont(u8g_font_6x10);  
  u8g.setFontRefHeightExtendedText();  
  u8g.setDefaultForegroundColor();  
  u8g.setFontPosTop();  
}  
   
void u8g_Tela1()  //Tela 1 - Arduino e Cia - Retangulos  
{
  u8g.setFont(u8g_font_unifont);  
  u8g.drawStr( 11, 35, "Arduino e Cia");  
  u8g.drawStr( 12, 35, "Arduino e Cia");  
  u8g.drawFrame(0,0,128,64);  
  u8g.drawFrame(2,2,124,60);   
}  
   
void u8g_Tela2() //Tela 2 - Moldura e relógio  
{
  u8g.drawRFrame(0,0,128,64,3);  
  u8g.drawStr( 3, 10, "Hor.: 13:00");  
  u8g.drawStr( 3, 25, "Temp: 27");  
  char s[2] = " ";  
  s[0] = 176;  
  u8g.drawStr(51, 25, s);  
  u8g.drawStr( 3, 40, "Umid: 25%");  
  u8g.drawCircle(95,32,28);  
  u8g.drawCircle(95,32,29);  
  u8g.drawLine(95, 9, 95, 4);  
  u8g.drawLine(123, 32, 118, 32);  
  u8g.drawLine(95, 55, 95, 60);  
  u8g.drawLine(67, 32, 72, 32);  
  u8g.drawLine(95, 32, 95, 12);  
  u8g.drawLine(95, 32, 100.8, 21.87 );  
  u8g.setFont(u8g_font_04b_03);  
  u8g.drawStr(89,43, "Tag");  
  u8g.drawStr(85,50, "Heuer");  
}  
   
void u8g_Tela3() //Tela 3 - Caracteres Ascii - Pag. 1  
{
  char s[2] = " ";  
  u8g.drawStr( 0, 0, "ASCII page 1");  
  for(int y = 0; y < 6; y++ ) 
  {  
    for(int x = 0; x < 16; x++ ) 
    {
      s[0] = y*16 + x + 32;  
      u8g.drawStr(x*7, y*10+10, s);  
    }  
  }  
}  
   
void u8g_Tela4()  //Tela 3 - Caracteres Ascii - Pag. 2  
{
  char s[2] = " ";  
  uint8_t x, y;  
  u8g.drawStr( 0, 0, "ASCII page 2");  
  for( y = 0; y < 6; y++ ) 
  {  
    for( x = 0; x < 16; x++ ) 
    {  
      s[0] = y*16 + x + 160;  
      u8g.drawStr(x*7, y*10+10, s);  
    }  
  }  
}  
   
void u8g_Tela5() //Tela 5 - Arduino e Cia - Retangulo preenchido  
{
  u8g.setFont(u8g_font_unifont);  
  u8g.drawBox(0,0,128,64);  
  u8g.drawBox(2,2,124,60);   
  u8g.setColorIndex(0);  
  u8g.drawStr( 11, 35, "Arduino e Cia");  
  u8g.drawStr( 12, 35, "Arduino e Cia");  
  u8g.drawFrame(2,2,124,60);  
}   
   
void u8g_Tela6()  //Tela 6 - Arduino e Cia em 0, 90 e 270 graus  
{
  u8g.setFont(u8g_font_helvB08);  
  u8g.drawStr(50,31, " Arduino");  
  u8g.drawStr90(50,31, " e");  
  u8g.drawStr270(50,31, " Cia");  
}  
   
void u8g_Tela7() //Tela 7 - Fontes diferentes  
{
  u8g.setFont(u8g_font_robot_de_niro);  
  u8g.drawStr(5,13, "Arduino e Cia !");  
  u8g.setFont(u8g_font_helvB08);  
  u8g.drawStr(5,25, "Arduino e Cia !");  
  u8g.drawBox(5,31, 118,11);  
  u8g.setColorIndex(0);  
  u8g.setFont(u8g_font_8x13);  
  u8g.drawStr(5,41, "Arduino e Cia !");  
  u8g.setColorIndex(1);  
  u8g.setFont(u8g_font_ncenB10);  
  u8g.drawStr(5,60, "Arduino e Cia !");  
}  
   
void draw() //Rotina Desenho  
{
  u8g_prepare();  
  switch(display) //Carrega a tela correspondente  
  {
   case 1:  
    u8g_Tela1();  
    break;  
   case 2:  
    u8g_Tela2();  
    break;  
   case 3:  
    u8g_Tela3();  
    break;  
   case 4:  
    u8g_Tela4();  
    break;  
   case 5:  
    u8g_Tela5();  
    break;  
   case 6:  
    u8g_Tela6();  
    break;  
   case 7:  
    u8g_Tela7();  
    break;  
  }  
}  
   
void setup() 
{  
  // flip screen, if required  
  //u8g.setRot180();  
   
  // assign default color value  
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )   
   u8g.setColorIndex(255);   // white  
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )  
   u8g.setColorIndex(1);     // max intensity  
  else if ( u8g.getMode() == U8G_MODE_BW )  
   u8g.setColorIndex(1);     // pixel on  
    
  //u8g.setContrast(0x30);  
}  
   
void loop() 
{  
  // picture loop   
  for (display =1; display < 8; display++) //Carrega as telas de 1 a 7  
  {  
    u8g.firstPage();   
    do 
    {  
    draw();  
    } 
    while( u8g.nextPage() );  
    delay(3000);  //Pausa de 3 segundos e reinicia o processo  
  }  
}     

Um último detalhe sobre esta biblioteca é que ela suporta vários tipos de displays e controladores, bastando para isso mudar os parâmetros de comunicação dentro do programa. Para uma lista completa dos dispositivos suportados e respectiva configuração, acesse este link.


21 setembro 2013

Livro Arduino Básico - Michael McRoberts

Hoje vou apresentar uma outra dica para quem está começando no Arduino, curte livros e precisa de uma boa fonte de referência para começar a programar o Arduino e montar seus próprios circuitos.

O livro Arduino Básico, do autor Michael McRoberts, apresenta sim, circuitos básicos para aqueles que estão iniciando no mundo Arduino, como ligar um led, mas também projetos mais avançados, com o uso de ethernet shield, motores e leitores de RFID.

Você pode comprar o seu com 20% de desconto, em uma parceria entre a Novatec e o site Arduino e Cia, clicando neste link. Faça a compra normalmente e utilize o seguinte código de promoção: ARDUINOCIA


Livro Arduino BAsico Michael McRoberts

São mais de 450 paginas com 50 projetos divididos em 17 capítulos, onde o autor ensina a ligação do Arduino ao computador, a configuração da IDE (ambiente de programação), passa pelo primeiro projeto, que consiste em piscar um led, e, à cada capítulo, vai aumentando o nível de dificuldade, sempre explicando não só a lógica dos programas, como também a montagem de cada circuito.

Relação dos capítulos :


  • Capítulo 1 - Introdução
  • Capítulo 2 - Acendendo as luzes 
  • Capítulo 3 - Efeitos com leds
  • Capítulo 4 - Sonorizadores e sensores simples
  • Capítulo 5 - Controlando um motor CC
  • Capítulo 6 - Contadores binários
  • Capítulo 7 - Displays de leds
  • Capítulo 8 - Displays de cristal líquido
  • Capítulo 9 - Servomecanismos
  • Capítulo 10 - Motores de passo e robôs
  • Capítulo 11 - Sensores de pressão
  • Capítulo 12 - Tela de toque
  • Capítulo 13 - Sensores de temperatura
  • Capítulo 14 - Telêmetros ultrassônicos
  • Capítulo 15 - Leitura e escrita de dados em um cartão SD
  • Capítulo 16 - Criação de um leitor RFID
  • Capítulo 17 - Comunicação via Ethernet

Uma ótima opção para quem está iniciando no Arduino, e para quem já tem experiência, uma boa fonte de referência para ter sempre à mão.

14 setembro 2013

Módulo Joystick Arduino

Para iniciar este artigo eu ia elaborar uma definição sobre o joystick, mas não encontrei definição mais "elegante" do que esta do Wikipedia :

"Joystick é um periférico de computador e videogame pessoal ou um dispositivo geral de controle que consiste em uma vara vertical na qual os pivôs se aproximam de uma extremidade e transmitem seu ângulo em duas ou três dimensôes a um computador"

Bonito não ? Bonito e útil. Você encontra joysticks (e suas variações) em computadores, videogames, guindastes, helicópteros e caminhões, apenas para citar alguns exemplos.

Bom, Joystick é o assunto do artigo de hoje, onde vou testar um módulo Joystick fornecido pela FilipeFlop, mostrar como você pode acompanhar as variações dos valores dos eixos pelo serial monitor e ainda montar um circuito simples com leds, que serão controlados pelo movimento do joystick.

joystick arduino

Falando primeiramente do módulo, ele consiste em uma haste vertical que controla dois potenciômetros (eixos X e Y), que ligaremos nas portas analógicas, e um push-button (eixo Z), que ligaremos em uma porta digital. A ligação ao Arduino é feita por meio de 3 conectores (X, Y e Z) na lateral, onde cada conector tem 3 fios : - (GND), + (5V) e S (sinal).


Joystick - detalhe potenciômetrosJoystick - detalhe conectores

No meu circuito, acrescentei ainda 5 leds, que acendem conforme o joystick é movimentado : eixo Y (esquerda e direita),  eixo X (superior e inferior), e também ao pressionar o botão (eixo Z).

Circuito - Arduino com módulo joystick

Devido à quantidade de conexões, uma boa idéia é utilizar este shield para sensores, que você também encontra na Loja FILIPEFLOP. Principalmente se, além do joystick, você utilizar em seus projetos outros sensores e motores :
Arduino Sensor Shield
O programa não exige nenhuma biblioteca especial, já que estamos apenas lidando com portas digitais e analógicas e os comandos básicos do Arduino. Carregue o programa, abra o serial monitor e movimente o potenciometro, observando a variação dos valores do Eixo X (Porta analógica A0), Eixo Y (porta analógica A1) e Eixo Z (porta digital 7).

 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
 //Programa : Teste modulo Joystick  
 //Autor : Arduino e Cia  
   
 int valorx = 0; //Armazena o valor lido do potenciometro - Eixo X  
 int valory = 0; //Armazena o valor lido do potenciometro - Eixo Y  
 int valorz = 0; //Armazena o valor lido do botão - Eixo Z  
 int pinoledesquerda = 2; //Pino Led Esquerdo  
 int pinoledsuperior = 3; //Pino Led Superior  
 int pinoleddireita = 4;  //Pino Led Direito  
 int pinoledinferior = 5; //Pino Led Inferior  
 int pinoledz = 10;    //Pino Led Eixo Z  
   
 void setup() 
 {  
 pinMode(7, INPUT);  //Pino Eixo Z  
 Serial.begin(9600);  
 pinMode(pinoledesquerda, OUTPUT);  
 pinMode(pinoledsuperior, OUTPUT);  
 pinMode(pinoleddireita, OUTPUT);  
 pinMode(pinoledinferior, OUTPUT);  
 pinMode(pinoledz, OUTPUT);  
 }  
   
 void loop() 
 {  
 //As linhas abaixo apagam todos os leds  
 digitalWrite(pinoledesquerda, LOW);  
 digitalWrite(pinoledsuperior, LOW);  
 digitalWrite(pinoleddireita, LOW);  
 digitalWrite(pinoledinferior, LOW);  
 digitalWrite(pinoledz, LOW);  
   
 //Le o valor do potenciometro ligado à porta analogica A0 - Eixo X  
 valorx = analogRead(0);   
   
 //Mostra o valor do eixo X no serial monitor  
 Serial.print("X:");  
 Serial.print(valorx, DEC);  
   
 //Testa o valor do Eixo X e aciona o led correspondente  
 if (valorx > -1 & valorx <200)  
 {  
  digitalWrite(pinoledinferior, HIGH); //Acende o led inferior  
 }  
 if (valorx > 700 & valorx <1025)  
 {  
  digitalWrite(pinoledsuperior, HIGH); //Acende o led superior  
 }  
   
 //Le o valor do potenciometro ligado à porta analogica A1 - Eixo Y  
 valory= analogRead(1);  
   
 //Mostra o valor do eixo Y no serial monitor  
 Serial.print(" | Y:");  
 Serial.print(valory, DEC);  
   
 //Testa o valor do Eixo Y e aciona o led correspondente  
 if (valory > -1 & valory <200)  
 {  
  digitalWrite(pinoleddireita, HIGH); //Acende o led da direita  
 }  
 if (valory > 700 & valory <1025)  
 {  
  digitalWrite(pinoledesquerda, HIGH); //Acende o led da equerda  
 }  
   
 //Lê o valor da porta Digital 7 - Eixo Z  
 valorz = digitalRead(7);  
   
 //Mostra o valor do Eixo Z no serial monitor  
 Serial.print(" | Z: ");  
 Serial.println(valorz, DEC);  
   
 //Caso o botão do Eixo Z seja pressionado, acende o led verde  
 if (valorz != 1 )  
 {  
  digitalWrite(pinoledz, HIGH);  
 }  
}  

11 setembro 2013

Ligando acelerômetro MMA7361 no Arduino

Quando se fala em acelerômetro, geralmente a primeira coisa que se pensa é no aparelho celular. É o acelerômetro que detecta a inclinação do aparelho, muda a orientação da tela e permite, por exemplo, a utilização de jogos de corrida onde a movimentação do celular define a direção do carrinho na tela.

Temos também acelerômetros instalados em notebooks, para detectar quedas do aparelho e dessa forma "travar" os discos do computador para proteção dos dados, e um exemplo bem mais comum, que é a utilização do acelerômetro nos controles de videogame, como o Nintendo Wii.

ligando acelerometro Arduino
(Bem) Resumidamente, o acelerômetro nada mais é do que um aparelho que serve para medir a aceleração de um corpo/objeto em relação à gravidade. Felizmente, temos a possibilidade de ver detalhadamente no Arduino como isso funciona, adquirindo um módulo acelerômetro MMA7361 como esse abaixo, que eu recebi recentemente da FilipeFlop.

Acelerômetro MMA7361

Esse módulo é bem prático e já vem pronto para uso, com os pinos já soldados. É um módulo de 3 eixos (X, Y e Z), que gera uma variação de tensão para cada eixo, variação esta que por sua vez é tratada pelas
portas analógicas do Arduino. Algo bem parecido com o que vimos neste artigo falando sobre dimmer, onde a variação de tensão nas portas analógicas determinava a luminosidade do led.

Características básicas desse módulo :
  • Operação com 5v ou 3.3v DC
  • 2 níveis de sensibilidade : 1,5G ou 6G
  • Modo sleep, ideal para uso em configurações que necessitem do uso de uma bateria
A ligação, como sempre, exige atenção e cuidado para não danificar o componente. São 10 pinos, cuja função mostro na tabela abaixo :

Tabela ligação acelerômetro MMA7361

Ao montar o circuito, repare que será necessário ligar o pino 3.3 Volts do Arduino Uno R3 ao pino AREF, para que tenhamos uma tensão de referência. Sem ele, a leitura dos dados fica totalmente prejudicada:

Acelerômetro MMA7361 Arduino
Se possível, recomendo a ligação fora da protoboard ou então a utilização de um mini protoboard, como mostrado no circuito, isso vai facilitar bastante na hora de testar os movimentos com o módulo.

Para teste vou usar um dos 3 programas exemplo que vem na própria biblioteca do MMA7361, o programa G_FORCE. Carregue o programa no Arduino, movimente o sensor e veja no serial monitor como se comportam as variações dos eixos X, Y, Z, e a gravidade (G).

Acelerômetro MMa7361 - Saída Serial Monitor


 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
//Programa : Teste Acelerometro MMA7361  
//Alterações e comentários : Arduino e Cia  
   
 #include <AcceleroMMA7361.h> //Carrega a biblioteca do MMA7361  
   
 AcceleroMMA7361 accelero;  
 int x;  
 int y;  
 int z;  
   
 void setup()  
 {  
  Serial.begin(9600);  
  accelero.begin(13, 12, 11, 10, A0, A1, A2);  
  //Seta a voltagem de referencia AREF como 3.3V
  accelero.setARefVoltage(3.3);
  //Seta a sensibilidade (Pino GS) para +/-6G    
  accelero.setSensitivity(LOW);    
  accelero.calibrate();  
 }  
   
 void loop()  
 {  
  x = accelero.getXAccel(); //Obtem o valor do eixo X  
  y = accelero.getYAccel(); //Obtem o valor do eixo Y  
  z = accelero.getZAccel(); //Obtem o valor do eixo Z  
  Serial.print("\nx: ");   //Mostra os valores no serial monitor  
  Serial.print(x);  
  Serial.print(" \ty: ");  
  Serial.print(y);  
  Serial.print(" \tz: ");  
  Serial.print(z);  
  Serial.print("\tG*10^-2");  
  delay(500);                     
 }  

06 setembro 2013

Controle remoto IR no Arduino

Já vimos aqui no Arduino e Cia como controlar remotamente o Arduino usando bluetooth (ainda não viu ? então veja o artigo Acionando portas do Arduino usando Android e bluetooth).

Hoje vou apresentar um outro método para controle remoto das portas do Arduino Uno R3, desta vez usando um Kit Controle Remoto IR, mostrado na foto abaixo, que chegou hoje da FILIPEFLOP :

Kit Controle Remoto IR

O kit é composto por 1 módulo receptor IR, 1 led infravermelho, 1 cabo de conexão e 1 controle remoto (com bateria CR2025).

No exemplo de hoje, vou focar na recepção do sinal do controle remoto, acendendo e apagando leds, conforme a sequência abaixo :

Tecla 1 : Acende led vermelho
Tecla 2 : Apaga led vermelho

Tecla 4 : Acende led verde
Tecla 5 : Apaga led verde

Tecla 9 : Apaga os 2 leds

Entendendo o principio de funcionamento do receptor IR, fica fácil controlar qualquer porta do Arduino e partir para o acionamento de relés, motores e outros dispositivos.

Atualizado : Veja também neste outro artigo  como utilizar o controle remoto IR para controlar um módulo relé 4 canais.

Circuito Arduino e módulo IR infravermelho


A ligação do módulo receptor IR segue o esquema mostrado na imagem abaixo, à esquerda, que consiste na ligação dos pinos do módulo à porta 11 do Arduino (sinal),  5v e GND. Na imagem da direita, podemos ver o módulo em funcionamento, com um led que pisca quando o módulo está recebendo sinais infravermelhos :

Pinagem receptor IR e receptor em funcionamento

Para o circuito, vamos utilizar 2 leds, 2 resistores de 330 ohms e o receptor IR, tomando o cuidado de observar a ligação correta dos pinos do módulo, evitando a queima do componente :

Circuito controle remoto IR
Criei um programa que faz a leitura do sinal IR recebido, e com base no valor lido, aciona as portas 5 e 7, onde estão ligados os leds. Esse programa também apresenta no monitor serial os valores lidos pelo receptor IR :

Monitor serial - Receptor IR

Desta forma consigo descobrir os valores, em hexadecimal, do sinal recebido por todas as teclas do controle remoto. No programa, usei os valores FF30CF (Tecla 1), FF18E7 (tecla 2), FF10EF (tecla 4), FF38C7 (tecla 5), e FF52AD (tecla 9).

Finalmente, no loop, eu testo o valor recebido pelo receptor IR, e com alguns comandos IF eu verifico qual tecla foi acionada, acendendo e apagando o led correspondente. Usei a tecla 9 para apagar os 2 leds de uma só vez.

Para este programa, vamos utilizar a biblioteca IRremote, que voce pode baixar clicando aqui :

 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
// Programa : Teste Controle Remoto IR  
// Autor : Arduino e Cia  
  
#include <IRremote.h>  
  
int RECV_PIN = 11;  
float armazenavalor;  
int pinoledvermelho = 5;  
int pinoledverde = 7;  
  
IRrecv irrecv(RECV_PIN);  
decode_results results;  
  
void setup()  
{  
  pinMode(pinoledvermelho, OUTPUT);   
  pinMode(pinoledverde, OUTPUT);  
  Serial.begin(9600);  
  irrecv.enableIRIn(); // Inicializa o receptor IR  
}  
   
void loop()  
{  
  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  
    {  
      digitalWrite(pinoledvermelho, HIGH);  //Acende o led vermelho  
    }  
    if (armazenavalor == 0xFF18E7) //Verifica se a tecla 2 foi acionada  
    {  
      digitalWrite(pinoledvermelho, LOW); //Apaga o led vermelho  
    }  
    if (armazenavalor == 0xFF10EF) //Verifica se a tecla 4 foi acionada  
    {  
      digitalWrite(pinoledverde, HIGH); //Acende o led verde  
    }  
    if (armazenavalor == 0xFF38C7) //Verifica se a tecla 5 foi acionada  
    {  
      digitalWrite(pinoledverde, LOW); //Apaga o led verde  
    }  
    if (armazenavalor == 0xFF52AD) //Verifica se a tecla 9 foi acionada  
    {  
      digitalWrite(pinoledvermelho, LOW); //Apaga todos os leds  
      digitalWrite(pinoledverde, LOW);  
    }  
  irrecv.resume(); //Le o próximo valor  
  }  
}