A medição de sinais analógicos é uma das técnicas mais utilizadas na eletrônica. Isso geralmente é feito por conversores analógicos para digital (adc). Os sinais analógicos são representados por tensões elétricas e indicam um nível de medição. Muitos sensores de temperatura, umidade, pressão, etc., fornecem em sua saída uma tensão análoga para a magnitude que estão medindo. Neste artigo, aprenderemos a conectar potenciômetros, resistores dependentes de luz ou LDR e sensores de temperatura. Leia e processe também seus sinais analógicos com microcontroladores da placa Arduino.
MIC021S
A Figura 1 mostra a placa Arduino Uno e seu Ambiente de Desenvolvimento (IDE), que podem ser baixados do site do Arduino. Esta placa contém um microcontrolador ATmega328P, que possui 6 canais analógicos que podem ser lidos através de um conversor analógico para Digital ou ADC com resolução de 10 bits. A Figura 2 mostra os pinos onde as entradas analógicas estão localizadas na placa do Arduino Uno. A Figura 3 mostra o diagrama de blocos do conversor analógico para digital (ADC) do microcontrolador.
As principais características do ADC são:
- resolução de 10 bits.
- Tempos de conversão entre 13 e 260 microssegundos.
- 6 canais de entrada multiplexados.
- Canal de entrada com sensor de temperatura.
- Ajuste de leitura opcional para a esquerda.
- Faixa de tensão de 0 a Vcc.
- Tensão de referência de 1,1 Volts para o ADC.
- Modo de conversão simples ou livre.
- Interrupção quando a conversão estiver concluída.
- Cancelamento de ruído no modo de baixo consumo (SLEEP).
Neste artigo, veremos que entender e usar o ADC da placa Arduino é muito fácil. Para isso, vamos usar potenciômetros, resistores dependentes de luz ou LDR e o sensor de temperatura LM35. A figura 4 mostra esses componentes eletrônicos. Exemplos de códigos podem ser encontrados no Arquivo de Menu-> Exemplos-> 03.Analog. Veja a Figura 5.
Muitos fenômenos físicos são capturados ou medidos como níveis de magnitude ou alcance. Por exemplo, a temperatura nos diz se algo está frio ou quente, mais se queremos saber a medida exata da temperatura, devemos usar um sensor e ler ou medir sua saída para conhecer a temperatura. Uma vez que o sensor nos forneça uma tensão ou tensão análoga à magnitude que queremos medir, é necessário conectar um circuito que converta essa medida em um valor digital.
Devido ao grande desenvolvimento dos processadores e microcontroladores, os circuitos utilizados para a conversão de tensão ou tensão, em um valor binário, são ADCs ou Conversores Analógicos para Digital.
CONECTANDO POTENCIÔMETROS AO ARDUINO UMA PLACA.
Nesta prática, conectaremos um potenciômetro à placa do Arduino Uno e leremos seu nível de tensão como mostrado na Figura 6. O código fonte para esta prática pode ser encontrado no Arquivo de Menu-> Exemplos-> 03.Analog-> AnalogInput:
int sensorPin = A0; // selecione o pino de entrada para o potenciômetroint ledPin = 13; // selecione o pino para o LEDint sensorValue = 0; // variável para armazenar o valor vindo do sensor void setup () { // declare o ledPin como um OUTPUT: pinMode(ledPin, OUTPUT); } void loop () { // leia o valor do sensor: sensorValue = analogRead(sensorPin); // liga o ledPin digitalWrite(ledPin, ALTO); // pare o programa por milissegundos: delay(sensorValue); // desliga o ledPin: digitalWrite (ledPin, BAIXO); // pare o programa por milissegundos: delay(sensorValue); }
No início do programa, configuramos o sensorPin como entrada analogica '0'. Para isso usamos a seguinte linha de código:
int sensorPin = A0;
Também configuramos o ledPin para o número de saída digital '13', no qual está o LED que a própria placa Arduino tem para teste. Para isso usamos a linha de código:
int ledPin = 13;
A variável sensorValue é usada para armazenar o valor do nível de tensão lido no potenciômetro. Para isso usamos a seguinte linha de código:
int sensorValue = 0;
Na função setup () declaramos que o pino ledPin será uma saída digital (OUTPUT). Por padrão, as entradas analógicas são configuradas como entrada analógica, por isso, não é necessário declarar que o pino sensorPin é uma entrada. O código para a função setup () é:
void setup () {
pinMode (ledPin, OUTPUT);
}
Na função loop (), primeiro lemos a entrada analógica '0' através da instrução analogRead (sensorPin); e o resultado é armazenado na variável sensorValue. Então ligamos o LED com a instrução digitalWrite (ledPin, HIGH); Em seguida, atrasamos a magnitude ou o nível lido no potenciômetro e seu valor foi armazenado em sensorValue. Após esse tempo, desligamos o LED e atrasamos novamente. É assim que o programa se repete indefinidamente. Como você pode ver, de acordo com o nível de tensão lido na entrada analógica '0', o LED irá piscar ou oscilar.
A Figura 7 mostra o fluxograma para este programa. O código para a função loop () é o seguinte:
void loop () { sensorValue = analogRead(sensorPin); digitalWrite(ledPin, ALTO); atraso(sensorValue); digitalWrite(ledPin, BAIXO); atraso(sensorValue); }
DETECÇÃO DE LUZ COM FOTORESISTOR (LDR)
Um fotorresistor ou LDR é um componente eletrônico que varia sua resistência elétrica dependendo do nível de luz que recebe. Em uma fotorresistor, quanto maior a quantidade de luz recebida, sua resistência interna diminui. Este componente é útil para medir o nível de luz em um ambiente ou local. Nesta prática aprenderemos como conectar um fotorresistor ao quadro do Arduino Uno e como processar o valor lido da luminosidade (luz), para executar alguma ação.
A Figura 8 mostra a conexão elétrica do LDR à placa Arduino. A resistência de 1 KOhms pode variar de 10 KOhms dependendo do fotorresistor usado. O seguinte é o programa de exemplo para esta prática:
// variável para manter o valor do sensorint sensorValue;// pino de LEDconst int ledPin = 13; void setup () { Serial.begin(9600); } void loop () { // leia a entrada de A0 e armazene-a em uma variável sensorValue = analogRead(A0); // enviar para monitor serial Serial.print("Light ="); Serial.print(sensorValue); // verificar o nível de luz if (sensorValue <300) { Serial.println ("- baixo"); } else if (sensorValue <600) { Serial.println ("- meio"); } else { Serial.println ("- alto"); } // espere por um momento delay(1000); }
No início do programa, definimos a variável sensorValue para armazenar a quantidade de luminosidade recebida na entrada '0' (A0) do conversor analógico para digital. O valor de ledPin é usado para definir o LED da placa Arduino que está conectada no pino 13.
A função setup () configura a porta serial para transmitir a 9600 bits por segundo. Nesta prática, usaremos a porta serial para nos comunicar com o computador e exibir os valores que estão sendo lidos do ADC em uma janela do monitor. Para acessar o Monitor da Série, vá ao menu: Ferramentas-> Monitorar Série ou clique no botão Monitor Series.
Veja a Figura 9. O código para a função setup () é:
void setup () {
Serial.begin (9600);
}
Na função loop (), primeiro lemos o canal '0' (A0) do ADC e armazenamos esse valor na variável sensorValue. Este valor é enviado para o monitor serial através da instrução:
Serial.print (sensorValue);
Em seguida, o código avalia a variável sensorValue para determinar o nível de luz ou luminosidade no ambiente. O código para esta avaliação é:
if (sensorValue <300) {
Serial.println ("- baixo");
} else if (sensorValue <600) {
Serial.println ("- meio");
} else {
Serial.println ("- alto");
}
Aqui nós fazemos uso da instrução Menor que é representada pelo símbolo ou caractere
Dependendo do nível de luz, enviamos um texto indicando o monitor da série para o monitor. Para isso, usamos a função Serial.println. Finalmente, atrasamos o programa por um segundo. Na Figura 11 podemos ver o diagrama de fluxo para o programa desta prática.
TERMÔMETRO COM O LM35 E ARDUINO UNO
O LM35 é um circuito integrado de sensor de temperatura. A sua saída é analógico e para todos os graus 0,1 graus centígrados seus saída analógica 1 milivolts aumenta, isto é, cada um grau Celsius, a voltagem é aumentada de 10 milivolts. O circuito é calibrado para graus centígrados e isso é feito quando o circuito integrado é fabricado. A Figura 12 mostra como conectar o LM35 à placa Arduino. O seguinte é o código para ler a temperatura ambiente:
void setup () { Serial.begin(9600); } loop void() { // leia a entrada de A0 e armazene-a em uma variável int temperature = analogRead(A0); // enviar para monitor serial Serial.print(temperatura); Serial.print(">"); // saída do sensor é 10mV por grau Celsius fload milivolts = (temperatura / 1024,0) * 5000; fload centigrades = milivolts / 10; // enviar para monitor serial Serial.print(centígrados); Serial.print("Centígrados"); // espere por um momento delay(1000); }
No início do programa, encontramos a função setup (), que é responsável por inicializar a comunicação da porta para 9600 bauds. Depois de encontrar a função loop () que lê o (A0) conversor analógico '0' para digital e armazena a variável temperatura e envia o valor para o monitor serial. Então calculamos o valor dos graus centígrados com base nos milivolts lidos e enviamos o resultado para o monitor serial. Finalmente, atrasamos por um segundo para que o loop se repita. Na Figura 13 podemos observar o fluxograma ou atividade dessa prática.
MAPEAMENTO OU ESCALA DOS VALORES ADQUIRIDOS NO ADC.
O compilador do Arduino tem uma função chamada map, que pode ser usada para mapear ou escalar valores adquiridos no ADC, para qualquer outro intervalo de valores. Por exemplo, queremos representar a porcentagem na qual um potenciômetro está localizado. Para isso, podemos usar a seguinte instrução:
percent = map(potValue, 0, 1023, 0, 100);
Na linha de cima código pode ver que o valor lido do potenciómetro é armazenado no intervalo de entrada variável é potValue 0-1023 e a escala de 0 a 100. O valor de retorno de saída é o resultado da conversão de escala que deve ser um valor proporcional de 0 a 100. Esta função é muito útil porque na eletrônica é comum representar ou converter valores em diferentes escalas.
O protótipo ou definição da função é:
map(valor, fromLow, fromHigh, toLow, toHigh)
Podemos ver que a função leva 5 parâmetros da seguinte forma:
valor: valor para mapear.
fromLow: menor valor da escala de entrada.
fromHigh: valor mais alto da escala de saída.
toLow: valor mais baixo da escala de saída.
toHigh: valor mais alto da escala de saída.
return: o valor mapeado.
O valor retornado pela função será o valor da escala de saída que você deseja mapear.
A seguir, um código de exemplo para mapear uma entrada analógica para um valor de 8 bits:
/ * Mapear um valor analógico para 8 bits (0 a 255) * /
void setup () {}
loop void ()
{
int val = analogRead(0);
val = map(val, 0, 1023, 0, 255);
analogWrite(9, val);
}
Como podemos notar no presente artigo, ler as entradas analógicas do ADC é uma tarefa simples. A função usada para isso é o analogRead, que recebe um único parâmetro, indicando o canal de entrada para ler e retorna seu valor inteiro.
