Robô seguidor de linha
Robô seguidor de linha
Neste tutorial vamos aprender a fazer um robô seguidor de linha utilizando o sensor de obstaculo infravermelho (Você poderá usar o Módulo Segue Faixa - TCRT5000) em conjunto com um Arduino.
Para melhor entendimento deste tutorial é necessário que você já tenha um conhecimento prévio sobre Arduino e ponte H. Mas não se preocupe pois nossa equipe já produziu outros tutoriais sobre esse assuntos e você pode conferir alguns destes nos seguintes links: Entradas e Saídas Analógicas e Módulo Ponte H L298n .
[toc]
A importância do robô seguidor de linha
O robô seguidor de linha, também conhecido como seguidor de faixa, é um projeto bem famoso entre os apaixonados por robótica. Quase sempre é o primeiro projeto de robótica móvel.
Em todo o mundo, competições de robótica possuem modalidades únicas para o seguidor de linha, o que faz deste projeto algo que nunca irá deixar de ser melhorado.
Seu projeto envolve conceitos de dimensionamento de energia, controle de motores, programação de embarcados, entre outros.
Esses mesmos conceitos são levados para projetos maiores e mais complexos, tanto acadêmicos quanto industriais.
Robôs seguidores de linha na industria
As aplicações industriais são bem diversificadas. Os robôs que gerenciam o estoque da grande rede de varejos Alibaba, começaram a funcionar com os princípios do seguidor de linha.
Eles manejavam as prateleiras de produtos dentro do estoque por meio de orientação de faixas no chão. Sua função era transportar os materiais de um lado para outro, seja para reajustar o estoque ou para levar para uma área de exportação.
Atualmente o Alibaba evoluiu os robôs, de forma que eles se comunicam, e se localizam, por meio de IA (Inteligência Artificial).
Como um robô seguidor de linha funciona ?
O funcionamento do robô seguidor de linha é simples. Ele 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.
Usaremos 2 sensores infravermelho 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.
Funcionamento do sensor infravermelho
O módulo sensor de obstáculo infravermelho IR é bem simples. Ele emite uma luz infravermelha por um LED negro e capta o reflexo com um LED receptor (LED claro).
Como sabemos, a luz reflete em superfícies claras e é absorvida em superfícies negras, como a fita isolante. Sendo assim o LED receptor irá detectar a luz infravermelha no branco e não detectar no preto.
Para uma melhor eficácia do sensor, a superfície em contraste com a faixa preta deve ser branca. Para ajustar a sensibilidade ao contraste, o modulo possui um potenciômetro de calibração.
Diferença entre sensores infravermelho obstaculo e o TCRT5000
Você pode usar diferentes sensores infravermelhos para o projeto seguidor de linha, o que você precisa levar em conta é as especificações de cada um.
Um sensor infravermelho amplamente utilizado é o TCRT5000, que tem como vantagem seu tamanho e preço. Porem, 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.
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.
Nesse tutorial, usaremos o sensor de obstaculo infravermelho. Dessa forma, caso esteja usando o TCRT5000, fique atento com a distância do chão. Ele precisa ficar com uma distância entre 1mm e 8mm para ser capaz de detectar a faixa.
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, porem 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 varias opções de Ponte H, nesse tutorial usaremos o módulo Ponte H com CI L298N que dispões de duas pontes H, sendo capaz assim 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. Como temos 2 pontes H, temos o Enable A(Ativa A) e o Enable B (Ativa B).
Normalmente os Enables A e B ficam em curto com um sinal de 5V da placa através de um jumper.
Se retiramos esse jumper e inserimos um sinal PWM nessas entradas, modularemos a tensão que é enviada para o motor. Isso ocorre porque a ponte H só ira “funcionar” enquanto o sinal de Enable estiver com 5V, assim teremos o mesmo efeito de tensão média explicado anteriormente.
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.
A descrição completa sobre como funciona uma ponte H L298N e como controlar a velocidade de um motor usando uma ponte H L298N pode ser visto nos nossos tutoriais sobre os respectivos assuntos.
Montado um robô seguidor de linha com sensor infravermelho
A partir de agora iremos mostrar como montar o seu próprio robô seguidor de linha.
Componentes Necessários
Para este projeto iremos utilizar:
- 1 x Arduino UNO
- 2 x Sensores de obstaculo infravermelho (ou módulo TCRT5000)
- 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 L298N
- 1 x Bateria 9 V + conector (ou fonte semelhante)
- Protoboard e Jumpers
Montando o projeto do robô seguidor de linha
Abaixo segue um esquema de ligações e montagem ELETRÔNICA do projeto:
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 seu carrinho.
Calibração do Sensor infravermelho
Ao usar o sensor infravermelho, seja o sensor de obstaculo ou o TCRT5000, você precisa calibrar o sensor para que seja capaz de detectar adequadamente a mudança de cor entre preto e branco.
No vídeo a segui eu mostramos como fazer essa calibração.
Programando o controle do Robô seguidor de linha
A programação do projeto é bem simples. O carrinho precisa fazer a leitura dos sensores e definir pra qual lado ele deve ir, somente isso, até por que um programa muito extenso pode prejudicar o rendimento.
/*DECLARAÇÃO DE VARIAVEIS*/
#define MotorA_sentido1 2
#define MotorA_sentido2 4
#define MotorB_sentido1 8
#define MotorB_sentido2 9
#define MotorA_PWM 3
#define MotorB_PWM 10
#define veloc0 0
#define veloc1 80
#define veloc2 180
#define veloc3 255
#define Sensor_direita 6
#define Sensor_esquerda 7
bool direita, esquerda;
void setup() {
Serial.begin(9600);
pinMode(MotorA_sentido1, OUTPUT);
pinMode(MotorA_sentido2, OUTPUT);
pinMode(MotorB_sentido1, OUTPUT);
pinMode(MotorB_sentido2, OUTPUT);
pinMode(MotorA_PWM, OUTPUT);
pinMode(MotorB_PWM, OUTPUT);
pinMode(Sensor_direita, INPUT);
pinMode(Sensor_esquerda, INPUT);
}
void loop() {
//Define o sentido de rotação dos motores
digitalWrite(MotorA_sentido1, LOW);
digitalWrite(MotorA_sentido2, HIGH);
digitalWrite(MotorB_sentido1, HIGH);
digitalWrite(MotorB_sentido2, LOW);
//Leituras dos Sensores
direita = digitalRead(Sensor_direita);
esquerda = digitalRead(Sensor_esquerda);
Serial.print(direita);
Serial.print(" || ");
Serial.println(esquerda);
//Rodando os motores dependendo das leituras
if(direita == false && esquerda == false){
analogWrite(MotorA_PWM, veloc2);
analogWrite(MotorB_PWM, veloc2);
} else if(direita == false && esquerda == true){
delay(400);
analogWrite(MotorA_PWM, veloc2);
analogWrite(MotorB_PWM, veloc1);
delay(400);
}else if(direita == true && esquerda == false){
delay(400);
analogWrite(MotorA_PWM, veloc1);
analogWrite(MotorB_PWM, veloc2);
delay(400);
}else if(direita == true && esquerda == true){
analogWrite(MotorA_PWM, veloc0);
analogWrite(MotorB_PWM, veloc0);
}
}
Colocando o Robô seguidor de linha para funcionar
Agora é só por o carrinho pra rodar na pista !
Problemas comuns e como resolver
Vale notar que ele pode não fazer o percurso de primeira, o que significa que ajustes devem ser feitos no código ou ate mesmo no hardware. Alguns problemas comuns de acontecer:
- Bateria fraca - 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.
- 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, o nosso código já possui outras velocidades definidas no cabeçalho. 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 diretos no 5 V do arduino (lembrando de por um resistor de 300Ohms).
- Carrinho não roda - Este é um problema complexo, pois podem ser 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.
Entendendo a fundo o Software
Declaração de Variáveis
Na primeira parte do código é feita a declaração das variáveis a serem utilizadas. Nota-se que a existe um grande numero de variáveis utilizando #define, isto é por conta de serem apenas nomes associados a números, não precisamos fazer contas com essas variáveis, portanto elas não precisam ser do tipo INT, FLOAT, entre outras.
O fato de declarar algo por meio de #define ocupa menos espaço de memória, o que dá um ganho na velocidade de execução do programa. As únicas variáveis a serem definidas por um tipo são as que armazenarão os valores lidos dos sensores (direita e esquerda), essas variáveis são do tipo bool e portanto só assumem dois estados (FALSE e TRUE).
/*DECLARAÇÃO DE VARIAVEIS*/ #define MotorA_sentido1 2 #define MotorA_sentido2 4 #define MotorB_sentido1 8 #define MotorB_sentido2 9 #define MotorA_PWM 3 #define MotorB_PWM 10 #define veloc0 0 #define veloc1 80 #define veloc2 180 #define veloc3 255 #define Sensor_direita 6 #define Sensor_esquerda 7 bool direita, esquerda;
Cada motor possui 3 pinos: 2 para definir o sentido de rotação da roda (IN1 e IN2 / IN3 e IN4) e 1 pra definir a velocidade de rotação (Enable A / Enable B)por meio de valores PWM. Lembre-se de que os pinos de velocidade devem conter o "~" desenhado ao lado da porta na placa Arduino, caracterizando o pino como PWM.
Declaramos também 4 velocidades de PWM que podem ser interpretadas como PARADO, DEVAGAR, NORMAL e RÁPIDO, respectivamente. Os sensores foram definidos em suas respectivas portas digitais(6 e 7) e por fim, foram declaradas 2 variáveis do tipo BOOL para armazenar os valores dos sensores.
Função Void Setup()
A função void setup, que roda apenas uma vez, defini todas as configurações necessárias para funcionamento do sistema.
void setup() {
Serial.begin(9600);
pinMode(MotorA_sentido1, OUTPUT);
pinMode(MotorA_sentido2, OUTPUT);
pinMode(MotorB_sentido1, OUTPUT);
pinMode(MotorB_sentido2, OUTPUT);
pinMode(MotorA_PWM, OUTPUT);
pinMode(MotorB_PWM, OUTPUT);
pinMode(Sensor_direita, INPUT);
pinMode(Sensor_esquerda, INPUT);
}
Nesta função declaramos as variáveis que definem os pinos utilizados no Arduino como sendo Entrada(INPUT) ou Saída(OUTPUT). Além disso colocamos a função Serial.begin() que inicializa a comunicação serial entre o Arduino e o computador.
MAS O CARRINHO NÃO RODA LIGADO NA BATERIA ?!?!?! Sim, porém precisamos fazer testes antes de executar a versão final, para isso utilizamos alguns comandos via serial para poder calibrar sensores, averiguar execução do programa, entre outros.
Função Void Loop ()
Em seguida temos o loop do nosso programa onde o carrinho ira fazer suas principais funções.
- Definindo sentido de giro dos motores
Primeiro é necessário definir o sentido de rotação das rodas.
//Define o sentido de rotação dos motores digitalWrite(MotorA_sentido1, LOW); digitalWrite(MotorA_sentido2, HIGH); digitalWrite(MotorB_sentido1, HIGH); digitalWrite(MotorB_sentido2, LOW);
Nesta parte do código precisamos mandar um sinal alto e um sinal baixo entre os pares de portas IN1/IN2 e IN3/IN4. Como nosso carrinho não anda pra trás nós vamos setar essas configurações para que as rodas girem no mesmo sentido(pra frente no caso).
Veja que os pares no nosso código estão invertidos, isso acontece por que a montagem de hardware foi invertida entre os motores.
É como se os polos fossem trocados de lugar entre os motores, porém lembre-se que motores DC não possuem polaridade definida, logo podemos inverter a ligação + e - sem problemas. Isso altera apenas o sentido para o qual o motor gira. Essa é uma das partes que devem ser testadas antes da montagem final do carrinho.
- Leituras dos Sensores
Adiante, temos as leituras dos sensores infravermelhos e a impressão na serial dos valores lidos. Isso é apenas para verificar se os sensores estão funcionando corretamente, não interferindo no funcionamento final do projeto.
//Leituras dos Sensores
direita = digitalRead(Sensor_direita);
esquerda = digitalRead(Sensor_esquerda);
Serial.print(direita);
Serial.print(" || ");
Serial.println(esquerda);
As variáveis do tipo BOOL são utilizadas para armazenar os valores digitais lidos pelos sensores.
- Controlando a direção do robô
Por fim, temos as condições de giro do motor com base no sensores infravermelhos.
//Rodando os motores dependendo das leituras
if(direita == false && esquerda == false){
analogWrite(MotorA_PWM, veloc2);
analogWrite(MotorB_PWM, veloc2);
} else if(direita == false && esquerda == true){
delay(400);
analogWrite(MotorA_PWM, veloc2);
analogWrite(MotorB_PWM, veloc1);
delay(400);
}else if(direita == true && esquerda == false){
delay(400);
analogWrite(MotorA_PWM, veloc1);
analogWrite(MotorB_PWM, veloc2);
delay(400);
}else if(direita == true && esquerda == true){
analogWrite(MotorA_PWM, veloc0);
analogWrite(MotorB_PWM, veloc0);
}
Para isso, utilizamos as condições IF Else, que são mais comum. São 2 variáveis combinatórias que geram 4 possibilidades, porém a ultima condição é quase "impossível" (true e true), pois seria a leitura dos sensores detectando a faixa preta ao mesmo tempo (como é um erro estranho, o carrinho deve parar).
Os motores estão ligados em portas DIGITAIS mas lembre-se que estamos utilizando valores PWM, logo as funções de comando são do tipo analogWrite(porta, PWM). Para que o carrinho possa ter tempo de verificar o estado dos sensores novamente, alguns delays de curto período são utilizados, mas isso pode variar de projeto para projeto.
Entendendo a fundo o Hardware
O carrinho funciona com uma comunicação entre os sensores, o Arduino e a ponte H controlando os motores.
Através das leituras do sensores enviadas 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.
Observe que utilizamos apenas 1 bateria para todo o sistema. A bateria que alimenta o Arduino pelo pino P4 energiza não somente o controlador como também a ponte H dos motores por meio do pino Vin do Arduino. Esta porta é capaz de emitir valores maiores do que os 5 volts que o regulador de tensão da placa utiliza. Sendo assim a tensão de entrada no pino P4 é a mesma do pino Vin.
Conclusão
Este é um dos projetos mais simples de robótica móvel utilizando Arduino e claro que pode ser melhorando em muitos aspectos.
Algumas sugestões de melhorias são: controle de velocidade PID, desvio de obstáculos, reconhecimento de pista, machining learning, etc.
Desafio
Crie uma função para o robô desviar de obstáculos e retornar para a pista. O sensor ultrassônico é uma ótima opção para ajudar nesse desafio.
Sensor de Distância Infravermelho Sharp GP2Y0A21YK0F
Sensor de Distância Infravermelho Sharp GP2Y0A21YK0F
Ao desenvolvermos projetos voltados a robótica ou sistemas para detecção de corpos, precisamos sempre utilizar sensores de distância. Estes dispositivos nos permitem detectar obstáculos que possam estar no caminho do nosso robô, ou até mesmo identificar se alguém, ou algum objeto passou, pelo local. Já vimos em outro tutorial que é possível medir distancias através som, usando, por exemplo, o famoso sensor ultrassônico HC-SR04. Além do som, podemos usar a luz infravermelha para medir distancias, usando, por exemplo, o Sensor Sharp GP2Y0A21YK0F, que é pequeno, robusto e capaz de medir distância com precisão e velocidade surpreendentes. Outra vantagem desse sensor é o fato de sua implementação junto ao Arduino ou outro microcontrolador ser muito simples. Dessa forma, neste tutorial você aprenderá a utilizar o sensor de distância infravermelho da Sharp (10cm a 80cm) em conjunto com um Arduino.
[toc]
Sensor infravermelho Sharp GP2Y0A21YK0F
O sensor infravermelho Sharp GP2Y0A21YK0F é um sensor de distância voltado a projetos em que precisamos de uma boa precisão na distância com resposta rápida.
Com uma interface de comunicação bem simples, esse sensor conta com apenas três pinos, sendo dois para alimentação e um para saída. O módulo Sharp GP2Y0A21YK0F é capaz de medir distâncias de 10 cm até 80 cm, fornecendo como saída de dados um valor analógico que é inversamente proporcional a distância lida ( quanto mais longe menor a tensão ).
- Especificações:
- Alimentação: 4,5 V até 5,5 Volts
- Distância: 10 até 80cm
- Sinal de Saída: Analógico
- Consumo: Aproximadamente 30 mA
Funcionamento do sensor
O sensor Sharp GP2Y0A21YK0F é composto por basicamente três componentes:
- Unidade de controle do emissor infravermelho: Responsável por emitir a luz infravermelha. Este conjunto é composto pela unidade de controle e o led emissor. Unidade de processamento de sinais: Responsável por ler o sinal emitido pela unidade emissora. Este conjunto é composto pela unidade de cálculo de distância e receptor infravermelho.
- Circuito de saída analógica: Circuito responsável por converter
o sinal vindo da unidade de processamento em uma onda analógica equivalente a distância lida.
Para calcular a distância, executa-se o seguinte processo:
- Inicialmente o módulo de controle do emissor infravermelho é ativo e o led infravermelho dispara um feixe de luz ( invisível ao olho humano) no objeto em questão
- Quando a luz chega até um determinado objeto, uma parte costuma ser absorvida e uma outra parte refletida, sabendo disso, a unidade de processamento de sinais é capaz de medir a distância baseada na quantidade de luz que foi refletida pelo objeto.
- Através de cálculos com a luminosidade recebida pelo receptor e algoritmos de triangulação, a unidade de processamento de sinais é capaz de aferir a distância e com o auxílio de um circuito de saída, retornar um valor analógico equivalente a distância lida.
Mãos à obra - Acionamento de leds baseado na distância
Para ilustrar o funcionamento desse sensor, vamos construir uma aplicação bem simples, onde utilizando dois leds ( azul e vermelho ) iremos definir se um objeto está próximo ou não.
Componentes Necessários
- 1x Arduino (Neste exemplo utilizei um Arduino Micro)
- 1x Led Vermelho
- 1x Led Azul
- 1x Sensor de distância Sharp
Montando o projeto
A montagem deste projeto é bem simples, pois neste tutorial iremos apenas utilizar duas portas digitais e uma analógica de nosso Arduino. Sabendo disso, a montagem será feita com base no o seguinte esquema de ligação:
Vejam só como ficou a montagem final :)
Antes de ligar o seu circuito, verifique se todas as conexões foram feitas corretamente. Um curto circuito causado por uma ligação errada pode danificar todo o seu projeto.
Programando
Agora que montamos o nosso projeto, iremos partir para a parte do código. Nesta versão não será necessário o uso de nenhuma biblioteca de terceiros, já que o sensor fornece uma saída analógica que pode ser lida através do método AnalogRead(). Porém, teremos que fazer um pequeno estudo sob o comportamento do sinal analógico resultante da leitura do sensor, estimando com base em sua onda uma formula fechada que nos informe a distância aproximada com base na leitura realizada. O código abaixo ilustra todo o processo de leitura dos dados.
/* Nome: Acionamento de leds com sensor de distância IR
* Feito por: Danilo Almeida
* Data: 20/12/2017
*/
#define pinoAnalogico A0 // Definição do pino Analógico utilizado na leitura do sensor de distância
#define ledAzul 2 // Definição do pino digital onde iremos ligar o led azul
#define ledVermelho 3 // Definição do pino digital onde iremos ligar o led vermelho
void setup() {
Serial.begin(9600); // Inicialização da comunicação serial ( Caso queira ver a distância em cm )
pinMode(ledAzul,OUTPUT); // Inicialização do led azul como saída
pinMode(ledVermelho,OUTPUT); // Inicialização do led vermelho como saída
digitalWrite(ledAzul,LOW); // Inicia o led azul em nível lógico baixo ( desligado )
digitalWrite(ledVermelho,LOW); // Inicia o led vermelho em nível lógico alto ( desligado)
}
void loop() {
// Obtenção do valor em Volts através da formula ( valorAnalógico * (5/1023) )
double valorVolts = analogRead(pinoAnalogico) * 0.0048828125;
// Formula para cálculo da distância levando em consideração o valor em volts
double distancia = 4800/(valorVolts*200 - 20 );
Serial.print(distancia);
Serial.println(" CM");
// Se a distância for maior que 20 CM ligamos o led azul e desligamos o led Vermelho
if (distancia>=20){
digitalWrite(ledAzul,HIGH);
digitalWrite(ledVermelho,LOW);
}
// Caso contrário ligamos o led vermelho e desligamos o azul
else{
digitalWrite(ledAzul,LOW);
digitalWrite(ledVermelho,HIGH);
}
// Bloqueio de execução por 100 ms
delay(100);
}
Colocando pra funcionar
Entendendo a Fundo
Software
- Declaração de pinos utilizados
Inicialmente declaramos todos os pinos que utilizaremos, tanto para leitura do sensor quanto para ligar e delisgar leds. O trecho de código abaixo ilustra a definição dada a cada pino utilizado.
#define pinoAnalogico A0 // Definição do pino Analógico utilizado na leitura do sensor de distância #define ledAzul 2 // Definição do pino digital onde iremos ligar o led azul #define ledVermelho 3 // Definição do pino digital onde iremos ligar o led vermelho
- Função Setup
Na função setup iremos configurar os pinos utilizados para ligar e desligar os leds. Iremos também inicializar a comunicação serial para fins de depuração da distância calculada.
void setup() {
Serial.begin(9600); // Inicialização da comunicação serial ( Caso queira ver a distância em cm )
pinMode(ledAzul,OUTPUT); // Inicialização do led azul como saída
pinMode(ledVermelho,OUTPUT); // Inicialização do led vermelho como saída
digitalWrite(ledAzul,LOW); // Inicia o led azul em nível lógico baixo ( desligado )
digitalWrite(ledVermelho,LOW); // Inicia o led vermelho em nível lógico alto ( desligado)
}
- Função loop
Já na função loop faremos todo o processo de leitura e cálculo da distância, baseados na saída analógica fornecida pelo sensor. Na linha abaixo, realizamos uma conversão do valor vindo do circuito ADC do Arduíno em um valor de tensão equivalente a saída do sensor. Basicamente multiplicamos o valor lido do ADC pela razão entre o nível de tensão utilizado como referência 5 Volts pela amplitude do circuito ADC, que no caso do Arduíno é 210 .
// Obtenção do valor em Volts através da formula ( valorAnalógico * (5/1023) ) double valorVolts = analogRead(pinoAnalogico) * 0.0048828125;
Com o valor em volts em mãos, podemos partir para a equação da distância, que é dada pela seguinte equação:
Onde V0 é o valor em volts lido na porta analógica e d é a distância em cm. Essa equação foi obtida através da análise da onda comportamental do circuito na figura abaixo:
double distancia = 4800/(valorVolts*200 - 20 ); // Formula para cálculo da distância levando em consideração o valor em volts
Por fim, com a distância calculada verificamos se existe um objeto a menos de 20 cm de distância, caso exista, o led vermelho é aceso e o azul é apagado, caso contrário o led azul é aceso e o vermelho é apagado.
Serial.print ("Distancia: ");
Serial.println(distancia);
if (distancia>=20){ // Se a distância for maior que 20 CM ligamos o led azul e desligamos o led Vermelho
digitalWrite(ledAzul,HIGH);
digitalWrite(ledVermelho,LOW);
}
else{ // Caso contrário ligamos o led vermelho e desligamos o azul
digitalWrite(ledAzul,LOW);
digitalWrite(ledVermelho,HIGH);
}
delay(100);
Desafio
Agora que você é capaz de acionar e apagar leds apenas com base na distância de um objeto, tente fazer com que outro tipo de dispositivo seja acionado ao se aproximar. Um tipo de acionamento largamente utilizado consiste em acionar um relé ao se aproximar de um sensor de distância, com base nisso, use o artigo Módulo relé - Acionando cargas com Arduino e tente fazer com que um relé acione ao detectar um objeto em uma determinada distância.Considerações Finais
Este tutorial teve como objetivo apresentar uma ótima alternativa aos sensores ultrassônicos de distância. Através da utilização do sensor Sharp GP2Y0A21YK0F é possível medir pequenas distâncias com uma ótima precisão, o que facilita bastante a elaboração e controle de processos onde necessitamos que a distância medida tenha uma boa precisão e um baixo tempo de resposta. Espero que tenham gostado do conteúdo apresentado, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
Referências
Tudo que foi explicado neste tutorial pode ser encontrado no datasheet do dispositivo, que se encontra no seguinte link:
Shield Ethernet W5100 - Monitorando sensores com um Servidor Web
Shield Ethernet W5100 - Monitorando Sensores com um Servidor Web
Se você gostou do nosso tutorial inicial sobre a criação de Servidores Web utilizando o Arduino UNO juntamente com o Shield Ethernet W5100, prepare-se, pois, neste tutorial vamos dar sequência ao conteúdo citado, apresentando novos conceitos para que você possa incrementar a sua aplicação. Neste tutorial você aprenderá como a monitorar as informações de seu Arduino, como por exemplo, temperatura, através de um navegador com o auxilio de um Servidor Web implementado com o Shield Ethernet W5100
É importante, para o pleno entendimento desse tutorial, que o leitor tenha lido o tutorial anterior: Shield Ethernet W5100 - Criando um Servidor Web com Arduino
[toc]
Mãos à obra - Monitorando sensores com um Servidor Web
Nesta seção iremos demonstrar todos os passos que você deve seguir para aprender a monitorar sensores com um Servidor Web. De maneira mais específica, vamos desenvolver um projeto em que o usuário consiga monitorar valores de temperatura provenientes de um sensor LM35 (não esqueça de conferir nosso tutorial sobre o sensor de temperatura LM35 clicando aqui) e também o estado de um botão, ou seja, se o mesmo está pressionado ou não.
Componentes necessários
Para reproduzir este projeto, você irá precisar dos seguintes componentes:
- 1 x Arduino UNO Rev 3
- 1 x Shield Ethernet Wiznet W5100
- 1 x Sensor de temperatura LM35
- 1 x Resistor 150 Ω
- 1 x Resistor 10k Ω
- 1 x Push-button
Montando o projeto
Na figura abaixo você pode conferir o hardware pronto para ser utilizado.
Gostaríamos de sugerir que você tenha bastante cuidado no momento em que for encaixar o Shield Ethernet W5100 no Arduino UNO, pois, além da possibilidade de entortar os pinos do shield, você também pode se machucar.
Lembre-se que o shield em questão possui uma série de pinos em sua parte inferior, tanto nas laterais como em sua parte dianteira, portanto, antes de pressionar o mesmo sobre o Arduino UNO, certifique-se de que os pinos estejam levemente posicionados em suas respectivas entradas para que então você possa ir realizando o encaixe lentamente.
Realizando as conexões
Para reproduzir este projeto, garanta que o seu Shield Ethernet W5100 esteja ligado corretamente a uma das portas LAN presentes no seu modem ou roteador.
Programando
Este programa foi elaborado a partir do código-exemplo da biblioteca Ethernet.h denominado WebServer.
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 25, 16);
EthernetServer server(80);
void setup()
{
pinMode(5,INPUT);
Ethernet.begin(mac, ip);
server.begin();
}
void loop() {
EthernetClient client = server.available();
if (client)
{
boolean currentLineIsBlank = true;
while (client.connected())
{
if (client.available())
{
char c = client.read();
if (c == '\n' && currentLineIsBlank) {
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("Refresh: 2");
client.println();
client.println("<!DOCTYPE html>");
client.println("<html>");
client.println("<head>");
client.println("<title>Servidor Web VDS</title>");
client.println("</head>");
client.println("<body>");
client.println("<h1><font color=#4279c7>Servidor Web do Vida de Silício</font></h1>");
client.println("<hr/>");
client.println("<h1>Temperatura</h1>");
porta_analogica(client);
client.println("<br/>");
client.println("<h1>Entrada digital</h1>");
porta_digital(client);
client.println("</body>");
client.println("</html>");
break;
}
if (c == '\n')
{
currentLineIsBlank = true;
}
else if (c != '\r')
{
currentLineIsBlank = false;
}
}
}
delay(1);
client.stop();
}
}
void porta_analogica(EthernetClient client_aux)
{
client_aux.print("LM35:");
int valor = analogRead(A0);
float temperatura = (((valor*5)/1023)-0.5)*100;
if(temperatura >=50)
{
client_aux.println("<font color=#FF0000>");
client_aux.println(temperatura);
client_aux.println("graus");
client_aux.println("</font>");
}
else
{
client_aux.println("<font color=#000000>");
client_aux.println(temperatura);
client_aux.println("graus");
client_aux.println("</font>");
}
}
void porta_digital(EthernetClient client_aux)
{
client_aux.print("Pino digital 5:");
bool valor = digitalRead(5);
if(valor == HIGH)
{
client_aux.println("<font color=#FF0000> Ligado</font>");
}
else
{
client_aux.println("<font color=#000000> Desligado</font>");
}
}
Colocando para funcionar
Veja como ficou nosso segundo Servidor Web.
Entendendo a fundo
Antes de começarmos com a explicação do código, gostaríamos de ressaltar que iremos apresentar os detalhes apenas dos tópicos não contemplados no tutorial anterior, pois, desta maneira, será mais fácil focar nas partes referentes às atualizações feitas sobre o programa já existente, portanto, caso você tenha alguma dúvida sobre alguma parte do programa que não seja explicada neste momento, sugerimos que acesse o nosso material citado anteriormente.
Software
- Definindo os pré-requisitos para o funcionamento do código
Inicialmente, devemos incluir duas bibliotecas no código para que o mesmo pudesse funcionar corretamente. A biblioteca SPI.h, responsável pela comunicação dos módulos do shield com o Arduino UNO utilizando o protocolo SPI e a biblioteca Ethernet.h que atua possibilitando a conexão do conjunto, em um primeiro momento, com uma rede local.
Após a inclusão das bibliotecas citadas, devemos definir um endereço MAC (lembre-se que este pode ser qualquer um, desde que seja único em sua rede local) e um endereço IP (este deve ser um endereço válido e disponível dentro da sua rede local). Além disso, devemos criar o objeto que será responsável por representar o Servidor Web no código (aqui, chamamos este de server) e relacioná-lo com a porta 80.
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 25, 16);
EthernetServer server(80);
- Definindo as configurações iniciais
Dentro da função setup(), devemos determinar o modo de operação do pino digital que será utilizado (este terá o papel de uma entrada digital) . Além disso, iniciamos a conexão com a rede local através da função Ethernet.begin() (passando como parâmetro os endereços MAC e IP definidos anteriormente) e também iniciamos o Servidor Web por meio da sentença server.begin() (lembre-se que server é o objeto criado para representar o Servidor Web no código).
void setup()
{
pinMode(5,INPUT);
Ethernet.begin(mac, ip);
server.begin();
}
- Criando a página para responder à requisição do navegador
No artigo anterior foi possível compreender como devemos proceder para elaborar uma página bem simples, contendo apenas elementos escritos e também estáticos, ou seja, que não sofriam nenhum tipo de alteração. Neste momento, iremos incrementar o programa criado anteriormente, portanto, vamos deixar de lado a parte referente ao processo de requisição do navegador (já explicado) e iremos focar apenas na elaboração da página que cumpra o objetivo proposto neste material.
Você se lembra do cabeçalho padrão que enviamos para o navegador antes de enviarmos a página propriamente dita? Para ajudar, vamos colocá-lo aqui.
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println();
Definindo tempo de atualização da página
A primeira modificação que faremos neste momento será a inclusão de uma linha de código que faça com que a página seja atualizada em intervalos de tempo definidos. Isto é importante para este projeto em virtude de estarmos trabalhando com aquisição de variáveis, portanto, devemos atualizar a página periodicamente para que seja possível visualizarmos sempre os valores atuais das variáveis envolvidas. Sendo assim, utilizamos a seguinte sentença para que a página seja atualizada de 2 em 2 segundos.
client.println("Refresh: 2");
Veja como ficará o nosso cabeçalho padrão
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("Refresh: 2");
client.println();
A estrutura da página em HTML
O próximo passo que faremos será construir, de fato, a página que será enviada ao navegador. Com uma breve recapitulação, devemos lembrar que todo conteúdo que compõe a página deve estar dentro da seguinte estrutura:
client.println("<!DOCTYPE HTML>");
client.println("<html>");
.
.
***** Conteúdo da página *****
.
.
client.println("</html>");
Como ressaltado anteriormente, dentro desta estrutura temos o conteúdo da página que queremos enviar para o navegador, de modo que, nesta, devemos ter pelo menos dois blocos, um responsável pelas informações gerais do documento, limitado pelo uso do par <head></head> e o outro, por sua vez, deve conter o corpo da página e está entre as tags <body> e </body>.
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
.
.
***** Bloco 1 *****
.
.
client.println("</head>");
client.println("<body>");
.
.
***** Bloco 2 *****
.
.
client.println("</body>");
client.println("</html>");
Definido o título para a página
Neste momento, vamos utilizar apenas uma tag dentro do bloco 1, denominada <title>, cuja função consistirá em definir um título para a página (este título aparecerá na aba do navegador). Para executarmos a ação proposta, devemos colocar o título desejado entre o par <title></title>.
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
client.println("<title>Servidor Web VDS</title>");
client.println("</head>");
client.println("<body>");
.
.
***** Bloco 2 *****
.
.
client.println("</body>");
client.println("</html>");
Veja como ficou o título da nossa página:
Escrevendo o corpo da página web
Quanto ao corpo da página (entre o par <body></body>), a primeira coisa que faremos será colocar um título visível na própria página. Para realizar este procedimento, utilizaremos a tag <h1>, que por sua vez, consiste em uma tag para apresentar um determinado texto em um modelo predefinido. Além disso, utilizaremos também a tag <font>, através da qual, poderemos fazer alterações no título produzido.
client.println("<h1><font color=#4279c7>Servidor Web do Vida de Silício</font></h1>");
Alguns pontos no trecho de código acima devem ser ressaltados:
- Tudo que estiver escrito entre o par <h1></h1> estará pré formatado no estilo deste cabeçalho.
- A tag <font> é responsável por modificar algum atributo relativo à formatação de uma determinada porção de texto. Para isto, devemos colocar o nome do atributo que queremos modificar, após a palavra font (apenas na tag de abertura), sendo assim, quando escrevemos <font color=#4279c7>, estamos indicando que a porção de texto entre o par <font color=#4279c7></font> deverá está colorida em um certo tom de azul (dado pelo código RGB em hexadecimal #4279c7).
- Repare que a palavra Silício foi escrita no código como Silício. Esta forma de escrita é necessária sempre que temos a utilização de algum tipo de acento, pois, nem todos os dispositivos estão configurados para apresentar caracteres acentuados da mesma forma. Sendo assim, utilizamos o comando í para colocar o acento agudo na letra i da palavra Silício.
Veja o resultado deste procedimento na figura abaixo:
Posteriormente, vamos inserir uma barra horizontal para separar o título criado no passo anterior dos textos que ainda serão criados, através do comando <hr/>.
client.println("<hr/>");
Após a inserção da barra citada, nossa página ficará da seguinte maneira:
Imprimindo a tempertatura
Em seguida, escrevemos outro texto utilizando o modelo de cabeçalho h1 referente ao valor que será obtido pelo sensor de temperatura LM35.
client.println("<h1>Temperatura</h1>");
Com este passo, a página será apresentada assim:
O próximo passo consiste em apresentar o valor de temperatura obtido através da conversão do sinal proveniente do sensor de temperatura utilizado. Obviamente, existem várias formas de fazer isso, no entanto, nós criamos uma função própria para isso, chamada porta_analogica() e passamos a variável client como parâmetro da mesma.
porta_analogica(client);
A função porta_analogica() será responsável por fazer a aquisição do valor de tensão na porta analógica A0 proveniente do sensor de temperatura LM35. Repare que nesta função utilizamos um conjunto if()/else para testar se o valor de temperatura é superior a um determinado valor, de modo que, caso seja, apresentaremos este valor na cor vermelha e caso não seja, na cor preta.
void porta_analogica(EthernetClient client_aux)
{
client_aux.print("LM35:");
int valor = analogRead(A0);
float temperatura = (((valor*5)/1023)-0.5)*100;
if(temperatura >=50)
{
client_aux.println("<font color=#FF0000>");
client_aux.println(temperatura);
client_aux.println("graus");
client_aux.println("</font>");
}
else
{
client_aux.println("<font color=#000000>");
client_aux.println(temperatura);
client_aux.println("graus");
client_aux.println("</font>");
}
}
A apresentação do valor de temperatura ficará conforme a figura abaixo:
Imprimindo o estado da entrada digital - Botão
Após chamar a função porta_analogica(), utilizamos o comando <Br/> para fazer com que a próxima sentença utilizada na construção da página ocorra na próxima linha da tela.
client.println("<br/>");
Neste momento escrevemos um outro texto utilizando o modelo de cabeçalho h1. Este irá definir o título da seção em que o estado do botão será apresentado.
client.println("<h1>Entrada digital</h1>");
Confira em que estágio nossa página está:
Por fim, chamamos a função porta_digital() cuja função consiste realizar os procedimentos necessários para apresentar o estado da nossa variável digital. Repare que, assim como na função porta_analogica(), também passamos a variável cliente como parâmetro.
porta_digital(client);
No bloco de código abaixo demonstramos o funcionamento da função porta_digital(), que por sua vez, apresentará a palavra Ligado, na cor vermelha, caso o botão esteja pressionado e a palavra Desligado, na cor preta, caso o botão esteja solto
void porta_digital(EthernetClient client_aux)
{
client_aux.print("Pino digital 5:");
bool valor = digitalRead(5);
if(valor == HIGH)
{
client_aux.println("<font color=#FF0000> Ligado</font>");
}
else
{
client_aux.println("<font color=#000000> Desligado</font>");
}
}
Veja o nosso resultado final:
Os procedimentos citados anteriormente servem para elaborar a página que será exibida no navegador em resposta a requisição feita pelo mesmo, de modo que, caso você queira entender partes do código externas ao que foi apresentado, verifique nosso primeiro tutorial.
Considerações finais
Neste tutorial, demonstramos como você monitorar as variáveis envolvidas no seu projeto, em uma página criada para ser exibida no seu navegador, utilizando um Arduino UNO e um Shield Ethernet W5100. Esta foi a segunda parte de uma série de artigos sobre a criação de Servidores Web, portanto, esperamos que 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 umidade do solo com Arduino - Higrômetro
Sensor de umidade do solo com Arduino - Higrômetro
Neste tutorial daremos o primeiro passo para desenvolver um sistema inteligente voltado para o monitoramento e controle das variáveis existentes em uma plantação. Começaremos aprendendo como usar o sensor de umidade do solo, também chamado de Higrômetro, em conjunto com um Arduino Nano.
[toc]
Sistemas automáticos na Agricultura
Plantas precisam de um solo de boa qualidade para crescerem de forma saudável e com qualidade, porém, existem vários tipos de situações ambientais que dificultam o seu crescimento, sendo algumas delas:
- Irradiação solar excessiva;
- Falta de nutrientes no solo;
- Solo com baixa umidade;
- Pragas;
- Entre outros.
Todas as situações descritas anteriormente podem gerar prejuízo. Por este motivo, faz-se necessária a utilização de, sistemas automáticos os quais vêm sendo cada vez mais explorados que auxiliem o agricultor no monitoramento de seus cultivos visando obter uma eficiência cada vez maior e consequentemente a redução da ocorrência de situações indesejadas
Sensor umidade do solo - Higrômetro
Neste tutorial, iremos utilizar o sensor de umidade do solo, para aferir a condutividade do solo através de uma haste com dois eletrodos existentes no mesmo. O princípio de funcionamento deste circuito é bem simples, pois, resume-se ao fato de que, através da aplicação de uma determinada corrente X nos eletrodos citados, é possível estimar o quão úmido ou seco o solo estará em virtude da condutividade do solo em ambos os casos. Basicamente, quando o solo estiver úmido, teremos uma condutividade melhor devido a absorção da água e isso resultará em um fluxo maior de corrente entre os dois eletrodos. Entretanto se o solo estiver seco, teremos pouca ou até nenhuma corrente entre os eletrodos.
O sensor é composto basicamente duas hastes que ficaram presas ao solo que iremos monitorar e um circuito comparador que irá nos retornar o nível de condutividade do solo. Este circuito é composto por um total de 6 pinos, sendo dois destes utilizados para conectar a haste de metal ao circuito de comparação. As outras 4 entradas possuem as funções de alimentar o circuito e retornar o nível de umidade do solo.
A determinação do nível de umidade do solo pode ser feita de duas formas, sendo elas:
- Um sinal digital que basicamente informa se o solo está seco ou não ( Menor precisão, porém não depende de um circuito ADC )
- Um sinal analógico que pode ser utilizado para estimar o quão úmido o solo está ( Maior precisão, porém dependerá de um circuito ADC )
Especificações do dispositivo
- Tensão de Operação: 3,3-5v
- Sensibilidade ajustável via potenciômetro
- Saída Digital TTL (D0) e Analógica(A0)
- Led indicador de detecção de umidade
Mãos à Obra - Medindo a umidade do solo utilizando o Arduino - Higrômetro
Componentes utilizados
Montando o projeto
Nesta primeira parte do tutorial, iremos apenas conectar o sensor de umidade, desta forma, iremos utilizar o seguinte esquema de ligação:
A montagem final do nosso sistema deve ser semelhante ao modelo abaixo
Veja só como ficou o nosso sistema inicial.
Antes de ligar o seu circuito, verifique se todas as conexões foram feitas corretamente. Um curto circuito causado por uma ligação errada pode danificar todo o seu projeto.
Programando
Com a parte física do nosso projeto montada, iremos agora partir para a parte de codificação do sistema. Nesta primeira versão não iremos utilizar nenhuma biblioteca em especial, porém iremos utilizar funções para leitura de dados analógicos e também iremos construir o nosso sistema de leituras de uma forma um pouco diferente como pode ser visto no código abaixo:
/* Nome: Sistema de aferição de umidade de solo - Higrômetro
* Feito por: Danilo Almeida
* Data: 7/11/2017
*/
#define sensorUmidade A0 // Sensor de umidade de solo do módulo
unsigned long tempoAnterior = 0; // Variável utilizada para guardar o tempo anterior
unsigned long intervalo = 1000; // Intervalo de tempo em MS para cada leituraa
void setup() {
Serial.begin(9600); // Inicialização da comunicação serial
}
void loop() {
unsigned long tempoAtual = millis(); // Realizamos a leitura atual do tempo em que o nosso Arduino Nano está ligado
if (tempoAtual-tempoAnterior > intervalo){ // Pequena lógica para realizar leituras temporizadas sem parar o microcontrolador
tempoAnterior =tempoAtual; // Guardamos o tempo anterior como o ultimo intervalo de tempo lido
int leitura = analogRead(sensorUmidade); // Leitura dos dados analógicos vindos do sensor de umidade de solo
if (leitura<=1023 && leitura>=682){ // Se a leitura feita for um valor entre 1023 e 682 podemos definir que o solo está com uma baixa condutividade, logo a planta deve ser regada
Serial.println("Nível de Umidade Baixo");
}else{
if (leitura<=681 && leitura>=341){ // Se a leitura feita for um valor entre 681 e 341 podemos definir que o solo está com um nível médio de umidade, logo dependendo da planta pode ou não ser vantajoso regar
Serial.println("Nível de Umidade Médio");
}
else{
if (leitura<=340 && leitura>=0){ // Se a leitura feita for um valor entre 0 e 340 podemos definir que o solo está com um nível aceitável de umidade, logo talvez não seja interessante regar neste momento
Serial.println("Nível de Umidade Alto");
}
}
}
}
}
Entendendo a Fundo
Software
- Definições e variáveis utilizadas no projeto
Inicialmente definimos todas as variáveis que iremos utilizar tanto para controlar as leituras que serão efetuadas quanto para realizar a leitura da entrada analógica do sistema. Neste trecho de código definimos as variáveis intervalo, tempoAnterior e criamos uma definição para o pino A0 do Arduino com o nome de sensorUmidade.
#define sensorUmidade A0 // Sensor de umidade de solo do módulo unsigned long tempoAnterior = 0; // Variável utilizada para guardar o tempo anterior unsigned long intervalo = 1000; // Intervalo de tempo em MS para cada leitura
- Função Setup - Inicialização da comunicação serial
Nesta primeira versão, iremos apenas verificar o nível de umidade do solo e com base nesta medição informar se o solo está úmido ou não. Para isso iremos utilizar a comunicação serial. Logo neste trecho de código basicamente inicializamos a comunicação serial do nosso Arduino.
void setup() {
Serial.begin(9600); // Inicialização da comunicação serial
}
- Função Loop - Usando a função millis para contar o tempo
Nossa função loop tem como objetivo realizar o processo de leitura dentro de cada intervalo de tempo definido na variável intervalo, porém diferente de como fazemos na maioria das implementações, não iremos utilizar o comando delay para sincronizar cada leitura realizada. Isso ocorre pois o comando delay "congela" o microcontrolador o impedindo de executar outras ações, como por exemplo ler um outro sensor, ou receber dados da porta serial. Com isso neste projeto iremos utilizar a função millis para sincronizar as leituras e não "congelar"o microcontrolador, possibilitando assim com que ele faça outras tarefas enquanto aguarda o tempo de realizar uma nova leitura.
O processo de sincronizar a leitura de forma não bloqueante é feito de uma maneira bem simples:
- Inicialmente armazenamos o tempo atual ( que é retornado pela função millis ).
unsigned long tempoAtual = millis(); // Realizamos a leitura atual do tempo em que o nosso Arduino Nano está ligado
- Com o tempo atual do microcontrolador armazenado, iremos agora realizar uma operação de subtração entre o tempo atual lido e o último tempo que armazenamos.
if (tempoAtual-tempoAnterior > intervalo)
- Se a subtração entre o tempo atual do microcontrolador e o último tempo armazenado for maior que o intervalo de tempo para cada leitura, significa que já é hora de realizar a leitura desejada, porém antes devo atualizar o meu tempo anterior já que realizei uma leitura.
tempoAnterior =tempoAtual; // Guardamos o tempo anterior como o ultimo intervalo de tempo lido
- Recomeçamos o processo no passo 1
- Leitura do nosso medidor de umidade de solo
Agora iremos realizar a leitura do nosso sensor de umidade de solo através da porta A0, esta leitura é feita através da função analogRead como mostra o código abaixo:
int leitura = analogRead(sensorUmidade); // Leitura dos dados analógicos vindos do sensor de umidade
Esta função basicamente retorna um valor numérico entre 0 e 1023, que representa o valor tem Volts lido do sensor de umidade. O valor está entre 0 e 1023 devido a resolução do circuito ADC que já vem integrado ao Arduíno, se você precisar de uma resolução maior, pode também utilizar circuitos ADC's dedicados.
- Tomada de decisão baseada no valor medido pelo sensor de umidade
Já por fim ( porém não menos importante ), iremos mostrar através da porta serial, em qual intervalo de valores a sua leitura está contida. Para isso, basicamente dividimos o valor da resolução máxima do circuito ADC do Arduino 1024 valores por três, o que resulta em três estados chamados: umidade baixa, umidade média, umidade alta.
if (leitura<=1023 && leitura>=682){ // Se a leitura feita for um valor entre 1023 e 682 podemos definir que o solo está com uma baixa condutividade, logo a planta deve ser regada
Serial.println("Nível de Umidade Baixo");
}else{
if (leitura<=681 && leitura>=341){ // Se a leitura feita for um valor entre 681 e 341 podemos definir que o solo está com um nível médio de umidade, logo dependendo da planta pode ou não ser vantajoso regar
Serial.println("Nível de Umidade Médio");
}
else{
if (leitura<=340 && leitura>=0){ // Se a leitura feita for um valor entre 0 e 340 podemos definir que o solo está com um nível aceitável de umidade, logo talvez não seja interessante regar neste momento
Serial.println("Nível de Umidade Alto");
}
}
}
Desafio
Agora que temos o nosso projeto montado e funcionando tente melhorar um pouco o nível de medição do sistema. Divida o valor máximo do conversor ADC por um valor maior que três e crie mais ifs para que você seja capaz de identificar melhor o nível de umidade do solo.
Considerações Finais
Este tutorial teve como objetivo apresentar e ilustrar o funcionamento do sensor de umidade do solo, que por sua vez, tem uma aplicação bastante interessante e importante que é identificar em qual momento uma planta deve ser regada, para que dessa forma ela tenha uma qualidade de vida melhor e seja capaz de produzir e aumentar a qualidade de sua produção. Como dito anteriormente, este projeto será uma série onde iremos construir um sistema de monitoramento em tempo real do solo e do ambiente onde nossa plantação está. Espero que tenham gostado do conteúdo apresentado, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
SCT-013 - Sensor de Corrente Alternada com Arduino
SCT-013 - Sensor de Corrente Alternada com Arduino
Neste tutorial ensinaremos a você como medir corrente alternada e estipular a potência instantânea de um circuito utilizando o Sensor de corrente alternada não invasivo SCT-013 juntamente com Arduino. Para este projeto, iremos medir a corrente e a potência de um ferro de solda.
Esse tutorial é dividido em três partes.
- Introdução: Nessa parte você conhecerá um pouco mais o sensor SCT013
- Mãos à obra: Aqui você aprenderá a usar o Sensor de corrente SCT-013 na prática
- Entendendo a fundo: Por fim você entenderá como funciona o software e hardware usado na experiência da parte 2
[toc]
Sensor de corrente não invasivo SCT-013
O sensor de corrente SCT-013 é muito versátil e tem como principal vantagem o fato de não precisar de contato elétrico com o circuito para medir a corrente elétrica alternada. Ou seja, não precisamos abrir o circuito para ligá-lo em série com a carga, basta apenas "abraçar" um dos fios ligados ao equipamento a ser monitorado.
Um pouco de física
Para fazer a medição da corrente sem a necessidade de contato elétrico com o circuito esse sensor de corrente alternada utiliza as propriedades magnéticas da corrente elétrica.
- Lei de Ampère
A Lei de Ampère diz que todo condutor por onde flui uma corrente elétrica induz ao seu redor um campo magnético proporcional à corrente.
- Corrente Alternada
A corrente alternada tem uma peculiaridade de se comportar como uma senoide, sendo assim sua intensidade varia ao longo do tempo indo do máximo positivo ao máximo negativo. Esse comportamento oscilatório tem uma frequência que pode ser de 50Hz ou de 60Hz conforme o país ou região. No Brasil é adotado a frequência de 60Hz, ou seja: a corrente elétrica varia entre positivo e negativo 60 vezes em 1 segundo.
Como o campo magnético é proporcional ao valor de corrente, o campo magnético gerado ao redor do condutor percorrido por uma corrente alternada irá variar ao logo do tempo conforme a variação da mesma.
- Lei de Faraday - lei da indução eletromagnética
A lei de Faraday diz que um campo magnético que varia ao longo do tempo induz em uma espira uma força eletromotriz que gera um corrente elétrica proporcional a intensidade do campo magnético.
Na figura acima podemos entender essa lei na prática. Veja que ao aproximar o imã das espiras estamos variando o campo magnético e está sendo indicado uma tensão no voltímetro (força eletromotriz) chegando quase a 20V. Depois, ao afastar o imã temos a tensão indo quase a 20V no sentido contrário.
- Resumo
- Lei de Ampère: Um condutor percorrido por uma corrente induz a formação de um campo magnético ao seu redor de valor proporcional à corrente;
- Corrente Alternada: A corrente alternada varia ao longo do tempo gerando um campo magnético também variante ao longo do tempo;
- Lei da indução de Faraday: Um campo magnético variante no tempo induz numa espira uma tensão, e por consequência um corrente elétrica, proporcional à intensidade do campo magnético
Levando em conta essas três propriedades, podemos montar um transformador de corrente.
Transformadores de corrente
Existe uma grande gama de sensores de corrente que usam essas propriedades magnéticas. Esse sensores são conhecidos com TC (Transformador de Corrente), que em inglês é CT (Current Transformer).
Um transformador de corrente, nada mais é que um conjunto de espiras que são colocadas ao redor de um condutor ao qual queremos medir a corrente. O transformador de corrente (TC) terá em seus polos uma corrente alternada induzida Is, que é proporcional a corrente alternada Ic que percorre o condutor ao qual pretendemos medir a corrente elétrica.
A corrente induzida no TC também será inversamente proporcional ao número de espiras de sua bobina.
Esse sensores são divididos em 2 modelos: Os split-core (núcleo dividido) e os solid-core (núcleo sólido).
Transformador de corrente SCT-013
SCT é a sigla para Split-core Current Transformer, ou seja, Transformador de corrente de núcleo dividido. Para fazer fazer a medição da corrente elétrica o SCT-013 possui uma bobina interna em sua estrutura, como podemos ver na figura abaixo.
Podemos ver essa bobina com mais detalhes na foto a seguir
O circuito é bem simples:
- Os Modelos de SCT-013
Com base nesse princípio de funcionamento, foram criados diferentes tipos de sensores não-invasivos, como pode ser observado em seu datasheet, com o objetivo de atenderem os mais diversos cenários, de forma que não exista um "melhor", mas sim o mais recomendado para a aplicação recorrente.
As duas principais diferenças são a Corrente eficaz máxima a ser medida (Input current) - e o Tipo de saída do sensor (Output type).
É possível observar que somente o modelo SCT-013-000 apresenta uma variação de corrente em sua saída de 0-50mA, já os outros modelos apresentam uma variação tensão de 0-1V, onde por meio destas variações é possível mensurar a corrente elétrica.
Para sabermos qual será a taxa variação tanto de corrente quanto de tensão basta dividirmos o valor máximo da saída pelo valor máximo a ser medido. Abaixo temos alguns exemplos deste cálculo:
- SCT-013-000:
- 0,05 / 100 = 0,5mA. A cada um Ampere a mais ou a menos, sua saída será de 0,5mA para mais ou a menos;
- SCT-013-005:
- 1 / 5 = 0,2V. A cada um Ampere a mais ou a menos, sua saída será de 0,2V para mais ou a menos;
- SCT-013-050:
- 1 / 50 = 0,02V. A cada um Ampere a mais ou a menos, sua saída será de 0,02V para mais ou a menos.
- SCT-013-000 - 100A / 0-50mA
Para esse tutorial usaremos o SCT-013-000. Ele poder medir valores de 0 até 100A de corrente alternada. Em sua saída teremos valores entre 0 a 50mA proporcionais ao valor de corrente percorrido no condutor principal.
Como nosso Arduino só lê valores de tensão, iremos precisar montar um circuito auxiliar para que essa corrente percorra um resistor e assim possamos converter os valores de correntes gerado pelo sensor em valores de tensão. Explicaremos o passo a passo de como dimensionar esse circuito no tópico Entendendo o Hardware.
Mãos à Obra - Monitorando a corrente AC com o Sensor de corrente SCT-013
Componentes necessários
Serão necessários os seguintes componentes para a execução deste projeto:
- 1 x Placa Arduino;
- 1 x Sensor de corrente SCT-013 100A;
- 1 x Protoboard;
- 2 x Resistores de 10kΩ;
- 1 x Resistor de 330Ω;
- 1 x Capacitor eletrolítico de 100uF;
- Jumpers;
Utilizaremos o SCT-013 100A e o Arduino Uno, além de um aparelho que terá sua corrente elétrica medida, no nosso caso, um ferro de solda. Você poderá medir a corrente elétrica de outros dispositivos.
O resistor de 330Ω foi dimensionado por meio de uma sequência de cálculos com o propósito de aumentar a precisão das medidas deste sensor de corrente. Os cálculos poderão ser visto na sessão "Entendendo o SCT-013".
*Caso o seu SCT-013 seja de outro modelo ao invés de 100A, o passo a passo será diferente.
Montando o projeto
Esse sensor de corrente normalmente vem com um plugue P2 do tipo macho em sua ponta. Para esse tutorial nós removemos ele e conectamos os dois fios presentes no interior do cabo diretamente na protoboard. Caso você não queira remover o plugue P2, recomendamos que você adquira um plugue P2 do tipo fêmea para poder utilizar esse sensor de corrente.
Com os componentes em mãos, montaremos o seguinte circuito na protoboard:
Após realizar esta montagem, é necessário conectar o SCT-013 ao condutor por onde a corrente elétrica a ser medida passará.
AVISO: Não conecte este sensor de corrente de acordo com a imagem abaixo, pois não será possível medir a corrente elétrica. A explicação do por quê será feita mais abaixo.
Como a corrente elétrica produz campo magnético conforme seu sentido e o sentido da corrente em um fio é o oposto ao sentido do outro fio, os campos magnéticos produzido pelos dois acabam se anulando. Se não há campo magnético, não há indução magnética no transformador do sensor de corrente, fazendo com que não circule a corrente Is necessária para a medição da corrente Ic consumida. Por esse motivo não podemos conectar este sensor aos dois fios de alimentação.
Com isso finalizamos o hardware do nosso projeto. Agora, bora programar!
Programando
- Bibliotecas necessária
É necessário baixar a biblioteca EmonLib (download). Após baixar, descompacte e mova para a pasta libraries da IDE do Arduino. A EmonLib será utilizada para nos auxiliar a calcular o valor da corrente elétrica consumida.
- Código utilizado
Para sabermos quantos Amperes estão passando pelo condutor, basta realizar a seguinte programação:
#include "EmonLib.h"
EnergyMonitor SCT013;
int pinSCT = A0; //Pino analógico conectado ao SCT-013
int tensao = 127;
int potencia;
void setup()
{
SCT013.current(pinSCT, 6.0606);
Serial.begin(9600);
}
void loop()
{
double Irms = SCT013.calcIrms(1480); // Calcula o valor da Corrente
potencia = Irms * tensao; // Calcula o valor da Potencia Instantanea
Serial.print("Corrente = ");
Serial.print(Irms);
Serial.println(" A");
Serial.print("Potencia = ");
Serial.print(potencia);
Serial.println(" W");
delay(500);
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Serial.println(".");
delay(500);
}
Após compilar e enviar o código ao Arduino, os valores de corrente elétrica e potência instantânea serão mostrados no Monitor Serial da IDE do Arduino, e serão atualizados a cada 2 segundos.
Colocando para funcionar
Código compilado e circuito montado! Veja abaixo o resultado.
Entendendo a fundo
Software
– Incluindo as bibliotecas a serem utilizadas no projeto
Inicialmente, observe que foi necessário incluir uma biblioteca no código para que o mesmo pudesse funcionar corretamente. A biblioteca EmonLib.h é a responsável por realizar os cálculos para encontrar o valor eficaz da corrente a ser medida, baseando-se nas amostras colhidas no pinSCT.
#include "EmonLib.h"
– Declarando o objeto SCT013
Em seguida, cria-se um objeto que será utilizado posteriormente para representar o sensor de corrente SCT-013 no código.
Lembre-se: SCT013 é apenas um nome, sendo assim, é importante ressaltar que este objeto poderia ser chamado por qualquer outro nome, como por exemplo, sensorSCT.
EnergyMonitor SCT013;
– Definindo as configurações iniciais
Declaramos pinSCT = A0 para poder facilitar e tornar intuitivo o uso da porta analógica do arduino.
int pinSCT = A0; //Pino analógico conectado ao SCT-013
Declaramos duas variáveis, uma chamada Tensao, e atribuímos o valor de 127, que equivale a tensão da rede aqui no nosso estado, e outra chamada Potencia, que será utilizada para reservar o resultado da multiplicação da tensão e da corrente.
int tensao = 127; int potencia;
No void setup(), chamamos a função SCT013.current(pinSCT, 6.0606) da biblioteca EmonLib, para que seja realizado o cálculo do valor eficaz da corrente, onde ele se baseará nas amostras lidas do pinSCT, e é empregado um valor de calibração de 6.0606 que ensinaremos como encontra-lo mais abaixo.
SCT013.current(pinSCT, 6.0606);
Habilitamos também a comunicação serial entre o arduino e o computador por meio do comando Serial.begin(9600).
Serial.begin(9600);
Caso você tenha dúvidas sobre como utilizar a comunicação serial do arduino, recomendamos que veja o tutorial Comunicação Serial Arduino (clique aqui), presente no portal.
– Aquisição do valor de corrente
Na função void loop(), utiliza-se primeiramente a função SCT013.calcIrms() para atribuir o valor de corrente à variável Irms. O valor entre parênteses representa o número de amostras que a função irá ler do pinSCT.
double Irms = SCT013.calcIrms(1480);
Veja que SCT013 é o nome que definimos para o objeto. Para usar uma função ligada a esse objeto, colocamos seu nome seguido de ponto e o nome da função. Ex: nomeobjeto.calcIrms().
- Cálculo da potência instantânea
Por meio da multiplicação da corrente Irms pela tensão estipulada, conseguimos descobrir a potência do dispositivo.
potencia = Irms * tensao;
Em seguida imprimimos o valor de corrente e da potência no monitor serial:
Serial.print("Corrente = ");
Serial.print(Irms);
Serial.println(" A");
Serial.print("Potencia = ");
Serial.print(potencia);
Serial.println(" W");
Esperamos um tempo para a próxima medição.
delay(500);
Serial.print(".");
delay(500);
Serial.print(".");
delay(500);
Serial.println(".");
delay(500);
Hardware
- Corrente gerada pelo sensor
O sensor é calibrado para medir a corrente alternada máxima de 100A AC. Esse valor de 100A é o valor RMS, que também é chamado de valor eficaz. O valor RMS é igual ao máximo valor que a corrente pode alcançar (corrente de pico) dividido pela raiz quadrada de dois.
Então, temos que a corrente de pico máxima medida é de 141.4A:
i (medido) = √2 * i (rms) = 1,414 * 100A = 141,4 A
Sabendo que para uma corrente de 100A no primário, ele produz 50mA no secundário, é só jogarmos na fórmula de relação de transformação. O resultado será:
N1 / N2 = I2 / I1
- I1 = corrente no primário (corrente a ser medida);
- I2 = corrente no secundário;
- N1 = número de votas do primário (no caso deste sensor, N1 será igual a 1);
- N2 = número de voltas do secundário.
N2 = 2000 espiras.
A corrente na saída do sensor é inversamente proporcional ao número de voltas (aqui é 2000):
i (sensor) = i (medido) / numero_de_espiras = 141,4A / 2000 = 0,0707A
Teremos na saída do sensor o sinal da corrente induzida semelhante ao da figura a seguir:
- Transformando corrente em tensão - Calculando a resistência de carga
O Arduino UNO só realiza, em seus pinos de entrada analógica, a leitura de níveis de tensão (entre 0V a 5V). Dessa forma, precisamos converter o sinal de corrente alternada do SCT-013 para um valor de tensão que seja legível para o Arduino.
O primeiro passo é adicionar um resistor de carga entre os polos do sensor de corrente:
Como a corrente alterna em torno de zero, vamos escolher um resistor que de na saída um valor máximo de tensão de 2,5V.
R(carga) = U(sensor)/I(sensor) = 2,5V / 0,0707A = 35,4Ω
O resistor de carga ideal é de 35,4Ω para uma corrente de até 100A, nesse caso usariamos um resistor de 33Ω. Dessa forma teremos o seguinte sinal de tensão sobre o resistor de carga:
OBS: Para nosso projeto, não iremos medir valores maiores que 10A. Dessa forma, podemos considerar que nossa corrente máxima é 10 vezes menor. Logo:
i (sensor) = i (medido) / numero_de_espiras = 14,14A / 2000 = 0,00707A
R(carga) = U(sensor)/I(sensor) = 2,5V / 0,00707A = 354Ω
Portanto, para nosso projeto adotamos o resistor de 330Ω.
Ou seja, você pode calcular o resistor ideal para a faixa de operação que você precisa. Se for 100A, você pode adotar o de 33Ω, se for de 10A você pode usar um resistor de 330Ω. Para outros valores, basta você calcular.
Seguiremos essa explicação considerando a faixa de operação de 100A, que é o máximo para nosso sensor.
- Convertendo sinal de tensão AC para DC
Agora temos um sinal de tensão alternada variando entre 2,5V positivo e 2,5V negativo. O Arduino não pode medir tensão negativa, então precisamos somar 2,5 V ao sinal para que ele varie entre 0V a 5V.
O primeiro passo para isso é montar um divisor de tensão usando a alimentação de 5V que a placa Arduino fornece. Assim, consideramos R1 e R2 iguais a 10kΩ, e com isso, a tensão sobre eles será igual, pois os 5V provenientes do Arduino se dividirá igualmente entre eles.
Em seguida adicionamos um capacitor entre o GND e a saída de 2,5V no meio do divisor de tensão:
Esse circuito funcionará como uma bateria de 2,5V adicionando essa tensão à fonte AC. Este valor de tensão que acrescentamos a forma de onda é chamado de offset.
Veja como vai fica nosso circuito:
Na figura a seguir mostramos o circuito com seus respectivos sinais:
Como explicado, o circuito de offset funciona como uma fonte tensão de 2,5V DC, somando essa tensão à senoide do SCT-013. O circuito poderia ser ilustrado como a figura a seguir:
- Calibrando o software
Agora que sabemos o sensor carga, modificamos a função SCT013.current onde definimos o pino de entrada e o valor de calibração.
SCT013.current(pinSCT, Valor_de_Calibracao);
Este valor é de calibração, destinado justamente para caso queiramos mudar o valor do resistor de carga. Para descobrir ele, basta dividir o número total de voltas (espiras) do secundário pelo valor do resistor de carga dimensionado:
- Valor_de_Calibração = 2000 / 33
- Valor_de_Calibração = 60,606
Dessa forma, teremos:
SCT013.current(pinSCT, 60,606);
obs: Para nosso projeto prático nosso resistor escolhido foi de 330Ω devido ao fato de trabalharmos com uma faixa de operação de 10A. Dessa forma o valor de calibração usado no projeto prático foi de 6,0606.
Valor_de_Calibração = 2000 / 330 = 6,0606
Mudando o range de medição
Calculamos até aqui o valor de uma resistência de carga e valor de calibração do software que possibilita nosso software medir valores de corrente eficazes de até 100A, que é o máximo valor de projeto do sensor. Só que conforme a aplicação, nunca chegaremos a correntes tão altas. Por isso, podemos calibrar nosso software e circuito para ler valores de máxima corrente distintos, desde que estejam dentro do permitido para esse sensor.
Talvez você tenha percebido inclusive que o valor de resistência encontrado em nossos cálculos (33Ω) foi 10 vezes menor que o usada em nossa experiencia (330Ω). Para nosso projeto adotamos uma corrente máxima de 10A, visto que a maiorias dos eletrodomésticos consomem correntes menores que esse valor.
Para calcular a resistência de carga adequada basta repetirmos os seguintes passos:
- Passo 1 - Escolher a corrente rms máxima que será medida pelo circuito
imax (rms) = 10A
- Passo 2 - Converter esta corrente para o valor de pico:
i (medido) = √2 * imax (rms) = 1,414 * 10A = 14,14 A
- Passo 3 - Descobrir o número total de espiras da bobina do secundário:
Sabendo que para uma corrente de 100A no primário, ele produz 50mA no secundário, é só jogarmos na fórmula de relação de transformação. O resultado será:
N1 / N2 = I2 / I1
- I1 = corrente no primário (corrente a ser medida);
- I2 = corrente no secundário;
- N1 = número de votas do primário (no caso deste sensor, N1 será igual a 1);
- N2 = número de voltas do secundário.
N2 = 2000 espiras.
- Passo 4 - Calcular a corrente de pico máxima do secundário do SCT-013:
i (sensor) = i (medido) / numero_de_espiras = 14,14A / 2000 = 0,00707A
- Passo 5 - Dimensionar o resistor de carga:
R(carga) = U(sensor)/I(sensor) = 2,5V / 0,00707A = 354Ω
Para o projeto, arredondamos este valor para 330Ω, que é um valor comercial de resistor.
R(carga) = 330Ω
- Passo 6 - Colocando o valor de calibração no software:
Agora que sabemos o sensor carga, modificamos a função SCT013.current onde definimos o pino de entrada e o valor de calibração.
SCT013.current(pinSCT, Valor_de_Calibracao);
Este valor é de calibração, destinado justamente para caso queiramos mudar o valor do resistor de carga. Para descobrir ele, basta dividir o número total de voltas (espiras) do secundário pelo valor do resistor de carga dimensionado:
Valor_de_Calibração = N2 / R(carga)
Valor_de_Calibração = 2000 / 330
Valor_de_Calibração = 06,0606
Dessa forma, teremos:
SCT013.current(pinSCT, 6.0606);
Pronto, agora você sabe como adaptar o hardware para o seu projeto.
Desafio
Desenvolva um projeto em que seja possível medir a potência requisitada por um determinado equipamento. Para isto, utilize o sensor de corrente SCT-013 (tratado com detalhes neste material) em conjunto com, por exemplo, o sensor de tensão GBK P8.
Considerações finais
Esperamos que este tutorial tenha esclarecido algumas dúvidas sobre os procedimentos necessários para realizar monitoramento das correntes elétricas utilizadas nos acionamentos dos seus equipamentos. Obrigado pela atenção e continue buscando conhecimento no portal do Vida de Silício.
Sensor de Gás MQ-135 e a Família de sensores MQ
Sensor de Gás MQ-135 e a família MQ de detectores de Gás
O sensor gás MQ-135 é capaz de detectar a concentração de vários gases tóxicos em um ambiente tais como: amônia, dióxido de carbono, benzeno, óxido nítrico e também fumaça ou álcool. Neste tutorial vamos aprender como usa o módulo sensor de gás MQ-135 junto a um Arduino. Esse tutorial também pode ser aplicado para outros sensores de gás, com alguns ajustes, tais como: MQ-2, MQ-3, MQ-4, MQ-5, MQ-6, MQ-7, MQ-8,MQ-9, etc.
[toc]
A importância dos sistemas de proteção
Os processos industriais envolvem o uso e fabricação de substâncias altamente perigosas, especialmente produtos inflamáveis, tóxicos e oxidantes. Os gases fazem parte desses ambientes como participantes de reações, catalisadores ou produtos finais. Outras vezes são resíduos ou subprodutos indesejáveis. Escapes ocasionais de gás ocorrem e criam um perigo potencial para a planta industrial, seus funcionários e pessoas que vivem nas proximidades. Incidentes e acidentes em todo o mundo, envolvendo asfixia, intoxicação, explosões e perdas de vidas é um lembrete constante desse problema.
Por isso, sistemas automáticos de detecção de gases são fundamentais para a proteção das pessoas envolvidas nesses processos. É necessário que tenhamos sensores adequados e que sejam posicionados em lugares estratégicos, de preferência com redundância.
É claro que esse tipo de proteção não se limita a industria. Podemos ver facilmente a aplicação de sensores de gás e fumaça em uma cozinha residencial ou em ambientes públicos. Enfim, podemos usar a automação a favor da vida, evitando assim acidentes.
Sensor de gás MQ
Existe uma grande gama de sensores de gás, estre eles, temos os MQ's. Esses sensores de detecção modernos e de baixo custo para gás combustível, são do tipo eletro-catalítico. Eles são feitos de uma bobina de fio de platina aquecido eletricamente, coberto primeiro com uma base de cerâmica, tais como alumina e, em seguida, com um revestimento final exterior do catalisador de paládio ou ródio disperso em um substrato de tório.
- Por dentro do sensor MQ
Na figura a seguir podemos entender um pouco melhor como é por dentro de um sensor de gás MQ.
Na vertical temos um resistência elétrica que aquece o ar. Essa resistência é ligada através da alimentação dos pinos H's, um vai no 5V e o outro no GND (0V).
De A para B temos nosso sensor de gás. Em uma atmosfera onde possa haver gás poluidor, a resistência do sensor de gás diminui conforme a concentração do gás poluente aumenta. Ou seja, quanto mais gás poluente, menor será a resistência entre A e B. Podemos conferir as variação da resistência conforme a concentração de gases no gráfico à seguir retirado da folha de dados do MQ-135:
Sendo assim, podemos montar um circuito onde temos uma tensão que será proporcional à quantidade de gases poluentes.
Conforme a resistência entre A e B diminuir (mais gases poluentes), maior será a tensão em cima do resistor RL. Falamos um pouco sobre esse tipo de circuito, o divisor de tensão, no tutorial sobre o sensor de luz LDR.
- Encapsulamento dos sensores MQ
Em geral, os sensores da família MQ possuem o formato como o da figura a seguir:
Como você pode ver, na parte de baixo temos alguns pinos. Ao todo são seis. Esse seis pinos dão acesso ao circuito interno já explicado.
Para facilitar o uso, podemos adquirir esse sensores junto a uma placa que já conta com o circuito necessário para seu pronto funcionamento alem de contar com um circuito comparador.
Lista de sensores de Gás
Aqui está a lista de alguns dos sensores de gás que você pode encontrar. Você pode escolher o mais adequado para o seu projeto.
| Nome do Sensor | Sensível para |
|---|---|
| MQ-2 | Detecção de gases inflamáveis: GLP, Metano, Propano, Butano, Hidrogênio, Álcool, Gás Natural, outros inflamáveis e fumaça. |
| MQ-3 | Detecção de Álcool , Etanol e fumaça. |
| MQ-4 | Detecção de Metano, Propano e Butano. |
| MQ-5 | Detecção de GLP e gás natural |
| MQ-6 | Detecção de gás GLP (Gás de Cozinha), Propano, Isobutano e Gás Natural Liquefeito |
| MQ-7 | Detecção do gás Monóxido de Carbono |
| MQ-8 | Detecção do gás hidrogênio |
| MQ-9 | Detecção de Monóxido de Carbono e gases inflamáveis |
| MQ-131 | Detecção de ozônio |
| MQ-135 | Detecção de Gás Amônia, Óxido Nítrico, Álcool, Benzeno, Dióxido de Carbono e Fumaça |
| MQ-136 | Detecção de Gás Sulfídrico H2S |
| MQ-137 | Detecção de Gás Amônia |
| MQ-138 | Detecção de n-hexano, benzeno, NH3, álcool, fumaça, CO, etc. |
Módulo sensor de Gás MQ-135 - Gases tóxicos e Fumaça
O modulo utilizado, MQ-135 funciona bem detecção de fumaça e outros gases tóxicos, especialmente amônia, vapor de sulfeto e benzeno. Sua capacidade de detectar vários gases nocivos e menor custo faz do MQ-135 uma escolha ideal de diferentes aplicações de detecção de gás.
Ele pode detectar concentrações na faixa de 10 a 1.000ppm (partículas por milhão), possuindo um range de tensão de 0 - 5V. Os módulos do MQ135 são capazes de operar na faixa de temperatura de -10 a 70ºC, consumindo uma corrente aproximada de 150mA.
O módulo também conta com um potenciômetro para regular a sensibilidade do sensor, girando ele para um dos lados o sensor ficara mais sensível aos gases.
Mãos a Obra - Desenvolvimento do Projeto
Componentes necessários
- 1 x Sensor de gás MQ -135
- 1 x Arduino UNO ou outra placa Arduino
- 1 x Protoboard 400 furos ou outra Protoboard
- Fios Jumpers
Montando o projeto
A montagem do circuito é bem simples e direta. Basta seguir o esquemático abaixo.
O modulo MQ 135 possui 4 pinos: dois pinos para alimentação (Vcc e GND) e dois pinos para emissão dos sinais elétricos, sendo um sinal digital (D0) e o outro um sinal analógico (A0). Para realizar a montagem, iremos conectar os pinos na seguinte ordem:
Em nossa experiência conectamos os pinos do sensor direto na placa Uno, sem o auxilio do protoboard, tal como indicado na tabela anterior. Veja como ficou o nosso montado:
Programando
Segue o código que utilizamos nesse projeto para fazer a detecção de gás no ambiente.
#define MQ_analog A2
#define MQ_dig 7
int valor_analog;
int valor_dig;
void setup() {
Serial.begin(9600);
pinMode(MQ_analog, INPUT);
pinMode(MQ_dig, INPUT);
}
void loop() {
valor_analog = analogRead(MQ_analog);
valor_dig = digitalRead(MQ_dig);
Serial.print(valor_analog);
Serial.print(" || ");
if(valor_dig == 0)
Serial.println("GAS DETECTADO !!!");
else
Serial.println("GAS AUSENTE !!!");
delay(500);
}
Colocando para funcionar
Primeiramente precisamos deixar que a resistência interna do sensor de gás esquente o suficiente para que as medições se estabilizem. Espere por 3 minutos. Chamamos essa espera de tempo de queima. Explicaremos isso mais a frente.
Após deixar o sensor de gás esquentar, vamos testa-lo forçando o ambiente com um fosforo/isqueiro para gerar CO2 (fumaça). O monitor serial irá indicar o valor analógico lido pelo sensor e também indicara se o gás foi detectado ou não, isso é uma resposta ao sinal digital emitido pelo módulo, e esse será calibrado conforme nos quisermos ao girar o potenciômetro. Para calibrar a detecção digital vamos estimular o sensor com o gás do isqueiro e quando acharmos que a estimulação seja suficiente, giramos o potenciômetro até que ele altere o estado entre NÃO DETECTADO <-> DETECTADO, assim esse passa a ser o novo ponto de referencia digital.
As imagens a seguir mostram a sequência que o sensor digital teve alternando o estado de LOW <->HIGH quando o valor analógico estava próximo de 82, neste exemplo eu mantive o fosforo acesso por alguns segundos próximo ao sensor apenas. Veja que na sequência de valores analógicos chega até 380, então de acordo com a duração e proximidade do fosforo ao sensor podemos ir calibrando o sensor digital dele.
Entendo a fundo
Software
– Nomeando os pinos utilizados através da diretiva #define
O primeiro passo do programa consiste fazer o uso das diretivas #define para nomear os pinos que serão utilizados no projeto, ou seja, o pinos que estarão conectados ao sensor apresentado anteriormente. Sendo assim, neste caso temos que o pino de entrada analógica do Arduino UNO A2 passa a ser identificado no código através do nome MQ_analog, enquanto, o pino de entrada digital 7 do mesmo será referenciado no código pelo nome MQ_dig.
#define MQ_analog A2 #define MQ_dig 7
– Declarando a variável responsável por armazenar o estado do sensor
Em seguida, declaramos duas variáveis para armazenar os valores que forem lidos pelas portas do Arduino UNO, sendo uma delas do tipo inteiro, para a parte analógica e a outra, booleana, para a parte digital.
int valor_analog; bool valor_dig;
– Configurando o sistema
Dentro da função void setup() vamos configurar as portas do Arduino e a comunicação serial. Vamos iniciar a comunicação serial numa taxa de 9600 bits por segundo e as portas utilizadas devem ser setadas como ENTRADAS (INPUT), afinal eles irão receber sinais elétricos para o Arduino.
void setup() {
Serial.begin(9600);
pinMode(MQ_analog, INPUT);
pinMode(MQ_dig, INPUT);
}
– Rodando o programa principal
Dentro do void loop() teremos o programa rodando em loop infinito, sendo assim iremos faremos a leitura das portas do Arduino e imprimiremos na serial os valores para que possamos ter parâmetros mensuráveis. Com a função analogRead() fazemos a leitura analógica da porta A2. Utilizaremos esse valor apenas como parâmetro para calibrar a sensibilidade digital do sensor.
valor_analog = analogRead(MQ_analog);
Utilizando a função digitalRead() temos a leitura booleana do sensor, quando a resposta for 1 o gás esta sendo detectado, e quando for 0 o gás está ausente. Veremos mais adiante que a sensibilidade do sensor precisa ser ajustada com o potenciômetro do modulo.
valor_dig = digitalRead(MQ_dig);
Por fim fazemos a impressão dos valores lidos na serial, para que assim, possamos ver o resultado das leituras.
if(valor_dig == 0)
Serial.println("GAS DETECTADO !!!");
else
Serial.println("GAS AUSENTE !!!");
Hardware
– Calibrando o módulo digital
Como dito antes é necessário calibrar o sensor digital do módulo MQ 135. Para isso rode o programa anterior e abra o monitor serial e, com auxilio de uma pequena chave Philips, gire o potenciômetro na parte de trás do módulo até que o você encontre um ponto que altere de 0 pra 1. O valor analógico irá servir como base para mediar a sensibilidade do sensor.
- Tempo de queima - Burn-in time
Para que o sensor esteja pronto para fazer as medições é necessário aguardar um tempo denominado como Burn -in time (Tempo de queima) ou preheat (pré aquecimento). Esse tempo varia de modelo para modelo, mas para testes mais simples, como para familiarizar com o sensor, podemos aguardar cerca de 3 minutos. Esse é o tempo necessário para que a resistência do sensor aqueça até a temperatura ideal de funcionamento do sensor. Durante esse período as medições podem oscilar muito.
Para aplicações oficiais, tal como implementação de um detector de incêndio, onde precisamos de uma precisão de medição maior e mais confiável, é recomendado pelos fabricantes que o tempo de queima seja de pelo menos 24 horas. Esse é o tempo necessário para que o sensor alcance a plena estabilização das medições entre os terminais internos A e B.
Considerações finais
Este projeto apresenta uma utilização básica do sensor MQ 135. Esperamos que você tenha gostado deste conteúdo, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
Caso esteja começando com Arduino recomendamos que conheça a Apostila Arduino Básico.
Sensor de Presença PIR | HC-SR501
Sensor de presença com Arduino | PIR HC-SR501
Automação residencial é claramente uma das áreas mais exploradas entre os grandes amantes de tecnologia. Nesse tutorial iremos aprender a montar um dos sistemas de automação mais comuns em nosso cotidiano, os detectores de presença e movimento. Para isso iremos abordar a utilização do Sensor de presença, também chamado de sensor de movimento, mais especificamente o Sensor PIR HC-SR501 e ensinar os procedimentos básicos na manipulação do mesmo para uso junto com Arduino.
[toc]
Sensores de Presença
É comum em alguns ambientes, tais como, banheiros não residenciais, garagens ou até mesmo corredores de edifícios, as lâmpadas acenderem de forma automática e instantânea.
Os sensores de presença possuem diversas aplicações, entre as mais populares estão a de controlar sistemas de iluminação e a de detectar a presença de invasores em alarmes. Com certeza você já viu um desses sensores.
Além da preocupação com a segurança, este tipo de comportamento automático também contribui para a economia de energia elétrica, evitando o desperdício da mesma e consequentemente para a diminuição de gastos.
Existem diversos formatos, todos com a mesma finalidade: Detectar a presença de pessoas. E como ele é capaz de fazer isso?
Sensor PIR
Todos esses sensores possuem uma coisa em comum, um sensor Piroelétrico ou também conhecido como Sensor PIR. Esse sensor é um pequeno componente capaz de detectar níveis de irradiação infravermelha emitidas pelo corpo humano.
Dentro desse sensor temos dois elementos piroelétricos que podem detectar uma faixa em uma faixa especifica determinados espectros de radiação.
Quando alguém passa na frente desse sensor, primeiramente a pessoa passará na zona de detecção do primeiro elemento piroelétrico e depois na zona de detecção do segundo elemento. Quando a pessoa passa pelo primeiro, ele gera um pulso de tensão na saída, quando ele passa na frente do outro, ele gera um pulso de tensão de sinal contrário. Tal como podemos ver na imagem abaixo:
Módulo Sensor PIR HC-SR501
Para nosso sistema automático iremos usar o módulo sensor de presença HC-SR501. Uma das vantagens desse sensor é a praticidade de usá-lo unido ao seu pequeno tamanho.
Tal como os demais detectores de presença, ele também possui um sensor piroelétrico por baixo desse domo branco. Vale ressaltar que esse domo branco tem uma função importante, ele aumenta a zona de alcance do sensor.
Este módulo já vem com todo sistema para tratamento do sinal e por isso o funcionamento deste sensor é bastante simples, de modo que, basta alimentar o mesmo, esperar a inicialização completa e a partir deste momento, quando algum corpo emissor de radiação infravermelha passar pelo alcance do sensor, o pino de saída deste proporcionará um sinal de nível alto em seu terminal, que por sua vez, pode ser utilizado por uma placa Arduino como sinalização da presença de algum elemento.
O sensor HC-SR501 possui dois potenciômetros na parte traseira onde, em um deles é possível selecionar o tempo em que o pino de saída citado ficará em nível alto quando o sensor detectar algo (este tempo pode variar de 5 segundos a 2 minutos e meio), enquanto o segundo possui a funcionalidade de ajustar a distância máxima de percepção do sensor, de modo que, é possível configurar esta sensibilidade para valores em torno de 3 a 7 metros.
Mãos à obra – Detectando elementos com o Sensor de presença - Sensor PIR HC-SR501
Componentes utilizados:
- Arduino Micro, Arduino Uno ou outro
- Sensor de Presença PIR HC-SR501
- Protoboard
- Fios Jumpers
- LED
- 1x Resistor 330Ohm ou 470Ohm
Montando o projeto
Na figura abaixo, o leitor poderá conferir como foi realizada a montagem do projeto apresentado neste tutorial. Lembre-se de montar o projeto com o seu Arduino desligado.
Veja como ficou o nosso:
Programando
Antes de adentrarmos na apresentação do código, disponibilizamos uma seção para ajudar aqueles que são iniciantes no assunto. Sinta-se livre para prosseguir caso você já tem domínio da IDE do Arduino.
Conectando o Arduino ao computador
Primeiramente, conecte seu Arduino ao computador e abra a IDE Arduino. Em seguida, é necessário selecionar a porta COM na qual o Arduino está conectado (este procedimento pode ser feito clicando no menu Ferramentas (tools) e em seguida escolhendo-se a porta correspondente no submenu Porta (port). Neste caso, a porta na qual está o Arduino é apresentada da seguinte maneira: COM3 (Arduino Micro).
Por fim, garanta também que o tipo de placa apropriado esteja selecionado (isso pode ser feito acessando o menu Ferramentas (tools) e o submenu Placa (board)).
– Código do projeto
Segue o código a ser utilizado no Arduino para Detectar um elemento com o sensor de Presença PIR - HC-SR501
bool estadoSensor;
void setup() {
pinMode(2,OUTPUT);
pinMode(3,INPUT);
}
void loop() {
estadoSensor = digitalRead(3);
if (estadosensor == HIGH)
{
digitalWrite(2, HIGH);
}
else
{
digitalWrite(2, LOW);
}
Entendendo a fundo
Software
- Declarando a variável responsável por armazenar o estado do sensor
O primeiro passo no desenvolvimento do código apresentado anteriormente consiste em criar uma variável booleana, ou seja, uma variável que pode assumir apenas dois estados (nível alto e nível baixo, 1 e 0, high e low, entre outras nomenclaturas). Esta variável será utilizada para armazenar a informação proveniente do sensor de presença.
bool estadoSensor;
- Definindo as configurações iniciais
O definição das configurações iniciais do programa ocorre dentro da função setup(). Em um primeiro momento, determinamos o modo de operação do pino 2 como um pino de saída digital (este pino estará conectado ao led responsável por sinalizar quando o sensor detectou algo).
pinMode(2,OUTPUT);
Em seguida, definimos o pino conectado ao sensor de presença como um pino de entrada digital, também através da função pinMode().
pinMode(3,INPUT);
Veja como ficou nossa função setup()
void setup() {
pinMode(2,OUTPUT);
pinMode(3,INPUT);
}
- Detectando a presença
O primeiro procedimento para realizar a detecção de presença corresponde à leitura do nível lógico retornado pelo sensor em um determinado instante. Isto é feito por meio da função digitalRead().
estadoSensor = digitalRead(3);
Posteriormente, utilizamos a função if() para conferir o valor referente ao estado do sensor (armazenado na variável estadoSensor), de modo que, caso o mesmo esteja em nível alto, o conteúdo da função if() será executado.
if (estadosensor == HIGH)
{
****** Conteúdo da função if() ******
}
Caso a sentença da função if() seja verdadeira, o Arduino deverá acender o led através da função digitalWrite().
digitalWrite(2, HIGH);
Em contrapartida, caso a condição da função if() não seja satisfeita, ou seja, caso a saída do sensor de presença seja um sinal em nível baixo, deve-se apagar o led.
else
{
digitalWrite(2, LOW);
}
Desafio
Agora que sabemos usar o sensor de presença e movimento, que tal usar um módulo relé para acender uma lâmpada? Seria uma boa ideia para automatizar o seu quarto, o que acha?
Faça isso:
- Ligue uma lâmpada quando detectar movimento no ambiente (Leia nosso Tutorial sobre módulo relé) .
Considerações finais
Neste tutorial demonstramos os procedimentos básicos para utilizar o sensor de presença e movimento HC-SR501 com o Arduino. Esperamos que você tenha gostado deste conteúdo, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
HC-SR04 - Sensor Ultrassônico com Arduino
HC-SR04 - Sensor Ultrassônico de distância com Arduino
O sensor ultrassônico HC SR04 é amplamente utilizado em aplicações onde se deseja medir distância ou evitar colisões, como na robótica móvel e de reabilitação. Neste tutorial aprenderemos como utilizar o Módulo Sensor HC-SR04 com Arduino.
Sensor Ultrassônico HC-SR04
Tudo começa pela emissão de um pequeno pulso sonoro de alta frequência que se propagará na velocidade do som no meio em questão. Quando este pulso atingir um objeto, um sinal de eco será refletido para o sensor. A distância entre o sensor e o objeto pode então ser calculada caso saibamos o tempo entre a emissão e a recepção do sinal, além da velocidade do som no meio em questão. Afigura a seguir exemplifica o processo.
Para uma melhor medição da distância, a área do objeto na qual a onda será refletida deve ser de pelo menos 0,5 m2.
Mãos à obra - Medindo distância com o HC-SR04
Componentes necessários:
Montando o projeto
Agora vamos conectar os componentes do projeto. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.
O HC SR04 possui 4 pinos sendo eles:
- Vcc – Deve ser conectado a um pino 5V do Arduino.
- Trig – Deve ser conectado a um pino digital configurado como saída. Utilizaremos o pino 8.
- Echo – Deve ser conectado a um pino digital configurado como entrada. Utilizaremos o pino 7.
- Gnd – Deve ser conectado a um pino GND do Arduino.
Programando
Crie um no programa (sketch) e salve com o nome de “programa_ultrassom_hcsr04”.
Nesse exemplo utilizaremos a biblioteca Ultrasonic.h. A utilização dessa biblioteca é bastante simples.
- Instalar a biblioteca pelo IDE do Arduino
Esse é o método mais fácil. Primeiramente, faça o download dos arquivos da biblioteca compactados no formato zip. Geralmente as bibliotecas já são distribuídas compactadas, porém às vezes é necessário fazer o download dos arquivos separadamente e compactá-los à parte. Em seguida, basta abrir o IDE e ir em “Sketch -> Incluir Biblioteca -> Adicionar biblioteca .ZIP” E selecionar o aquivo baixado:
Com isso, a nova biblioteca foi instalada. Para utilizá-la, basta ir em “Sketch -> Incluir Biblioteca” e selecionar a biblioteca desejada.
Você pode ver mais detalhes sobre como adicionar uma biblioteca no tutorial Sensores DHT11 e DHT22 e o Uso de Bibliotecas.
- Código exemplo
Com o seu programa salvo, escreva nele o código abaixo:
//Leitura de distância com o sensor HC-SR04
#include <Ultrasonic.h>
Ultrasonic ultrassom(8,7); // define o nome do sensor(ultrassom)
//e onde esta ligado o trig(8) e o echo(7) respectivamente
long distancia;
// Esta função "setup" roda uma vez quando a placa e ligada ou resetada
void setup() {
Serial.begin(9600); //Habilita Comunicação Serial a uma taxa de 9600 bauds.
}
// Função que se repete infinitamente quando a placa é ligada
void loop()
{
distancia = ultrassom.Ranging(CM);// ultrassom.Ranging(CM) retorna a distancia em
// centímetros(CM) ou polegadas(INC)
Serial.print(distancia); //imprime o valor da variável distancia
Serial.println("cm");
delay(100);
}
Após escrever o código, salve e depois clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Abra o Serial Monitor e coloque um obstáculo na frente do sensor ultrassônico. Se tudo deu certo, conforme você variar a distância do obstáculo em relação ao sensor, a distância medida aparecerá no serial monitor, tal como a figura a seguir.
Entendendo a fundo
Entendendo o Software
- Biblioteca Ultrasonic.h
Na elaboração do software utilizaremos a biblioteca Ultrasonic.h. Essa biblioteca implementa as funcionalidades do sensor ultrassom HC-SR04, tornando sua utilização extremamente simples.
- Declarando um Ultrassom
Para o uso dessa biblioteca devemos definir o nome do sensor e em quais pinos estão conectados os pinos trig e echo.
Ultrasonic nomesensor(trig,echo);
No exemplo a seguir, o nome do sensor é ultrassom, o pino do trig está conectado na porta 8 e o pino do echo na porta 7.
Ultrasonic ultrassom(8,7);
- Medindo a distância
Para ler a distância, basta chamar a função Ranging(CM). Para valor em centímetros, deve-se usar CM e para valor em polegadas, deve-se usar INC. Essa função retorna um valor de variável long.
long distancia = ultrassom.Ranging(CM); // distancia recebe o valormedido em cm
Observe que usamos o nome do sensor escolhido, no nosso caso ultrassom, seguido de ponto e o nome da função que queremos usar. Para o Arduino estamos falando que queremos usar determinada função do objeto mencionado, no nosso caso o ultrassom.
- Imprimindo na porta serial
Para imprimir o valor de distância lido usamos a função Serial.print().
Serial.print(distancia); //imprime o valor da variável distancia
Serial.println("cm");
Repare que na primeira linha imprimimos o valor da variável distância e na segunda linha imprimimos a palavra cm, que está entre aspas duplas. Sempre que quisermos imprimir um texto devemos colocá-lo dentro de aspas duplas, caso contrário o programa irá entender que o texto é o nome de uma variável.
Repare também que na segunda linha usamos o sufixo -ln depois de print. Esse sufixo informa que depois de escrito o texto, o programa deve pular uma linha.
Entendendo o Hardware
Como dito anteriormente, o sensor ultrassom mede a distância através da medição do tempo que uma onda leva para sair do emissor, colidir com um obstáculo e ser refletido, para, finalmente, ser detectado pelo receptor. Desta forma, podemos notar que nosso sensor ultrassom possui dois cilindros metálicos que se assemelham a olhos em sua placa. São, na realidade, dois altos falantes: um trabalha como o emissor do sinal ultrassom e o outro como receptor.
- Fazendo a leitura do tempo
Para iniciarmos uma medição, o pino Trig, que funciona como gatilho do nosso sensor ultrassom, deve receber um pulso de 5V por pelo menos 10 microssegundos. Isso fará com que o sensor HC-SR04 emita 8 pulsos ultrassônicos em 40kHz (T piezzo) e o pino ECHO, que funcionará como nosso cronômetro, vai para 5V, iniciando assim a espera pelas ondas refletidas.
Assim que uma onda refletida for detectada, o pino Echo, que estava em 5V, será alterado para 0V. Desta forma, o período que o pino Echo fica em 5V é igual ao tempo que a onda emitida leva para ir até o obstáculo e voltar.
Veja a imagem abaixo para entender o que acontece no sensor HC-SR04.
Por fim, para sabermos quão longe nosso obstáculo está, basta contarmos quanto tempo (T) a tensão no pino Echo ficou em 5V. Em posse desse tempo, sabendo que ele é o dobro do tempo de ida e volta da onda do sensor ultrassônico até o obstáculo, e, considerando a velocidade do som igual a 340,29 m/s, temos:
Desta forma, temos que a distância até o obstáculo é igual a ΔS.
A função Ultrasonic.h faz exatamente o procedimento descrito, retornando apenas o valor da distância.
Outra opção de código
Poderíamos seguir o procedimento explicado usando o seguinte código:
// Leitura HC-SR04
const uint8_t trig_pin = 10;
const uint8_t echo_pin = 9;
uint32_t print_timer;
void setup() {
Serial.begin(9600); // Habilita Comunicação Serial a uma taxa de 9600 bauds.
// Configuração do estado inicial dos pinos Trig e Echo.
pinMode(trig_pin, OUTPUT);
pinMode(echo_pin, INPUT);
digitalWrite(trig_pin, LOW);
}
void loop() {
// Espera 0,5s (500ms) entre medições.
if (millis() - print_timer > 500) {
print_timer = millis();
// Pulso de 5V por pelo menos 10us para iniciar medição.
digitalWrite(trig_pin, HIGH);
delayMicroseconds(11);
digitalWrite(trig_pin, LOW);
/* Mede quanto tempo o pino de echo ficou no estado alto, ou seja,
o tempo de propagação da onda. */
uint32_t pulse_time = pulseIn(echo_pin, HIGH);
/* A distância entre o sensor ultrassom e o objeto será proporcional a velocidade
do som no meio e a metade do tempo de propagação. Para o ar na
temperatura ambiente Vsom = 0,0343 cm/us. */
double distance = 0.01715 * pulse_time;
// Imprimimos o valor na porta serial;
Serial.print(distance);
Serial.println(" cm");
}
}
Desafio
Sabendo como funciona um sensor ultrassônico, faça o programa que meça a distância sem o auxílio da biblioteca.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
DHT11 e DHT22 | Sensor de umidade e Temperatura com Arduino
DHT11 e DHT22, Sensor de umidade e Temperatura com Arduino
Umidade e temperatura são duas grandezas que estão muito relacionadas quando o assunto é climatização. Nesse tutorial você aprenderá a medir essas duas grandezas através do sensor de umidade e temperatura DHT11 ou o DHT22 em conjunto com um Arduino.
[toc]
Sensores de umidade e temperatura DHT11 e DHT22
O sensor DHT11 e o sensor DHT22 são sensores básicos e de baixo custo que utilizam um termistor e um sensor capacitivo para medir a temperatura e a umidade do ar ambiente.
Esses sensores são bastante simples de usar, mas requer cuidado com o tempo entre duas leituras consecutivas, uma vez que é necessário um intervalo de, no mínimo, 1 segundo entre uma leitura e outra.
Existem diferentes versões do DHT, similares na aparência e na pinagem, porém com características diferentes. As características do DHT11 e DHT22, dois modelos populares desse sensor, são:
Sensor DHT11
- Muito baixo custo
- Tensão de alimentação de 3V a 5V
- 2.5mA de corrente máxima durante a conversão
- Bom para medir umidade entre 20% e 80%, com 5% de precisão
- Bom para medir temperaturas entre 0 e 50°C, com ±2°C de precisão
- Taxa de amostragem de até 1Hz (1 leitura por segundo)
- Dimensões: 15.5mm x 12mm x 5.5mm
- 4 pinos com 0.1" de espaçamento entre eles
Sensor DHT22
- Baixo custo
- Tensão de alimentação de 3V a 5V
- 2.5mA de corrente máxima durante a conversão
- Bom para medir umidade entre 0% e 100%, com 2% a 5% de precisão
- Bom para medir temperaturas entre -40 e 125°C, com ±0,5°C de precisão
- Taxa de amostragem de até 0,5Hz (2 leituras por segundo)
- Dimensões: 15.1mm x 25mm x 7.7mm
- 4 pinos com 0.1" de espaçamento entre eles
Como pode ser observado, o DHT22 é um pouco mais preciso e trabalha em uma faixa um pouco maior de temperatura e umidade. Porém, ambos utilizam apenas um pino digital e são relativamente lentos, visto que é necessário um intervalo de tempo relativamente grande entre cada leitura.
Incluindo Bibliotecas
Uma grande vantagem das placas Arduino é a grande diversidade de bibliotecas disponíveis que podem ser usadas em seu programa. Isso faz com o trabalho pesado em programação seja abstraído e resumido em simples comandos.
Com isso, o desenvolvedor não precisa de conhecimento muito aprofundado em programação, podendo gastar menos tempo nisso, resultando em mais tempo para trabalhar com empenho na estratégia de controle.
A seguir, iremos aprender como adicionar uma biblioteca em sua IDE. Esse mesmo procedimento será usado para outros sensores ou módulos.
Incluindo a biblioteca DHT
Para trabalhar de forma fácil com o DHT, podemos baixar uma biblioteca para ele no GitHub do Rob Tillaart (https://github.com/RobTillaart/Arduino/tree/master/libraries/DHTlib).
Há mais de uma forma de incluir bibliotecas no seu programa, a principal é:
Instalar a biblioteca pelo IDE do Arduino
Esse é o método mais fácil. Primeiramente, faça o download dos arquivos da biblioteca compactados no formato zip. Geralmente as bibliotecas já são distribuídas compactadas, porém às vezes é necessário fazer o download dos arquivos separadamente e compactá-los à parte. Em seguida, basta abrir o IDE e ir em "Sketch -> Incluir Biblioteca -> Adicionar biblioteca .ZIP":
Na janela que abrir, selecione a biblioteca a ser adicionada:
Com isso, a nova biblioteca foi instalada. Para utilizá-la, basta ir em "Sketch -> Incluir Biblioteca" e selecionar a biblioteca desejada:
Observe que o IDE adicionou no início do seu código a linha incluindo a biblioteca no seu programa.:
#include <dht.h>
Outras opções:
Instalar manualmente a biblioteca
Para instalar manualmente uma biblioteca, feche o IDE do Arduino e em seguida descompacte os arquivos da biblioteca. Se os arquivos .cpp e .h não estiverem dentro de uma pasta, crie uma e mova os arquivos para lá. Em seguida, basta mover a pasta para o local:
Windows: "Meus documentos\Arduino\libraries"
Mac: "Documents/Arduino/libraries"
Depois desse processo, a biblioteca estará disponível em "Sketch -> Incluir Biblioteca" na próxima vez que o IDE for aberto.
Incluir a biblioteca sem instalá-la
É possível também utilizar a biblioteca sem instalá-la no IDE do Arduino. Para isso, basta descompactar a biblioteca e colocar os arquivos .h e .cpp no mesmo diretório do programa, incluindo no início do mesmo a linha:
#include "nome_da_biblioteca.h"
Mãos à obra – Usando o Sensor de umidade e temperatura DHT11 com Arduino
Componentes necessários
- DHT11 ou DHT22
- Fios Jumper’s
- Protoboard
- Arduino Uno ou similar
Montando o projeto
Agora vamos conectar os componentes do projeto. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o 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)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “programa_dht11”.
Com o seu programa salvo, escreva nele o código conforme escrito abaixo.
#include <dht.h> // Inclui a biblioteca no seu código
dht DHT; // Cria um objeto da classe dht
uint32_t timer = 0;
void setup()
{
Serial.begin(9600); // Inicializa serial com taxa de transmissão de 9600 bauds
}
void loop()
{
// Executa 1 vez a cada 2 segundos
if(millis() - timer>= 2000)
{
DHT.read11(A1); // chama método de leitura da classe dht,
// com o pino de transmissão de dados ligado no pino A1
// Exibe na serial o valor de umidade
Serial.print(DHT.humidity);
Serial.println(" %");
// Exibe na serial o valor da temperatura
Serial.print(DHT.temperature);
Serial.println(" Celsius");
timer = millis(); // Atualiza a referência
}
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Caso tenha ocorrido tudo conforme esperado, poderemos fazer a leitura da temperatura através do monitor serial. Abra o monitor serial para verificar o que está sendo lido na entrada A0.
Entendendo a fundo
Entendendo o Software
millis()
Retorna o número de milissegundos desde a placa Arduino começou a funcionar com programa atual. Este número irá saturar (voltar para zero), após, aproximadamente, 50 dias.
timer = millis(); //Atualiza a referência
Veja que usamos o millis como nossa referência de tempo. Toda vez que a diferença entre o millis e o timer for de 2000 milissegundos, entraremos no if e o timer irá assumir o valor atual de millis.
Desta forma, o programa irá executar o que está dentro do if de 2000 em 2000 milissegundos, ou seja, 2 em 2 segundos.
Esse tipo de estrutura é muito comum e será usada em outras experiências.
Biblioteca dht.h
Na elaboração do software utilizamos a biblioteca dht.h. Esta biblioteca implementa as funcionalidades do sensor DHT11 e DHT22 tornando sua utilização extremamente simples.
Declarando um DHT
Ao usar essa biblioteca trataremos cada sensor DHT como um objeto, dessa forma precisamos declará-lo no início do código.
dht DHT; // Cria um objeto da classe dht
Depois de declarado, sempre que quisermos mexer em alguma função desse DHT, devemos usar o nome da função precedida do nome do DHT e ponto.
DHT.exemplo(); // chama função exemplo() para o objeto DHT
Lendo o sensor
Para ler o sensor basta chamar o método de leitura (read11 se estiver utilizando o DHT11, ou read22 se estiver utilizando o DHT22) e em seguida ler os valores nos atributos temperature e humidity.
Importante: O sensor demora no mínimo 1 segundo de intervalo entre uma leitura e outra.
DHT.read11(A1); // chama método de leitura da classe dht,
// com o pino de transmissão de dados ligado no pino A1
Temos o valor de umidade em porcentagem armazenado em:
float umidade = DHT.humidity
Temos o valor de temperatura em graus Celsius armazenado em:
float temperatura = DHT.temperature
Exemplo de aplicação:
// Exibe na serial o valor de umidade
Serial.print(DHT.humidity);
Serial.println(" %");
// Exibe na serial o valor da temperatura
Serial.print(DHT.temperature);
Serial.println(" Celsius");
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Tutorial feito em parceria com Ronan Largura
Sensor de Luz com LDR
Sensor de Luz - Aprendendo a usar o LDR com Arduino
Que tal construir um dispositivo que seja capaz de detectar luz? Você pode, por exemplo, fazer uma lâmpada que ligue sozinha durante a noite. Nesse tutorial, iremos aprender a usar um componente simples e barato que pode ser usado em diversos projetos, o LDR, montando um sensor de luz com uma placa Arduino.
Relembrar é viver
Quem nunca se perguntou como as lâmpadas dos postes ligam sozinhas de noite? Quantas vezes, quando éramos crianças, tentamos apagar as lâmpadas deles usando um laser? Possivelmente, muitos de nós já sabíamos qual era o dispositivo que acionava as lâmpadas.
O nome do dispositivo responsável por saber a hora certa de iluminar é conhecido como fotocélula ou relé fotocélula que nada mais é que um sensor de luz. Ele recebe a luz através dessa parte transparente. Como é possível ver na imagem abaixo, a fotocélula possui um LDR que irá medir a luminosidade.
Nessa fotocélula, quando o valor de luminosidade é menor do que o valor desejável, ele comuta uma chave que poderá ligar uma lâmpada, por exemplo.
LDR
O LDR, sigla em inglês de Light-Dependent Resistor, que significa resistor dependente de luz, nada mais é do que o que o próprio nome diz. Tipicamente, quanto maior a luz incidente nesse componente, menor será sua resistência.
O LDR é constituído de um semicondutor de alta resistência, que ao receber uma grande quantidade de fótons oriundos da luz incidente, ele absorve elétrons que melhoram sua condutibilidade, reduzindo assim sua resistência.
Dessa forma, esse semicondutor pode assumir resistências na ordem de mega Ohm no escuro e resistência na ordem de poucas centenas quando exposto a luz.
https://www.youtube.com/watch?v=EvVUemlMsSY
Mãos à obra – Fazendo um sensor de luz com LDR
Componentes necessários:
- LDR - Sensor de Luz
- Fios Jumper’s
- Protoboard
- Arduino Uno Rev3 ou similar
- LED
- Resistor 300Ohm
- Resistor 10kOhm
Montando o projeto
Agora vamos conectar os componentes do projeto na protoboard. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.
Veja como ficou o nosso:
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o 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)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “programa_sensor_de_luz”.
Com o seu programa salvo, escreva nele o código conforme escrito abaixo.
//Sensor de luz com LDR
int ledPin = 7; //Led no pino 7
int ldrPin = 0; //LDR no pino analígico 8
int ldrValor = 0; //Valor lido do LDR
void setup() {
pinMode(ledPin,OUTPUT); //define a porta 7 como saída
Serial.begin(9600); //Inicia a comunicação serial
}
void loop() {
///ler o valor do LDR
ldrValor = analogRead(ldrPin); //O valor lido será entre 0 e 1023
//se o valor lido for maior que 500, liga o led
if (ldrValor>= 800) digitalWrite(ledPin,HIGH);
// senão, apaga o led
else digitalWrite(ledPin,LOW);
//imprime o valor lido do LDR no monitor serial
Serial.println(ldrValor);
delay(100);
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Caso tenha ocorrido tudo como esperado, ao cobrir o LDR, o LED irá acender. Abra o monitor serial para verificar o que está sendo lido na entrada A0.
Entendendo a fundo
Entendendo o Hardware
- Resistência
Imagine que a tubulação que une os dois reservatórios tenha uma espessura menor em uma situação A que em outra em uma situação B, como na figura abaixo.
Por intuição, sabemos que, na situação A, a vazão entre os dois reservatórios será menor que na situação B.
O mesmo acontece com a corrente elétrica, existe uma propriedade chamada resistência quem tem como unidade o Ohm representado pelo símbolo grego ômega (Ω).
O nome da unidade da resistência faz homenagem a Ohm que criou as duas leis de Ohm. Uma delas diz que:
"A corrente que flui por um circuito é diretamente proporcional à tensão e inversamente proporcional à resistência."
Traduzindo, a resistência limita a corrente de forma proporcional, visto que para um tensão V fixa teremos um corrente cada vez menor para uma resistência cada vez maior.
V = R * I
Sabemos que energia não se perde ou se cria, ela se transforma. A energia perdida na desaceleração dos elétrons é convertida em calor.
- Divisor de tensão
Quando temos duas resistências associadas em série temos a seguinte situação:
Vin= (R1 + R2)*Ia
Se nossa tensão é fixa (Vin = 5V), temos:
Ia = 5V / (R1 + R2)
Ou seja, a corrente é o resultado da divisão da tensão 5V pela soma da resistências.
Nesse circuitos temos um efeito interessante: temos as mesma corrente para os dois resistores mas temos uma tensão diferente em cada um.
Vr1 = Ia * R1 e Vr2 = Ia * R2
Ou seja, a queda de tensão será maior no resistor maior.
Esse circuito é chamado de divisor de tensão. Como a corrente do circuito é calculada pela divisão da tensão total pela soma dos resistores, teremos a tensão em cima de um resistor igual a resistência desse resistor vezes a tensão total dividida pela soma dos resistores.
Ia = 5V / (R1 + R2) e Vr2 = Ia * R2
Vr2 = (5V / (R1 + R2)) * R2
O exemplo a seguir mostra como funciona o cálculo o para dois resistores.
Quando usamos um LDR, que é uma resistência foto-variável, podemos usar da propriedade do divisor de tensão para medir a variação da queda de tensão em cima do mesmo. Sabemos que a tensão total e a resistência total são fixas. Dessa forma, o divisor de tensão vai variar com a resistência entre A0 e GND.
Levando em conta que quanto menos luz incidir sobre o LDR maior será sua resistência, teremos a tensão sobre o LDR e por conseguinte o valor de A0 maior com um índice de luminosidade incidente menor, isto é, num local mais escuro.
VA0 = (5V / (1K + LDR)) * LDR
- Quanto menor luminosidade maior a resistência do LDR;
- Quanto maior a resistência do LDR, maior a tensão em A0;
- Então: quanto menor a luminosidade maior é a tensão em A0.
Entendendo o Software
- Lendo da entrada analógica
A leitura da entrada analógica é feita com a função analogRead, que recebe como parâmetro o pino analógico a ser lido e retorna o valor digital que representa a tensão no pino. Como o conversor analógico-digital do Arduino possui uma resolução de 10 bits, o intervalo de tensão de referência, que no nosso caso é 5 V, será dividido em 1024 pedaços (2^10) e o valor retornado pela função será o valor discreto mais próximo da tensão no pino.
ldrValor = analogRead(ldrPin); //O valor lido será entre 0 e 1023
O código acima lê o valor analógico de tensão no pino A0 e guarda o valor digital na variável valorLido. Supondo que o pino está com uma tensão de 2V, o valor retornado pela conversão será:
2 x 1024 / 5 = 409,6
O resultado deve ser inteiro para que nosso conversor consiga representá-lo, logo, o valor 410 será escolhido por ser o degrau mais próximo. Esse valor representa a tensão 2,001953125, inserindo um erro de 0,001953125 em nossa medida devido à limitação de nossa resolução.
Você pode ler mais sobre sinal analógico no tutorial Entradas e Saídas Analógicas.
- Lógica do programa
Em resumo, nosso programa lerá qual é o valor do sinal em A0 com o auxílio do comando analogRead(), que retornará um valor entre 0 a 1023, e o comparará com um valor de referência que em nosso caso é 800. Tendo em vista que, quanto mais escuro, maior será o valor de A0, caso A0 seja maior que o valor de referência o programa liga o LED conectado ao pino 7. Do contrário, ele apaga o LED. O programa também imprime o valor de A0 para que possamos verificar a faixa de valores e até mesmo calibrar nosso sensor.
Tente mudar o valor de referência e veja que, quanto maior esse valor, menor será sua sensibilidade.
Desafios
- Crie um alarme usando um buzzer e um LDR, explicado em nosso ultimo tutorial Usando buzzer com Arduino, Quando houver pouca luz, o alarme deve disparar.
- Usando 3 ou mais LED's e um LDR, faça um programa que aumente o numero de LED's acesos conforme a intensidade de luz seja menor.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
LM35 - Medindo temperatura com Arduino
Sensor de temperatura LM35 - Medindo temperatura com Arduino
Em diversas aplicações temos que fazer a leitura de variáveis físicas, tais como a temperatura, distancia, entre diversas outras. Nesse tutorial iremos aprender como fazer a leitura de temperatura usando o sensor de temperatura LM35, um sensor barato e de ótima precisão com uma placa Arduino.
[toc]
Sistemas autônomos
Quando pensamos em um sistema autônomo, pensamos em um sistema que faça a tarefa designada por conta própria, sem a necessidade de interferência do homem. Para isso, é fundamental que o seu sistema autônomo enxergue as variáveis físicas que serão importantes para o desempenho da atividade.
Pense em uma geladeira ou num ar condicionado. Neles devemos definir o valor de temperatura desejado e a partir desse valor o equipamento deve controlar essa variável. Para que ele tenha capacidade de controlar a temperatura, é fundamental que o sistema possa ler a variável. É ai que entram os sensores.
Sensores
Da famosa enciclopédia online Wikipédia, temos que:
“Um sensor é um dispositivo que responde a um estímulo físico/químico de maneira específica e mensurável analogicamente.”
Ou seja, sensores são dispositivos capazes de ler variáveis físicas ou químicas do ambiente e transformá-las em informação.
Qualquer processo automático possui sensores. Em industrias, onde há processos de produção automatizados, temos muitos tipos de sensores medindo as mais diversas variáveis do processo: temperatura, pressão, peso, pH, dentre muitos outros. Devido a importância da leitura dessas variáveis, existe uma área responsável por instrumentos de medição, a Instrumentação Industrial.
Nós, seres humanos, também somos feitos de vários sensores que nos ajudam a desenvolver nossas tarefas. Os nossos cinco sentidos: Olfato, audição, paladar, tato e visão, nada mais são do que conjuntos de sensores que colhem informações do ambiente para que o cérebro possa tomar decisões adequadas em cada situação.
Usando sensores
Tão importante quanto medir uma variável física é transformá-la em uma informação legível pelo cérebro do sistema autônomo, nosso Arduino, por exemplo. Pensando em eletrônica, essa informação pode ser digital ou analógica (Veja o tutorial Grandezas Digitais e Analógicas e PWM)
- Digital: Quando a informação é passada através de valores lógicos Altos(1) ou valores lógicos baixos(0).
- Analógico: Quando a informação pode assumir qualquer valor dentro de um máximo e um mínimo. Quando trabalhamos com eletrônica, geralmente essa informação é dada por um valor de corrente ou tensão.
LM35 - Sensor de temperatura
O sensor LM35 é um sensor de precisão que apresenta uma saída de tensão linear proporcional à temperatura em que ele se encontrar no momento, tendo em sua saída um sinal de 10mV para cada Grau Célsius de temperatura.
Esse sensor não necessita de qualquer calibração externa para fornecer com exatidão, valores temperatura com variações de ¼ºC ou até mesmo ¾ºC dentro da faixa de temperatura entre –55ºC e 150ºC.
Ele pode ser usado de duas formas, com alimentação simples ou simétrica, dependendo do que se desejar como sinal de saída, mas independentemente disso, a saída continuará sendo de 10mV/ºC.
Em cada uma dessas duas formas de alimentação, o range de temperatura, ou seja, a temperatura máxima e mínima medida com exatidão, é diferente.
Uma vantagem é o fato desse sensor drenar apenas 60μA para estas alimentações. Dessa forma, seu auto-aquecimento é de aproximadamente 0.1ºC ao ar livre e possui um consumo muito baixo.
O sensor LM35 é apresentado com vários tipos de encapsulamentos, sendo o mais comum o TO-92, que mais se parece com um transistor, e oferece ótima relação custo benefício, por ser o encapsulamento mais barato sem diferenças em seu uso ou exatidão.
Veja a folha de dados dele clicando aqui.
Mãos à obra – Medindo temperatura
Componentes necessários:
Montando o projeto
Agora vamos conectar os componentes do projeto. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.
Veja como ficou o nosso:
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o 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)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (Sketch) e salve com o nome de “programa_sensor_de_temperatura”.
Com o seu programa salvo, escreva nele o código conforme escrito abaixo.
//Sensor de temperatura usando o LM35
const int LM35 = A0; // Define o pino que lera a saída do LM35
float temperatura; // Variável que armazenará a temperatura medida
//Função que será executada uma vez quando ligar ou resetar o Arduino
void setup() {
Serial.begin(9600); // inicializa a comunicação serial
}
//Função que será executada continuamente
void loop() {
temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Serial.print("Temperatura: ");
Serial.println(temperatura);
delay(2000);
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Caso tenha ocorrido tudo conforme esperado, poderemos fazer a leitura da temperatura através do monitor serial. Abra o monitor serial para verificar o que está sendo lido na entrada A0.
O resultado será algo semelhante à imagem a seguir:
Entendendo a fundo
Entendendo o Software
Lendo o valor de temperatura
Primeiramente, em nosso programa usamos o comando de leitura analógica, já estudado no tutorial Entradas e Saídas Analógicas, para fazer a leitura do valor em A0. Além disso, usamos a comunicação serial, também discutida em outro tutorial, Comunicação Serial Arduino . É importante que o leitor entenda como eles funcionam. Experimente ler nossos tutoriais anteriores.
Em resumo, nosso programa lerá qual é o valor do sinal no pino A0, que varia de 0 a 1023, onde 0 corresponde a 0Volts e 1023 corresponde a 5Volts. Como sabemos, 1ºC é igual a 10mV. Sendo assim, temos:
Tensão em A0 = (Valor lido em A0)*(5/1023)
Temperatura = Tensão em A0/10mV
Logo:
Temperatura = [(Valor lido em A0)*(5/1023)]/10mV
Em linguagem de programação, ficará:
temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Transformando o tipo da variável
Perceba que colocamos o comando de leitura do valor analógico, analogRead, dentro de float(). Você saberia me dizer o motivo?
Quando o Arduino faz uma leitura analógica, ele converte o valor lido, que pode ser um valor de tensão entre 0V e 5V, em um número entre 0 e 1023. Ou seja, o Arduino divide 5Volts, que é o maior valor que ele é capaz de ler, em 1023 partes iguais e lhe informa quantas partes tem o valor que ele está medindo.
Pense que temos uma rampa que vai de 0 à 5V e dividimos essa rampa em 1024 degraus. Então, quando estamos no degrau 0, estamos no que equivale a 0V, quando subimos o primeiro degrau vamos para o que equivale a 5V/1023 (5 Volts dividido pelos 1023 degraus restantes), que é aproximadamente igual à 0,00487V.
O número que o Arduino nos informa é do tipo inteiro, contudo, o valor de temperatura é um numero racional, que pode assumir valores decimais. Por conta disso, no nosso programa, declaramos a temperatura como uma float.
Em programação, quando multiplicamos uma variável inteira por uma variável racional, o programa considera que o resultado deve ser inteiro, eliminando a parte decimal da variável. Dessa forma, para que tenhamos um resultado racional, devemos transformar o número inteiro em um número racional.
Em virtude disso, em nosso código foi necessário colocar o comando de leitura do valor analógico, analogRead, dentro de float().
numeroracional = float(numero); temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Sempre que for necessário fazer um calculo com o valor analógico, precisamos convertê-lo para uma variável do tipo float.
Em alguns casos, precisamos transformar uma variável qualquer para o tipo inteiro. O procedimento é o mesmo, ou seja, basta colocar o valor ou variável dentro dos parenteses de int();
numerointeiro= int(numero); temperatura = int((float(analogRead(LM35))*5/(1023))/0.01);
Se usamos o int() no calculo de temperatura, tal como mostrado acima, teremos um resultado sem os números decimais. Faça o teste.
Desafios
- Tente retirar o comando float() do calculo de temperatura e veja o resultado. Provavelmente você terá o valor de temperatura igual a zero, descubra o motivo.
- Crie um alarme usando um buzzer e um LM35, explicado em nosso ultimo tutorial Usando buzzer com Arduino, Quando a temperatura estiver muito alta, o alarme deve disparar.
- Usando 3 ou mais LED's e um LM35, faça um programa que aumente o numero de LED's acesos conforme a temperatura seja maior.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.