09 julho 2017

5 Projetos com o Shield Arduino Multifunções

Neste post vou falar de um shield bem interessante para você que é iniciante, estudante ou simplesmente quer aprender mais sobre placas Arduino sem montar complicados circuitos eletrônicos ou depender de outros componentes: o Shield Arduino Multifunções com Sensores e I/O´s, que na imagem abaixo está encaixado em uma Placa Uno.
Shield Arduino Multifunções e Arduino Uno
Como o próprio nome diz, esse shield tem incorporado uma série de sensores e portas para você fazer projetos básicos, sendo uma excelente opção para aprendizado de programação nessa placa microcontrolada.


O Shield Arduino Multifunções


Na imagem abaixo temos a disposição dos sensores e I/O´s no Shield Arduino Multifunções. Os conectores em amarelo permitem acesso à 2 portas digitais (D7 e D8), uma porta analógica (A3), interface serial e interface I2C:

Shield Arduino Multifunções - Detalhes


E temos uma série de sensores e componentes de uso comum. Note que na placa já temos a marcação de quais pinos são utilizados para cada sensor, botão ou led. Para facilitar, na lista abaixo coloquei entre parênteses a porta utilizada por cada componente:

  • Sensor de temperatura e umidade DHT11 (porta D4)
  • Sensor de temperatura LM35 (A2)
  • Buzzer Passivo (D5)
  • Sensor de Luz LDR (A1)
  • Receptor IR (D6)
  • Led RGB (D9, D10 e D11)
  • Potenciômetro (A0)
  • 2 botões customizáveis (D2 e D3)
  • 2 leds de uso geral (D12 e D13)

Vamos agora combinar esses componentes para criar 5 projetos básicos com o Shield Arduino Multifunções.

Projeto 1 - Use Botões, led e Buzzer


O primeiro projeto é bem básico e nele você vai utilizar os botões SW1 e SW2, no lado esquerdo do shield, para acionar os leds azul e vermelho, e ao mesmo tempo fazer com que o buzzer emita um som. Neste programa não é utilizada nenhuma biblioteca, já que apenas efetuamos a escrita e leitura das portas digitais dos botões (portas digitais D2 e D3), dos leds (D12 e D13) e do buzzer (D5).

 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
//Programa: Shield Arduino Multifuncoes
//Objetivo: Uso de botoes, led e buzzer
//Autor: Arduino e Cia

//Definicao dos pinos
#define Pino_SW1 2
#define Pino_SW2 3
#define Pino_Led_Azul 13
#define Pino_Led_Vermelho 12
#define Pino_Buzzer 5

//Armazena valor botoes
int valor_SW1, valor_SW2;

void setup()
{
  //Pinos led e buzzer como saida
  pinMode(Pino_Led_Azul , OUTPUT);
  pinMode(Pino_Led_Vermelho , OUTPUT);
  pinMode(Pino_Buzzer, OUTPUT);
  //Pinos botoes SW1 e SW2 como entrada
  pinMode(Pino_SW1, INPUT);
  pinMode(Pino_SW2, INPUT);
}

void loop()
{
  //Verifica se o botao SW1 foi acionado
  valor_SW1 = digitalRead(Pino_SW1);
  if (valor_SW1 == 0)
  {
    //Acende o led azul
    digitalWrite(Pino_Led_Azul, HIGH);
    //Aciona o buzzer
    tone(Pino_Buzzer, 50,30);
  }
  else
  {
    //Desliga o led azul e o buzzer
    digitalWrite(Pino_Led_Azul, LOW);
    noTone(Pino_Buzzer);
  }

  //Verifica se o botao SW2 foi acionado
  valor_SW2 = digitalRead(Pino_SW2);
  if (valor_SW2 == 0)
  {
    //Acende o led vermelho
    digitalWrite(Pino_Led_Vermelho, HIGH);
    //Aciona o buzzer
    tone(Pino_Buzzer, 900,50);
  }
  else
  {
    //Desliga o led azul e o buzzer
    digitalWrite(Pino_Led_Vermelho, LOW);
    noTone(Pino_Buzzer);
  }
}

Altere o valor da frequência do som emitido pelo buzzer nas linhas 35 e 51 do programa. Você pode ter mais informações sobre como emitir som no Arduino acessando o post Sons no Arduino usando buzzer.

Projeto 2 - Usando o potenciômetro


Este projeto também vai usar os dois leds, mas controlados por um potenciômetro que está ligado na porta analógica A0 do Arduino. Os leds piscam alternadamente e quanto mais você girar o potenciômetro para a direita, mais lentamente eles vão piscar.

 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: Shield Arduino Multifuncoes
//Objetivo: Potenciometro com leds
//Autor: Arduino e Cia

//Definicao dos pinos
#define Pino_Led_Azul 13
#define Pino_Led_Vermelho 12
#define Pino_Pot A0

//Armazena valor lido do potenciometro
int valor_pot;

void setup()
{
  //Pinos led e buzzer como saida
  pinMode(Pino_Led_Azul , OUTPUT);
  pinMode(Pino_Led_Vermelho , OUTPUT);
  //Pino potenciometro como entrada
  pinMode(Pino_Pot, INPUT);
}

void loop()
{
  //Le o valor do potenciometro
  valor_pot = analogRead(Pino_Pot);
  valor_pot = map(valor_pot, 0, 1024, 100, 500);

  //Pisca o led de acordo com o valor lido
  digitalWrite(Pino_Led_Azul, HIGH);
  digitalWrite(Pino_Led_Vermelho, LOW);
  delay(valor_pot);
  digitalWrite(Pino_Led_Azul, LOW);
  digitalWrite(Pino_Led_Vermelho, HIGH);
  delay(valor_pot);
}

Este programa utiliza o comando MAP (linha 26), que "converte" o valor lido da porta analógica A0 (entre 0 e 1024) em um valor entre 100 e 500, que é o valor que será usado para determinar o tempo (comando DELAY) que os leds ficarão acesos. Lembrando que esse tempo é em milissegundos (ms), ok?

Projeto 3 - Sensor de luminosidade LDR


O LDR (Light Dependent Resistor, ou Resistor Dependente de Luz) é um sensor de luminosidade que já mostramos no post Controle de Luz utilizando LDR, e é um componente que varia sua resistência conforme a intensidade da luz sobre o sensor. O programa abaixo faz a leitura da porta onde está ligado o LDR (porta analógica A1), e conforme aumentamos a intensidade da luz sobre o sensor, a luz do led RGB vai se apagando.

 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
//Programa: Shield Arduino Multifuncoes
//Objetivo: LDR e led RGB
//Autor: Arduino e Cia

//Pino cor verde led RGB
int pinoled = 10;
//Pino ligado ao LDR
int pino_LDR = A1;
//Armazena valor lido do LDR, entre 0 e 1023
int valor_LDR = 0;
//Valor de luminosidade do led
float luminosidade = 0;

void setup()
{
  //Inicializa a serial
  Serial.begin(9600);
  //Define o pino do led como saída
  pinMode(pinoled, OUTPUT);
  //Define o pino do LDR como entrada
  pinMode(pino_LDR, INPUT);
}

void loop()
{
  // Le o valor do pino do LDR
  valor_LDR = analogRead(pino_LDR);

  // Converte o valor lido
  luminosidade = map(valor_LDR, 0, 1023, 255, 0);

  //Monstra no serial monitor o valor lido
  Serial.print("Valor lido do LDR : ");
  Serial.print(valor_LDR);

  // Acende o led com luminosidade variável
  analogWrite(pinoled, luminosidade);
}

O LDR é um componente de baixo custo e muito simples de usar, e com ele você pode acender as luzes da sua casa ao anoitecer, criar sistemas de alarme, sistemas de regulagem de luminosidade, etc.

Projeto 4 - Sensor de temperatura com led RGB


Neste 4o. exemplo vamos mostrar o uso do Sensor de temperatura LM35, e de acordo com a temperatura lida vamos acender o led RGB nas cores vermelho (quando a temperatura estiver acima de 28 graus), verde (temperatura menor do que 25 graus) ou azul (temperatura entre 25 e 28 graus).

 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
//Programa: Shield Arduino Multifuncoes
//Objetivo: Sensor de temperatura LM35 e Led RGB
//Autor: Arduino e Cia

//Pino conectado ao LM35
int pin = A2;

// Variavel que armazena a temperatura
int tempc = 0;

// Array para precisão na medição do LM35
int samples[8];

void setup()
{
  Serial.begin(9600);
  //Pino cor verde do led RGB
  pinMode(10, OUTPUT);
  //Pino cor vermelha do led RGB
  pinMode(9, OUTPUT);
  //Pino cor azul do led RGB
  pinMode(11, OUTPUT);
}

void loop()
{
  // Loop que faz a leitura da temperatura 8 vezes
  for (int i = 0; i <= 7; i++)
  {
    samples[i] = ( 5.0 * analogRead(pin) * 100.0) / 1024.0;
    //A cada leitura, incrementa o valor da variavel tempc
    tempc = tempc + samples[i];
    delay(100);
  }
  // Divide a variavel tempc por 8, para obter precisão na medição
  tempc = tempc / 8.0;

  //Se a temperatura estiver abaixo de 25, acende o led verde
  if (tempc < 25)
  {
    digitalWrite(10, HIGH);
    digitalWrite(11, LOW);
    digitalWrite(9, LOW);
  }

  //Se a temperatura estiver acima de 28, acende o led vermelho
  if (tempc > 28)
  {
    digitalWrite(9, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
  }

  //Se a temperatura estiver acima de 25 e abaixo de 28,
  //acende o led azul
  if ((tempc > 25) && (tempc < 28))
  {
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(9, LOW);
  }

  //As linhas abaixo enviam para o monitor serial
  //o valor da temperatura em Celsius
  Serial.print("Temperatura: ");
  Serial.print(tempc, DEC);
  Serial.println(" Cels.");

  tempc = 0;
  delay(1000); // Aguarda 1 segundo e reinicia o processo
}

Neste exemplo você pode acompanhar o valor da temperatura abrindo o serial monitor da IDE do Arduino. Este programa foi baseado no post LM35 - Sensor de Temperatura., e adaptado para utilizar os pinos do led RGB (9, 10 e 11) do Shield Arduino Multifunções.

Projeto 5 - Sensor de temperatura DHT11


Neste projeto vamos efetuar a leitura do sensor de temperatura DHT11, mostrar esses valores no serial monitor e acionar o buzzer se a temperatura estiver acima de 25 graus. 

Nesse programa, você vai utilizar a biblioteca DHT Sensor Library da Adafruit, e você pode instalar à partir da própria IDE do Arduino. Acesse o menu Sketch => Incluir Biblioteca => Gerenciar Bibliotecas. Procure pela biblioteca DHT11 e clique em Instalar:

Instalação Biblioteca DHT11

O valor da temperatura que aciona o buzzer pode ser modificado alterando a linha 40 do programa de acordo com a sua necessidade.

 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
//Programa: Shield Arduino Multifuncoes
//Objetivo: Sensor de temperatura DHT11 e Buzzer
//Autor: Arduino e Cia

#include "DHT.h"

//Pino conectado ao DHT11
#define DHTPIN 4

//Variavel que armazena a temp do DHT11
float tempc_DHT11 = 0;
//Variavel que armazena a umidade do DHT11
float hum_DHT11 = 0;

//Definicoes do sensor DHT11
DHT dht(DHTPIN, DHT11);

void setup()
{
  Serial.begin(9600);
  //Inicializa o DHT11
  dht.begin();
}

void loop()
{
  //Leitura da temperatura do DHT11
  tempc_DHT11 = dht.readTemperature();
  //Leitura da umidade do DHT11
  hum_DHT11 = dht.readHumidity();

  //As linhas abaixo enviam para o monitor serial
  //o valor da temperatura em Celsius
  Serial.print("DHT11: ");
  Serial.print(tempc_DHT11, 0);
  Serial.print(" Cels. Umid: ");
  Serial.print(hum_DHT11, 0);
  Serial.print(" %");

  if (tempc_DHT11 >= 25)
  {
    tone(5, 900);
    Serial.print(" Alarme!!");
  }
  else
  {
    noTone(5);
  }
  Serial.println();
  delay(2000);
}

Abra o serial monitor para verificar os valores de temperatura e umidade do DHT11, e também avisos sobre o acionamento do buzzer:

Serial Monitor DHT11

Esses foram apenas alguns exemplos de utilização do Shield Arduino Multifunções. Experimente combinar as funções e sensores do shield da sua própria maneira, criando novos projetos.

Verifique também o post Controle Remoto IR no Arduino, adaptando-o para utilizar o receptor IR deste shield.

Nenhum comentário:

Postar um comentário