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
- 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.
Robô Seguidor de Linha com Sensor TCRT5000:
Chassi 2WD como Seguidor de Linha:
O seguidor de linha é um dos primeiros projetos de robótica móvel que todos os entusiastas, hobistas ou profissionais constroem no intuito de nos ensinar o quão simples e ainda sim inigualável é a cultura maker e as tecnologias de interação entre nós e os objetos e entre os objetos. Precipuamente, antes de irmos para a montagem do Robô Seguidor de Linha com Sensor TCRT5000 vamos aprender sobre os principais componentes para o seu funcionamento, sendo o restante conectores, alimentação e a carcaça do carrinho. Para a construção do seguidor de linha utilizaremos o Módulo segue faixa(TCRT5000), Módulo Driver ponte H HG7881 L9110S, Protoboard, jumpers e Adaptador P4/KRE Macho para a conexão e, o Chassi 2WD que é a carcaça do Robô.
Imagem do seguidor de faixa
Para melhor entendimento deste tutorial é necessário que você já tenha um conhecimento prévio sobre Arduino e ponte H. Entretando não se preocupe, pois nossa equipe já produziu outros tutoriais sobre esses assuntos e você pode conferir alguns destes nos seguintes links: Entradas e Saídas Analógicas e Módulo Ponte H L298n.
- Robô Seguidor de Linha com Sensor TCRT5000 nas escolas
Em início, como já sabemos, o seguidor de linha já é muito utilizado em indústrias, mas para que utilizar nas escolas? Bem, com um projeto deste, mesmo que simples, podemos integrá-lo em diversas áreas. O robô seguidor de linha, em suma, foi criado para competições interdisciplinares e ajudar jovens a trabalhar em equipe e desenvolver o cognitivo.
Então, na História, filosofia e sociologia podemos aprender como se desenvolveu a tecnologia até a criação do robô, bem como surgiu o arduino ou como a cultura maker, sendo está uma arte, é tão disseminada por todo o globo terrestre. Na geografia como robôs e equipamentos eletrônicos foram e são tão importantes para descobertas e no nosso dia a dia como, por exemplo, prever o clima. Já na matemática temos a rotação dos motores e na física a energia elétrica que passa pelo circuito e o funcionamento óptico do sensor de faixa e suas cores preta e branca.
- Como funciona um Robô Seguidor de Linha com Sensor TCRT5000 ?
Imaginemos uma pista de corrida preta e um carro sobre ela com sensores de detecção de infravermelho embaixo do carro, quando o carro sair da pista a cor do chão irá mudar e os sensores irão detectar está mudança fazendo o que o carro vire voltando assim de volta para pista. No caso da imagem abaixo somente quando ele receber o infravermelho que ele irá virar, pois será quando o carro saiu da pista preta.
Imagem de um carro em uma pista de corrida
Similarmente o seguidor de linha deve seguir andando por cima de uma linha de cor preta (fita isolante) ou branca. Os circuitos podem alternar entre as cores do campo e da faixa, no nosso caso iremos assumir que a pista é branca e a faixa é preta, ou seja, quando o carro detectar a cor preta, não recebendo o infravermelho de volta ele irá virar. Usaremos 2 sensores infravermelhos que detectam a presença ou não desta faixa. De acordo com a combinação dos sensores, o carrinho irá para frente ou virar para um dos lados.
Imagem do funcionamento do sensor de faixa
Na imagem acima temos um carrinho com dois sensores nas laterais onde quando detectar a presença do preto o carrinho vira. Enquanto o carrinho não está detectando a cor preta o motor das rodas fica girando em uma velocidade constante com 360°graus de rotação em linha reta.
- Funcionamento do sensor infravermelho
O módulo sensor TCRT5000 emite uma luz infravermelha por um LED negro e capta o reflexo com um LED receptor (LED claro). Como sabemos pela física, a luz reflete em superfícies claras, sendo a branca a que mais reflete, e é absorvida em superfícies escuras, sendo a preta a que mais absorve, como a fita isolante. Sendo assim o LED receptor irá detectar a luz infravermelha no branco e não detectar no preto. Entretanto, para uma melhor eficácia do sensor, a superfície em contraste com a faixa preta deve ser branca.
Funcionamento do sensor infravermelho
Muitas vezes haverá a necessidade de ajustarmos a sensibilidade do sensor por isso ele possui um potenciômetro de calibração.
- Diferença entre sensores infravermelhos obstaculo e o TCRT5000
Nos pode usar diferentes sensores infravermelhos para o projeto seguidor de linha, o que precisamos considerar é as especificações de cada um. Um sensor infravermelho amplamente utilizado é o TCRT5000, o qual utilizaremos neste tutorial, que tem como vantagem seu tamanho e preço. Porém, ele precisa está próximo ao chão para que seja capaz de identificar a faixa, uma vez que seu alcance é de até 8mm. Entretanto, ele possui a vantagem de sofrer menos interferências de luzes infravermelhas externas.
Módulo Sensor de linha TCRT5000
Em contrapartida, a vantagem de usar o sensor de obstaculo é o seu maior alcance possuir ajuste, porem ele é mais suscetível a interferências das luzes ambientes.
Sensor de obstáculo infravermelho
Nesse tutorial, usaremos o TCRT5000. Dessa forma, caso esteja usando o sensor de obstaculo infravermelho, fique atento com as interferências. O local precisa estar bem iluminado e sem reflexo de luzes que possam mudar a cor da superficie que o sensor incidir.
Controlando motores com Ponte H
Quando lidamos com controle de cargas que consomem grande quantidade de energia, é importante que essas cargas sejam controladas com circuitos que separem o circuito de controle do circuito de potência. Para controlar motores, é comum usarmos um circuito chamado ponte H, ele é capaz por controlar o sentido de giro do motor e a sua velocidade, usando o PWM.
- PWM
PWM (Pulse Width Modulation – Modulação por Largura de Pulso) é uma técnica para obter resultados analógicos por meios digitais (Leia mais sobre Grandezas digitais e analógicas e PWM). Essa técnica consiste na geração de uma onda quadrada em uma frequência muito alta em que pode ser controlada a porcentagem do tempo em que a onda permanece em nível lógico alto, alterando, assim, a tensão média.
Por exemplo, se a saída é de 5V, porém ela fica apenas 50% do tempo em 5V e outros 50% do tempo em nível lógico baixo, isso resulta em uma tensão média de 2,5V (50% x 5V). Dessa forma, esta variável de tempo é capaz de controlar de velocidade do nosso carrinho alterando a tensão média aplicada no motor. Os valores de PWM variam de 0 (parado) até 255 (velocidade máxima ou 5 V).
- Controlando a velocidade do motor através da Ponte H
Existem várias opções de Ponte H, nesse tutorial usaremos o Módulo Driver Ponte H HG7881 L9110S que dispões de duas pontes H, sendo capaz de controlar dois motores. Cada ponte H possui um pino que ativa ou não a ponte H. Caso tenha um sinal de 5V aplicado nele, a ponte estará ligada, caso seja 0V a ponte estará desligada.
Imagem da ponte H
O "Motor A" e "Motor B" da parte superior utilizaremos como conexões de saída para alimentação dos motores A e B. No entanto, já o "Motor A" e o "Motor B" da parte inferior utilizaremos para receber e passar informação para os motores A e B, respectivamente. Através desses pinos conectados ao Arduino podemos controlar a velocidade e o sentido de rotação dos motores A e B, respectivamente. A parte de alimentação serve para alimentar o modulo com tensão entre 2.5 a 12V (Corrente Contínua).
Apesar de a ponte H ser controlada por um sinal de 5V, elá pode chavear uma tensão diferente. Podemos, por exemplo, controlar uma tensão de 6V, vindo de um conjunto de 4 pilhas AA. Nesse caso, apesar de o sinal PWM ser de 5V ele modulará os 6V nos motores. Vai depender da tensão necessária para o funcionamento dos motores.
Podemos calcular a tensão de alimentação com a fórmula: Vm = Va + 1,5V (Vm = tensão mínima necessária para alimentar o motor, Va = tensão nominal do motor DC). Como exemplo temos que caso o motor tenha uma tensão nominal de 3,5 V a tensão mínima da fonte externa deve ser de 5,0V.
-Datasheet
No datasheet do chip L9110S podemos obter diversas informações de como é o funcionamento e controle da ponte H por esse chip. Em suma, uma das observações que podemos fazer é na tabela de tensão e conrrente, onde está indicando que a tensão minima é 2.5V e a maxima é 12V. Já a corrente de operação, podemos observar que a minima é de 200 microampere e a maxima é de 500 microampere. Em contrapartida, temos outra tabela ao lado sobre os pinos de rotação horaria e anti-horaria do motor como na tabela abaixo:
Tabela de rotação dos motores
Ou seja, existem apenas dois tipos de rotação, a normal e a invertida. No nosso programa nos só queremos a rotação normal, sendo assim utilizaremos a primeira linha de High e Low.
Mãos a obra - Montando um Robô Seguidor de Linha com Sensor TCRT5000
Componentes Necessários
- 1 x Arduino UNO
- Jumpers Fêmea x Macho e Jumpers Macho x Macho
- 2 x Módulo TCRT5000 (ou Sensores de obstaculo infravermelho)
- 1 x Chassi Robô móvel 2WD ( Ou 2 x Motores DC 5 v com roda + um suporte para o carrinho)
- 1 x Ponte H HG7881
- 1 x Adaptador P4/KRE Macho
- Protoboard
- Montando o projeto do Robô Seguidor de Linha com Sensor TCRT5000
Abaixo segue o esquema de ligações e montagem eletrônica do driver Ponte H HG7881:
Diagrama de montagem da Ponte H
A carcaça do robô deve ser montada conforme o manual. Agora segue o esquema de ligações e montagem eletrônica dos Módulos TCRT5000:
Diagrama de montagem dos Módulos TCRT5000
Os módulos devem ser fixos na frente do chassi em direção ao chão na parte de baixo para poder detectar o caminho a ser seguido. Como resultado aos esquemas anteriores temos um esquema completo de montagem Ponte H + Módulos TCRT5000:
Diagrama de montagem Ponte H + Módulos TCRT5000
Este projeto possui um procedimento de montagem complexo devido ao fato da necessidade de termos que passar vários fios por um espaço limitado ao tamanho do chassi do carrinho. Como resultado da montagem do robô temos as imagens abaixo:
Imagens do carrinho pronto
PS: Devemos Lembrar que o suporte das baterias deve ficar instalado embaixo do carrinho.
- Calibração do Sensor infravermelho
Ao usar o sensor infravermelho, seja o TCRT5000 ou o sensor de obstaculo, você precisa calibrar o sensor para que seja capaz de detectar adequadamente a mudança de cor entre preto e branco. Esta calibração deve ser feita no próprio sensor com o auxílio de uma chave de fenda no potenciômetro acoplado a ele.
Potenciometro(Trimpot) de ajuste do sensor
- Programando o Robô Seguidor de Linha com Sensor TCRT5000
Neste instante vamos conectar o arduino no computador e abrir a IDE arduino. Desta forma iremos escrever o programa abaixo na IDE e compilar 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 M1AA 10 //Definição do pino que controla o motor A
#define M1AB 11 //Definição do pino que controla o motor A
#define M2BA 5 //Definição do pino que controla o motor B
#define M2BB 6 //Definição do pino que controla o motor B
#define pinS1 7 //Definindo o pino 7 como pino do primeiro sensor
#define pinS2 8 //Definindo o pino 8 como pino do segundo sensor
bool Sensor1 = 0; //Declarando a variavel "Sensor1" e atribuindo a ela o valor "0"
bool Sensor2 = 0; //Declarando a variavel "Sensor2" e atribuindo a ela o valor "0"
int velocidade = 125; //Declarando a variavel "velocidade" e atribuindo a ela o valor "125"
void setup(){
pinMode(M1AA, OUTPUT); // Define o pino de controle do motor A como saída
pinMode(M1AB, OUTPUT); // Define o pino de controle do motor A como saída
pinMode(M2BA, OUTPUT); // Define o pino de controle do motor B como saída
pinMode(M2BB, OUTPUT); // Define o pino de controle do motor B como saída
digitalWrite(M1AB, LOW); // Setamos a direção inicial do motor 1 como 0, isto fará com que o motor gire para frente
digitalWrite(M2BB, LOW); // Setamos a direção inicial do motor 2 como 0, isto fará com que o motor gire para frente
pinMode(pinS1, INPUT); // Define o pino do sensor 1 como entrada
pinMode(pinS2, INPUT); // Define o pino do sensor 2 como entrada
}
void loop(){
Sensor1 = digitalRead(pinS1); // A variavel "Sensor1" recebe o valor digital lido pelo sensor 1
Sensor2 = digitalRead(pinS2); // A variavel "Sensor2" recebe o valor digital lido pelo sensor 2
if((Sensor1 == 0) && (Sensor2 == 0)) // Os dois lados detectaram branco
{
analogWrite(M1AA, velocidade); //O motor A recebe velocidade 125
analogWrite(M2BA, velocidade); //O motor B recebe velocidade 125
delay(25);
}
if((Sensor1 == 1) && (Sensor2 == 0)) // O primeiro sensor detectou preto e o segundo branco
{
analogWrite(M1AA, 0); //O motor A recebe velocidade 0
analogWrite(M2BA, 140); //O motor B recebe velocidade 140, girando assim o carrinho
delay(25); //Espera de 25 milissegundos
}
if((Sensor1 == 0) && (Sensor2 == 1)) // O primeiro sensor detectou branco e o segundo preto
{
analogWrite(M1AA, 140); //O motor A recebe velocidade 140, ficando assim ligado
analogWrite(M2BA, 0); //O motor B recebe velocidade 0, desligando-o e fazendo assim o carrinho virar no outro sentido
delay(25); //Espera de 25 milissegundos
}
}
– Testando o funcionamento do Robô Seguidor de Linha com Sensor TCRT5000:
Agora é só pôr o carrinho para rodar na pista!
Video do carrinho funcionando e seguindo a faixa
- Problemas recorrentes e como resolver
Bateria baixa – Os testes podem ter consumido a bateria e talvez seja necessário o uso de uma nova. Baterias abaixo de 6,5 Volts já começam a diminuir a eficiência do carrinho e já pode não ser mais suficiente para energizar os motores como vimos anteriormente.
Carrinho saindo da pista – Isso pode acontecer por ele estar rápido de mais ou por falha do infravermelho. Em caso de ele estar muito rápido basta trocar a velocidade dos motores em cada situação. Se o problema for com o contraste da pista (talvez parte dela esteja mais escura) use 2 LEDs de alto brilho na frente do carrinho para iluminar a pista próximo aos sensores. Os LEDs podem ir conectados direto no 5 V do arduino (lembrando de por um resistor de 300Ohms). Também pode ser que os sensores não estejam detectando o chão, pois foram colocados em uma posição que não facilita a leitura ou podem estar acima de 8mm do chão dificultando a leitura.
Carrinho não anda – Este é um problema complexo, pois podem ter infinitas possibilidades. Tente isolar os componentes e testar 1 por 1, principalmente os motores e a ponte H. Em alguns casos pode ser problemas de aterramento da bateria também, ou seja, a conexão dos jumpers.
PS: Vale ressaltar que o robô pode não fazer o percurso de primeira, o que significa que ajustes devem ser feitos no código ou até mesmo no hardware.
Entendendo a fundo
Software
– Definições e Declarando variáveis utilizadas no projeto do Robô Seguidor de Linha com Sensor TCRT5000
Inicialmente a instrução #define apenas associa os pinos do arduino nomes referente aos componentes conectados nestes pinos. Semelhantemente, temos logo depois a declaração de variaveis e atribuições de valores a estas variaveis. Nas variaveis declaradas "Sensor1" e "Sensor2" do tipo bool atribuimos a elas o valor "0". Já na variavel declarada do tipo int atribuimos a ela o valor "125", pois é o valor de velocidade que queremos para os motores.
#define M1AA 10 //Definição do pino que controla o motor A #define M1AB 11 //Definição do pino que controla o motor A #define M2BA 5 //Definição do pino que controla o motor B #define M2BB 6 //Definição do pino que controla o motor B #define pinS1 7 //Definindo o pino 7 como pino do primeiro sensor #define pinS2 8 //Definindo o pino 8 como pino do segundo sensor bool Sensor1 = 0; //Declarando a variavel "Sensor1" e atribuindo a ela o valor "0" bool Sensor2 = 0; //Declarando a variavel "Sensor2" e atribuindo a ela o valor "0" int velocidade = 125; //Declarando a variavel "velocidade" e atribuindo a ela o valor "125"
– Função Void Setup()
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. A função pinMode serve para definir quais serão os pinos de entrada e de saida. Repare que apenas os que declaramos com #define anteriormente, estão no pinMode, isto é porque as outras são variaveis que escolhemos para atribuir valores. Na função pinMode definimos que M1AB, M1AA, M2BA, M2BB (pinos dos motores) são saida e os pinos dos sensores pinS1 e pinS2 são entradas.
pinMode(M1AA, OUTPUT); // Define o pino de controle do motor A como saída pinMode(M1AB, OUTPUT); // Define o pino de controle do motor A como saída pinMode(M2BA, OUTPUT); // Define o pino de controle do motor B como saída pinMode(M2BB, OUTPUT); // Define o pino de controle do motor B como saída pinMode(pinS1, INPUT); // Define o pino do sensor 1 como entrada pinMode(pinS2, INPUT); // Define o pino do sensor 2 como entrada
– Definindo sentido de giro dos motores no projeto do Robô Seguidor de Linha com Sensor TCRT5000
Proseguindo temos a função digitalWrite que escreve nas portas do M1AB e M2BB nivel logico baixo, ou seja, o motor não irá girar para trás, fazendo assim com que os motores girem somente para frente.
digitalWrite(M1AB, LOW); // Setamos a direção inicial do motor 1 como 0, isto fará com que o motor gire para frente digitalWrite(M2BB, LOW); // Setamos a direção inicial do motor 2 como 0, isto fará com que o motor gire para frente
– Função Void Loop ()
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.
– Leituras dos Sensores no projeto do Robô Seguidor de Linha com Sensor TCRT5000
De inicio temos as variaveis Sensor1 e Sensor2 recebendo o valor (0 ou 1, pois é digital) da leitura dos pinos dos sensores pinS1 e pinS2, sendo a função responsável por está leitura a digitalRead().
Sensor1 = digitalRead(pinS1); // A variavel "Sensor1" recebe o valor digital lido pelo sensor 1 Sensor2 = digitalRead(pinS2); // A variavel "Sensor2" recebe o valor digital lido pelo sensor 2
– Controlando a direção do robô
Logo após as variaveis receberem esses valores vamos para a estrutura de decisão if onde temos as condições que se os dois sensores receberem o valor "0", ou seja, detectaram a cor branca, será escrito nos pinos dos motores a velocidade 125 declarada anteriormente fazendo com que o carrinho continue andando reto.
if((Sensor1 == 0) && (Sensor2 == 0)) // Os dois lados detectaram branco
{
analogWrite(M1AA, velocidade); //O motor A recebe velocidade 125
analogWrite(M2BA, velocidade); //O motor B recebe velocidade 125
delay(25);
}
Agora, caso a varivel Sensor1 receba o valor 1(o sensor detectou assim a cor preta)e a variavel Sensor2 receba o valor 0(o sensor detectou a cor branca) a estrutura de decisão abaixo que será verdadeira e não a de cima, fazendo com que escreva no pino do motor 1 a velocidade 0 e no pino do motor 2 a velocidade 140, girando assim o carrinho como mostra na Imagem do funcionamento do sensor de faixa.
if((Sensor1 == 1) && (Sensor2 == 0)) // O primeiro sensor detectou preto e o segundo branco
{
analogWrite(M1AA, 0); //O motor A recebe velocidade 0
analogWrite(M2BA, 140); //O motor B recebe velocidade 140, girando assim o carrinho
delay(25); //Espera de 25 milissegundos
}
Em ultima alternativa temos o contrario da anterir. Caso não seja o primeiro sensor que detectou o preto, mas sim o segundo a estrutura de decisão abaixo que será verdadeira e não as anteores fazendo com que escreva no pino do motor 1 a velocidade 140 e no pino do motor 2 a velocidade 0, girando assim carrinho para o outro lado como mostra na Imagem do funcionamento do sensor de faixa.
if((Sensor1 == 0) && (Sensor2 == 1)) // O primeiro sensor detectou branco e o segundo preto
{
analogWrite(M1AA, 140); //O motor A recebe velocidade 140, ficando assim ligado
analogWrite(M2BA, 0); //O motor B recebe velocidade 0, desligando-o e fazendo assim o carrinho virar no outro sentido
delay(25); //Espera de 25 milissegundos
}
}
Hardware
O carrinho funciona com uma comunicação entre os sensores, o Arduino e a ponte H controlando os motores. Por meio das leituras que os sensores fazem do meio e enviam para o Arduino por meio das portas digitais, o controlador irá acionar um motor mais rápido ou mais devagar do que o outro. Os sensores emitem 5 V (faixa preta) ou 0 V(pista branca) para as portas digitais. O Arduino modula os valores de velocidade pelos valores PWM que variam de 0 volts (0) até 5 volts (255), fazendo isso ao longo de todo trajeto. A bateria que alimenta o Arduino energiza não somente o controlador como também a ponte H dos motores por meio do pino Vin do Arduino.
Considerações finais:
Neste tutorial mostramos como funciona e como montar o robô seguidor de faixa. Caso queria veja também o tutorial “ROBÔ SEGUIDOR DE LINHA”, nele utilizamos o sensor de obstáculos para construir o seguidor de faixa. 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.
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
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.
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.
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
- 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.
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
- 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.
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
- 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.
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
- 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.
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.
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
- 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.
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.
SENSOR MAGNÉTICO REED SWITCH
Sensor Magnético Reed Switch
Já pensou em controlar motores, relés ou LEDs de forma barata e fácil ? Com o sensor magnético Reed Switch, isso é possível. Esse dispositivo, como o nome já sugere, é um sensor de campo magnético, ou seja, ele é capaz de detectar quando um ímã está se aproximando ou se afastando. Simples e eficiente, o reed switch apresenta grande aplicabilidade na indústria e em diversos projetos de robótica e automação, sendo amplamente usados em portões eletrônicos e em sistemas antifurto, por exemplo.
Como funciona o sensor magnético reed switch ?
Os sensores magnéticos reed switch são ampolas constituídas por um bulbo de vidro, que contém, em seu interior, duas hastes metálicas flexíveis que se movimentam conforme a ação de um campo magnético. Essa configuração possibilita que as hastes se mantenham em contato fechado ou aberto, o que implica se haverá ou não passagem de corrente elétrica.
Quando há um ímã próximo do sensor, ocorre a magnetização dos contatos metálicos do dispositivo, fazendo com que estes se fechem, o que permite a passagem de corrente elétrica. De forma análoga, com o ímã afastado, os contatos se mantêm abertos, impedindo a passagem da corrente. Nesse sentido, a passagem ou não de corrente elétrica indica ao Arduino se o ímã está longe ou perto do sensor.
Sistemas antifurto
A partir dessa informação, conseguiremos, através do Arduino, controlar os dispositivos que quisermos, como um buzzer em um sistema antifurto de um cofre, por exemplo. Em projetos como esse, geralmente se acopla o reed switch a uma das paredes do cofre, enquanto um ímã é anexado à sua porta. Dessa maneira, o Arduino irá interpretar quando a porta estiver aberta (sensor afastado do ímã) ou quando estiver fechada (sensor próximo ao ímã), de modo que o usuário consiga identificar arrombamentos.
Em sistemas como o da figura, quando ocorre um arrombamento, a porta do cofre permanece aberta, de maneira que o ímã e o sensor ficam separados. Desse modo, tal informação é lida pelo Arduino, que, por sua vez, coordenará o acionamento de um buzzer, que atua como um sinalizador.
Sendo assim, neste tutorial, você vai aprender a conectar o sensor reed switch ao Arduino. Além disso, vai aplicar seu conhecimento num projeto de alarme antifurto com o sensor magnético reed switch e um buzzer, seguindo o modelo do exemplo apresentado.
Mãos à obra - Alarme antifurto com sensor magnético reed switch
Componentes necessários
- Buzzer Passivo
- Ampola de Reed Switch NA - Sensor Magnético
- Placa Arduino
- Resistores de 470Ω ou similares
- 1 Ímã
Montando o projeto
Vamos conectar os componentes do projeto. Para isso, desligue o cabo USB do seu Arduino e monte o circuito conforme a figura a seguir:
Programando
Crie um sketch e salve-o com o nome "reed_switch_alarme". Em seguida, com o sketch salvo, escreva o programa da seguinte forma:
#define buzzer 2 //buzzer na porta digital 2
#define sensor 9 //sensor reed switch na porta digital 9
#define led 12 //LED na porta digital 12
int leitura;
void setup() {
pinMode(buzzer,OUTPUT); //buzzer atuando como saída
pinMode(sensor, INPUT); //sensor atuando como entrada
pinMode(led,OUTPUT); //LED atuando como saída
}
void loop() {
leitura = digitalRead(sensor);
if(leitura==0){ //se nenhum campo magnético for detectado
tone(buzzer,1500); // o buuzer toca
digitalWrite(led,HIGH); //o led acende
}
if(leitura==1){ //se houver campo magnético
noTone(buzzer); //buzzer não toca
digitalWrite(led,LOW); // led apagado
}
}
Após digitar o código, clique em carregar, para que o programa seja transferido para a placa Arduino.
Colocando para funcionar
Terminado o passo-a-passo, você perceberá que, ao aproximar um ímã do circuito, tanto o buzzer quanto o LED permanecem desativados. Contudo, ao afastar o ímã, o buzzer irá apitar, e o LED acenderá, de maneira semelhante ao que ocorre no exemplo do cofre descrito acima.
Entendendo a fundo
Entendendo o software
O sensor magnético reed switch é do tipo NA (normalmente aberto), ou seja, quando a leitura do sensor tiver valor lógico 1 (HIGH), significa que há campo magnético sendo detectado. Do contrário, quando o valor lido for 0 (LOW), é sinal de que o ímã está afastado, pois não há campo magnético ao redor.
No código, a variável "leitura" recebe o valor digital lido pelo sensor através da função digitalRead()
leitura = digitalRead(sensor);
Após a leitura, o próximo passo é indicar ao Arduino o momento em que o buzzer e o LED devem ser acionados. Para isso, utiliza-se uma estrutura condicional.
if(leitura==0){ //se nenhum campo magnético for detectado
tone(buzzer,1500); // o buuzer toca
digitalWrite(led,HIGH); //o led acende
}
if(leitura==1){ //se houver campo magnético
noTone(buzzer); //buzzer não toca
digitalWrite(led,LOW); // led apagado
}
Dessa forma, se o valor captado pelo sensor for 0 (LOW), o que significa ausência de campo magnético, o buzzer toca, e o LED acende (HIGH); Caso contrário, se o sensor indicar 1 (HIGH), é sinal de que existe um campo magnético ao redor, e portanto, o Arduino deverá acionar tanto o buzzer quanto o LED.
Funções tone() e noTone()
A função tone() serve para o acionamento do buzzer. Como parâmetros, ela recebe a variável (buzzer) que representa o dispositivo usado e a frequência com que o som deve ser emitido. No nosso caso, utilizamos o valor de 1500 HZ.
tone(buzzer,1500); // o buzzer toca
Já a função noTone(), como o nome indica, serve para desativar o buzzer e tem como parâmetro apenas a variável que representa o dispositivo utilizado.
Considerações Finais
Agora que você aprendeu a usar o sensor magnético reed switch, que tal aplicar seus conhecimentos em outro projeto semelhante ? Como desafio, tente usar esse sensor para controlar um motor, simulando o que acontece em portões eletrônicos, em que o reed switch atua como um sensor fim de curso, boa sorte !
Sensor de Chuva: Detectando água
MÓDULO SENSOR DE CHUVA: DETECTANDO LIQUIDO
Neste tutorial vamos ensinar a utilizar o sensor de chuva com arduino para projetos que precisam da detecção de água. Antes de mais nada utilizaremos um sensor de chuva para atuar na detecção de partículas liquidas.
O que é o módulo sensor de chuva?
Este sensor como todos os outros trabalha com os conceitos físicos.
— Funcionamento
Precipuamente, o sensor de chuva usa da reflexão e refração da luz infravermelha para seu funcionamento que como por exemplo em um para-brisa a propriedade de reflexão é aplicada a ele e o sensor de chuva inicia seu trabalho. Quando há a presença de partículas de chuva no para-brisa o recebimento da luz infravermelho diminui, ou seja, quando há presença de algum líquido, a quantidade de luz recebida pelo sensor diminui, alterando a leitura desse infravermelho do sensor. Então, o sensor de chuva consegue detectar essa diferença na reflexã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, 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)
Módulo do sensor de chuva
Mãos à obra — Configurando um sensor de chuva
Componentes Necessários
- 1 x Arduino Uno R3
- 1 x Módulo sensor de chuva
- 1 x Protoboard
- 1 x LED
- 1 x Resistor de 150Ohms
- Jumpers Macho x Macho
- Jumpers Macho x Fêmea
- Jumpers Femea x Fêmea (Já vem com o sensor)
- Montando o projeto:
A princípio vamos utilizar os jumpers que vem com a placa sensora para conectar ela ao módulo de leitura. Já os jumpers não possuem distinção, ou seja, podem ser conectados de ambos os lados. Ligue ao módulo de leitura. Conectaremos o VCC do módulo no 5V do arduino, o GND do módulo no negativo(-) da protoboard e o pino D0 do módulo no pino digital 3 do arduino. Na protoboard vamos conectar o LED sendo que a perna menor do LED será conectada ao negativo(-) da protoboard e a perna maior no resistor de 150ohms. Por outro lado, a outra extremidade do resistor este será conectada ao pino digital 12 do arduino. Enfim, o GND do arduino ao negativo(-) da protoboard para assim fechar o circuito. Veja o circuito abaixo:
Diagrama de montagem do sensor de chuva
- 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)”.
#define pinoLed 12 //PINO DIGITAL UTILIZADO PELO LED
#define pinoSensor 3 //PINO DIGITAL UTILIZADO PELO SENSOR
int lersensor = 0;// DECLARA UMA VARIAVEL CHAMADA lersensor E ATRIBUA A ELA O VALOR 0
void setup(){
pinMode(pinoSensor, INPUT); //DEFINE O PINO COMO ENTRADA
pinMode(pinoLed, OUTPUT); //DEFINE O PINO COMO SAÍDA
}
void loop(){
lersensor = digitalRead(pinoSensor);
if(lersensor == LOW){ //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
}
Enfim, quando tudo estiver correto o sensor de chuva ficará constantemente em nível lógico alto (HIGH) enquanto a placa sensora estiver seca. Quando ela começa a receber pingos, o nível lógico vai para baixo (LOW). Caso queira ou aja necessidade também é possível realizar a leitura analógica dos valores lidos e assim poder agir gradativamente conforme a chuva.
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 chuva funcionando
Como resultado temos que ao detectar uma quantidade de líquido pre-determinado, ajustando a sensibilidade no potenciômetro(trimpot), o LED acenderá.
Potenciômetro do sensor para a regulação de sensibilidade
Entendendo a fundo:
Software
— Definições e variáveis utilizadas no projeto do sensor de chuva com arduino
A instrução #define apenas associa as portas dos pinos do arduino a nomes referente aos componentes conectados nestes pinos. Logo depois as variáveis declaradas com o tipo int são atribuídas a elas valores escolhidos pelo programador.
#define pinoLed 12 //PINO DIGITAL UTILIZADO PELO LED #define pinoSensor 3 //PINO DIGITAL UTILIZADO PELO SENSOR int lersensor = 0;// DECLARA UMA VARIÁVEL CHAMADA "lersensor" E ATRIBUI-LHE O VALOR "0"
— Função Setup – Definindo pinos do sensor de chuva 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 pinMode define que o pino do sensor será uma entrada e o pino do led será uma saída.
void setup(){
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 chuva com arduino 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 variável lersensor será atribuído a leitura do pino digital 3 que está o sensor. Logo apos, temos a estrutura de decisão if. Primeiramente, caso a variável lersensor seja igual ao nível logico baixo, já que o sensor não está detectando a luz infravermelha, então será executado a função no if. Em contrapartida, se a variável lersensor for igual ao nível logico alto significa que o sensor está detectando a luz infravermelha e que a condição dentro do if é falsa, então não possui liquido sobre o sensor. Assim sendo, será executado o else.
A função digitalWrite irá escrever no pino digital 12 onde está o LED (declarado anteriormente como saída), nível logico alto ou nível logico baixo dependendo se a condição dentro dos parenteses da estrutura de decisão if for verdadeira ou falsa.
void loop(){
lersensor = digitalRead(pinoSensor);
if(lersensor == LOW){ //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
— Trimpot:
No módulo de leitura existe um potenciômetro(trimpot) para o ajustar de quando o sensor entenderá como chuva ou seco. Dependendo da intensidade da chuva que você pretende sentir.
Considerações finais:
Neste tutorial mostramos como funciona e como utilizar o sensor de chuva. Semelhantemente a ele tem o sensor de umidade, 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.
Sensor de Som com arduino: Acendendo uma Lâmpada
ACENDENDO UMA LÂMPADA COM VIBRAÇÕES SONORAS
Este tutorial visa ensinar uma maneira prática de utilizar o sensor de som com arduino para automação residencial. Enfim daremos o primeiro passo para desenvolver um sistema inteligente acendendo uma lâmpada quando o sensor de som detectar vibrações sonoras.
O que é o módulo sensor de som?
O sensor de som com arduino apesar de muitos acreditarem ser um microfone, na verdade, constitui uma placa de circuito impresso com uma função específica. O módulo faz com que emite pulsos de energia ao detectar som fazendo com que uma lâmpada acenda ou apague. Este sensor também pode ser utilizado como um "sensor de presença" do ambiente, porém utilizarão ondas sonoras para entender o que acontece ao seu redor.
- Funcionamento
Precipuamente o sensor realiza a transformação da intensidade das ondas sonoras para tensões de 0 a 5V. Em segundo plano, o pino de leitura digital manda um sinal de nível alto se detectar som. Além disso, 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. 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. Ademais é possível construir seu próprio sensor de som com praticamente os mesmos componentes do módulo. Entretanto o modulo sensor de som fornece maior praticidade na hora da utilização, com ele é possível controlar diversos eletrodomésticos em sua casa sem o auxílio de interruptores convencionais, ou seja, utilizando apenas o bater de palmas.
- Ondas sonoras
De início são ondas mecânicas que vibram em uma frequência de 20 a 20.000 hertz (Hz), sendo normalmente perceptíveis pelo ouvido humano. Elas são originadas por vibrações no meio material em que elas vão se propagar, onde na maioria dos casos, esse meio é o ar. Além disso, essa vibração é transmitida para as moléculas de ar que estão ao redor, que por sua vez passam a vibrar. O sensor de som detectas essas ondas e em seguida atua através das saídas nos fornecendo os resultados que o programamos para ter.
ATENÇÃO: tenha cuidado ao executar projetos envolvendo alta tensão! Certifique-se de realizar as conexões entre os componentes com o circuito desligado da rede.
- 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(OUT) – Pino de saída
Sensor de Som
Mãos à obra — Automatizando uma lâmpada
Componentes Necessários
- 1 x Arduino Uno R3
- 1 x Módulo sensor de som
- 1 x Protoboard
- 1 x Módulo relé 1 Canal 5V
- 1 x Clip bateria 9V com terminal P4
- 1 x Fonte externa
- 1 x Bocal
- 1 x Lâmpada
- Jumpers Macho x Macho
- Jumpers Macho x Fêmea
- Montando o projeto:
Primeiramente veremos como funciona um interruptor eletromecânico (Relé) para ligar e desligar a lâmpada com indução magnética. Conecte o 5v e o GND do arduino nos pinos horizontais da protoboard. Logo depois, conecte o módulo sensor de som na protoboard, o VCC será conectado no 5v da protoboard e o GND do módulo será conectado no GND da protoboard. Posteriormente o OUT do sensor de som conectaremos no pino 4 do arduino.
Além disto, conecte agora o módulo relé. O VCC do módulo será conectado no 5v da protoboard e o GND do módulo relé no GND da protoboard. A porta IN do módulo relé será conectada no pino 7 do arduino, como mostra a imagem abaixo.
Diagrama de montagem do sensor de som sem lâmpada
Veja abaixo o circuito sem lâmpada:
Imagem do circuito do sensor de som
- 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)”.
#define pinorele 7 // pino em que o relé será conectado
#define pinosom 4 // pino em que o sensor de som será conectado
bool rele;
void setup() {
pinMode(pinorele,OUTPUT); //Define o pino do relé como saída
pinMode(pinosom,INPUT); //Define o pino do sensor de som como entrada
rele=false; // A variável rele recebe falso
digitalWrite(pinorele, rele); //Escreve no pino digital do relé falso
}
void loop() {
if(digitalRead(pinosom)==HIGH){ //Lê o pino do sensor de som
rele=!rele;
}
digitalWrite(pinorele,rele); //Escreve no pino do rele
}
ATENÇÃO: caso a compilação de erro certifique se a porta do seu arduino está selecionada na IDE.
- Conectando a lâmpada:
Antes de mais nada adicionaremos a lâmpada ao circuito para ver como irá funcionar na prática. Aliás, desconecte o arduino do computador e corte um dos dois fios que vai até à lâmpada e conectar no módulo relé como mostra a figura abaixo.
Imagem da Lâmpada com um dos dois fios cortados
Não tem importância qual dos dois fios da lâmpada será cortado, apenas deve prestar atenção onde conectá-los no relé. Um deve ficar no pino do meio no relé e o outro em qualquer uma das extremidades.
Diagrama de montagem do sensor de som com a lâmpada
ATENÇÃO: verifique que não tenha nenhum fio desencapado e com risco de choque ou curto-circuito. Caso tenha, utilize uma fita isolante para eliminar este risco.
- Testando o sensor de som:
Conecte o arduino a fonte externa de 9v e a lâmpada na tomada. O resultado deve ser igual à imagem abaixo:
Imagem do circuito do sensor de som finalizado
Posteriormente, caso sua lâmpada esteja acendendo e apagando com muita facilidade, você deve ajustar a sensibilidade do sensor de som. Primeiramente desligue a lâmpada da tomada. Após isso, com a lâmpada desligada utilize uma chave de fenda pequena para regular a sensibilidade no sensor de som como mostra a imagem abaixo. Logo após regulada a sensibilidade conecte a lâmpada na tomada novamente.
Potenciômetro do sensor para a regulação de sensibilidade
Entendendo a Fundo:
Software
– Definições e variáveis utilizadas no projeto do sensor de som com arduino
As instruções #define são apenas para associar nomes aos pinos do relé e do sensor no arduino. Já a variável rele é criada para que posteriormente possamos chamá-la em alguma parte de nossa programação.
#define pinorele 7 // pino em que o relé será conectado #define pinosom 4 // pino em que o sensor de som será conectado bool rele;
– Função Setup – Definindo pinos do sensor de som 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 pinMode define que o pino do relé será a saída, acendendo ou não a lampada, e o pino do sensor será a entrada dos sinais elétricos. A função digitalWrite escreve no pino 7 o valor atribuído a variável rele.
void setup() {
pinMode(pinorele,OUTPUT); //Define o pino do relé como saída
pinMode(pinosom,INPUT); //Define o pino do sensor de som como entrada
rele=false; // A variável rele recebe falso
digitalWrite(pinorele, rele); //Escreve no pino digital do relé falso
}
– Função Loop – Leitura do nosso sensor de som com arduino e Estruturas de decisão
Por analogia, a função loop ao contrário da setup ira rodar tudo que estiver dentro dela varias vezes em um loop constante até que seja reiniciado ou parado o programa. Então na função if se a leitura digital(digitalRead) do pino do sensor for nível logico alto(HIGH) o rele recebe true, acendendo a lâmpada. Caso a leitura seja nível logico baixo será escrito(digitalWrite) false no relé, apagando a lâmpada.
void loop() {
if(digitalRead(pinosom)==HIGH){ //Lê o pino do sensor de som
rele=!rele;
}
digitalWrite(pinorele,rele); //Escreve no pino do rele
}
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.
– LM393
É um Amplificador Operacional que consiste em dois comparadores de tensão de precisão e independentes.
Diagrama do Circuito Integrado LM393
conforme acima temos o diagrama do circuito integrado LM393 com pinos de entrada e saída, um pino do vcc e outro do GND e mais dois pinos um negativo e outro positivo. Estes pinos devem ser utilizados conforme a aplicação que queira realizar com o circuito integrado. No projeto ele é responsável por amplificar os sons do ambiente em 100 vezes para que o sensor de som com arduino funcione corretamente.
Considerações finais:
Neste tutorial mostramos como utilizar o sensor de som para automatizar sua residência. No tutorial "MÓDULO SENSOR DE SOM KY-037: ACENDENDO UM LED" mostramos como utilizar o sensor de som para acender um LED. 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.
Sensor Indutivo NPN de proximidade com Arduino
Utilizando o sensor indutivo NPN de proximidade com Arduino
O sensor indutivo de que vamos falar neste tutorial também é conhecido como sensor indutivo de proximidade NPN modelo LJ12A3-4-Z/BX. Aqui, vamos desenvolver uma aplicação que nos permita saber quando um determinado objeto metálico passou sobre o nosso sensor.
[toc]
O sensor indutivo
O Sensor Indutivo NPN de Proximidade – LJ12A3-4-Z/BX é um componente eletrônico capaz de detectar a proximidade de objetos metálicos. Entre as características deste componente está o fato de não possuir partes móveis em sua estrutura, o que faz com ele possa ser aplicado em uma vasta gama de ambientes e para um grande número de aplicações. Portanto, pode-se afirmar que este sensor possui uma vida útil estendida quando o comparamos a outros elementos que desempenham as mesmas funções, mas que possuem mecanismos móveis. Além disso, este também é um sensor de alta confiabilidade.
O princípio de funcionamento deste sensor baseia-se na criação de um campo magnético a partir de um oscilador e de uma bobina - ambos contidos dentro da estrutura do mesmo - de modo que, caso a intensidade deste campo varie devido a sua interação com a presença de algum corpo metálico, o circuito de sensoriamento detecta esta alteração, e muda o estado de saída do sensor para nível lógico alto ou baixo.
O sensor de proximidade que estamos abordando neste tutorial funciona com tensões entre 6 e 36 volts DC (corrente contínua). O sinal de saída mantém-se em nível alto (1 lógico) se nenhum objeto estiver em frente ao sensor, e muda para nível baixo (0 lógico) quando aproximamos um objeto metálico da extremidade azul. É importante destacar que, para que o objeto seja detectado, deve estar bem próximo, cerca de 4 a 5 mm do sensor.
Mãos à obra - "Detectando objetos metálicos utilizando o sensor indutivo com o Arduino"
Componentes necessários
Para realizar o projeto proposto neste tutorial, você vai precisar dos seguintes componentes:
- 1 x Arduino UNO Rev 3
- 1 x Led vermelho difuso
- 1 x Sensor indutivo de proximidade NPN
- 1 x Resistor 220 Ω
- 1 x Resistor 1k Ω
- 1 x Fonte Bivolt 12V 2A
- 1 x Adaptador P4/KRE Fêmea
Montando o projeto
Para realizar a alimentação do sensor indutivo basta plugar o Adaptador P4/KRE Fêmea no terminal da Fonte Bivolt 12V 2A e realizar a conexão dos jumpers com o sensor.
Programando
void setup() {
Serial.begin(9600);
pinMode(7,INPUT);
pinMode(12,OUTPUT);
}
void loop() {
if(digitalRead(7) == HIGH) {
Serial.print("Nenhum objeto foi detectado");
digitalWrite(12,LOW);
while(digitalRead(7) == HIGH) { }
}
else {
Serial.print("Um objeto foi detectado");
digitalWrite(12,HIGH);
while (digitalRead(7) == LOW) { }
}
}
Colocando para funcionar
Após compilar este código, você vai obter um resultado como esse:
Entendendo a fundo
Software
- Definindo as configurações iniciais
Na primeira parte do código estão as configurações que precisam ser realizadas. Dentro da função setup() nós inicializamos a comunicação serial através da sentença Serial.begin(). Também definimos os modos de operação do pinos 7 e 12, para que eles atuem como portas de entrada digital e saída digital respectivamente.
void setup() {
Serial.begin(9600);
pinMode(7,INPUT);
pinMode(12,OUTPUT);
}
- Detectando objetos com o Sensor indutivo NPN
Em seguida vem a lógica para detecção de objetos metálicos com o sensor. O que fazemos dentro da função loop() é utilizar uma estrutura condicional if() para conferirmos se não há nenhum objeto metálico passando pela frente do sensor. Isto é feito comparando o sinal de tensão existente na entrada digital do pino 7 com um sinal de nível lógico alto.
void loop() {
if(digitalRead(7) == HIGH) {
}
}
Caso esta hipótese seja verdadeira (o pino 7 continua em nível alto), apresentamos no Monitor Serial, a frase "Nenhum objeto foi detectado" e apagamos o led conectado na saída digital do pino 12. Com a função while(), mantemos o programa neste estado até que um objeto seja detectado (fazemos isso para não imprimirmos a mesma frase repetidas vezes no Monitor Serial). Quando um objeto for detectado, o programa sai do while().
if(digitalRead(7) == HIGH) {
Serial.println("Nenhum objeto foi detectado");
digitalWrite(12,LOW);
while(digitalRead(7) == HIGH) { }
}
Em seguida, utilizamos uma estrutura condicional complementar else para checar a hipótese complementar à anterior, ou seja, a de que existe um objeto passando pela frente do sensor. Neste caso, imprimimos no Monitor Serial a frase "um objeto foi detectado" e acendemos o led. De forma semelhante ao caso anterior, mantemos o programa num loop com o while() até que o objeto em questão não seja mais detectado.
else {
Serial.print("Um objeto foi detectado");
digitalWrite(12,HIGH);
while (digitalRead(7) == LOW) { }
}
O código final completo da aplicação é este aqui:
void setup() {
Serial.begin(9600);
pinMode(7,INPUT);
pinMode(12,OUTPUT);
}
void loop() {
if(digitalRead(7) == HIGH) {
Serial.println("Nenhum objeto foi detectado");
digitalWrite(12,LOW);
while(digitalRead(7) == HIGH) { }
}
else {
Serial.print("Um objeto foi detectado");
digitalWrite(12,HIGH);
while (digitalRead(7) == LOW) { }
}
}
Considerações finais
Neste tutorial, demonstramos como fazer para conseguir detectar objetos metálicos com o sensor indutivo de proximidade NPN modelo LJ12A3-4-Z/BX. 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.
Montando um medidor de batimento cardíaco com Arduino
O que é um fotopletismógrafo?
Fotopletismógrafo é um aparelho com o qual podemos medir a frequência cardíaca através da variação do fluxo de sangue em determinada parte do corpo.
A medida que o coração bate, a densidade de sangue em determinado membro do corpo varia mantendo um comportamento bem definido que acompanha a frequência cardíaca. Desta forma, podemos medir a frequência cardíaca citada através do uso de um emissor e de um sensor de luz, pois a intensidade de luz que atinge o sensor varia juntamente com a densidade de sangue. Este tipo de processo é também chamado de hemodinâmico, devido ao seu princípio de funcionamento.
[toc]
Mãos à obra - Montando um fotopletismógrafo
Componentes necessários
Para a montagem do projeto necessitamos dos seguintes itens:
- 1 x Protoboard;
- 2 x Capacitor eletrolítico maior que 10µF;
- 8 x Capacitor cerâmico de 100nF;
- Jumpers;
- 4 x Amplificador TL071;
- 1 x Capacitor de poliéster de 100nF;
- 1 x Capacitor de poliéster de 1.5µF;
- 1 x Capacitor de poliéster de 2.2µF;
- Resistores - 1 de 4.7MΩ/ 1 de 680Ω/ 1 de 68kΩ/ 2 de 2.2kΩ/ 1 de 2.7kΩ/ 1 de 22kΩ/ 1 de 1kΩ/ e 1 de 10kΩ;
- 1 x Diodo foto-emissor de alto brilho;
- 1 x Pedaço de velcro preto.
- 1 x Foto-receptor (BPW34 ou outros).
Observação: Para montar este dispositivo, você precisará de um led de alto brilho branco e de um sensor de luz. Neste caso usaremos o BPW34, que nada mais é que um foto receptor cuja sensibilidade é mais direcionada (a luz ambiente pouco interfere no resultado, já que o sensor é sensível a luz incidente em uma área bem determinada). Além disso, construiremos filtros e amplificadores de sinais usando capacitores, resistores e amplificadores operacionais.
Montando o projeto
– Montagem do sensor
Primeiramente faremos a montagem do nosso sensor. Para isso, cortamos um pedaço de velcro, de modo que possa cobrir o dedo indicador e através de furos inserimos o fotoemissor em uma parte e o fotorreceptor em outra. Para firmá-los colocamos cola quente nas laterais e na parte de trás. Nas imagens abaixo temos o fotoemissor e o fotorreceptor respectivamente:
– Bloco amplificador
Nas montagens de protoboard a seguir as duas linhas de alimentação mais externas serão destinadas ao Ground ou referência do circuito.
Feito isso, agora vamos ao primeiro bloco do nosso circuito para tratar o sinal. O fotorreceptor gera um sinal de corrente que é proporcional a luz que incide sobre ele. Com isso, precisamos de um bloco que transforma esse sinal de corrente em um sinal de tensão amplificado. Para isso, usamos um Amplificador de Transresistência, que está representado abaixo:
– Bloco do filtro passa-alta
Assim, partimos para a segunda parte do nosso projeto, que é um filtro passa altas de primeira ordem com frequência de corte em 1Hz e ganho unitário:
– Bloco filtro passa-baixa
A terceira parte é um filtro passa baixas de segunda ordem, com frequência de corte em 40Hz e ganho de 20dB:
Com isso, a montagem completa do circuito é mostrada abaixo:
Na montagem podemos ver um resistor circulado em vermelho que serve para limitar corrente no LED de alto brilho, já que ele é ligado com a mesma tensão de alimentação positiva dos amplificadores operacionais. Seu valor é 680 ohms.
O fotorreceptor deve ter um de seus terminais ligados na entrada inversora do amplificador de transresistência e o outro ligado ao GND.
Com isso, já podemos visualizar a onda correspondente aos batimentos cardíacos de uma pessoa no osciloscópio. Na figura abaixo é mostrada a onda de frequência cardíaca de uma pessoa usando a montagem deste tutorial.
Caso você não tenha acesso a um osciloscópio, poderá plotar esse mesmo sinal com o Serial Ploter do arduino. Para isso, será preciso dar um Offset no sinal para que não haja parte negativa, já que a entrada analógica do arduino aceita tensões de 0V a 5V. Assim sendo, podemos acrescentar uma outra parte no nosso circuito, que é um amplificador somador.
– Adicionando um offset ao sinal
Além de amplificar o sinal, este bloco do circuito soma uma tensão DC ao sinal que é uma fração da tensão de alimentação, de modo que o sinal permanece no intervalo apropriado ao arduino.
Repare que o amplificador usado no final será um Amplificador somador inversor, de modo que a forma de onda estará de “cabeça para baixo”. Com isso, você precisará inverter seu sinal no arduino (usando uma lógica simples com valores altos para tensões perto de 0V e valores baixos para tensões perto de 5V), antes de plotá-lo no Serial Plotter, ou você poderá optar por usar um amplificador somador não-inversor. Ou ainda, acrescentar mais um circuito amplificador inversor antes do amplificador de Offset, o que não será muito eficiente, mas funcionará bem.
Hardware montado
Com isso, nossa montagem final para representar o sinal no arduino será a seguinte:
Programando
Caso você não tenha o osciloscópio e deseje ver a forma de onda no seu computador, basta utilizar o seu arduíno com o código descrito abaixo. A saída da montagem precisa estar conectada na entrada A0 analógica do arduíno. O código abaixo possui a função de ler o sinal e monta o gráfico em função do tempo do sinal de entrada.
int analogPin = A0;
int sinal = 0;
void setup()
{
Serial.begin(9600);
void loop()
{
sinal = analogRead(analogPin);
Serial.println(sinal);
}
Feito isto, basta apertar Ctrl+Shift+L.
Entendendo a fundo
Os batimentos do coração bombeiam sangue para as diversas partes do corpo de modo que a densidade sanguínea varia na mesma frequência que o coração bate. Com isso o sensor de luz na ponta do dedo indicador capta essa variação de densidade e transforma isso em um sinal de corrente que é amplificado e transformado em um sinal de tensão pelo amplificador de transresistência. O BPW34 é um fotorreceptor que funciona como uma fonte de corrente, com valores na faixa de µA, portanto, dependentes da luminosidade que incide nele.
Depois do amplificador de transresistência, temos um filtro passa-altas com frequência de corte de 1Hz, cuja função é atenuar toda e qualquer tensão com frequência menor que 1Hz. Deste modo, eliminamos qualquer tensão DC da iluminação natural sobre o sensor.
Com o filtro passa baixas de 40Hz, conseguimos atenuar tensões de frequência maiores que 40Hz, que na maioria das vezes são ruídos e não compõem os harmônicos do sinal de interesse.Esse filtro atenua as frequência maiores que 40hz de forma mais abrupta, pois ele é de segunda ordem. Além disso ele dá um ganho de 20dB (10 vezes) no sinal de entrada que está na banda de passagem (menor que 40Hz).
Todos os capacitores cerâmicos e os dois capacitores eletrolíticos (que ficam entre o +vcc e o terra e o outro entre o terra e o -vcc) servem para manter a tensão de alimentação dos amplificadores operacionais constantes e assim, eliminar ruídos e interferências.
No fim, o amplificador somador, além de amplificar o sinal, soma-o com uma tensão DC que neste caso é 0.22% da tensão de alimentação.
Se você ainda tiver problemas com ruído, talvez seja devido ao efeito capacitivo do diodo fotorreceptor. Para resolver isto, basta acrescentar um capacitor em paralelo com o resistor de 4.7MΩ. O valor deste capacitor deve o mesmo do efeito capacitivo do diodo, algo na faixa de pF, basta verificar no datasheet do componente (no caso do BPW34 é algo na faixa de 20 a 100 pF).
Considerações finais
Assim concluímos o nosso tutorial. Espero que todos consigam montar este, que é um dos dispositivos mais usados na área médica. Lembrem-se de verificar os valores de todos os componentes e testar cada bloco do projeto para que erros sejam facilmente detectados. Em caso de dúvidas, deixem nos comentários.
Medindo Temperatura com Termistor NTC e Arduino
Medindo Temperatura com Termistores
Em alguns projetos, faz-se necessária a medição de uma determinada temperatura para a tomada de alguma decisão, como por exemplo, acionar uma carga ou sinalizar algo. Dependendo do projeto, talvez seja necessário monitorar a temperatura de um circuito eletrônico a fim de evitar falhas ou problemas que possam ocorrer. Com isso mente, neste tutorial te ensinaremos como utilizar o termistor NTC 10k em conjunto com um Arduino.
[toc]
Da Automação Industrial para Automação Residêncial
O monitoramento da temperatura por muito tempo limitou-se a ambientes industriais, como por exemplo, no controle de fornos, no monitoramento do funcionamento de máquinas, em controle de processos, entre outros.
A redução do custo dos sistemas automáticos, impulsionada pela disseminação das placas de desenvolvimento de baixo custo e dos conceitos de Internet das Coisas (IoT - Internet of Things), possibilitaram que sensores de grandezas físicas (luminosidade e temperatura) ganhassem importância em ambientes residencias e empresariais.
Hoje, qualquer pessoa pode montar seu próprio sistema de automação que responda sozinho a variações de luminosidade e/ou temperatura utilizando tecnologias baratas tais como placas Arduino.
Os diferentes tipos de sensores de temperatura
A variedade de tipos de processos e ambientes no qual precisamos medir temperatura resultou em uma grande variedade de sensores de temperatura, cada um com sua particularidade.
Os principais sensores de temperatura encontrados no mercado são:
- Termopares
- RTD - Transdutores Termoresistivos
- Termistores
Obs: Ainda existe outros sensores inteligentes tais como o LM35 e o DS18B20
Termopares
Sensores baseados na variação proporcional da tensão entre dois metais a temperatura ao qual são submetidos. Este efeito é chamado de Seebeck. Com custo elevado, são empregados em aplicações profissionais, onde se requer alta confiabilidade e precisão.
Esse tipo de sensor é explicado com detalhes no Tutorial Termopar tipo K + MAX6675.
RTD - Transdutores Termorresistivos
Seu funcionamento tem como base a variação proporcional da resistência de um material condutor conforme temperatura ao qual é submetido. Esse efeito é denominado de termorresistividade.
Como exemplo de transdutores termos o PT100 e o PT1000 feitos com fio de Platina. Estes dois sensores apresentam uma alta importância na indústria, pois apresentam alta precisão, além de oferecerem estabilidade e alta imunidade aos ruídos elétricos produzidos no ambiente no qual foi empregado.
Termistores
Os termistores também utilizam a propriedade física da termorresistência. A diferença é que os termistores são constituídos de semicondutores, enquanto os transdutores são constituídos por metais.
Esses componentes, quando submetidos a uma variação de temperatura, apresentam variação no valor de sua resistência.
A grande vantagem dos termistores é seu baixo custo e pequeno tamanho. Esses sensores são comumente utilizados em sistemas eletrônicos tais como impressoras, eletrodomésticos, notebooks,etc.
Diferença entre Termistores NTC e PTC
A relação entre temperatura e resistência pode variar de forma negativa ou positiva conforme variação de temperatura, fazendo com que os termistores se dividam em dois grupos:
- Termistores NTC
NTC é a sigla para o termo Negative Temperature Coefficient, que traduzindo significa Coeficiente Negativo de Temperatura. Isso significa que para um aumento de temperatura o termistor terá a sua resistência diminuída seguindo sua curva característica. Abaixo é possível visualizar essa curva característica de um modelo de termistor como exemplo.
- Termistores PTC
PTC é a sigla para o termo Positive Temperature Coefficient, que significa Coeficiente Positivo de Temperatura. Ele apresenta um funcionamento inverso ao anterior, ou seja, quando ocorre aumento de temperatura, a resistência do termistor aumentará seguindo sua curva característica. Como no caso anterior, abaixo poderá ser visto um exemplo de curva característica de um modelo de termistor PTC.
Resistência do Termistor
Por padrão, os termistores são especificados pela sua resistência na temperatura de 25ºC. Ou seja, o termistor NTC 10k terá a resistência de 10k Ohm quando submetido a temperatura de 25ºC.
A relação entre resistência e temperatura de um termistor não é linear e pode ser feita usando coeficiente B ou Beta, fornecido pelo datasheet.
Este coeficiente é calculado baseado na formula de Steinhart–Hart que descreve a temperatura de um dispositivo semicondutor em dada temperatura. Você pode entender melhor esse coeficiente no artigo em inglês do Wikipédia sobre Termistores.
Para esse tutorial utilizarmos a biblioteca thermistor.h que calculará o valor da temperatura conforme a resistência medida, assim não ficará mais simples medir a temperatura.
Termistor NTC 10K
Quando se trata de Arduino e outras placas de desenvolvimento, o termistor NTC 10k é definitivamente um dos sensores de temperatura mais populares.
Sua popularidade se dá pelo seu baixo preço e facilidade de utilização junto com microcontroladores.
Esse termistores possuem as seguintes especificações:
- Resistência à 25ºC: 10k Ohm
- Faixa de leitura: -55 a 125°C
- Coeficiente Beta: B25/100 = 4300 K
Veja as especificações desse sensor na página 37 deste datasheet.
Mãos a obra - Medindo a temperatura ambiente com Termistor NTC
Componentes necessários
Para este exemplo prático, serão necessários os seguintes itens:
Com esses itens em mãos, conseguiremos medir a temperatura utilizando o sensor.
Montando o projeto
O circuito eletrônico pode ser visto logo abaixo:
Programando
Tratando-se do código, é necessário realizar o download da biblioteca "thermistor.h", que pode ser baixada clicando aqui.
O código utilizado se encontra abaixo.
#include "thermistor.h"
int pinNTC = A1;
float temperatura;
THERMISTOR thermistor(pinNTC, 10000, 3950, 10000);
void setup()
{
Serial.begin(9600);
}
void loop()
{
temperatura = thermistor.read();
Serial.print("Temperatura: ");
Serial.print(temperatura);
Serial.println(" graus");
Serial.println("");
delay(1000);
}
Colocando em prática
Aqui está imagens do resultado deste exemplo prático.
Entendendo a fundo
Neste tópico serão abordados o hardware e o software deste exemplo, com o objetivo de permitir que você possa compreender bem todo o funcionamento e com isso fazer as alterações que julgar necessárias para adaptá-lo aos seus projetos.
Hardware
O hardware deste circuito consiste em um simples divisor de tensão, no qual o pino analógico A0 é conectado na junção entre o sensor e o resistor, que por sua vez, estão conectados em série. A tensão de 5V é conectada ao outro terminal do sensor e o GND é conectado ao terminal restante do resistor.
Quando ocorre variação de temperatura, há uma variação na resistência do sensor, e consequentemente na tensão sobre o resistor de 10kΩ. Essa variação de tensão sobre o resistor será lida pelo Arduino e com isso o valor de temperatura poderá ser estipulado.
Caso você utilize um termistor que apresente outro valor de resistência máxima, lembre-se de ter em mãos um resistor que possua um valor de resistência igual ao do termistor.
Software
Agora será explicado cada linha do código utilizado.
- Configurações iniciais
É incluso a biblioteca "Thermistor.h".
#include <thermistor.h>
Cria-se duas variáveis, uma para armazenar o valor da temperatura e outra para usar como identificador do pino analógico utilizado.
int pinNTC = A1; float temperatura;
Cria-se o objeto "thermistor" com os seguintes parâmetros: pino utilizado para a leitura no arduino, valor da resistência do termistor, coeficiente do termisto, valor da resistência do resistor utilizado.
THERMISTOR thermistor(pinNTC, 10000, 3950, 10000);
Habilitamos a conexão serial entre o arduino e o computador com 9600 de baud rate.
Serial.begin(9600);
- Leitura do sensor e envio para o monitor serial
É efetuada a leitura do sensor pelo comando thermistor.read() e é salvo na variável "temperatura".
temperatura = thermistor.read();
O valor é mostrado no monitor serial e após isso, é dado um tempo de espera de 1 segundo.
Serial.print("Temperatura: ");
Serial.print(temperatura);
Serial.println(" graus");
Serial.println("");
delay(1000);
Considerações finais
Esperamos que este tutorial tenha esclarecido qualquer dúvida sobre a utilização de um termistor e suas aplicações no mundo maker.
Obrigado pela atenção e continue buscando conhecimento no portal do Vida de Silício.
Termopar tipo K + MAX6675 - Medindo temperatura
Termopar tipo K + MAX6675 - Medindo temperatura
Neste tutorial iremos demonstrar como desenvolver sistemas de monitoramento de temperatura utilizando o termopar tipo K em conjunto com o MAX6675. Para demostrar seu funcionamento, utilizaremos o Arduino uno.
[toc]
Sensores de Temperatura
Os sensores de temperatura são dispositivos que ajudam a identificar o nível de aquecimento de um determinado equipamento ou processo com o objetivo de fazer com que este permaneça em condições adequadas para o seu funcionamento. Em virtude dos infinitos tipos de aplicações existentes, é fácil perceber a necessidade de uma vasta gama de sensores, os quais, de maneira individual, cumprem requisitos particulares de cada situação.
Aqui em nosso portal nós tempos dois tutoriais muito interessantes sobre medição de temperatura:
Os termopares
Os termopares são os elementos mais populares quando falamos na realização de medições de temperaturas de processos. Estes são bastante conhecidos em virtude de sua versatilidade, sendo utilizados em vários tipos de aplicações, indo desde as mais simples até as mais complexas (geralmente existentes em áreas industriais) por serem dispositivos robustos e de custo reduzido.
O princípio de funcionamento dos termopares foi descoberto quando o físico alemão Thomas Seebeckconstatou experimentalmente a existência de uma corrente elétrica ao juntar dois fios de materiais diferentes formando um circuito fechado e posteriormente submeter uma das junções desta união a uma fonte de calor. Algum tempo depois, percebeu-se que a magnitude desta corrente era determinada pela natureza dos dois metais e pela diferença de temperatura entre as duas junções.
Caso o circuito apresentado na figura anterior seja aberto, pode-se constatar a existência de uma força eletromotriz cujo módulo é proporcional à diferença de temperatura entre as junções.
O MAX6675
Apesar de os termopares serem versáteis como citamos anteriormente, a sua utilização requer um pouco de cuidado em dois pontos muito importantes. Um dos tópicos que devem ser olhados com atenção é a chamada compensação de junta fria e o outro diz respeito à necessidade de uma certa sensibilidade na medição das tensões provenientes de um termopar, pois, para cada variação na temperatura ocorre uma pequena variação na tensão existente nos terminais do termopar.
Felizmente existem dispositivos como o circuito integrado MAX6675 que faz o papel de intermediador realizando o contato entre um Arduino e um termopar de maneira fácil. Este chip mede a saída de um termopar tipo K e entrega o resultado para o Arduino através da interface SPI.
Mãos à obra - Medindo temperaturas com um termopar tipo K + MAX6675
Componentes necessários
Para desenvolver este projeto, precisaremos dos seguintes componentes:
Montando o projeto
Programando
#include "max6675.h"
int SO = 8;
int CS = 9;
int CLK = 10;
MAX6675 sensor(CLK, CS, SO);
void setup()
{
Serial.begin(9600);
delay(500);
}
void loop()
{
Serial.print("Graus C = ");
Serial.print(sensor.readCelsius());
delay(500);
}
Colocando para funcionar
Entendendo a fundo
Software
Neste ponto, serão demonstrados todos os passos para o desenvolvimento do código que deve ser inserido no Arduino UNO para que seja possível a realização da medição de temperaturas com o termopar tipo K.
– Incluindo as bibliotecas que serão utilizadas
O primeiro passo que devemos realizar para atingir o objetivo proposto consiste na inclusão da biblioteca adequada para permitir a interação do módulo MAX6675 com o Arduino UNO. Caso você não tenha esta biblioteca, clique aqui para fazer o download da mesma.
#include "max6675.h"
– Definindo os parâmetros que serão utilizados
Posteriormente, devemos declarar as variáveis que irão conter os valores relativos aos parâmetros que serão utilizados na criação do objeto que representará o módulo Max6675 em nosso código. Aqui, nós criamos 3 variáveis do tipo int, que por sua vez, armazenarão os números referentes aos pinos do Arduino UNO que serão conectados com os pinos SO, CS e CLK do módulo Max6675.
int SO = 8; int CS = 9; int CLK = 10;
– Criando o objeto
Antes de prosseguirmos para a função setup(), devemos criar o objeto que representará o módulo Max6675 em nosso código. O nome do objeto em questão será sensor.
MAX6675 sensor(CLK, CS, SO);
– Definindo as configurações iniciais
Na função Setup() nós vamos apenas iniciar a comunicação serial através da sentença Serial.begin() com uma taxa de transmissão de 9600 bauds.
void setup() {
Serial.begin(9600);
}
– Realizando as medidas de temperatura
Dentro da função loop(), utilizamos duas sentenças Serial.print(), de modo que, a primeira delas é responsável por enviar o fragmento de texto "Graus C" para o Serial Monitor através da porta serial. Já a segunda, envia o valor de temperatura lido pelo sensor (obtido através da sentença sensor.readCelsius() utilizada como parâmetro da função print()). Por fim, recorremos à função delay() para determinar qual será o intervalo de tempo entre duas leituras sucessivas.
void loop()
{
Serial.print("Graus C = ");
Serial.print(sensor.readCelsius());
delay(500);
}
Considerações finais
Neste tutorial, demonstramos como você deve proceder para realizar medições de temperatura com um termopar do tipo K utilizando o Max 6675. 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.
Medindo Tensão AC com Módulo GBK P8 e Arduino
Medindo Tensão Elétrica AC com Módulo GBK P8 e Arduino
Neste tutorial vamos aprender como medir a tensão da rede elétrica utilizando o sensor de tensão GBK P8 em conjunto com um Arduino UNO.
[toc]
Módulo GBK P8
Em alguns projetos, é necessário medir grandezas elétricas em algum aparelho ou circuito, para monitorar condições de funcionamento, prevenir falhas, ou medir seu consumo de energia.
O módulo Sensor de Tensão GBK P8 é uma opção para medição de tensão elétrica. A placa é baseada num optoacoplador (TIL 116) e com ela é possível realizar a medição de tensões de 127 até 220 V.
Mãos à obra - Medindo Tensão AC com Módulo Sensor de Tensão GBK P8
Componentes necessários
Neste projeto, vamos monitorar o valor de tensão de um equipamento para verificar se ele está ligado ou desligado. Para isso, precisaremos de:
- 1 x Arduino UNO;
- 1 x Sensor de Tensão Módulo P8 GBK;
- Jumpers
Montando o projeto
A placa possui três terminais, que estão identificados, como a figura abaixo.
Os três terminais são:
- +5Vcc, é o pino de alimentação, que é ligado ao 5 V do Arduino
- gnd, é o terminal de 0 V, ligado no GND do Arduino
- Out, que será conectado no do Arduino
ATENÇÃO! Ao realizar este projeto, você estará trabalhado diretamente com tensões maiores que o habitual. Nesse nível de tensão, um choque elétrico pode causar danos a você e ao seu equipamento.
Se você está em dúvida sobre como proceder nessa parte, peça ajuda a alguém que saiba como trabalhar com segurança.
A montagem fica assim:
Programando
Após conectarmos o Arduino ao computador e abrirmos sua IDE, selecionamos o modelo da placa que estamos usando - no caso, Arduino UNO - e selecionamos a porta de conexão dele com o computador.
Escreva na IDE o seguinte código:
#define gbk A0
const int R1 = 220000;
const int R2 = 10000;
int valorLido = 0;
float acum = 0;
float v1 = 0;
void setup() {
Serial.begin(9600);
}
void tensaoCalculo() {
valorLido = analogRead(gbk);
v1 = valorLido * 0.004882812;
acum = v1 / (R2 / (R2 + R1));
if(acum == 0) {
Serial.println("Aparelho desconectado da tomada");
Serial.println("");
} else {
Serial.println("Aparelho conectado a tomada");
Serial.print("Tensao = ");
Serial.print(acum);
Serial.println(" V");
Serial.println("");
}
}
void loop() {
tensaoCalculo();
delay(1000);
}
Colocando pra funcionar
ATENÇÃO! Ao realizar este projeto, você estará trabalhado diretamente com tensões maiores que o habitual. Nesse nível de tensão, um choque elétrico pode causar danos a você e ao seu equipamento.
Se você está em dúvida sobre como proceder nessa parte, peça ajuda a alguém que saiba como trabalhar com segurança.
Após dar upload do código ao Arduino, conectamos o módulo em PARALELO ao dispositivo. No nosso caso, adaptamos uma extensão para ligar direto na rede elétrica em tensão AC.
IMAGEM LIGAÇÃO EXTENSÃO E SENSOR
Depois de concluir todos os passos, o Arduino deve imprimir a seguinte mensagem no monitor serial: "Aparelho desconectado da tomada". Agora conecte a extensão na tomada e veja o resultado no monitor serial.
IMAGEM MONITOR SERIAL
Através da saída analógica do sensor de tensão AC o Arduino consegue dizer quando o aparelho está conectado a tomada e informar a tensão elétrica.
Entendendo o Módulo GBK P8
Hardware
O módulo GBK é composto por um optoacoplador, resistores e um capacitor. O esquema de ligação pode ser visto logo abaixo.
(esquemático GBK P8)
Por estar conectado em paralelo com a tomada, entre os terminais de conexão da rede elétrica haverá uma diferença de potencial interligados por um resistor de 220 kΩ (como visto no esquemático acima), com isso, circulará uma corrente com valor bem reduzido por esse resistor. Essa corrente passará também pela entrada do optoacoplador TIL116.
Na entrada do optoacoplador existe um diodo infravermelho, que emite luz quando há corrente. Essa luz chega ao fototransistor do acoplador, chaveando corrente e criando um sinal de tensão em sua saída.
A forma de onda da saída do optoacoplador seria a um retificador de meia onda, permitindo corrente apenas nos ciclos positivos de corrente. Entretanto, a presença do capacitor no circuito altera o sinal, descarregando para o circuito no ciclo negativo, criando uma tensão de ripple com menos variação.
Software
Vamos explicar os trechos do código, para que você entenda por completo o que está sendo feito, e possa modificar o que for necessário no seu projeto.
- Variáveis do programa
O programa inicia com a definição de uma constante para o compilador: onde aparecer gbk o compilador interpreta como A0, que é o pino da leitura analógica. A vantagem desse recurso é que se o pino for alterado fisicamente depois, basta fazer a alteração em apenas um lugar do código, o que é bem útil em programas muito grandes.
Depois são declaradas algumas variáveis e constantes que ficarão na memória. R1 e R2 são constantes que armazenam os valores das resistências do módulo. A variável valorLido armazena a leitura analógica do pino A0, que vem do módulo. As variáveis v1 e acum são utilizadas no cálculo da tensão.
#define gbk A0 const int R1 = 220000; const int R2 = 10000; int valorLido = 0; float acum = 0; float v1 = 0;
- As definições no setup
No setup acontece a inicialização da comunicação serial, para a utilização do monitor serial
Serial.begin(9600);
- A função de cálculo da tensão
A função que calcula a tensão, com base na leitura analógica, é chamada logo no início da função loop.
void tensaoCalculo() {
valorLido = analogRead(gbk);
v1 = valorLido * 0.004882812;
acum = v1 / (R2 / (R2 + R1));
if(acum == 0) {
Serial.println("Aparelho desconectado da tomada");
Serial.println("");
} else {
Serial.println("Aparelho conectado a tomada");
Serial.print("Tensao = ");
Serial.print(acum);
Serial.println(" V");
Serial.println("");
}
}
Ela inicia fazendo a leitura analógica do pino A0 e armazenando na variável valorLido. Em sequência, faz a conversão da leitura, que vai de 0 a 1023, para um valor de tensão, que vai de 0 a 5 V. A conversão é feita multiplicando o valorLido por 0,004882812. Esse valor é equivalente a 5/1024, e representa quanto vale em volts cada inteiro da leitura analógica. A multiplicação então, converte a leitura analógica para um valor de tensão.
valorLido = analogRead(gbk); v1 = valorLido * 0.004882812;
Depois, se faz o cálculo de quanto a tensão lida representa no valor real. A tensão lida no sensor é uma tensão de 0 a 5 V, na saída de um divisor de tensão. Para o valor real, a tensão faz o cálculo inverso ao do divisor de tensão:
acum = v1 / (R2 / (R2 + R1));
- Declarando a função tensaoCalculo()
Antes de iniciar o void loop(), é necessário declarar a função que será chamada por ele.
void tensaoCalculo()
- Lendo os dados do pino A0
É armazenado o valor lido no pino A0 na variável do tipo inteiro "valorLido".
valorLido = analogRead(A0);
- Convertendo para tensão
Multiplica-se o valor lido na entrada analógica por 0,00482812 para descobrir o valor da tensão da entrada analógica do arduino.
v1 = valorLido * 0.004882812;
Considerações finais
Esperamos que este tutorial tenha ajudado a entender como utilizar o Módulo Sensor de Tensão GBK P8, e como utilizá-lo em projetos para medir tensão da rede elétrica, ou de dispositivos ligados em tensão AC.
Deixe nos comentários suas dúvidas. Críticas e sugestões também são muito bem vindas.
Até o próximo!
Módulo ACS712 - Medindo Corrente Elétrica Alternada e Contínua com Arduino
Módulo ACS712 - Medindo Corrente Elétrica Alternada e Contínua com Arduino
Neste tutorial você aprenderá como medir corrente elétrica alternada utilizando o módulo sensor de corrente ACS712 juntamente com um Arduino. Para isso, realizaremos a medição do valor de corrente de um motor universal monofásico, com o objetivo de monitorar seu consumo de energia. Recomendamos a você que leia os tópicos introdutórios do tutorial SCT-013 - Sensor de Corrente Alternada com Arduino, pois, além de serem abordados os conceitos à respeito da medição de corrente, também são vistos os conceitos relacionados à Potência Elétrica, os quais, que serão utilizados neste tutorial.
Apesar de abordarmos como medir corrente alternada, a medição de corrente Contínua é muito semelhante e será comentada em um tópico ao final do tutorial.
[toc]
Sensor de corrente ACS712
O ACS712 é um pequeno sensor de corrente invasivo para baixas e médias correntes com alta sensibilidade e baixo custo. Ele é capaz de medir valores de corrente continua e alternada.
O ACS712 é um sensor de efeito Hall que gera uma saída de tensão proporcional a corrente que flui entre os pinos IP+ e IP- do sensor.
Por usar o efeito Hall, o circuito do sensor ficar isolado eletricamente do circuito cujo o qual se está aferindo a corrente.
Existem diversos modelos do ACS712 com diferentes limites de medição de corrente, como podemos ver na tabela abaixo.
As informações que serão importantes para nós são: os modelos (Part Number), a temperatura de operação em graus Celsius (TA), a corrente máxima a ser medida em Ampères (Optimized Range) e a relação de mV/A (Sensitivity, Sens). As informações completas podem ser consultadas no datasheet do fabricante.
O Módulo sensor de corrente ACS712
O módulo ACS712 nada mais é que um placa com o ACS712 e tudo que é preciso para usá-lo de maneira mais simples. Lembrando que este é um sensor de corrente invasivo, onde é necessário interromper o circuito para que ele seja instalado. Para este tutorial, será utilizado o módulo ACS712 30A, que por sua vez, consegue ler valores de corrente de até 30 Ampères.
Caso esteja usando o módulo ACS712 5A você precisa levar em conta a sensibilidade dele e fazer a devida alteração no código do Arduino.
Efeito hall
O ACS712 utiliza do efeito Hall para realizar a interface entre a corrente real do circuito com o Arduino, no qual, segundo preleciona Thomazini no livro Sensores Industriais:
"O efeito Hall caracteriza-se basicamente pelo aparecimento de um campo elétrico transversal em um condutor percorrido por uma corrente elétrica, quando ele se encontra mergulhado em um campo magnético".
Os sensores por efeito Hall são constituídos por dispositivos semicondutores que sofrem influência de campo magnético. Quando colocamos esse dispositivo semicondutor em série com a fonte e a carga, ocorre a passagem de elétrons por meio dele.
Ao adicionarmos um campo magnético perpendicular ao movimento dos elétrons, surge uma força magnética, chamada de força de Lorentz.
Sob influência dessa força, os elétrons livres não se moverão mais de forma retilínea, mas se concentrarão na direção da força magnética.
Essa concentração faz surgir um potencial negativo, logo, na parte onde houver falta desses elétrons, surgirá o potencial negativo. Dessa forma, haverá uma diferença de potencial entre essas extremidades que será proporcional ao valor de corrente que está passando pelo material semicondutor. Com isso, medindo a tensão entre essas extremidades e por meio de cálculos, é possível descobrir o valor de corrente.
Mãos à Obra - Medindo Corrente Elétrica Alternada com Módulo ACS712 30A
Componentes necessários
Para a realização deste tutorial serão necessários:
Além desses itens, utilizaremos um pequeno motor universal monofásico para realizar a medição da corrente inerente ao funcionamento da mesma e também da potência consumida estipulada.
Montando o projeto
Por se tratar de um sensor de corrente invasivo, é necessário realizar a interrupção do circuito para que o ACS712 possa ser conectado ao circuito, como vemos abaixo.
Após isso, conectamos a alimentação (5V e GND) do ACS712 no arduino, e o pino OUT conectamos ao pino analógico A0, de acordo com o diagrama abaixo.
Programando
Após concluir a montagem descrita acima, basta dar upload no código abaixo para o arduino, no qual a explicação detalhada de cada linha poderá ser vista no tópico "Entendendo a fundo/Software". Lembre-se de selecionar a placa e a porta que está utilizando corretamente.
float vetCorrente[300];
void setup()
{
Serial.begin(9600);
pinMode(A0, INPUT);
}
void loop()
{
double maior_Valor = 0;
double valor_Corrente = 0;
float tensao = 127;
float potencia = 0;
for(int i = 0; i < 300; i++)
{
vetCorrente[i] = analogRead(A0);
delayMicroseconds(600);
}
for(int i = 0; i < 300; i++)
{
if(maior_Valor < vetCorrente[i])
{
maior_Valor = vetCorrente[i];
}
}
maior_Valor = maior_Valor * 0.004882812;
valor_Corrente = maior_Valor - 2.5;
valor_Corrente = valor_Corrente * 1000;
valor_Corrente = valor_Corrente / 66; //sensibilidade : 66mV/A para ACS712 30A / 185mV/A para ACS712 5A
valor_Corrente = valor_Corrente / 1.41421356;
Serial.print("Corrente = ");
Serial.print(valor_Corrente);
Serial.println(" A");
potencia = valor_Corrente * tensao;
Serial.print("Potencia = ");
Serial.print(potencia);
Serial.println(" W");
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Serial.println("");
}
Colocando pra funcionar
Código compilado e circuito montado! Veja o resultado abaixo.
Entendendo a fundo
Neste tópico serão tratados o funcionamento de cada parte do projeto deste tutorial, onde veremos os cálculos realizados pelo arduino para chegar ao valor de corrente correto.
Hardware
O circuito integrado ACS712 é fabricado pela Allegro MicroSystems, no qual é possível visualizar sua pinagem na imagen logo abaixo.
- IP+ / IP- : são os terminais que serão conectados em série com a carga. É por onde a corrente elétrica irá fluir.
- VIOUT: corresponde ao pino de saída do sensor. Ele irá representar a forma de onda da corrente proporcional a sua entrada, no qual a sua proporcionalidade é definida pelo modelo que será utilizado. A forma de onda em sua saída apresentará um offset de 2,5V.
- FILTER: terminal no qual será conectado um capacitor que definirá a largura de banda.
- VCC / GND: correspondem aos terminais de alimentação do circuito integrado.
Logo abaixo é mostrado o circuito típico de suas aplicações.
Software
A programação será responsável por, primeiramente, realizar várias leituras do pino analógico, no qual o ACS712 está conectado, durante um período de tempo, assim, podemos ter uma noção dos valores que constituem a senoide da corrente. Com esses valores, o arduino poderá calcular o valor de pico da senoide, no qual o mesmo equivale ao maior valor da amostra encontrada, e após isso, basta dividir esse valor por √2, segundo a seguinte fórmula:
Irms = Ipico / √2
Assim, conseguiremos descobrir o valor rms (eficaz) da corrente passando pelo condutor no qual o ACS712 está conectado.
Agora será explicado a função de cada linha presente no código apresentado no tópico "Programando".
- Criando um vetor
Inicialmente é criado um vetor que será utilizado para armazenar 300 amostras de valores que serão lidos adiante.
float vetCorrente[300];
- Aquisição das amostras por meio de uma estrutura de repetição
É criado um "for" para que o arduino possa armazenar vários valores de corrente durante um determinado instante de tempo.
for(int i = 0; i < 300; i++)
{
vetCorrente[i] = analogRead(A0);
delayMicroseconds(600);
}
- Encontrando o maior valor de amostra do vetor "vetCorrente[300]"
Cria-se outro laço "for" para que o arduino possa encontrar, entre as 300 amostras, a que apresente o maior valor.
for(int i = 0; i < 300; i++)
{
if(maior_Valor < vetCorrente[i])
{
maior_Valor = vetCorrente[i];
}
}
- Calculando o valor da corrente
No primeiro instante é necessário converter o valor encontrado, que se encontra entre 0 e 1023, para o valor de tensão lido pelo arduino. Para isso, por meio de uma regra de 3 simples, é possível encontrar o valor de tensão.
1024 - 5
(valor da amostra) - x
Seguindo essa regra de 3, é possível descobrir que basta multiplicar o valor da amostra por 0,004882812 para encontrar o valor da tensão lido pelo arduino.
maior_Valor = maior_Valor * 0.004882812;
- Removendo o valor de offset das amostras
A forma de onda resultante na saída do módulo ACS712 equivale a uma senoide com uma tensão de offset, como podemos ver abaixo.
Seguindo seu datasheet, o valor da tensão de offset (equivalente ao zero da forma de onda senoidal da corrente) é proporcional ao valor de VCC * 0,5, que no nosso caso seria:
Voffset = VCC * 0,5
Voffset = 5 * 0,5
Voffset = 2,5 V
Por esse motivo foi necessário diminuirmos o valor de tensão encontrado por 2,5, como é indicado logo abaixo.
valor_Corrente = maior_Valor - 2.5;
- Convertendo para mili
O datasheet deste módulo apresenta os valores de sensibilidade de mV/A, com isso, foi necessário converter os valores de V para mV, para que o arduino possa calcular o valor da corrente adiante.
valor_Corrente = valor_Corrente * 1000;
- Encontrando o valor de pico da corrente
Agora dividiremos o resultado pelo valor equivalente a sensibilidade do sensor. Como visto anteriormente, existem diferentes modelos de ACS712, no qual o que foi utilizado neste tutorial é o ACS712ELCTR-30A-T, conhecido como ACS712 30A, no qual consultando seu datasheet foi possível encontrar o valor de sensibilidade de mV/A, que corresponde a 66 mV/A.
valor_Corrente = valor_Corrente / 66;
Caso o seu ACS712 seja de outro modelo, substitua o valor "66" pelo valor que corresponda a sensibilidade do seu módulo. Para o ACS712 5A, por exemplo, você precisa mudar para 185.
- Calculando o valor rms da corrente
Achado o valor de pico, é possível calcular o valor rms da corrente, finalizando assim o código referente a corrente.
valor_Corrente = valor_Corrente / 1.41421356;
- Mostrando o resultado no monitor serial
É mostrado os valores de corrente e potência no monitor serial, para que você possa visualizá-los.
Serial.print("Corrente = ");
Serial.print(valor_Corrente);
Serial.println(" A");
Serial.print("Potencia = ");
Serial.print(potencia);
Serial.println(" W");
É dado um tempo para a próxima atualização dos valores.
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Medindo corrente contínua
Uma vantagem deste sensor é que com ele você poderá medir também o valor da corrente de cargas DC, ou seja, do mesmo modo que ele pode ser empregado para medir corrente alternada, ele também pode ser empregado para medir corrente contínua. Para isso, basta mudarmos algumas linhas da programação referentes ao vetor de amostras vetCorrente[300]. Abaixo é detalhado as alterações que deverão ser feitas.
Ao invés de encontrarmos o maior valor presente no vetor, como foi descrito no tópico Encontrando o maior valor de amostra do vetor "vetCorrente[300]" logo acima, teremos que realizar um cálculo de média aritmética com todos os valores.
Veja abaixo o código a ser retirado.
for(int i = 0; i < 300; i++)
{
if(maior_Valor < vetCorrente[i])
{
maior_Valor = vetCorrente[i];
}
}
maior_Valor = maior_Valor * 0.004882812;
valor_Corrente = maior_Valor - 2.5;
Em seu lugar, colocaremos o seguinte código.
int somaTotal;
for(int i = 0; i < 300; i++)
{
somaTotal = vetCorrente[i] + somatorio;
}
valor_medio = somaTotal / 300;
valor_medio = valor_medio * 0.004882812;
valor_Corrente = valor_medio - 2.5;
Além disso, devemos retirar a seguinte linha do código:
valor_Corrente = valor_Corrente / 1.41421356;
Retirar essa linha se faz necessário pois ela converter o valor de pico da corrente para o valor rms, mas, por estarmos tratando de corrente contínua, isso não é necessário.
Essas modificações surtirão no seguinte efeito:
- Por meio do laço for será realizado a soma de todos os valores presentes no vetor vetCorrente[300], e armazenando o resultado na variável somaTotal;
- É realizado a divisão da variável somaTotal pelo número 300, encerrando assim o cálculo da média aritmética;
- As linhas seguintes serão responsáveis por converter o valor achado até o momento no valor de corrente realmente lido.
O código final com essas alterações pode ser visualizado logo abaixo.
float vetCorrente[300];
void setup()
{
Serial.begin(9600);
pinMode(A0, INPUT);
}
void loop()
{
double maior_Valor = 0;
double valor_Corrente = 0;
float tensao = 127;
float potencia = 0;
for(int i = 0; i < 300; i++)
{
vetCorrente[i] = analogRead(A0);
delayMicroseconds(600);
}
int somaTotal = 0;
for(int i = 0; i < 300; i++)
{
somaTotal = vetCorrente[i] + somaTotal;
}
valor_medio = somaTotal / 300;
valor_medio = valor_medio * 0.004882812;
valor_Corrente = valor_medio - 2.5;
valor_Corrente = valor_Corrente * 1000;
valor_Corrente = valor_Corrente / 66; //sensibilidade : 66mV/A para ACS712 30A / 185mV/A para ACS712 5A
Serial.print("Corrente = ");
Serial.print(valor_Corrente);
Serial.println(" A");
potencia = valor_Corrente * tensao;
Serial.print("Potencia = ");
Serial.print(potencia);
Serial.println(" W");
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Serial.println("");
}
Com essas alterações, você poderá medir a corrente de sua carga DC tranquilamente.
Considerações finais
Esperamos que este tutorial tenha tanto trazido-lhe o entendimento a respeito do módulo ACS712 quanto tirado suas dúvidas sobre esse sensor de corrente.