Sensor Reflexivo de Obstáculo KY-032

Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino:

Semelhantemente ao Módulo Sensor de linha TCRT5000 do tutorial “ROBÔ SEGUIDOR DE LINHA COM SENSOR TCRT5000: ” e o Sensor de obstáculo infravermelho do tutorial “ROBÔ SEGUIDOR DE LINHA” temos o Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino. Porém, com a diferença de que ao invés de identificar as cores preto e branco iremos utilizá-lo para identificar objetos.

Como funciona o Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino ?

Precipuamente, o funcionamento do nosso sensor é baseado no sistema de reflexão infravermelho, ou seja, possui um LED emissor de infravermelho e um LED fotodiodo receptor, quando algum obstáculo/objeto passa no ângulo de detecçãodo sensor na distância ajustada, o sensor indica tal situação colocando a saída em nível lógico BAIXO. Vemos isso na imagem abaixo:

Imagem dos LED’s emissor e receptor detectando objeto

- Circuito Integrado

Os circuitos integrados tem a função de temporizador, controlar, oscilar e amplificar a presença ou não de obstáculos, sinalizando assim com o valor logico 1(alto) se não houver a presença de obstáculos e com valor logico 0(baixo) se houver a presença de obstáculos. O circuito integrado utilizado no sensor é um chip preto acoplado ao módulo é baseado em um temporizador NE555. Vejamos abaixo uma imagem de um circuito integrado:

Circuito Integrado

Para sua operação o modulo foi projetado para funcionar com frequência de 38KHz, há uma tensão de 3.3 a 6VDC. Além disso, o módulo possui dois potenciômetros ajustáveis, um para controle da frequência de operação e outro para controle da sensibilidade da distância de detecção que pode ficar entre 2cm e 40cm. Vejamos abaixo o Módulo Sensor Reflexivo de Obstáculo Infravermelho KY-032 e seus componentes:

Imagem do Sensor Infravermelho KY-032

Vemos que temos os dois potenciômetros P2 para ajuste do feixe de luz do emissor e P1 para ajuste da distância de detecção, uma entrada para jumper e ao lado temos o circuito integrado NE555. Logo depois, embaixo temos o sensor de energização do módulo (Power LED) que fica constantemente aceso quando o sensor está sendo energizado e logo ao lado temos o LED identifica se detectou ou não a presença de obstaculo. Em seguida temos os LEDs emissor e receptor.

- Óptica

O princípio físico do funcionamento do sensor tem a ver com a absorção da luz e emissão de calor pelas cores. A absorção da luz é o processo pelo qual a luz que incide sobre um corpo é convertida em energia e com isso os elétrons deste corpo se agitam, fazendo com que oscilem e emitem calor. Para isso acontecer, a luz que incide sobre um material em particular precisa ter uma frequência de oscilação próxima da frequência na qual os elétrons dos átomos desse material vibram. Veja a tabela de frequência de cores abaixo:

Tabela identificando as principais frequências da luz

Temos então que as cores que não produzem a própria luz depende da frequência que elas são capazes de absorver e da forma como elas interagem com a luz que as incide, ou seja, a cor não está no objeto. Temos que, na verdade, os objetos absorvem todas as cores que estão na luz branca e refletem apenas aquela que vemos. Essa luz é a que chega aos nossos olhos. Por exemplo, temos que se um objeto absorve todas as frequências de luz igualmente, então a cor que será expressa por ele que veremos será a cor preta. Porém, caso não consiga absorve algum intervalo de frequência de luz visível, como a azul, nós enxergaremos esse objeto com a cor azul, pois será está a cor que refletirá nos nossos olhos.

- Cores

Imagem de incidência da mesma luz branca em dois objetos

Em suma, acima iluminamos dois objetos com a mesma luz branca, e ambos os objetos absorvem todas as cores, exceto a luz azul para o da esquerda e a luz verde para o da direita. Como a luz azul e a luz verde não são absorvidas, elas são refletidas em todas as direções, tornando assim o objeto da esquerda azul e o da direita verde aos nossos olhos. No sensor temos que a luz infravermelho é emitida e quando temos a presença de um objeto essa luz é refletida para o LED receptor.

- Infravermelho

As luzes ditas não-visíveis são aquelas que a frequência está abaixo da frequência da luz vermelha e acima da frequência da luz violeta.

Imagem das luzes visíveis e não visíveis

Em inicio vemos que a luz vermelha tem a maior velocidade de propagação já que o comprimento de onda é o maior e possui a menor frequência das luzes visíveis. Logo depois, por ultimo temos que a violeta é a de menor velocidade de propagação e sua frequência é a maior das luzes visíveis. O infravermelho é um tipo de radiação eletromagnética que apresenta frequência menor que a da luz vermelha, por isso, não está no espectro eletromagnético visível. Ela é utilizada para detectar a temperatura de corpos e objetos, e para o nosso sensor não difere disso, pois o LED emissor envia uma onda de luz infravermelha e quando detecta um objeto está onda é refletida para o receptor. Além disso, temos também outras luzes que não estão no espectro da luz visível, como a ultravioleta.

- Os terminais deste sensor são: 

• VCC(+) – Tensão de entrada, entre 3,3 a 5 volts 
• GND(-) – O pino de O V do módulo, conectado ao GND do Arduino ou fonte Saida 
• EN – Pino de controle do módulo
• Saída Digital(OUT)– Pino de saída digital (retorna HIGH ou LOW) 

Mãos à obra — Configurando um Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino

Componentes Necessários 

• 1 x Arduino Uno R3 
• 1 x Sensor Infravermelho
• Jumpers Macho x Fêmea

- Montando o projeto: 

Precipuamente, conectaremos o GND do Módulo no GND do arduino e o VCC do Módulo no 5V do arduino. Logo após, conectaremos o OUT do Módulo no Pino 8 do arduino. Veja o Diagrama de montagem abaixo:

Diagrama de montagem do Sensor de Obstáculo Infravermelho KY-032

- Programando o Arduino: 

Neste instante vamos conectar o arduino no computador e abrir a IDE arduino. Desta forma iremos escrever o programa abaixo na IDE e compile o programa para o seu arduino.

Em contrapartida, antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.

#define pino_out 8 //Define o fino 8 como "pino_out"

void setup(){
  pinMode(pino_out, INPUT); //  Define o "pino_out" como entrada
  Serial.begin (9600); //Inicializa a comunicação serial com velocidade
}

void loop(){
  if(digitalRead(pino_out) == LOW){ // Se a leitura do "pino_out" for igual a LOW, Executa
    Serial.println ("Objeto detectado"); //Imprime o texto "Objeto detectado" no serial monitor
  }else{ //Senão, faz
    Serial.println ("Nenhum objeto detectado"); //Imprime o texto "Nenhum objeto detectado" no serial monitor
  }
}

ATENÇÃO: não esqueça de definir a placa e a porta que esta utilizando para carregar

- Testando o funcionamento:

PS: o tamanho e cor do obstáculo influenciam na distância de detecção. Além disso, os trimpots do módulo devem ser ajustados para melhorar o raio de detecção. Se tudo estiver correto temos o resultado abaixo:

GIF do sensor funcionando

- Ajuste de sensibilidade do Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino

O ajuste para a detecção de objetos é feita no trimpot. Quando o LED de leitura de detecção estiver aceso, significa que o sensor está recebendo o sinal infravermelho de volta, detectando assim o obstaculo/objeto.

Imagem dos trimpots

Entendendo a fundo: 

Software 

– Definições e variáveis utilizadas no projeto do Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino

A instrução #define apenas associou a porta 8 dos pinos do arduino ao nome “pino_out”, pois é mais fácil para se lembrar durante o programa.

#define pino_out 8 //Define o fino 8 como "pino_out"

– Função Setup – Definindo pinos do Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino

Sabemos que função setup é aquela que irá rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. Em início na função pinMode nos definimos se os pinos serão entradas ou saída, no caso do “pino_out” ele será uma entrada. Logo depois, por último inicializamos a comunicação serial para podemos visualizar o que esta acontecendo no serial monitor.

void setup(){
  pinMode(pino_out, INPUT); //  Define o "pino_out" como entrada
  Serial.begin (9600); //Inicializa a comunicação serial com velocidade
}

– Função Loop – Leitura do nosso Sensor Reflexivo de Obstáculo Infravermelho KY-032 com arduino de som e Estruturas de decisão 

Em analogia, a função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa.

Na estrutura de decisão if temos que se for verdadeira a condição entre parenteses o que está entre os colchetes do if será executado, caso contrario o que estiver entre os colchetes do else que será. A função digitalRead() faz a leitura do pino que está entre parenteses. Assim sendo, vemos que no caso do nosso programa o pino em questão é o “pino_out” e se a leitura feita for o valor “0”, nível logico baixo, a condição do if será verdadeira e será impresso no monitor serial o texto "Objeto detectado". Logo depois, caso a função digitalRead() leia “1”, nível logico alto, o else que será executado imprimindo assim o texto "Nenhum objeto detectado" no serial monitor.

void loop(){
  if(digitalRead(pino_out) == LOW){ // Se a leitura do "pino_out" for igual a LOW, Executa
    Serial.println ("Objeto detectado"); //Imprime o texto "Objeto detectado" no serial monitor
  }else{ //Senão, faz
    Serial.println ("Nenhum objeto detectado"); //Imprime o texto "Nenhum objeto detectado" no serial monitor
  }
}

Considerações finais: 

No tutorial mostramos como funciona e como utilizar o Sensor Reflexivo de Obstáculo Infravermelho KY-032 . Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Módulo Sensor de Tensão AC com arduino

Módulo Sensor de Tensão AC – ZMPT101B:

Neste tutorial utilizaremos o Módulo Sensor de Tensão AC com arduino. Este, no que lhe concerne, é muito utilizado para verificar a existência de energia alternada de até 250V em um determinado circuito onde esteja conectado. Vamos visualizar como este pequeno componente funciona e desenvolver uma aplicação para ele.

O  que é o Módulo Sensor de Tensão AC?

Este componente como todos os outros sensores trabalha com os conceitos físicos. O Módulo Sensor de Tensão AC é um módulo eletrônico que apresenta resultados rápidos e precisos em projetos de automação residencial e robóticos, onde é necessário verificar a presença de tensão. Ele também pode ser utilizado para fazer a medição da tensão por uma função, voltímetro, permitindo ao usuário saber o valor exato que está passando nos fios em determinado momento. Em seu interior ele é capaz de medir o fluxo dos elétrons, comumente chamado de corrente, que passa por ele. Após isso, o sensor analisa a diferença de potencial, mais comumente chamada de tesão, vendo qual a quantidade de elétrons que está o atravessando, pois como sabemos quanto maior a diferença de potencial maior é o fluxo de elétrons

- Tensão de corrente alternada

Precipuamente, a tensão/corrente alternada, diferente da corrente/tensão contínua, não possui polaridade fixa. Em suma, este é o motivo de receberem estes nomes, exatamente porque o nível de corrente/tensão alterna entre o positivo e o negativo repetidamente e não possui um valor fixo. Como por exemplo na imagem abaixo, na corrente temos Inicialmente com nível zero e aumenta gradativamente até o máximo positivo e inicia seu retorno ao zero formando um semiciclo, observe que facilmente podemos considerar este semiciclo como sendo metade de uma circunferência e temos então 180°.

Imagem do comportamento da corrente/tensão alternada

Observando a imagem acima temos um círculo trigonométrico na esquerda que ao ser circulado por uma espera em seu entorno podemos representar graficamente essas variações em um gráfico a direita. Estas variações são o comportamento da corrente alternada indo do positivo ao negativo. Em um circuito, a corrente alternada realiza alternância do seu valor indo do positivo para negativo e logo depois do negativo para positivo.

- Os componentes deste sensor são:

O sensor possui Bornes a parafuso para a entrada de energia AC, Pinagem para alimentação do circuito com energia DC, Pinos para saída de sinal e Potenciômetro para calibração da forma de onda na saída. Também possui um Transformador ZMPT101B.

Módulo Sensor de Tensão AC

Mãos à obra — Configurando um Módulo Sensor de Tensão AC

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Módulo Sensor de Tensão AC
• Jumpers Macho-Fêmea
• 1 x  Cabo de força Rabicho

ATENÇÃO! Cuidado ao manusear o rabicho e o sensor de tensão, pois estamos tratando de corrente alternada.

- Montando o projeto:

Primeiramente, conecte o rabicho no sensor de tensão AC com o auxílio de uma chave de fenda (Caso não tenha acesse o vida de silício), tome cuidado ao conectá-lo, A fase da tomada deve ir à entrada L escrita embaixo do sensor e O neutro da tomada deve ir na entrada N também escrito embaixo do sensor. Logo depois, conecte o GND do sensor de tensão no GND do arduino e o VCC do sensor no 5V do arduino. Em seguida, conecte o OUT do sensor no A0 do arduino. Como mostra o Diagrama abaixo.

Diagrama do Módulo Sensor de Tensão AC

- Programando o Arduino:

Primeiro verifique se o sensor NÃO está conectado na tomada. Agora vamos conectar o arduino no computador e abrir a IDE arduino, escreva o programa abaixo na IDE e compile o programa para o seu arduino. Em contrapartida, antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino: “COM3 (Arduino/Genuino Uno)”.

int corrente_inst[300];
int zero = 0;
int diferenca = 0;
int leitura = 0;
int pino_sensor = A2;

float corrente_pico;
float corrente_eficaz;
float tensao_rms;
float tensao_pico;
float frequencia_sinal;

double maior_valor = 0;
double corrente_valor = 0;

unsigned long tempo_zero_inicio;  
unsigned long tempo_zero_final;  
unsigned long semi_periodo;  
unsigned long periodo_completo;  

void setup(){
  Serial.begin(9600);
  pinMode(pino_sensor, INPUT);
}

void loop(){
  maior_valor = 0;
  for(int i = 0; i <300; i++){
    corrente_inst[i] =  analogRead(pino_sensor);
  }
  for(int i = 0; i <300; i++){
    if(maior_valor < corrente_inst[i]){
      maior_valor = corrente_inst[i];
    }
  }
  Serial.print("Maior Valor");
  Serial.println(maior_valor);
  delay(5000);

  tensao_pico = map(maior_valor,500,661,0,313);
  tensao_rms = tensao_pico/1.4;
  
  Serial.print("Tensão de Rede Elétrica: ");
  Serial.println  (tensao_rms);
}

ATENÇÃO: não esqueça de definir a placa e a porta que esta utilizando para carregar o programa.

-Testando o funcionamento:

Enfim conecte o rabicho na tomada conforme as especificações anteriormente ditam (Fase no L e Neutro no N). Como resultado podemos visualizar o sensor funcionando através do monitor serial já que nos inicializamos ele com a função Serial.begin(9600) basta clicar na lupa no canto direito superior da IDE arduino como na imagem abaixo:

Monitor serial

Veja abaixo o circuito do sensor pronto:

Circuito do Módulo Sensor de Tensão AC

Entendendo a fundo:
Software

– Definições e variáveis utilizadas no projeto do Módulo Sensor de Tensão AC com arduino

Esta instrução define quais as variáveis que iremos utilizar durante nosso programas os tipos de variáveis e os valores ou pinos atribuídos a elas. Assim sendo, temos como primeira variável do tipo int a variável "corrente_inst" sendo esta um vetor devido ao "[300]". Em seguida temos como primeira variável do tipo float "corrente_pico" declarada sem atribuições a ela. Logo depois temos a declaração "maior_valor = 0" do tipo "double" a qual foi atribuído a ela o valor 0. Por fim, temos a declaração "tempo_zero_inicio" do tipo "unsigned long". Todas está variaveis de tipos diferentes foram declaradas assim, pois elas ocupam espaços diferentes na memoria. Algumas ocupam menos como do tipo "int" e outras mais como do tipo "unsigned long".

int corrente_inst[300];
int zero = 0;
int diferenca = 0;
int leitura = 0;
int pino_sensor = A2; //Define o pino A2 como pino do sensor

float corrente_pico;
float corrente_eficaz;
float tensao_rms;
float tensao_pico;
float frequencia_sinal;

double maior_valor = 0;
double corrente_valor = 0;

unsigned long tempo_zero_inicio;  
unsigned long tempo_zero_final;  
unsigned long semi_periodo;  
unsigned long periodo_completo;

– Função Setup – Definindo pinos do Módulo Sensor de Tensão AC com arduino

  A função setup é aquela que ira rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. Com a função Serial.begin(9600) inicializamos a comunicação serial e definimos uma velocidade para podermos visualizar o que está acontecendo no serial monitor. Já com a pinMode definimos que o pino do sensor, declarado anteriormente, é uma entrada.Ou seja, é ele que irá receber a informação do meio e atuar atravez de saidas.

void setup(){
  Serial.begin(9600);
  pinMode(pino_sensor, INPUT);
}

– Função Loop – Leitura do nosso sensor Módulo Sensor de Tensão AC com arduino e Estruturas de decisão

A função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. Antes de tudo temos a variável "maior_valor = 0" que já foi declarada anteriormente recebendo o valor 0. Depois, ao longo do código temos a estrutura de repetição for a qual foi inicializada com a variável "i" recebendo o valor 0. Logo depois, temos que a função irá se repetir e tudo o que está dentro dela irá ser executado até que "i" seja maior ou igual a 300. Enfim temos que será adicionado +1 a variável "i" toda vez que a execução da estrutura terminar. Já na primeira linha depois do for temos que o vetor "corrente_inst[i]" recebera a leitura analógica do pino do sensor a cada ciclo e armazenará em seus devidos endereços.

void loop(){
 maior_valor = 0;
 for(int i = 0; i <300; i++){
 corrente_inst[i] = analogRead(pino_sensor);
 }

Após a estrutura anterior, temos ela novamente e dentro dela uma estrutura if de decisão. Nesta ótica, temos que caso a condição entre os parenteses do if for verdadeira tudo o que está entre os colchetes será executado. Então, caso o valor da variável "maior_valor" for menor que o respectivo valor do vetor "corrente_inst[i]", sendo esta variavel a que armazena os valores que o sensor detectou do meio, a variável "maior_valor" vai receber o valor do vetor "corrente_inst[i]" até que o valor que esteja na variavel "maior_valor" seja o maior valor que o sensor detectou.

for(int i = 0; i <300; i++){
 if(maior_valor < corrente_inst[i]){
 maior_valor = corrente_inst[i];
  }
 }

Em seguida, como resultado as duas funções for anteriores temos a função Serial.print que irá imprimir no monitor serial o texto "Maior Valor" e depois o maior valor que o sensor conseguiu detectar e que está variável armazena. Logo em seguida temos o delay que interrompe o programa por 5000 milissegundos.

Serial.print("Maior Valor");
Serial.println(maior_valor);
delay(5000);

A variável "tensao_pico" vai receber o valor da função "map(maior_valor,500,661,0,313)". A função "map(maior_valor,500,661,0,313)" nos permite efetuar o mapeamento de um intervalo numérico em outro intervalo numérico desejado. Já a variável "tensao_rms" recebera o valor da razão entre a variável "tensao_pico" e o valor 1.4. Para finalizar o código irá imprimir no serial monitor o texto "Tensão de Rede Elétrica: " e depois o valor da variavel "tensao_rms" que é a tensão que queremos saber.

  tensao_pico = map(maior_valor,500,661,0,313);
  tensao_rms = tensao_pico/1.4;
  
  Serial.print("Tensão de Rede Elétrica: ");
  Serial.println  (tensao_rms);

Considerações finais:

Neste tutorial mostramos como funciona e como utilizar o Módulo Sensor de Tensão AC – ZMPT101B. Veja também o tutorial "MEDINDO TENSÃO AC COM TRANSFORMADOR" onde falamos mais a respeito da tensão de corrente alternada. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Sensor Touch Capacitivo TTP223B com arduino

Sensor Touch Capacitivo TTP223B:

No tutorial ensinaremos a usar o Sensor Touch Capacitivo com arduino. Este, por sua vez, é muito utilizado para mudar momentaneamente o estado(HIGH ou LOW) de um certo componente. Vamos visualizar como este pequeno componente funciona e desenvolver uma aplicação para ele.

O  que é o Sensor Touch Capacitivo TTP223B?

Este componente como todos os outros sensores trabalha com os conceitos físicos.

- Funcionamento do Sensor Touch Capacitivo com arduino

Primeiramente, o Sensor Touch Capacitivo TTP223B funciona como um interruptor momentâneo, ou seja, consegue reconhecer toques e ao ser pressionado muda o estado logico do componente. Temos que este sensor pode ser utilizado em controle de lampadas, desktops e interruptores touch por meio de projetos com Raspberry, Arduino ou outros microcontroladores já que o formato dele com furos nas laterais permite uma fácil fixação e instalação.

- Campo Elétrico do Sensor Touch Capacitivo com arduino

O campo elétrico é um campo de força provocado pela ação de cargas elétricas. Em suma, sabemos que cargas elétricas colocadas num campo elétrico estão sujeitas à ação de forças elétricas, elas de atração e repulsão.

Imagem do campo elétrico de cargas elétricas

Sensores capacitivos são sensores que detectam qualquer tipo de massa. Seu funcionamento se dá por meio de incidência de um campo elétrico gerado por cargas elétricas em sua face, formando assim um capacitor. Ou seja, no sensor touch capacitivo contém cargas elétricas. Elas por sua vez geram um campo elétrico constante que permite que o sensor detecte qualquer presença de toque no local sinalizado resultando em, por exemplo, nível logico alto para a saída. Os pinos VCC(+) e GND(-) do serve justamente para que o sensor reconheça o toque, já o pino IO serve para informar ao microcontrolador que foi identificado toque ou não.

Os terminais deste sensor são:

• VCC – Tensão de entrada, entre 3,3 a 5 volts
• GND – O pino de O V do módulo
• IO – Pino de saída digital

Módulo do Sensor Touch Capacitivo TTP223B

Mãos à obra — Configurando um Sensor Touch Capacitivo TTP223B

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Sensor Touch Capacitivo TTP223B
• Jumpers Macho x Macho
• 1 x Resistor 150Ω
• Jumpers Macho-Fêmea
• 1 x Led 3MM Branco Difuso

- Montando o projeto:

Precipuamente, conectamos led na protoboard, na perna mais curta(-) conecte o resistor de 150 ohms e a perna mais longa(+) vai no pino digital 12. Logo depois, conectamos o resistor no negativo da protoboard. Em seguida, o GND do sensor será conectado também no GND da protoboard, e o VCC do sensor conectado no 5V do arduino. Logo após, conectemos o IO do sensor é conectado no pino digital 2, como mostra o diagrama abaixo:

Diagrama do Sensor Touch Capacitivo TTP223B

- Programando o Arduino:

Agora vamos conectar o arduino no computador e abrir a IDE arduino.  Escreva o programa abaixo na IDE e compile o programa para o seu arduino. Entretanto, antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino: “COM3 (Arduino/Genuino Uno)”.

#define pinSensor  2 // Conexão sensor no pino digital 2 do Arduino
#define pinLed 12  // Conexão led no pino digital 12 do Arduino
 
void setup() {
  pinMode(pinSensor, INPUT); // Define o pino do sensor como ENTRADA do Arduino
  pinMode(pinLed, OUTPUT); // Define o pino do led como SAÍDA do Arduino
}
 
void loop() {
  if (digitalRead(pinSensor) == HIGH){ // Se o sensor foi tocado, leitura é HIGH
    digitalWrite(pinLed, HIGH); // Acende o led enquanto mantemos o dedo tocando o sensor
  }
  else{
    digitalWrite(pinLed,LOW); // O led é desligado
  } 
}

ATENÇÃO: não esqueça de definir a placa e a porta que esta utilizando para carregar o programa.

- Testando o funcionamento:

Como resultado, caso tudo estiver correto vemos que o resultado será igual à imagem abaixo:

Imagem do circuito do Sensor Touch Capacitivo TTP223B

Entendendo a fundo:

Software

— Definições e variáveis utilizadas no projeto do Sensor Touch Capacitivo com arduino

A instrução #define apenas associa as portas dos pinos do arduino a nomes referente aos componentes conectados nestes pinos. Temos então que a porta 2 estamos associando ao nome pinSensor, pois é onde será conectado o pino do sensor. Logo depois, temos que na porta 12 estamos associando-a ao nome pinLed, pois é onde o LED será conectado

#define pinSensor  2 // Conexão sensor no pino digital 2 do Arduino
#define pinLed 12  // Conexão led no pino digital 12 do Arduino

— Função Setup – Definindo pinos do Sensor Touch Capacitivo com arduino

A função setup é aquela função que colocamos para rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. No pinMode definimos que o pino do sensor será uma entrada, ou seja, irá receber a informação do meio e atuará através das saídas e o pino do led uma saída assim irá expressar a informação recebida pelo sensor realizando alguma tarefa que configuramos com o código em questão.

pinMode(pinSensor, INPUT); // Define o pino do sensor como ENTRADA do Arduino
pinMode(pinLed, OUTPUT); // Define o pino do led como SAÍDA do Arduino

— Função Loop – Leitura do nosso Sensor Touch Capacitivo com arduino e Estruturas de decisão

A função loop ao contrário da setup colocamos para roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. A função if será executada caso a condição "digitalRead(pinSensor) == HIGH"(a leitura digital do pino do sensor seja nível logico alto) seja verdadeira, ou seja, o sensor detectou algum tipo de toc. Em contrapartida, caso a condição for falsa as operações dentro do else que serão compiladas, ou seja, o pino do LED receberá nível logico baixo e o LED apagará.

if (digitalRead(pinSensor) == HIGH){ // Se o sensor foi tocado, leitura é HIGH
   digitalWrite(pinLed, HIGH); // Acende o led enquanto mantemos o dedo tocando o sensor
 }
 else{
   digitalWrite(pinLed,LOW); // O led é desligado
 }

Hardware

- Circuitos integrados

São circuitos eletrônicos constituídos por um conjunto de componentes como: transístores, díodos, resistências e condensadores. Eles são todos fabricados num mesmo processo, sobre uma substância comum semicondutora de silício que se designa vulgarmente por chip. Em suma a sua função é realizar ações complexas que não tem como ser executadas por apenas um componente. Dessa forma, eles podem servir como temporizador, oscilador, amplificador, controlador e muito mais.

Imagem de exemplos de circuitos integrados

- Circuito integrado TTP223B

Este circuito integrado é utilizado para identificar a variação da capacitância na placa com grande precisão e sensibilidade.

Considerações finais:

Neste tutorial mostramos como funciona e como utilizar o Sensor Touch Capacitivo TTP223B. Veja também o tutorial "SENSOR CAPACITIVO COM ARDUINO", lá você irá entender de forma mais aprofundada o capacitor. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Medindo pressão/temperatura com Sensor barométrico BMP180

Sensor de Pressão e Temperatura BMP180: Analisando seu funcionamento

Neste tutorial utilizaremos o sensor barométrico com arduino. Este, no que lhe concerne, é muito utilizado para construção de estações meteorológicas e aperfeiçoamento de navegação GPS. Vamos visualizar como este pequeno componente funciona e desenvolver uma aplicação para ele.

O  que é o módulo Sensor de Pressão e Temperatura BMP180?

o sensor barométrico com arduino como todos os outros sensores trabalha com os conceitos físicos.

- Funcionamento do sensor barométrico com arduino

O sensor  barométrico BMP180 tem como finalidade fazer a medição de pressão atmosférica e temperatura. Além disso, as aplicações com esse sensor são diversas como em projetos com Arduino ou outras plataformas microcontroladoras em que seja necessário fazer a medição de pressão atmosférica, temperatura e altitude.

— Temperatura, sensor barométrico com arduino

Primeiramente, a temperatura é a grandeza física que mede o grau de agitação térmica, ou energia cinética e vibracional dos átomos que constituem um corpo. Além disso, quanto mais agitadas as moléculas, maior será a sua temperatura. Então, o sensor barométrico justamente mede e identifica essas agitações e nos fornece a temperatura em que ele esta exposto. Uma das aplicações para o sensor é claramente na meteorologia, pois como observamos na imagem abaixo existem vários graus de agitações entre as moléculas de água.

Imagem dos vários estados atmosféricos

— Pressão, sensor barométrico com arduino

Pressão é a grandeza física a qual é podemos obtê-la pela razão entre a força aplicada e sua área de contato. Vale ressaltar que a unidade de pressão no sistema internacional de unidades é o pascal. Sendo assim, o sensor barométrico irá realizar o cálculo da razão entre força aplicada a ele por sua área de contato e nos informar o resultado de tal calculo

- Os terminais do sensor barométrico com arduino:

• Vin(+) – Tensão de entrada, entre 3,3 a 5 volts
• GND(-) – O pino de O V do módulo
• SCL - I2C Serial Clock (SCL);
• SDA - I2C Serial Data (SDA);

Módulo do sensor de Pressão e Temperatura BMP180

Mãos à obra — Configurando um sensor barométrico BMP180

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Módulo sensor barométrico BMP180
• Jumpers Macho x Macho
• 1 x Protoboard

- Montando o projeto:

Precipuamente, conecte o sensor na protoboard. Logo depois, o pino Vin será conectado ao 5V do arduino, e o pino GND no GND do arduino. Logo após, conecte o pino SCL ao pino analógico A5 do Arduíno e o pino SCA  é conectado ao pino analógico A4, como mostra o diagrama abaixo:

Diagrama de montagem do sensor barométrico BMP180

- Biblioteca "Wire.h”:

Neste tutorial utilizaremos a biblioteca Wire.h a qual é responsável por conter as funções necessárias para gerenciar a comunicação entre os dispositivos através do protocolo I2C. Para baixar a biblioteca click no link e depois no quadrado verde escrito código.

- Biblioteca "Adafruit-BMP085”:

A outra biblioteca que utilizaremos será a Adafruit-BMP085. Logo Após o download do arquivo zip, abra a IDE e adicione a biblioteca em forma zip ao seu programa. Caso não entenda nada de biblioteca ou como prosseguir,veja o tutorial “COMO INSTALAR UMA BIBLIOTECA NO ARDUINO IDE” no portal vida de silício.

- Programando o Arduino:

Neste instante vamos conectar o arduino no computador e abrir a IDE arduino. Desta forma iremos escrever o programa abaixo na IDE e compile o programa para o seu arduino.

Em contrapartida antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.

#include <Wire.h> //INCLUSÃO DE BIBLIOTECA
#include <Adafruit_BMP085.h> //INCLUSÃO DE BIBLIOTECA
 
Adafruit_BMP085 bmp; //OBJETO DO TIPO Adafruit_BMP085 (I2C)
   
void setup(){
  Serial.begin(9600); //INICIALIZA A SERIAL
  if (!bmp.begin()){ //SE O SENSOR NÃO FOR INICIALIZADO, FAZ
  Serial.println("Sensor BMP180 não foi identificado! Verifique as conexões."); //IMPRIME O TEXTO NO MONITOR SERIAL
  while(1){} //SEMPRE ENTRE NO LOOP
  }
}
   
void loop(){
    
    Serial.print("Temperatura: "); //IMPRIME O TEXTO NO MONITOR SERIAL
    Serial.print(bmp.readTemperature()); //IMPRIME NO MONITOR SERIAL A TEMPERATURA
    Serial.println(" *C (Grau Celsius)"); //IMPRIME O TEXTO NO MONITOR SERIAL
        
    Serial.print("Pressão: "); //IMPRIME O TEXTO NO MONITOR SERIAL
    Serial.print(bmp.readPressure()); //IMPRIME NO MONITOR SERIAL A PRESSÃO
    Serial.println(" Pa (Pascal)"); //IMPRIME O TEXTO NO MONITOR SERIAL
     
    Serial.print("Altitude: "); //IMPRIME O TEXTO NO MONITOR SERIAL
    Serial.print(bmp.readAltitude()); //IMPRIME NO MONITOR SERIAL A ALTITUDE APROXIMADA
    Serial.println(" m (Metros)"); //IMPRIME O TEXTO NO MONITOR SERIAL
    
    Serial.print("Pressão a nível do mar (calculada): "); //IMPRIME O TEXTO NO MONITOR SERIAL
    Serial.print(bmp.readSealevelPressure()); //IMPRIME NO MONITOR SERIAL A PRESSÃO A NÍVEL DO MAR
    Serial.println(" Pa (Pascal)"); //IMPRIME O TEXTO NO MONITOR SERIAL

    Serial.print("Altitude real: "); //IMPRIME O TEXTO NO MONITOR SERIAL
    Serial.print(bmp.readAltitude(101500)); //IMPRIME NO MONITOR SERIAL A ALTITUDE REAL
    Serial.println(" m (Metros)"); //IMPRIME O TEXTO NO MONITOR SERIAL
     
    Serial.println("-----------------------------------"); //IMPRIME UMA LINHA NO MONITOR SERIAL
    delay(2000); //INTERVALO DE 2 SEGUNDOS
}

ATENÇÃO: não esqueça de definir a placa e a porta que esta utilizando para carregar o programa.

Imagem do circuito do sensor barométrico BMP180

- Testando o funcionamento:

Em seguida podemos visualizar o sensor funcionando através do monitor serial já que nos inicializamos ele com a função Serial.begin(9600). Basta clicar na lupa no canto direito superior da IDE arduino como na imagem abaixo:

Monitor serial

Entendendo a fundo:

Software

– Definições e variáveis utilizadas no projeto do sensor barométrico com arduino

Inicialmente a instrução #include <> serve para incluirmos bibliotecas ao nosso código, facilitando assim a escrita do mesmo, incluímos as bibliotecas Wire.h e Adafruit_BMP085.h. Logo depois, definimos um objeto do tipo Adafruit_BMP085 bmp.

#include <Wire.h> //INCLUSÃO DE BIBLIOTECA
#include <Adafruit_BMP085.h> //INCLUSÃO DE BIBLIOTECA 

Adafruit_BMP085 bmp; //OBJETO DO TIPO Adafruit_BMP085 (I2C)

– Função Setup – Definindo pinos do sensor barométrico com arduino

A função setup é aquela que ira rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. Em princípio, inicializamos a comunicação serial. Logo depois, temos uma estrutura de decisão if na qual a condição de que se o sensor não for inicializado "!bmp.begin()" for verdadeira ele executara imprimindo no serial monitor o texto "Sensor BMP180 não foi identificado! Verifique as conexões.". Então, en seguida temos a estrutura de repetição "while(1)" formando um loop.

Serial.begin(9600); //INICIALIZA A SERIAL
if (!bmp.begin()){ //SE O SENSOR NÃO FOR INICIALIZADO, FAZ
Serial.println("Sensor BMP180 não foi identificado! Verifique as conexões."); //IMPRIME O TEXTO NO MONITOR SERIAL
while(1){} //SEMPRE ENTRE NO LOOP

– Função Loop – Leitura do nosso sensor barométrico com arduino e Estruturas de decisão

A função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. A função serial.print imprime primeiro um texto em que esta entre coxetes e depois entre aspas e depois imprime a leitura feita no sensor. Neste instante, na função loop temos uma série de Serial.print a qual vai imprimir no monitor serial textos entre aspas, a temperatura, a altitude e pressão. A função "bmp.readTemperature()" serve justamente para ler a temperatura neste caso, no sensor e nos retornar o resultado, A função "bmp.readPressure()" serve para ler a pressão no sensor e nos retornar o resultado e A função "bmp.readAltitude()" serve para ler a altitude no sensor e nos retornar o resultado. Logo depois, irá imprimir no serial monitor o resultado. Temos no final uma espera de 2000 milissegundos de espera para depois executar toda a função loop novamente.

Serial.print("Temperatura: "); //IMPRIME O TEXTO NO MONITOR SERIAL
   Serial.print(bmp.readTemperature()); //IMPRIME NO MONITOR SERIAL A TEMPERATURA
   Serial.println(" *C (Grau Celsius)"); //IMPRIME O TEXTO NO MONITOR SERIAL
       
   Serial.print("Pressão: "); //IMPRIME O TEXTO NO MONITOR SERIAL
   Serial.print(bmp.readPressure()); //IMPRIME NO MONITOR SERIAL A PRESSÃO
   Serial.println(" Pa (Pascal)"); //IMPRIME O TEXTO NO MONITOR SERIAL
    
   Serial.print("Altitude: "); //IMPRIME O TEXTO NO MONITOR SERIAL
   Serial.print(bmp.readAltitude()); //IMPRIME NO MONITOR SERIAL A ALTITUDE APROXIMADA
   Serial.println(" m (Metros)"); //IMPRIME O TEXTO NO MONITOR SERIAL
   
   Serial.print("Pressão a nível do mar (calculada): "); //IMPRIME O TEXTO NO MONITOR SERIAL
   Serial.print(bmp.readSealevelPressure()); //IMPRIME NO MONITOR SERIAL A PRESSÃO A NÍVEL DO MAR
   Serial.println(" Pa (Pascal)"); //IMPRIME O TEXTO NO MONITOR SERIAL

   Serial.print("Altitude real: "); //IMPRIME O TEXTO NO MONITOR SERIAL
   Serial.print(bmp.readAltitude(101500)); //IMPRIME NO MONITOR SERIAL A ALTITUDE REAL
   Serial.println(" m (Metros)"); //IMPRIME O TEXTO NO MONITOR SERIAL
    
   Serial.println("-----------------------------------"); //IMPRIME UMA LINHA NO MONITOR SERIAL
   delay(2000); //INTERVALO DE 2 SEGUNDOS

Considerações finais:

Neste tutorial mostramos como funciona e como utilizar o Sensor de Pressão e Temperatura BMP180. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Sensor de Fluxo de Água: Medindo a vazão com Arduino

Sensor de Fluxo de Água: Medindo a vazão com Arduino

O Sensor de Fluxo de Água 1/2″ – YF-S201 é um dispositivo usado para medir o volume ou a massa em fluxo de um gás, ou líquido que passa por uma turbina. Neste tutorial aprenderemos como usá-lo e visualizaremos como este pequeno componente funciona.

O  que é o Sensor de Fluxo de Água?

Este componente, como todos os outros sensores, trabalha com os conceitos físicos.

- Funcionamento

Portanto, o Sensor de Fluxo de Água possui como componentes o sensor hall, a vedação externa, a turbina, um imã e a carcaça para juntar todos esses componentes como na imagem abaixo:

Imagem interna do sensor de vazão de água

Como podemos observar quando a água flui através da entrada até a turbina, esta gira e a velocidade muda conforme o fluxo de água aumenta ou diminui e enquanto as turbinas estão exercendo seu trabalho, o imã e o sensor de efeito Hall realiza a leitura e emite um sinal de pulso, respectivamente. Mas como assim? Bom, a leitura da vazão funciona da seguinte forma. Quando a água passa pela turbina, ela gira e detecta a quantia de voltas dadas. A leitura desses dados se faz pelo ímã, o qual possui um polo norte e um polo sul, posicionado em uma das pás da turbina, e o sensor de efeito hall de forma paralela envia o sinal digital para o microcontrolador e por fim a água sai pelo outro lado.

Ps: Quanto maior a intensidade da água por minuto maior será a contagem de pulsos.

- Os terminais deste sensor de vazão são:

• VCC(vermelho) – Tensão de entrada, entre 3,3 a 5 volts
• GND(preto) – O pino de O V do módulo, conectado ao GND do Arduino ou fonte
• Saída Digital(amarelo) – Pino de saída digital de contagem de pulsos por minuto

Mãos à obra — Configurando um Sensor de Fluxo de Água

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Sensor de Fluxo de Água 1/2″ – YF-S201
• Jumpers Macho x Macho

- Montando o projeto com Sensor de vazão de água

Primeiramente, conecte o terminal preto do sensor de fluxo no GND do Arduino e o terminal vermelho no 5V do Arduino e conecte o terminal amarelo será conectado no pino digital D2, como mostra o diagrama abaixo:

- Programando o Arduino para usar o Sensor de fluxo de água

Agora, que já montamos nosso projeto, vamos conectar o arduino no computador e abrir a IDE arduino.  Escreva o programa abaixo na IDE e compile o programa para o seu Arduino.

Para isso, antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Em seguida, clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.

int contaPulso; //Variável para a quantidade de pulsos

void setup(){
  Serial.begin(9600);
  pinMode(2,INPUT);
  attachInterrupt(0,incpulso,RISING); //Configura o pino 2(Interrupção 0)interrupção
  
}


void loop(){
  
sei(); //Habilita interrupção
delay(1000);
cli(); //Desablilita interrupção
if(contaPulso>0){
  Serial.print("Contagem de Pulsos");
  Serial.println(contaPulso);
}
else{
  Serial.println("Sem pulsos");
}
contaPulso = 0;
}

void incpulso(){
  contaPulso++; //Incrementa a variável de pulsos
}

- Testando o funcionamento do Sensor de vazão de água

Enfim, caso tudo estiver correto o resultado será igual à imagem abaixo. 

Dessa forma, visualizamos o sensor funcionando através do monitor serial já que nos inicializamos ele com a função Serial.begin(9600) basta clicar na lupa no canto direito superior da IDE Arduino como na imagem abaixo:

Entendendo a fundo

Software

– Definições e variáveis utilizadas no projeto

Primeiramente, nesta instrução declaramos uma variável para podermos usá-la em nosso programa. Neste caso, a variável que declaramos é do tipo int, ou seja, possui dois bytes de memória disponível para ela.

int contaPulso; //Variável para a quantidade de pulsos

– Função Setup – Definindo pinos

Em seguida. a função setup é aquela que roda apenas uma vez no início do programa. Está função é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada.

Nesta função, Serial.begin inicializa a comunicação serial da placa arduino com o computador. Em seguida, o comando pinMode define o que será entrada e o que será saída na nossa programação. E por fim o comando attachInterrupt define o pino de leitura como interrupção do Arduino no programa. 

Serial.begin(9600);
pinMode(2,INPUT);
attachInterrupt(0,incpulso,RISING); //Configura o pino 2(Interrupção 0)interrupção

– Função Loop – Leitura do nosso Sensor de Fluxo de Água e Estruturas de decisão

Enfim, a função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. A função if define uma condição para que o Arduino execute as funções dentro dele, caso a condição for verdadeira, ou seja, a variável declarada anteriormente tiver o valor maior que 0, o Arduino executa tudo o que esta nos colchetes do if. Senso assim, irá imprimir no serial monitor o texto "Contagem de Pulsos" e depois o valor que está atribuído a variável contaPulso. Entretanto, caso a condição do if seja falsa o que esta nos colchetes do else que será executado, o seja, irá imprimir no serial monitor o texto "Sem pulsos". Logo depois, a variável contaPulso recebe o valor 0. Toda vez que houver interrupção, ou seja, houver a mudança de estado de 0V (0) para 5V(1) a função void incpulso será executada, já que na função attachInterrupt(0,incpulso,RISING) nos definimos isso. Assim será adicionado +1 a variável contaPulso.

sei(); //Habilita interrupção
delay(1000);
cli(); //Desablilita interrupção
if(contaPulso>0){
  Serial.print("Contagem de Pulsos");
  Serial.println(contaPulso);
}
else{
  Serial.println("Sem pulsos");
}
contaPulso = 0;
}

void incpulso(){
  contaPulso++; //Incrementa a variável de pulsos

Considerações finais:

Por fim, neste tutorial mostramos como funciona e como utilizar o sensor de fluxo de água. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Módulo Sensor de Gesto e RGB APDS9960 com Arduino

Módulo sensor de gesto e RGB APDS9960: Analisando seu funcionamento

Neste tutorial utilizaremos o sensor de gesto e RGB APDS9960 com arduino. Este, no que lhe concerne, é utilizado para fazer a medição de luz, cor ambiente, detecção de proximidade e detecção de gestos. Visualizaremos como este pequeno componente funciona e desenvolveremos uma aplicação para ele.

O  que é o Módulo Sensor de Gesto e RGB APDS9960?

Este módulo possui o Sensor APDS-9960. Ele mede na parte de cor RGB a intensidade da luminosidade do ambiente, cor ambiente. Além disso, ele também na parte de sensor de gestos detecta nível de proximidade e sentido de gestos (direita, esquerda, alto e baixo) o que permite que um computador, robô ou plataforma microcontroladora possa ser controlado por ele.

- Funcionamento

Primeiramente, o sensor utiliza barramento I2C para utilização (pinos SDA e SCL), possui pino de interrupção (INT) para transferir os dados de proximidade de gesto e um pino adicional (VL) para LED infravermelho além de ser utilizado em projetos  com diversos tipos de Arduino como o NodeMCU ESP8266, pequenos computadores como o Raspberry ou qualquer outra plataforma microcontroladora. Ao mover o sensor, ele consegue identificar o movimento e direção por meio dos gestos que realizamos com ele e nos informar.

- Movimento

De início, os controladores por gestos são muito utilizados hoje em nossos smartphones. Temos então que antes de serem inseridos na sociedade havia a necessidade de ter botões nas telas dos smartphones, entretanto com a chegado desta tecnologia, agora apenas temos que arrastar para o lado quando queremos desbloquear ou mudar de aba no smartphone.

Imagem do sensor de gesto em Smartphones

Aliás, vemos que os sensores de gestos como mostra a imagem abaixo são capazes de imitar perfeitamente os movimentos que fazemos com nossas mãos, por exemplo, em outros objetos.

Imagem do sensor de gesto imitando movimentos

- Os terminais deste sensor são:

• INT - pino de interrupção
• VCC - Tensão de entrada 3.3V
• GND - O pino de O V do módulo, conectado ao GND do Arduino ou fonte
• SDA  - Pino utilizado pelo barramento I2C
• SCL - Pino utilizado pelo barramento I2C
• VL - Pino adicional para LED infravermelho.

Sensor de Gesto e RGB APDS9960

Mãos à obra — Configurando um sensor de gesto

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Sensor de gesto e RGB APDS9960
• Jumpers Macho x Macho
• 1 x Protoboard

- Montando o projeto:

Primeiramente, o sensor da vida de silício vem sem os pinos Headers soldados, então antes de iniciar a montagem vamos soldá-los ao módulo, lembrando que soldamos ao módulo a parte de menor comprimento. Após a soldagem conectaremos o modulo sensor de gesto na protoboard e conectar o VCC do módulo no 3.3V do arduino (Cuidado para não conectar no 5V ou pode danificar o módulo). Logo depois, vamos conectar o GND do módulo ao GND do arduino, já o SDA do módulo conectaremos no pino analógico A4 do arduino e o SCL do módulo conectamos no pino analógico A5 do arduino. Observe o diagrama de montagem abaixo:

Diagrama de montagem do sensor de gesto e RGB APDS9960

 — Biblioteca <Adafruit_APDS9960.h>:

A biblioteca que utilizaremos será a Adafruit_APDS9960.h . Esta biblioteca nos permitirá configurar o sensor com função que já estão dentro dela e apenas precisaremos utilizá-las em nosso programa. Após o download do arquivo zip, abra a IDE e adicione a biblioteca em forma zip ao seu programa. Caso não entenda nada de biblioteca ou como prosseguir,veja o tutorial  “COMO INSTALAR UMA BIBLIOTECA NO ARDUINO IDE” no portal vida de silício.

- Programando o Arduino:

Agora vamos conectar o arduino no computador e abrir a IDE arduino.  Escreva o programa abaixo na IDE e compile o programa para o seu arduino.

Entretando, antes de carregar o programa, precisamos selecionar qual porta desejamos usar para fazer o carregamento do nosso programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.

#include <Adafruit_APDS9960.h> //INCLUSÃO DE BIBLIOTECA
Adafruit_APDS9960 apds; //OBJETO DO TIPO Adafruit_APDS9960 (I2C)

void setup() {
  Serial.begin(9600); //INICIALIZA A SERIAL
  
  if(!apds.begin()){ //SE O SENSOR NÃO FOR INICIALIZADO, FAZ
    Serial.println("Falha ao inicializar o dispositivo. Verifique as conexões!"); //IMPRIME O TEXTO NO MONITOR SERIAL
  }//SENÃO, FAZ
  else Serial.println("Dispositivo inicializado!"); //IMPRIME O TEXTO NO MONITOR SERIAL

  //O MODO DETECÇÃO DE GESTO SERÁ HABILITADO QUANDO O SENSOR DETECTAR ALGO PRÓXIMO DO MÓDULO (APROXIME SEU DEDO E AFASTE)
  apds.enableProximity(true);
  apds.enableGesture(true);
}

void loop() {
    uint8_t gesture = apds.readGesture(); //FAZ A LEITURA DA DIREÇÃO DO GESTO
    if(gesture == APDS9960_DOWN) Serial.println("↓"); //SE DETECTAR GESTO (DE CIMA PARA BAIXO), IMPRIME O SÍMBOLO NO MONITOR SERIAL
    if(gesture == APDS9960_UP) Serial.println("↑"); //SE DETECTAR GESTO (DE BAIXO PARA CIMA), IMPRIME O SÍMBOLO NO MONITOR SERIAL
    if(gesture == APDS9960_LEFT) Serial.println("←"); //SE DETECTAR GESTO (DA DIREITA PARA A ESQUERDA), IMPRIME O SÍMBOLO NO MONITOR SERIAL
    if(gesture == APDS9960_RIGHT) Serial.println("→"); //SE DETECTAR GESTO (DA ESQUERDA PARA A DIREITA), IMPRIME O SÍMBOLO NO MONITOR SERIAL
}

- Testando o funcionamento:

Em fim, caso tudo estiver correto o resultado será igual à imagem abaixo. Temos que o sensor de gestos ficará identificando os seus movimentos ao passar com a mão encima dele e mostrará no serial monitor a direção.

Imagem do serial monitor

ATENÇÃO: não esqueça de definir a placa e a porta que esta utilizando para carregar o programa.

Imagem do circuito do Sensor de Gestos

Entendendo a fundo:

Software

– Definições e variáveis utilizadas no projeto do sensor de gesto e RGB APDS9960 com arduino

Precipuamente, a instrução inclui <> permitirá que adicionemos a biblioteca Adafruit_APDS9960.h ao nosso programa. Assim podemos utilizar suas funcionalidades em nosso algoritmo.

#include <Adafruit_APDS9960.h> //INCLUSÃO DE BIBLIOTECA

– Função Setup – Definindo pinos do sensor de gesto e RGB APDS9960 com arduino

Vemos que a função setup é aquela que ira rodar apenas uma vez quando nosso programa for iniciado. Além disso, ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. Em princípio, temos a função Serial.begin que irá inicializar a comunicação serial para podermos visualizar os resultados nela. Temos que na função if, antes de mais nada, possui uma condição entre parenteses "!apds.begin()" a qual se for verdadeira tudo o que tiver entre os colchetes do if será executado, ou seja, será impresso no monitor serial o texto "Falha ao inicializar o dispositivo. Verifique as conexões!". Em seguida, podemos observar que caso a condição seja falsa o comando else será executado e imprimirá "Dispositivo inicializado!" no serial monitor. As funções " apds.enableProximity(true)" e "apds.enableGesture(true)" da biblioteca serão executadas como parâmetro "true".

Serial.begin(9600); //INICIALIZA A SERIAL
 
 if(!apds.begin()){ //SE O SENSOR NÃO FOR INICIALIZADO, FAZ
   Serial.println("Falha ao inicializar o dispositivo. Verifique as conexões!"); //IMPRIME O TEXTO NO MONITOR SERIAL
 }//SENÃO, FAZ
 else Serial.println("Dispositivo inicializado!"); //IMPRIME O TEXTO NO MONITOR SERIAL

 //O MODO DETECÇÃO DE GESTO SERÁ HABILITADO QUANDO O SENSOR DETECTAR ALGO PRÓXIMO DO MÓDULO (APROXIME SEU DEDO E AFASTE)
 apds.enableProximity(true);
 apds.enableGesture(true);

– Função Loop – Leitura do nosso sensor de gesto e RGB APDS9960 com arduino e Estruturas de decisão

A função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. Primeiramente, temos a leitura das direções do sensor "uint8_t gesture = apds.readGesture()" com a função declarada no void setup. Logo depois, temos uma série de comando if's, que por sua vez, caso forem verdadeiras irão imprimir no serial monitor os textos em aspas. No entando, seguindo a lógica apenas uma pode ser verdadeira de cada vez. Similarmente, temos que a primeira condição "gesture == APDS9960_DOWN" que será verdadeira caso a direção for para baixo, a função "Serial.println("↓")" será executada. Na mesma perspectiva, caso a condição "gesture == APDS9960_UP" que, por assim dizer, detectou gesto para cima, for verdadeira a função "Serial.println("↑")" será executada e assim por diante.

uint8_t gesture = apds.readGesture(); //FAZ A LEITURA DA DIREÇÃO DO GESTO
   if(gesture == APDS9960_DOWN) Serial.println("↓"); //SE DETECTAR GESTO (DE CIMA PARA BAIXO), IMPRIME O SÍMBOLO NO MONITOR SERIAL
   if(gesture == APDS9960_UP) Serial.println("↑"); //SE DETECTAR GESTO (DE BAIXO PARA CIMA), IMPRIME O SÍMBOLO NO MONITOR SERIAL
   if(gesture == APDS9960_LEFT) Serial.println("←"); //SE DETECTAR GESTO (DA DIREITA PARA A ESQUERDA), IMPRIME O SÍMBOLO NO MONITOR SERIAL
   if(gesture == APDS9960_RIGHT) Serial.println("→"); //SE DETECTAR GESTO (DA ESQUERDA PARA A DIREITA), IMPRIME O SÍMBOLO NO MONITOR SERIAL

Hardware

- Cor RGB - APDS9960:

A Cor RGB digital APDS-9960 é a parte do sensor que permite identificar cores e intensidades de luz em um ambiente.

Considerações finais:

Neste tutorial mostramos como funciona e como utilizar o sensor de gesto e RGB APDS9960. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Como descobrir o endereço do módulo Bússola Digital / Magnetômetro Três Eixos – GY-273

Como descobrir o endereço do Módulo Bússola Digital / Magnetômetro Três Eixos – GY-273

Neste tutorial descobriremos como achar o endereço de do módulo bússola digital com arduino, mais especificamente do módulo Bússola Digital / Magnetômetro Três Eixos – GY-273.

O  que é o módulo Bússola Digital / Magnetômetro Três Eixos – GY-273?

O Módulo Bússola Eletrônica 3 Eixos Campo Magnético HMC5883L é um dispositivo de Bússola e Magnetômetro equipado com o chip HMC5883L.

- Funcionamento

Precipuamente o Magnetômetro consegue detectar onde fica o norte geográfico magnético da Terra através de um sensor magnético de 3 eixos, fornecendo na saída informações sobre os eixos X, Y e Z. Não obstante, utiliza o protocolo de comunicação I2C. Ademais, para mais informações sobre o chip HMC5883L e o sensor acesse o (datasheet) e visualize a sua composição.

- Circuito integrado

O chip HMC5883L é um circuito integrado é por isso é responsável por realizar tarefa complexas que não poderiam ser executadas por apenas um componente.

Circuitos Integrados

- Campo magnético

O sensor Magnetômetro utiliza do campo magnético da terra para o seu funcionamento com o fim de identificar a sua posição em relação aos eixos X, Y e Z e em relação ao norte da terra onde a bússola como já sabemos sempre aponta. Além disso, o campo magnético faz com que à terra funcione como um ímã gigante já que possui um norte e um sul e as linhas do campo vão de um para o outro. Aliás, o Polo norte é na verdade o sul magnético e o polo sul o norte magnético.

- Os terminais deste sensor são:

• VCC(+) – Tensão de entrada, entre 3,3 a 5 volts
• GND(-) – O pino de O V do módulo, conectado ao GND do Arduino ou fonte
• Pino SCL - I2C Serial Clock
• Pino SDA - I2C Serial Data

Módulo Bússola Digital / Magnetômetro

Mãos à obra — Configurando uma Bússola Digital

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Bússola Digital (Magnetómetro) - HMC5883L
• 1 x Protoboard

- Montando o projeto:

Primeiramente conecte o VCC do módulo no 3.3V do arduino e logo após conecte o GND do módulo no GND do arduino. Depois disso conecte o SCL do módulo no pino A5 e o SDA no pino A4 do arduino desta forma temos como mostra o diagrama abaixo:

Diagrama de montagem do Módulo Bússola Digital / Magnetômetro

- Biblioteca  <wire.h>:

A biblioteca que utilizaremos será a Wire.h. Após o download do arquivo zip, abra a IDE e adicione a biblioteca em forma zip ao seu programa. Não obstante, caso não entenda nada de biblioteca ou como prosseguir, veja o tutorial  “COMO INSTALAR UMA BIBLIOTECA NO ARDUINO IDE” no portal vida de silício.

- Programando o Arduino:

Antes de mais nada vamos conectar o arduino no computador e abrir a IDE arduino.  Escreva o programa abaixo na IDE e compile o programa para o seu arduino.

Antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.

#include <Wire.h>
 
void setup()
{
  Wire.begin();//Inicie a biblioteca Wire
  Serial.begin(9600);//Inicie a Comunicação Serial
  while (!Serial);             //Espera pelo serial monitor
  Serial.println("\nI2C Scanner");
}
 
void loop()
{
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
 
    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
 
      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknow error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
 
  delay(5000);           // wait 5 seconds for next scan
}

Se as conexões estiverem corretas, ao abrir o serial monitor você terá a seguinte tela, mostrando o endereço do dispositivo detectado.

Imagem do serial monitor

O I2C Scanner é um programa que serve não apenas para este módulo, mas também para qualquer outro dispositivo I2C conectado ao barramento. Tenha este programa sempre à mão para descobrir o endereço do dispositivo ou simplesmente para verificar se ele está se comunicando com o Arduino, podemos ver isto no tutorial do Sensor de Movimento de cabeça, onde é utilizamos o mesmo programa.

Imagem do circuito da Bússola Digital

Entendendo a fundo:

Software

– Definições e variáveis utilizadas no projeto do módulo bússola digital com arduino

A instrução #include<> serve para incluir bibliotecas no algoritmo.

#include <Wire.h>

– Função Setup – Definindo pinos do módulo bússola digital com arduino

A função setup é aquela que ira rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. A função "Wire.begin()" Inicializa a biblioteca Wire. Semelhantemente a função Serial.begin inicia a comunicação serial e define uma velocidade para ela. A função "while (!Serial)" Espera pelo serial monitor e a função "Serial.println" imprime no serial monitor o texto "I2C Scanner".

void setup() { 
 Wire.begin();//Inicie a biblioteca Wire
 Serial.begin(9600);//Inicie a Comunicação Serial
 while (!Serial); //Espera pelo serial monitor
 Serial.println("\nI2C Scanner");
 }

– Função Loop – Leitura do nossa módulo bússola digital com arduino e Estruturas de decisão

Em primeira instância a função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. Temos primeiro a declaração das variáveis do tipo byte "error" e "address" e a variável do tipo int "nDevices". Logo depois imprime no serial monitor o texto "Scanning..." e atribui a variável nDevices o valor 0.

void loop() { 
 byte error, address;
 int nDevices;
 Serial.println("Scanning...");
 nDevices = 0;

Posteriormente temos a estrutura de repetição for onde atribui a variável "address" o valor 1, depois coloca a condição"address < 127" de que enquanto a variável "address" for menor que 127 tudo que estiver entre os colchetes será executado e a seguir a cada ciclo irá ser adicionado +1 a variável "address" no comando "address++". Lodo depois, dentro do for temos de incio por assim dizer o comando" Wire.beginTransmission(address)" que inicia a comunicação com START e referência o dispositivo escravo address. Já o comando "error = Wire.endTransmission()" atribua a variável error um valor recebido pela função.

for(address = 1; address < 127; address++ ) {
 Wire.beginTransmission(address);
 error = Wire.endTransmission();

- IF's e Else's do nossa módulo bússola digital com arduino

Similarmente dentro do for temos a estrutura de decisão if que será executada caso a condição de a variável error for igual a 0 ser verdadeira. Assim sendo, temos a função Serial.print que executará dentro do if e imprimirá o texto "I2C device found at address 0x" no serial monitor. Logo após temos outra estrutura de decisão dentro da anterior, onde caso a condição da variável address ser menor que 16 for verdadeira será executada e em seguida imprimira no serial monitor o texto "0", depois o endereço hexadecimal da bússola e depois o texto " !" e adicionará a variável nDevice +1.

if (error == 0) {
 Serial.print("I2C device found at address 0x");
 if (address<16) Serial.print("0");
 Serial.print(address,HEX);
 Serial.println(" !");
 nDevices++;
 }

Se a variável error for igual a 4 a estrutura else if será executada e não a if anterior, assim sendo a variável nDevices não receberá +1 e será escrito no monitor serial o texto "Unknow error at address 0x". Em contrapartida, semelhantemente ao if anterior caso a variável address for menor que 16  será impresso no serial monitor o texto "0" e logo depois o endereço hexadecimal do módulo.

else if (error==4) {
 Serial.print("Unknow error at address 0x");
 if (address<16){
  Serial.print("0");
  Serial.println(address,HEX);
   }
 }

Na estrutura if abaixo se a variável nDevices for igual a 0 será impresso no monitor serial o texto "No I2C devices found". Entretando, caso o nDevices não for igual a 0 o else será executado, então será impresso no serial monitor o texto "done" e esperará 5000 milissegundos para executar a próxima linha.

 
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
  delay(5000);           // wait 5 seconds for next scan
}

Considerações finais:

Neste tutorial mostramos como funciona e como ver o endereço do Módulo Bússola Eletrônica 3 Eixos Campo Magnético HMC5883L. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Sensor de Vibração SW-420 com arduino

Sensor de Vibrações: Detectando Oscilações Sonoras

Neste tutorial utilizaremos o sensor de vibração com arduino. Este, no que lhe concerne, é muito utilizado para alarmes e detecção de vibrações do meio. Vamos visualizar como o pequeno componente funciona e desenvolver uma aplicação para ele.

O  que é o módulo sensor de vibração?

O sensor como todos os outros trabalha com os conceitos físicos.

- Funcionamento

Precipuamente, o sensor possui uma esfera de metal solta dentro de um cilindro acoplado a ele, quando este sensor sente vibrações a esfera se movimenta(Vibra) desfazendo o contato com os dois terminais que vão para o sensor. Além disso, enquanto o sensor não está detectando vibrações, a saída fica em nível logico baixo, somente quando o sensor detecta um certo nível de vibração regulado manualmente no trimpot a saída fica em nível logico alto.  Uma das inúmeras aplicações para este sensor é no monitoramento de condições de um determinado equipamento, ou seja, mede as vibrações de um equipamento onde quando é detectado um nível de vibração anormal logo é informado o possível defeito.

— Vibração

As vibrações ou oscilações são movimentos que se repetem de forma contínua ou não dado um intervalo de tempo. As direções das ondas de vibração são com toda certeza longitudinais e transversais. Ela está em toda nossa volta já que tudo o que é material está em constante vibração

Onda transversal

Por analogia podemos observar as moléculas de água as quais entre seus 3 estados o mais agitado, que estão vibrando com mais intensidade é o gasoso.

Molécula vibrando 

- Frequência

A frequência está relacionada com a vibração. Ela é a quantidade de vezes que ocorre a vibração completa dado um intervalo de tempo de 1 segundo. Podemos usar as figuras de Chladni que dependendo da frequência da vibração sobre o composto em cima da tela preta temos formas diferentes.

Figuras de Chladni

No sensor de vibração a frequência é fundamental para seu funcionamento, pois sem ela não seria possível identificar as vibrações irregulares de um equipamento.

- Os terminais deste sensor são:

• VCC(+) – Tensão de entrada, entre 3,3 a 5 volts
• GND(-) – O pino de O V do módulo conectado ao GND do Arduino ou fonte
• Saída Digital(D0)– Pino de saída digital (retorna HIGH ou LOW)

Módulo do sensor de vibrações

Mãos à obra — Configurando um Sensor de Vibrações

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Módulo sensor de vibrações SW-420
• 1 x Protoboard
• 1 x LED
• 1 x Resistor de 150Ohms
• Jumpers Macho x Fêmea
• Jumpers Macho x Macho

- Montando o projeto:

Primeiramente conecte o LED e o resistor na protoboard.  Logo depois, a perna maior do LED será conectada no resistor e a menor no negativo da  protoboard. Já a outra extremidade do resistor será conectada ao pino 12 do arduino. Em seguida conecte o VCC do sensor de vibração no 5V do arduino e o GND do sensor no negativo da protoboard. A saida digital(D0) do sensor será conectada ao pino 5 do arduino. Depois de ter realizado os passos anteriores conectem o GND do arduino no negativo da protoboard. Veja abaixo o circuito do sensor com mais detalhes:

Diagrama de montagem do sensor de vibração

- Programando o Arduino:

Vamos agora conectar o arduino no computador e abrir a IDE arduino.  Escreva o programa abaixo na IDE e compile o programa para o seu arduino.

Antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.

#define pinoLed 12 //Pino digital utilizado pelo led
#define pinoSensor 5 //Pino digital utilizado pelo sensor

int ler = 0; // Declaração da Variavel "ler"
void setup(){
  Serial.begin(9600);
  pinMode(pinoSensor, INPUT); //Define o pino como entrada
  pinMode(pinoLed, OUTPUT); //Define o pino como saída
}

void loop(){
  ler = digitalRead(pinoSensor);// A varialvel "ler" recebe o nivel logico lido no pino do sensor de vibrações
  Serial.println(ler);// Printa no monitor serial o valor atribuido a variavel "ler"
  delay(150);// Espera 150 milisegundos
  if(ler == HIGH){ //Se a leitura do pino for igual a low, executa
      digitalWrite(pinoLed, HIGH); //ACENDE O LED
  }else//Senão, executa
  {
    digitalWrite(pinoLed, LOW); //APAGA O LED
  }
}

- Testando o funcionamento:

Caso tudo estiver correto o resultado será igual à imagem abaixo em que o sensor de vibração ficará constante em nível lógico baixo(LOW) enquanto ele não detectar vibração, por exemplo. E ao detectar vibração o nível lógico da saida vai para alto (HIGH).

ATENÇÃO: não esqueça de definir a placa e a porta que esta utilizando para carregar o programa.

Imagem do circuito do sensor de vibração funcionando

Como resultado, ao detectar uma quantidade de vibração pré-determinada ajustando a sensibilidade no potenciômetro(trimpot) o LED acenderá, tente utilizar uma chave de fenda ou algo do tipo e bata com ela em uma superfície rigida , certifique-se se o sensor esta perto para detectar as vibrações.

Potenciômetro do sensor para a regulação de sensibilidade

Podemos visualizar o sensor funcionando através do monitor serial já que inicializamos ele com a função Serial.begin(9600) basta clicar na lupa no canto direito superior da IDE arduino como na imagem abaixo:

Monitor serial

Entendendo a fundo:
Software

— Definições e variáveis utilizadas no projeto do sensor de vibração com arduino

A instrução #define apenas associa as portas dos pinos do arduino a nomes referente aos componentes conectados nestes pinos. O pino 12 está definido como pinoLed e o pino 5 está como pinoSensor. Logo depois as variáveis declaradas com o tipo int são atribuídas a elas valores escolhidos pelo programador. A variável ler do tipo int foi atribuído o valor 0.

#define pinoLed 12 //PINO DIGITAL UTILIZADO PELO LED
#define pinoSensor 5 //PINO DIGITAL UTILIZADO PELO SENSOR
int ler = 0; // Declaração da Variavel "ler"

— Função Setup – Definindo pinos do sensor de vibração com arduino

A função setup é aquela que ira rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada e a função pinMode dentro da setup define o que será entrada e o que sera saída na nossa programação. A função serial.begin está inicializando a comunicação serial. Já a função pinMode esta definindo o pino 12 que está como "pinoSensor" como entrada, ou seja, é neste pino que o sensor atuará após receber vibrações do meio e converter em sinais elétricos e o pino 5 como saída que expressará o resultado que queremos com o código e o sensor.

void setup(){
  Serial.begin(9600);
  pinMode(pinoSensor, INPUT); //DEFINE O PINO COMO ENTRADA
  pinMode(pinoLed, OUTPUT); //DEFINE O PINO COMO SAÍDA
}

— Função Loop – Leitura do nosso sensor de vibração com arduino e Estruturas de decisão

A função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. Na variável "ler" será atribuído a leitura das vibrações do pino digital 5 onde esta o sensor. No monitor serial será impresso o valor atribuído a variável ler, assim saberemos se o sensor identificou uma vibração fora do comum. A função daley irá espera 150 milisegundos para  imprimir novamente o que o sensor está lendo.

void loop(){  
 ler = digitalRead(pinoSensor);// A varialvel "ler" recebe o nivel logico lido no pino do sensor de vibrações  
 Serial.println(ler);// Printa no monitor serial o valor atribuido a variavel "ler"  
 delay(150);// Espera 150 milisegundos

Já a função digitalWrite irá escrever no pino digital 12 onde está o LED (declarado anteriormente como saída), nível logico alto caso a condição no if seja verdadeira, ou seja, a variável ler ter recebido nive logico alto, assim o led irá acender indicando que o sensor identificou uma vibração incomum. Se a condição do if for falsa será executado o que estiver dentro dos colchetes do else, ou seja, o led irá apagar.

  if(ler == HIGH){ //SE A LEITURA DO PINO FOR IGUAL A LOW, FAZ    
   digitalWrite(pinoLed, HIGH); //ACENDE O LED  
 }else//SENÃO, FAZ 
  { digitalWrite(pinoLed, LOW); //APAGA O LED 
 } 
}

Hardware

— Elemento de vibração do sensor:

É um cilindro com uma esfera metálica em seu interior e no momento em que o sensor detectar vibração, a esfera se movimentará desfazando o contato com os terminais do sensor, assim sabemos que detectou vibração fora do comum.

Considerações finais:

Neste tutorial mostramos como funciona e como utilizar o sensor de vibrações. Veja também o tutorial "SENSOR DE SOM COM ARDUINO: ACENDENDO UMA LÂMPADA" em nosso portal. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Sensor de Movimento de Cabeça – ITG3205 + ADXL345 + HMC5883L

GY-85 – SENSOR IMU – ITG3205 + ADXL345 + HMC5883L

Neste tutorial aprenderemos sobre o Sensor de Movimento de Cabeça GY-85. Este, no que lhe concerne, é muito utilizado em controles em jogos de videogame. Visualizaremos como este pequeno componente funciona e desenvolveremos uma aplicação para ele.

O  que é o Sensor IMU — GY-85?

O sensor IMU é utilizado como dito anteriormente para projetos vestíveis(wearables) para movimentação. Contudo, ele utiliza 3 sensores em uma mesma placa: acelerômetro, giroscópio e magnetômetro. 

- Funcionamento

Primeiramente, o sensor de movimento IMU(Inertial Measurement Unit) possui 9 eixos acoplados a ele, sendo estes: 3 eixos acelerômetros, 3 eixos giroscópio e 3 eixos campo magnético. Com estes eixos é possível detectar qualquer tipo de movimento que efetuar com o sensor. Os sensores utilizam da força da gravidade, de seus polos e das direções X, Y e Z para realizar as suas funcionalidades, cada um para determinar algo distinto. Com a gravidade da terra e com os eixos X, Y e Z destes sensores é possivel saber o posicionamento espacial, a aceleração, a direção e o sentido daquele que utiliza o sensor como por exemplo um smartphone.

- Campo Magnético 

Graças a um efeito de dínamo a terra possui um campo magnético e como consequencia nos podemos usar ele em nossas tecnologias. Como sabemos o núcleo líquido de ferro que se movimenta cria correntes elétricas no interior da terra, enquanto a rotação da Terra em seu próprio eixo faz com que essas correntes gerem um campo magnético gigante, o qual nos orientou por muito tempo com o auxilio da bussola e nos orienta até hoje em direção ao futuro, nos ajudando no desenvolvimento das tecnologias.

Imagem do campo magnético da terra

O fato dos campos magnéticos irem do polo sul até o polo norte faz com que a terra seje considerada um imã. O sensor IMU utiliza do campo magnético, da força gravitacional e dos circuitos integrados para identificar seu posicionamento espacial, aceleração, intensidade, distancia e sentido .

- Sensores acoplados:

As funções dessa placa são controladas por 3 Circuitos integrados, cada um com sua função específica:

• ITG3205 (3-Axis Angular Rate Sensor) – Giroscópio 3 eixos
• ADXL345 (3-Axis Digital Accelerometer) – Acelerômetro 3 eixos
• HMC5883L (3-Axis Digital Compass) – Bússola digital / Magnetômetro 3 eixos

- Os terminais deste sensor que serão utilizados são:

• VCC_IN(+) – Tensão de entrada, entre 3,3 a 5 volts
• GND(-) – O pino de O V do módulo, que é conectado ao GND do Arduino ou fonte
• SCL - I2C Serial Clock
• SDA - I2C Serial Data

Módulo do sensor IMU

Mãos à obra — Configurando um sensor IMU

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Módulo Sensor IMU GY-85 
• 1 x Protoboard
• Jumpers Macho x Fêmea

- Montando o projeto:

Mostraremos como utilizar cada sensor ligando-o ao Arduino Uno. Sobretudo, como todos eles utilizam o mesmo barramento I2C, teremos apenas um circuito para todos os programas exemplos. A principio, para a montagem do circuito conectemos o sensor na protoboard. O VCC do sensor é conectado no 5v do arduino, logo após conectaremos o GND do sensor ao GND do arduino. Além disso, o pino SCL do sensor é conectado ao pino A5 do arduino e o pino SDA é conectado ao pino A4 do arduino como mostra o diagrama abaixo:

Diagrama de montagem do sensor IMU

- Biblioteca Wire.h:

Neste tutorial utilizaremos a biblioteca Wire.h responsável por conter as funções necessárias para gerenciar a comunicação entre os dispositivos através do protocolo I2C. Ademais, caso não entenda nada de biblioteca ou como prosseguir, veja o tutorial “COMO INSTALAR UMA BIBLIOTECA NO ARDUINO IDE” no portal vida de silício.

- Programando o Arduino:

Agora vamos conectar o arduino no computador e abrir a IDE arduino.  Escreva o programa abaixo na IDE e compile o programa para o seu arduino.

Antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
A primeira coisa que você notará é que ao alimentar o sensor não há nenhuma indicação de que ele está ligado. A placa não possui nenhum led , logo utilizaremos um programa chamado I2C Scanner (http://playground.arduino.cc/Main/I2cScanner) para efetuar um rastreamento no barramento I2C e garantir que o sensor esteja adequadamente ligado ao Arduino. Carregue o I2C Scanner:

#include <Wire.h>
void setup()
{
  Wire.begin();
  Serial.begin(9600);
  Serial.println("\nI2C Scanner");
}
void loop()
{
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for(address = 1; address < 127; address++ ) 
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16) 
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
      nDevices++;
    }
    else if (error==4) 
    {
      Serial.print("Unknow error at address 0x");
      if (address<16) 
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
  delay(5000);           // wait 5 seconds for next scan
}

Se as conexões estiverem corretas, ao abrir o serial monitor teremos a seguinte tela, mostrando os endereços dos dispositivos detectados:

O I2C Scanner é um programa que serve não apenas para este módulo, mas também para qualquer outro dispositivo I2C conectado ao barramento. Além disso, Tenha este programa sempre à mão para descobrir o endereço do dispositivo ou simplesmente para verificar se ele está se comunicando com o Arduino.

Imagem do circuito do sensor IMU

- Acelerômetro 3 eixos(ADXL345)

Já sabendo o endereço do circuito integrado ADXL345 podemos proseguir. Este circuito é um acelerômetro muito utilizado nos telefones celulares, pois é através do acelerômetro que o seu celular detecta a posição do aparelho e permite que você passe horas jogando sem apertar nenhum botão, apenas movimentando o aparelho. Utilize o programa abaixo para testar o ADXL345 (datasheet), cujo endereço I2C é 0x53:

#include <Wire.h>
#define Register_ID 0
#define Register_2D 0x2D
#define Register_X0 0x32
#define Register_X1 0x33
#define Register_Y0 0x34
#define Register_Y1 0x35
#define Register_Z0 0x36
#define Register_Z1 0x37
// Endereco I2C do sensor : 83 em decimal ou 0x53
int ADXAddress = 0x53;  // the default 7-bit slave address
int reading = 0;
int val=0;
int X0,X1,X_out;
int Y0,Y1,Y_out;
int Z1,Z0,Z_out;
double Xg,Yg,Zg;
void setup()
{
  Wire.begin();                
  Serial.begin(9600);    
  delay(100);
  // enable to measute g data
  Wire.beginTransmission(ADXAddress);
  Wire.write(Register_2D);
  Wire.write(8);                //measuring enable
  Wire.endTransmission();     // stop transmitting
}
void loop()
{
  //--------------X
  Wire.beginTransmission(ADXAddress); // transmit to device
  Wire.write(Register_X0);
  Wire.write(Register_X1);
  Wire.endTransmission();
  Wire.requestFrom(ADXAddress,2); 
  if(Wire.available()<=2)   
  {
    X0 = Wire.read();
    X1 = Wire.read(); 
    X1=X1<<8;
    X_out=X0+X1;   
  }
  //------------------Y
  Wire.beginTransmission(ADXAddress); // transmit to device
  Wire.write(Register_Y0);
  Wire.write(Register_Y1);
  Wire.endTransmission();
  Wire.requestFrom(ADXAddress,2); 
  if(Wire.available()<=2)   
  {
    Y0 = Wire.read();
    Y1 = Wire.read(); 
    Y1=Y1<<8;
    Y_out=Y0+Y1;
  }
  //------------------Z
  Wire.beginTransmission(ADXAddress); // transmit to device
  Wire.write(Register_Z0);
  Wire.write(Register_Z1);
  Wire.endTransmission();
  Wire.requestFrom(ADXAddress,2); 
  if(Wire.available()<=2)   
  {
    Z0 = Wire.read();
    Z1 = Wire.read(); 
    Z1=Z1<<8;
    Z_out=Z0+Z1;
  }
  //
  Xg=X_out/256.0;
  Yg=Y_out/256.0;
  Zg=Z_out/256.0;
  Serial.print("X= ");
  Serial.print(Xg);
  Serial.print("       ");
  Serial.print("Y= ");
  Serial.print(Yg);
  Serial.print("       ");
  Serial.print("Z= ");
  Serial.print(Zg);
  Serial.println("  ");
  delay(200);
}

Movimente o sensor e observe a variação dos eixos X, Y e Z  de acordo com a força gravitacional que incide sobre o circuito integrado no serial monitor:

Imagem do serial monitor para o acelerômetro

- Bússola digital(HMC5883L)

O circuito integrado HMC5883L (datasheet) é um instrumento usado para medir a intensidade, direção e sentido de campos magnéticos e possui 3 eixos. É com ele que montamos uma bússola com o Arduino, utilizando como base o programa abaixo, que mostra os valores correspondentes aos eixos X, Y e Z. O endereço I2C do sensor é 0x1E, o qual já achamos anteriormente:

#include <Wire.h>
// Define o endereco do HMC5883L - 0x1E ou 30 em decimal
#define address 0x1E 
void setup()
{
  Serial.begin(9600);
  Wire.begin();
  
  // Inicializa o HMC5883L
  Wire.beginTransmission(address);
  // Seleciona o modo
  Wire.write(0x02); 
  // Modo de medicao continuo
  Wire.write(0x00); 
  Wire.endTransmission();
}
void loop()
{
  int x,y,z; //triple axis data
  
  // Indica ao HMC5883L para iniciar a leitura
  Wire.beginTransmission(address);
  Wire.write(0x03); //select register 3, X MSB register
  Wire.endTransmission();
 
  // Le os dados de cada eixo, 2 registradores por eixo
  Wire.requestFrom(address, 6);
  if(6<=Wire.available())
  {
    x = Wire.read()<<8; //X msb
    x |= Wire.read(); //X lsb
    z = Wire.read()<<8; //Z msb
    z |= Wire.read(); //Z lsb
    y = Wire.read()<<8; //Y msb
    y |= Wire.read(); //Y lsb
  }
  
  // Imprime os vaores no serial monitor
  Serial.print("x: ");
  Serial.print(x);
  Serial.print("  y: ");
  Serial.print(y);
  Serial.print("  z: ");
  Serial.println(z);
  
  delay(250);
}

Da mesma forma que no exemplo anteriores, os valores são mostrados no serial monitor de acordo com o campo magnetico que incide sobre o circuito integrado:

Imagem do serial monitor para a Bússola digital

Entendendo a fundo:

Software

– Definições e variáveis utilizadas no projeto do sensor de movimento de cabeça

A instrução #include<> serve para incluir bibliotecas no algoritmo.

#include <Wire.h>

– Função Setup – Definindo pinos do nosso sensor de movimento de cabeça

 A função setup é aquela que ira rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. A função  Serial.begin inicia a comunicação serial e define uma velocidade para ela para que possamos visualizar o funcionamento do sensor no serial monitor da IDE arduino. A função Serial.println escreve no serial monitor o texto "I2C Scanner" .

Serial.begin(9600);
Serial.println("\nI2C Scanner");

– Função Loop – Leitura do nosso sensor de movimento de cabeça e Estruturas de decisão

A função loop ao contrário da setup roda tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. Precipuamente, declaramos uma variavel do tipo int e logo depois do "Serial.println" atribuimos o valor 0 a ela. Também declaramos as veriaveis do tipo byte "error" e "address".

void loop(){ 
 byte error, address;  
 int nDevices;   
 Serial.println("Scanning...");   
 nDevices = 0;

Não obstante, a estrutura de repetição for será executada enquanto a variavel declarada anteriormente "address" for menor que 127. Ela inicializa com o valor 1 e a cada ciclo adiciona- se +1.

for(address = 1; address < 127; address++ ){

Similarmente, estrutura de de decisão if será executada caso a condição entre parenteses for verdadeida. No primeiro if caso a variave "error" fo igual a zero a linha de código "Serial.print("I2C device found at address 0x");" será executada.

if (error == 0){       
  Serial.print("I2C device found at address 0x");

Logo depois, caso a variavel "address" for menor que 16 as linhas de código dentro dos colchetes será executada. Irá imprimir o texto "0" e logo após o endereço dos circuitos integrados. Tambem irá imprimir no serial monitor o texto " !" e  vai adicionar +1 a variavel nDevices com o comando "nDevices++".

if (address<16) {        
  Serial.print("0");        
  Serial.print(address,HEX);        
  Serial.println("  !");        
  nDevices++;  
   }

Caso a estutura if com a condição "error == 0" não for verdadeira iremos direto para a estrutura else if. Se for verdadeira, ou seja, a variavel error for igual a quatro a linha "Serial.print("Unknow error at address 0x");" será executada e impressa no serial monitor.

 else if (error==4){    
   Serial.print("Unknow error at address 0x");

Igualmente a estura if, se a variavel "address" for menor que 16 será executado as linhas de código abaixo, imprimindo no serial monitor o texto zero e o endereço dos circuitos integrados.

if (address<16)  {        
  Serial.print("0");       
  Serial.println(address,HEX);    
 }

Agora, caso a variavel "address" for maior que 16, então as estruturas anteriores com a condição "address<16" não serão executadas e a variavel "nDevices" permanecerá com o valor 0. Sendo assim, a estrutura if a seguir será verdadeira e a estrutura "Serial.println("No I2C devices found\n");" será executada. Em contrapartida, se a variavel "address" for menor que 16 de fato, a estrutura else que será executada.

       
    
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
    delay(5000);           // wait 5 seconds for next scan
}

Hardware

- ITG3205

O sensor giroscópio de 3 eixos acoplado ao sensor IMU permite entender o posicionamento espacial através da força de gravidade. sendo assim, quando um objeto está em movimento, os sensores de eixo do giroscópio conseguem informar exatamente para qual direção o produto está se movendo. Uma de suas aplicações é em aparelhos smartphones onde detecta quando você gira o aparelho detectando a velocidade angular do aparelho e se está apontado para cima ou para baixo. O que podemos tirar disto é que ele é muito empregado em sistema que necessitam interpretar os movimentos do utilizador.

- ADXL345

O sensor acelerômetro de 3 eixos acoplado ao sensor IMU mede a aceleração através da força de gravidade a que o sensor está sujeito em cada um dos três eixos. Ele mede a inclinação e o movimento. Sendo assim, consegue detectar o movimento de rotação e gestos tais como balançar ou agitar um objeto do qual ele faz parte.

O gráfico (a) representa uma situação onde o acelerômetro se encontra em repouso, pousado numa superfície plana, os valores comunicados pelos sensores serão x= 0, y=0 e z=-1. Já o gráfico (b) representa a rotação do eixo X para baixo, os valores comunicados pelo sensor serão x=1, y=0 e z=0. O grafico (c) representa a rotação do eixo Y, os valores comunicados pelo sensor serão x=0, y=1 e z=0.

- HMC5883L

Sensor magnetômetro de 3 eixos é acoplado ao sensor IMU.  Sendo assim, ele funciona como uma bússola digital e identifica a intensidade, direção e sentido de campos magnéticos . Com o arduino é usado para literalmente nos dar um norte.

Considerações finais:

Neste tutorial mostramos como funciona e como utilizar o sensor de movimento IMU. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra

Sensor de Som KY-037: Acendendo LED com arduino

MÓDULO SENSOR DE SOM KY-037: ACENDENDO UM LED COM ARDUINO

 Este tutorial tem como objetivo ensinar a utilizar o sensor de som para acender um LED. Surpreendentemente, vamos automatizar e programar um LED para acender quando o sensor detectar som. Além disso, aprimoraremos os seus conhecimentos sobre programação para arduino utilizando as funções digitalWrite e delay.

O  que é o módulo sensor de som?

O sensor de som constitui uma placa de circuito impresso com uma função específica. O módulo faz com que emita pulsos de energia ao detectar som fazendo com que uma lâmpada acenda ou apague.

- Funcionamento

Presipuamente, o sensor realiza a transformação da intensidade das ondas sonoras para tensões de 0 a 5V. Em seguida, o pino de leitura digital manda um sinal de nível lógico alto se uma determinada intensidade do som for atingida. Este sensor em especial possui também um pino analógico para podermos ter diversos valores da intensidade do som.
O sensor de som utiliza o microfone para captar o som, identificando a vibração das ondas no meio e o Trimpot(Potenciômetro) para ajustar a sensibilidade do microfone a essas vibrações.
Este componente possui um potenciômetro com a função de ajustar a sensibilidade do som que queira detectar. Támbem, possui dois leds em sentidos opostos onde um serve para alertar que o módulo está energizado e o outro que a saída está ativa, pois ele detectou som.

ATENÇÃO: Entretanto, quando o circuito estiver montado, ao alimentar a placa o LED pode iniciar piscando. Isto indica que você deve ajustar a sensibilidade do sensor no trimpot.

- Os terminais deste sensor são:

• VCC(+) – Tensão de entrada, entre 3,3 a 5 volts
• GND(-) – O pino de O V do módulo, que é conectado ao GND do Arduino ou fonte
• Saida Analogica(A0) – Pino de saída analogica (retorna o valor da intensidade do som captado)
• Saída Digital(D0)– Pino de saída digital (retorna HIGH ou LOW)

Sensor de Som

Mãos à obra - Fazendo um pisca-pisca usando o Arduino

Componentes Necessários

• 1 x Arduino Uno R3
• 1 x Módulo sensor de som
• 1 x Protoboard
• 3 x LEDs
• 3 x Resistores 470
• Jumpers Macho x Macho
• Jumpers Macho x Fêmea

- Montando o projeto:

Neste tutorial montaremos um circuito para acender um LED, porem ao contrário de muitos outros neste utilizaremos da programação para transformar um simples acender de LED em um pisca-pisca quando o sensor de som detectar vibrações. Monte conforme o projeto abaixo:

Diagrama de montagem do sensor de som

A perna maior dos LEDs esta ligada aos pinos das portas digitais(sendo estes, verde ligada a porta 7, amarelo ligada a porta 6 e vermelho ligada a porta 5) e a perna menor no resistor de 470 ohm. O resistor no que lhe concerne esta ligado ao GND da protoboard. Enfim, no circuito do sensor o VCC está ligado ao 5V do arduino, o GND esta também ligado no GND(-) da protoboard e a saída digital(D0) esta ligada ao pino 12 do arduino.

Imagem do circuito do sensor de som

- Programando o Arduino:

Com o circuito montado vamos conectar o arduino no computador e abrir a IDE arduino para configurar o programa. Escreva programa abaixo na IDE e compile o programa para o seu arduino. Vamos comentá-lo mais adiante.

Antes de carregar o programa, você precisa selecionar qual porta você deseja usar para fazer o carregamento do seu programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.

#define led1 7 // O led1 esta definido no pino 7
#define led2 6 // O led2 esta definido no pino 6
#define led3 5 // O led3 esta definido no pino 5
#define sensor 12 // O pino 12 contem o sensor de som
int  valor_A0 = 9; // Cria uma variável do tipo inteiro(int) chamada valor_A0 e atribui-lhe o valor 9
int aceso = 0; // Cria uma variável do tipo inteiro(int) chamada aceso e atribui-lhe o valor 0
void setup() {
  Serial.begin(9600); //Inicializa a comunicação serial e estabelece uma velocidade para ela
  pinMode(led1, OUTPUT); // Define o pino 7 onde esta o led1 como saída
  pinMode(led2, OUTPUT);  // Define o pino 6 onde esta o led2 como saída
  pinMode(led3, OUTPUT);  // Define o pino 5 onde esta o led3 como saída
  pinMode(sensor, INPUT); // Define o pino 12 como saída
}

void loop() {
  valor_A0 = digitalRead(sensor);// A variavel  valor_A0 recebe a leitura digital do pino 12 onde o sensor esta
  Serial.print("\nSaida A0: "); // Imprime no serial monitor "\nSaida A0: "
  Serial.print(valor_A0); // Imprime no serial monitor o valor que a variável valor_A0 recebeu
  delay(500); // O delay espera 500 milissegundos
   if(valor_A0 == HIGH){ // é detectada a presença de som
    switch(aceso){ // switch necessário para definir se o led vai acender ou apagar
      case 0: // caso o led esteja apagado...
        digitalWrite(led1, HIGH); // ...ele se acenderá
        delay(1000);
        digitalWrite(led3, HIGH); // ...ele se acenderá
        delay(1000);
        digitalWrite(led1, LOW); // ...ele se apagará
        delay(500);
        digitalWrite(led2, HIGH); // ...ele se acenderá
        delay(1000);
        digitalWrite(led3, LOW); // ...ele se apagará
        delay(500);
        digitalWrite(led1, HIGH); // ...ele se apagará
        delay(1000);
        digitalWrite(led2, LOW); // ...ele se apagará
        delay(500);
        digitalWrite(led3, HIGH); // ...ele se acenderá
        delay(1000);
        digitalWrite(led1, LOW); // ...ele se apagará
        delay(500);
        digitalWrite(led2, HIGH); // ...ele se acenderá
        delay(1000);
        digitalWrite(led3, LOW); // ...ele se apagará
        delay(500);
        digitalWrite(led1, HIGH); // ...ele se apagará
        delay(1000);
        digitalWrite(led2, LOW); // ...ele se apagará
        delay(500);
        digitalWrite(led3, HIGH); // ...ele se acenderá
        delay(1000);
        digitalWrite(led2, HIGH); // ...ele se apagará
        delay(1000);
        aceso = 1; // atribuição para definir que o led está aceso
        break;
      case 1: // caso o led esteja aceso...
        digitalWrite(led1, LOW); // ...ele se apagará
        delay(1000);
        digitalWrite(led3, LOW); // ...ele se apagará
        delay(1000);
        digitalWrite(led1, HIGH); // ...ele se acenderá
        delay(500);
        digitalWrite(led2, LOW); // ...ele se apagará
        delay(1000);
        digitalWrite(led3, HIGH); // ...ele se apagará
        delay(500);
        digitalWrite(led1, LOW); // ...ele se apagará
        delay(1000);
        digitalWrite(led2, HIGH); // ...ele se apagará
        delay(500);
        digitalWrite(led1, HIGH); // ...ele se acenderá
        delay(500);
        digitalWrite(led1, LOW); // ...ele se apagará
        delay(1000);
        digitalWrite(led3, LOW); // ...ele se apagará
        delay(1000);
        digitalWrite(led2, LOW); // ...ele se apagará
        delay(100);
        aceso = 0; // atribuição para definir que o led esta apagado
        break;
    }
  }
}

ATENÇÃO: não esqueça de definir a placa e a porta que esta utilizando para carregar o programa.

Imagem do circuito do sensor de som funcionando

Em seguida, regule o potenciômetro para detectar as vibrações desejadas:

Imagem do regulador de vibrações

Assim, abra o Monitor serial e visualize o funcionamento do sensor:

Monitor serial

Entendendo a Fundo:

Software

– Definições e variáveis utilizadas no projeto

A instrução #define apenas associa os numeros dos pinos do arduino a nomes referente aos componentes conectados nestes pinos.  Semelhantemente, nas variáveis declaradas com o tipo int são atribuídas a elas valores escolhidos pelo programador.

#define led1 7 // O led1 esta definido no pino 7
#define led2 6 // O led2 esta definido no pino 6
#define led3 5 // O led3 esta definido no pino 5
#define sensor 12 // O pino 12 contem o sensor de som
int  valor_A0 = 9; // Cria uma variável do tipo inteiro(int) chamada valor_A0 e atribui-lhe o valor 9
int aceso = 0; // Cria uma variável do tipo inteiro(int) chamada aceso e atribui-lhe o valor 0

– Função Setup – Inicialização da comunicação serial e definindo pinos

A função setup é aquela que irá rodar apenas uma vez quando nosso programa for iniciado. Ela é do tipo void, ou seja, não tem retorno e também não tem parâmetros de entrada. O serial.begin(9600) inicializa a comunicação serial, assim possibilitando que visualizemos as intensidades do som no Monitor serial da IDE arduino. A função pinMode define quais dos pinos serão entradas e quais serão as saídas.

void setup() {
  Serial.begin(9600); //Inicializa a comunicação serial e estabelece uma velocidade para ela
  pinMode(led1, OUTPUT); // Define o pino 7 onde esta o led1 como saída
  pinMode(led2, OUTPUT);  // Define o pino 6 onde esta o led2 como saída
  pinMode(led3, OUTPUT);  // Define o pino 5 onde esta o led3 como saída
  pinMode(sensor, INPUT); // Define o pino 12 como saída
}

– Função Loop – Usando o monitor serial, leitura do nosso sensor de som e Estruturas de decisão

Por analogia, a função loop ao contrário da setup rodará tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. Então, na variável valor_A0 será atribuído a leitura digital(digitalRead) do pino do sensor. A função Serial.print imprime no monitor serial primeiro o texto entre aspas e depois o valor que esta na variável valor_A0. Logo após, a função delay(500) faz com que esta impressão do texto e valor seja mais lenta dando tempo para a visualização.

void loop() {
valor_A0 = digitalRead(sensor);// A variável  valor_A0 recebe a leitura digital do pino 12 onde o sensor esta
Serial.print("\nSaida A0: "); // Imprime no serial monitor "\nSaida A0: "
Serial.print(valor_A0); // Imprime no serial monitor o valor que a variável valor_A0 recebeu delay(500); // O delay espera 500 milissegundos

O if é uma estrutura de decisão onde entre parenteses esta a condição para ser verdadeiro, ou seja, se a variável valor_A0 for igual a HIGH significa que detectou som e ele executará a estrutura swich - case. A estrurura ”switch(aceso)” determina qual dos dois cases serão executados. Se na variável aceso estiver atribuído a ela o valor 0 será o primeiro case, em contrapartida se estiver atribuído a ela o valor 1 será o segundo.
O digitalWrite escreve no pino do led nível logico HIGH ou LOW. Já o delay espera 1000 milissegundos para executar a próxima linha do código.

if(valor_A0 == HIGH){ // é detectada a presença de som
   switch(aceso){ // switch necessário para definir se o led vai acender ou apagar
     case 0: // caso o led esteja apagado...
       digitalWrite(led1, HIGH); // ...ele se acenderá
       delay(1000);
       digitalWrite(led3, HIGH); // ...ele se acenderá
       delay(1000);
       digitalWrite(led1, LOW); // ...ele se apagará
       delay(500);

Hardware

– Microfone

Microfones são transdutores sonoro-elétricos, ou seja, são dispositivos que convertem energia sonora em energia elétrica através de uma membrana flexível chamada diafragma. Este diafragma entra em vibração ao receber ondas sonoras. Através de um processo específico esta vibração produz um sinal elétrico que é depois amplificado e filtrado em aparelhos eletrônicos.

– LM393D

É um circuito integrado com amplificadores operacionais, capaz de executar tarefas avançadas.

Diagrama do Circuito Integrado LM393D

Acima temos o diagrama do circuito integrado LM393D com pinos saída, pinos de entrada com dois negativos e dois positivos, um pino do vcc e outro do GND . Estes pinos devem ser utilizados conforme a aplicação que queira realizar com o circuito integrado. No projeto ele é responsável por amplificar os som do ambiente em 100 vezes.

Considerações finais:

Neste tutorial mostramos como utilizar o sensor de som, que por sua vez, tem uma aplicação bastante interessante na automação onde utilizamos para energizar e desenergizar uma lâmpada como vemos no tutorial "ACENDENDO UMA LÂMPADA COM VIBRAÇÕES SONORAS". Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Angelo Lyra