Neste post será mostrado o conversor analógico para digital no Arduino UNO, que possui uma resolução de 10 bits, e vamos mostrar os valores lidos usando a varredura em 4 displays de sete segmentos. Também vamos verificar o resultado usando o Tinkercad.

Conversor AD

Vamos começar com uma breve introdução para verificar alguns parâmetros do conversor AD que precisamos conhecer. Não serão mostrados todos os detalhes do conversor AD.

Quando usamos o conversor AD precisamos saber qual a tensão de referência está sendo utilizada, caso um valor não seja configurado, seja a nível de hardware ou de firmware, alguns microcontrolador utilizam o valor da própria alimentação do microcontrolador como tensão de referência. É muito importante checar o datasheet do componente.

O primeiro detalhe que precisamos entender é com relação a resolução do AD, que no caso do microcontrolador utilizado no Arduino UNO é de 10 bits. Isso quer quantos valores o AD pode ler, ou o quão baixo é a tensão que conseguimos ler. Vamos verificar dois exemplos, usando um tensão de referência de 5V.

Para 10 bits temos:

Para 12 bits temos:

No caso de 10 bits, a cada 4,883mV temos um 1 bit, ou seja, quando é aplicado 0V temos 0 bit, quando aplicamos 4,883mV temos 1 bit, quando temos 9,766mV temos 2 bits e assim sucessivamente.

E em 10 bits temos 1024 valor disponíveis, com um range que vai de 0 a 1023, e em 12 bits temos 4096 valores, com um range que vai de 0 a 4095.

Existem outras informações que podem ser relevantes dependendo do projeto, como taxa de amostragem, tensão de referência.

Projeto do conversor AD

O projeto apresentado utiliza um interface com display de 7 segmentos, e o conversor AD do Arduino. Abaixo é possível verificar o diagrama esquemático do circuito utilizado.

O circuito utiliza 4 display de 7 segmentos, com todos os segmentos conectados em paralelo, com transistores MOSFET de canal para ligar ou desligar o display que deve ou não mostrar o digito. Esse tipo de circuito é muito comum em mostradores a LED; o que se feito é mostrar um digito de cada vez com uma determinada velocidade, e para nossa visão temos a impressão que está sendo exibido o valor completo.

Código para ser gravado no Arduino

Abaixo é mostrado o código fonte para ser gravado no Arduino após a montagem do circuito.

/**************************************************************
counter with the 7 display
www.wantronics.com.br
**************************************************************/

#define digit1 2
#define digit2 3
#define digit3 4
#define digit4 5
//------------------------------------------------------------
#define segmentA 9
#define segmentB 10
#define segmentC 13
#define segmentD 12
#define segmentE 11
#define segmentF 8
#define segmentG 7

int number = 0;

void digitNumber (int val);
void display (long num);

void setup()
{
  pinMode (digit1, OUTPUT);
  pinMode (digit2, OUTPUT);
  pinMode (digit3, OUTPUT);
  pinMode (digit4, OUTPUT);
  
  pinMode (segmentA, OUTPUT);
  pinMode (segmentB, OUTPUT);
  pinMode (segmentC, OUTPUT);
  pinMode (segmentD, OUTPUT);
  pinMode (segmentE, OUTPUT);
  pinMode (segmentF, OUTPUT);
  pinMode (segmentG, OUTPUT);
}

void loop()
{
  number = analogRead(A0);
  display (number);
}

void digitNumber (int val) {
  int i = 0;
  int j = 0;

  // Mapping the Arduino pins connected to the display
  int segment[] ={segmentA, segmentB, segmentC, segmentD,
                segmentE, segmentF, segmentG};

  // Displays numbers
  int digit[10][7] { // A  B  C  D  E  F  G
 					   {1, 1, 1, 1, 1, 1, 0}, // 0
 					   {0, 1, 1, 0, 0, 0, 0}, // 1
                       {1, 1, 0, 1, 1, 0, 1}, // 2
 					   {1, 1, 1, 1, 0, 0, 1}, // 3
                       {0, 1, 1, 0, 0, 1, 1}, // 4
 				   	   {1, 0, 1, 1, 0, 1, 1}, // 5
                       {1, 0, 1, 1, 1, 1, 1}, // 6
 					   {1, 1, 1, 0, 0, 0, 0}, // 7
                       {1, 1, 1, 1, 1, 1, 1}, // 8
 					   {1, 1, 1, 0, 0, 1, 1}, // 9
                    };

    for (i = 0; i < 7; i++) {
      digitalWrite (segment[i], digit[val][i]);
    }
}

void display (long num) {
  int digit[] ={digit1, digit2, digit3, digit4};
  int i = 0;
  int j = 1000;
  int mem = 0;
  
  for (i = 0; i < 4; i++) {
    mem = (num / j) % 10;
    j = j / 10;
    digitNumber (mem);
    digitalWrite (digit[i], HIGH);
    digitalWrite (digit[i], LOW);
  }
}

Temos duas funções principais em nosso código, uma que mostra os dígitos de 0 a 9, e outra que que recebe um valor de 0 a 9999 e é responsável por separa os valores de unidade, dezena, centena e milhar e fazer com que cada digito seja escrito no lugar certo.

No loop principal fazemos o uso do conversor analógico para digital e usamos a função display para mostrar o valor nos displays. O valor mostrado no display pode ser configurado para mostrar valores de 0 a 5V, ou caso seja utilizado um divisor de tensão e se deseje medir tensões maiores do que 5V.

Simulação no Tinkercad

Abaixo é possível verificar o funcionamento do circuito com a simulação no Tinkercad.

https://www.tinkercad.com/things/kyWtNduC00y

https://www.tinkercad.com/