26 junho 2014

Enviando texto do Android para o Arduino usando bluetooth

Aproveitando o gancho do último artigo sobre display LCD 20x4, no post de hoje vou mostrar como utilizar o módulo bluetooth HC-05 para enviar textos (strings) para o Arduino à partir de um celular com Android, e mostrar esses dados no display.

Quando enviamos dados do Android para o módulo bluetooth, esses dados são transmitidos para o Arduino via serial. É o mesmo processo utilizado quando interagimos com o Arduino usando o Serial Monitor : o Serial Monitor pode tanto receber como enviar informações.

No projeto desse post, eu tenho um celular com Android e bluetooth, e o programa Bluetooth SPP instalado. Nesse programa, eu vou digitar uma string e enviá-la para o módulo blueooth do Arduino.

O Arduino vai receber essa informação, e ao detectar o caracter de controle "\n", indicando o final da string, vai mostrá-la no display :



Para esse experimento vamos utilizar o seguinte material :

19 junho 2014

Display LCD 20x4 Arduino

Informações de data, hora, temperatura, pressão, umidade, coordenadas de um acelerômetro e ainda alertas para o usuário. Às vezes queremos (ou precisamos) exibir tantas informações em um display que os mais comuns, de 16x2, se tornam limitados.

Para esses casos, podemos adotar displays LCD 20x4, com pouquíssimas alterações no código do Arduino e assim ganhar espaço para exibir mais do que o dobro de informações.

Display LCD 20x4 Arduino

Não há muito segredo para conectar um LCD 20x4. Fisicamente as conexões são iguais às outras encontradas em displays LCD 16x2. São 16 pinos para conexão, sendo que o pino mais à esquerda (Vss), é o pino 1:


A ligação básica deste LCD ao Arduino utiliza somente 4 pinos de dados e 2 de controle, na seguinte ordem :

Tabela ligação Arduino e LCD 20x4

Seguindo a tabela, o nosso circuito de conexão do display ao Arduino Uno fica desse jeito. O potenciômetro de 10 K (ou outro valor de sua preferência) serve para ajustar o contraste do LCD. A intensidade da luz de fundo pode ser controlada adicionando um resistor ao pino 16 :

display lcd 20x4





O LCD 20x4 também utiliza a biblioteca LiquidCrystal, bastando alterar os parâmetros de inicialização no comando lcd.begin, indicando que agora estamos utilizando um display com 20 colunas e 4 linhas :

lcd.begin(20,4);

Basicamente esta é a única alteração necessária. Depois disso, você pode utilizar o comando lcd.setCursor para posicionar os caracteres dentro das 20 colunas (numeradas de 0 a 19), e 4 linhas (numeradas de 0 a 3) :

 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 : Teste LCD 20x4 Arduino
// Autor : Arduino e Cia

// Carrega a biblioteca do LCD
#include <LiquidCrystal.h>

// Inicializa o LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
  // Define o LCD com 20 colunas e 4 linhas
  lcd.begin(20, 4);
  
  // Mostra informacoes no display
  lcd.setCursor(3,0);
  lcd.print("Arduino e Cia");
  lcd.setCursor(2,1);
  lcd.print("Display LCD 20x4");
  lcd.setCursor(1,3);
  lcd.print("arduinoecia.com.br");
}

void loop()
{
  // Seu codigo aqui
}

Com mais espaço no display você pode usar as informações do post LCD 16x2 + RTC + Numeros Grandes, para criar, por exemplo, um relógio com hora, data, e informações de temperatura, com um layout parecido com esse :

 


11 junho 2014

Ligando um sensor de chuva ao Arduino

Preparado para a época de chuvas ? Não ? Que tal uma ajudinha com o Arduino ?

Utilize um sensor de chuva como esse da foto abaixo, para que você consiga fechar uma janela  quando não estiver em casa ou acionar uma bomba para armazenar água da chuva.


sensor de chuva arduino


O sensor de chuva para Arduino é um componente com duas partes : a placa do sensor, formada por várias trilhas resistentes à oxidação, que vão detectar o nível de líquido que está atingindo a placa, e o módulo com chip comparador LM393, que é o responsável por ler as informações desse sensor e enviar os dados pelas pinos A0 (analógico), ou D0 (digital - valores 0 e 1).

Esse módulo também tem um potenciômetro para ajuste de sensibilidade, um led vermelho para indicação de LIGADO, e um led verde que indica a transmissão de dados :

Sensor de chuva Arduino - Pinos e Leds

Voltando aos exemplos que eu citei no início do post, você pode utilizar um motor ligado à saída digital para abrir (sem chuva - nível HIGH) ou fechar (com chuva - nível LOW) uma janela quando for detectada chuva, e com a saída analógica você pode abrir uma válvula ou acionar uma bomba dependendo da intensidade da chuva, lendo os valores de 0 à 1023 fornecidos por essa porta.

Teste o seu módulo com apenas 3 leds e 3 resistores, montando o circuito abaixo. O módulo pode ser alimentado com tensões de 3.3 à 5 volts :

Circuito Sensor de Chuva Arduino Uno
O programa de teste lê as informações do sensor e acende os leds de acordo com o nível de líquido detectado, testando os valores lidos em uma série de comandos IF (SE), que podem ser acrescentados ou alterados de acordo com o nível de precisão desejada :

 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
// Programa : Teste sensor de chuva
// Autor : Arduino e Cia

int pino_d = 2; //Pino ligado ao D0 do sensor
int pino_a = A5; //Pino ligado ao A0 do sensor
int val_d = 0; //Armazena o valor lido do pino digital
int val_a = 0; //Armazena o valor lido do pino analogico

// Portas ligadas aos leds
int pino_led_verde = 5;
int pino_led_amarelo = 6;
int pino_led_vermelho = 7;

void setup()
{
  // Define os pinos do sensor como entrada
  pinMode(pino_d, INPUT);
  pinMode(pino_a, INPUT);

  // Define os pinos dos leds como saida
  pinMode(pino_led_verde, OUTPUT);
  pinMode(pino_led_amarelo, OUTPUT);
  pinMode(pino_led_vermelho, OUTPUT);
  Serial.begin(9600);
}

void loop()
{
  //Le e arnazena o valor do pino digital
  val_d = digitalRead(pino_d);
  //Le e armazena o valor do pino analogico
  val_a = analogRead(pino_a);
  //Envia as informacoes para o serial monitor
  Serial.print("Valor digital : ");
  Serial.print(val_d);
  Serial.print(" - Valor analogico : ");
  Serial.println(val_a);
 
  // Acende o led de acordo com a intensidade 
  if (val_a >900 && val_a <1024)
  {
    // Acende led verde - intensidade baixa
    digitalWrite(pino_led_verde, HIGH);
    digitalWrite(pino_led_amarelo, LOW);
    digitalWrite(pino_led_vermelho, LOW);
  }
  if (val_a >400 && val_a <900)
  {
    // Acende led amarelo - intensidade moderada
    digitalWrite(pino_led_verde, LOW);
    digitalWrite(pino_led_amarelo, HIGH);
    digitalWrite(pino_led_vermelho, LOW);
  }
  if (val_a > 0 && val_a <400)
  {
    // Acende led vermelho - intensidade alta
    digitalWrite(pino_led_verde, LOW);
    digitalWrite(pino_led_amarelo, LOW);
    digitalWrite(pino_led_vermelho, HIGH);
  }
  delay(1000);
}

Caso você queira testar apenas o sensor, sem montar todo o circuito, os valores também são exibidos no serial monitor :

Sensor de Chuva Arduino - Serial Monitor

O funcionamento do circuito teste você confere no vídeo abaixo :


04 junho 2014

Sensor de presença com módulo PIR DYP-ME003

Os sensores de presença mais comuns usam sensores PIR (Passive Infrared Sensor, ou Sensor Infravermelho Passivo) como detector de movimentos.

No Arduino, temos o módulo PIR DYP-ME003, que une numa mesma estrutura o sensor PIR e também os circuitos necessários para ajuste e controle do sinal de saída.
Modulo PIR DYP-ME003
O módulo contém o sensor PIR propriamente dito, composto internamente por duas faixas com material sensível ao infravermelho. Na parte externa, uma espécie de capa/tampa que na verdade é uma lente fresnel.

Quando há variação na detecção do sinal infravermelho entre essas duas faixas de material sensível, a saída é acionada por um determinado tempo. A lente fresnel tem a função de, vamos dizer assim, "ampliar" o campo de visão do sensor, condensando a luz em um único ponto.

Felizmente existem figuras para traduzir toda essa teoria e mostrar de uma forma mais clara como isso funciona.

Abaixo, o sensor PIR, a lente fresnel e as duas faixas de detecção, acionadas quando alguém passa em frente ao sensor :
sensor de presença com PIR
Imagem : electronicsgurukulam.blogspot.com



Nessa outra figura, uma representação de como funciona uma lente fresnel :

Lente fresnel e sensor PIR


Resumidamente, é assim que a coisa funciona. Uma explicação muito melhor e mais detalhada você encontra no datasheet do módulo, nesse link.

Vamos então para a parte boa, analisando o módulo e testando-o com um Arduino Uno. :-)

No lado esquerdo da imagem, o módulo sem a lente, com o sensor exposto. No lado direito, a parte inferior do módulo, com os 2 pinos de alimentação (4.5 à 20 volts ) e sinal, os potenciômetros para ajuste da sensibilidade e tempo de acionamento da saída, e também o jumper que controla o modo de operação do trigger (gatilho) :

Detalhe módulo PIR Arduino


Apenas preste atenção quando for ligar o seu módulo, pois alguns apresentam os pinos Vcc e GND invertidos. Na dúvida, consulte o datasheet do seu módulo ou verifique as indicações na placa.

Nesse módulo, praticamente não há necessidade de programação no Arduino, já que a saída é colocada em HIGH (ALTO), quando um objeto for detectado, e permanece assim pelo tempo que configurarmos no potenciômetro. Basta então definirmos o que será feito com as saídas do Arduino :

Circuito sensor de presença PIR Arduino Uno
No loop do programa, o valor lido da porta 3 (ligada ao pino de sinal do sensor), é constantemente checado, e caso ocorra movimentação em frente ao sensor, o led vermelho ligado à porta 5 é acionado. Caso contrário, é o led azul ligado à porta 6 que permanece acionado.

 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
// Programa : Sensor de presenca com modulo PIR
// Autor : Arduino e Cia

int pinoledverm = 5; //Pino ligado ao led vermelho
int pinoledazul = 6; //Pino ligado ao led azul
int pinopir = 3;  //Pino ligado ao sensor PIR
int acionamento;  //Variavel para guardar valor do sensor

void setup()
{
  pinMode(pinoledverm, OUTPUT); //Define pino como saida
  pinMode(pinoledazul, OUTPUT); //Define pino como saida
  pinMode(pinopir, INPUT);   //Define pino sensor como entrada

}

void loop()
{
 acionamento = digitalRead(pinopir); //Le o valor do sensor PIR
 if (acionamento == LOW)  //Sem movimento, mantem led azul ligado
 {
    digitalWrite(pinoledverm, LOW);
    digitalWrite(pinoledazul, HIGH);
 }
 else  //Caso seja detectado um movimento, aciona o led vermelho
 {
    digitalWrite(pinoledverm, HIGH);
    digitalWrite(pinoledazul, LOW);
 }
}

E o resultado desse experimento você confere no vídeo abaixo :



Se você planeja melhorar esse circuito e acionar um relé ou adicionar um buzzer, recomendo a leitura destes artigos aqui mesmo no Arduino e Cia :

Artigos relacionados à relés

Artigos relacionados à buzzer e sons no Arduino