Escrito por: Alfonso Pérez

   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

 

Alfonso Pérez é nosso colaborador hispânico que escreve a partir do Perú para nosso site em espanhol. Assim, mantivemos nas figuras as indicações no idioma original.

 

Figura 1
Figura 1

 

   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.

 

Figura 2
Figura 2

 

 

Figura 3
Figura 3

 

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.

 

 Figura 4
Figura 4

 

 

 Figura 5
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:

 

 Figura 6
Figura 6

 

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.

 

 Figura 8
Figura 8

 

   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.

 

 Figura 9
Figura 9

 

   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

 

 Figura 10
Figura 10

 

   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.

 

 Figura 11
Figura 11

 

 

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:

 

 Figura 12
Figura 12

 

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.