A maioria dos sensores possui uma saída analógica. Poucos sensores vêm com um controlador integrado e podem transmitir as medições de saída através de um protocolo digital. É por isso que a conversão de analógico para digital é um dos recursos básicos que todo microcontrolador/porta possui. Os outros recursos básicos incluem entrada/saída digital, saída analógica, geração PWM e comunicação de dados serial.
Com o MicroPython, é útil ler tensões analógicas de sensores nas placas/portas do microcontrolador suportadas. Comparado a outros ecossistemas de microcontroladores populares como o Arduino, o MicroPython permite até mesmo acessar os componentes internos dos periféricos ADC das placas suportadas. Você não pode apenas ler tensões analógicas; você pode até configurar periféricos ADC com configurações personalizadas. Este artigo discutirá os módulos ADC no MicroPython e examinará como o firmware MicroPython é usado para ler sinais analógicos no ESP8266 e ESP32.
Módulo de máquina
MicroPython consiste em vários módulos específicos de hardware. Um desses módulos é a máquina. Este módulo consiste em várias classes que são escritas para controlar entrada/saída digital, controlar sinais de saída de dispositivos externos, modulação por largura de pulso, conversão de analógico para digital, controlar periféricos ADC, UART, SPI, I2C, I2S, Timer, RTC, Watchdog timer e gerenciar o cartão SD. Há uma classe ADC no módulo da máquina para controlar conversões analógico-digitais – uma classe adicional, ADCBlock, escrita para configuração personalizada e gerenciamento de periféricos ADC.
Classe ADC no módulo de máquina
A classe ADC é responsável por fornecer uma interface para conversores analógico-digitais em portas MicroPython. Ele fornece funções limpas e diretas que permitem definir as configurações do ADC e recuperar leituras do ADC como valores discretos ou tensões diretas. Este módulo é importado em um script MicroPython usando a instrução a seguir.
da importação de máquina ADC
Após importar a classe ADC do módulo de máquina, deve-se instanciar um objeto ADC. Isso é feito chamando o método machine.ADC com uma atribuição a uma variável. O método machine.ADC possui o seguinte protótipo.
classe machine.ADC(id, *, sample_ns, atten)
O método ADC leva três argumentos – id, sample_ns e atten, quais sample_ns e atten são parâmetros opcionais. O ID é a identificação da fonte ADC. Pode ser um canal ADC ou um pino ADC. A identificação da fonte ADC depende da porta específica. É especificado por um número inteiro que representa o canal ADC ou por um objeto PIN. O parâmetro sample_ns é o tempo de amostragem em nanossegundos. O parâmetro atten especifica a atenuação de entrada.
Uma vez que o objeto ADC é definido com a ajuda do construtor ADC , ele pode ser modificado posteriormente chamando o método ADC.init . O método possui o seguinte protótipo.
ADC.init(*, sample_ns, atenção)
A classe ADC fornece dois métodos para ler a entrada ADC como valores inteiros. Leva sample_ns e atten como argumentos. O parâmetro id não é permitido porque o identificador do objeto ADC não pode ser alterado.
ADC.ler : Este método faz a leitura analógica e retorna um valor de 0 a 1023. O valor retornado é uma representação proporcional da tensão detectada escalonada de forma que o valor mínimo seja 0 e o valor máximo seja 1023. O método é sempre chamado sem nenhum argumento.
ADC.read_u16 : Este método faz a leitura analógica e retorna um valor de 0 a 65535. O valor retornado é uma representação proporcional da tensão detectada escalonada de forma que o valor mínimo seja 0 e o valor máximo seja 65535. O método é sempre chamado sem nenhum argumento.
A classe ADC de módulos de máquina também fornece um método que retorna diretamente a tensão detectada expressa em microvolts. Este método é ADC.read_uv . Se o valor retornado está calibrado ou não depende da porta específica.
A classe ADC também fornece um método que permite alterar a resolução do ADC. Este método é ADC.largura . É necessário o número de bits conforme a resolução do ADC a ser definida. A disponibilidade deste método depende da porta específica. Pode ser utilizado apenas nas portas nas quais a resolução dos canais ADC é configurável.
Classe de bloco ADC no módulo de máquina
MicroPython fornece uma classe adicional para controle mais preciso do periférico ADC. Esta classe é ADCBlock. Se esta classe está disponível ou não depende da porta específica. Está disponível apenas para as portas nas quais vários canais ADC estão associados ao periférico ADC. Se a porta selecionada possuir um periférico ADC que possua vários canais associados a ela, um objeto da classe ADCBlock deverá ser instanciado ao invés da classe ADC. Essa classe é importada para um script MicroPython usando as instruções a seguir.
da importação da máquina ADCBlock
Um objeto de ADCBlock pode ser instanciado chamando o método machine.ADCBlock . Este método possui o seguinte protótipo.
classe máquina.ADCBlock(id, *, bits)
O construtor usa dois parâmetros – id e bits. O id é um número inteiro ou string que especifica o periférico ADC. Os bits de parâmetro especificam a resolução do ADC em bits. A resolução anterior ou padrão é definida para o periférico ADC se o argumento bits não for passado. É possível modificar o objeto ADCBlock posteriormente chamando o método ADCBlock.init . O método possui o seguinte protótipo.
ADCBlock.init(*,bits)
O método ADCBlock.init permite apenas reconfigurar a resolução periférica do ADC. Outro método importante da classe ADCBlock é connect . Possui o seguinte protótipo.
ADCBlock.connect(fonte)
ADCBlock.connect(canal)
ADCBlock.connect(canal, fonte)
O método ADCBlock.connect se conecta a um canal ADC do periférico ADC especificado. O método leva um ou dois argumentos. Se apenas a fonte for especificada, o objeto ADC será conectado ao canal padrão do periférico ADC especificado. A origem deve ser especificada como um objeto Pin. Se apenas um canal for especificado, o canal selecionado será configurado para amostragem com um pino padrão. O canal deve ser especificado como um número inteiro. Se o canal e a fonte forem especificados, o objeto pino atribuído será conectado ao canal especificado do periférico ADC.
Depois que o objeto ADCBlock é instanciado e conectado, as leituras ADC podem ser obtidas chamando os métodos read , read_u16 ou read_uv no objeto. A seguir está um exemplo válido de leitura de tensão analógica usando a classe ADCBlock.
#ADCBlock com id de periférico e resolução de 12 bits
bloco = ADCBlock(id, bits=12)
# conecta o canal 4 ao pino fornecido
adc = block.connect(4, pino)
# lê a tensão analógica em microvolts
val = adc.read_uv
Conversão analógico para digital no ESP8266
ESP8266 possui apenas uma entrada analógica. Ele está disponível em um pino dedicado chamado A0. O periférico ADC associado possui uma resolução fixa de 10 bits. Portanto, as leituras analógicas variam de 0 a 1023. Embora o pino ADC no ESP8266 possa tolerar tensões de até 3,3 V, a tensão de entrada aplicada para medição deve estar entre 0 V e 1,0 V.
Pinos de entrada analógica no ESP8266
Para ESP8266, um objeto ADC pode ser instanciado no MicroPython usando a classe ADC. Como existe apenas uma entrada analógica, o objeto deve ser definido utilizando a seguinte instrução.
adc = ADC(0)
Apenas a resolução de 10 bits é permitida, portanto a leitura do ADC pode ser obtida apenas chamando o método ADC.read da seguinte forma.
adc.ler
Conversão analógico para digital no ESP32
ESP32 possui dois periféricos SAR ADC. Esses periféricos são chamados ADC1 e ADC2. Eles são identificados como bloco ADC 1 e bloco ADC 2. ADC1 possui 8 canais ADC e ADC2 possui 10 canais ADC. Os pinos 32~39 estão conectados aos canais ADC do ADC1 (bloco 1). Os pinos 0, 2, 4, 12, 13, 14~15 e 25~27 estão conectados aos canais ADC do ADC2 (bloco 2).
A resolução padrão dos periféricos ESP32 ADC é de 12 bits. Portanto, as leituras analógicas podem variar de 0 a 4095. No entanto, a resolução de ambos os periféricos ADC é configurável e pode ser definida para uma resolução mais baixa, como 10 bits, 9 bits ou 8 bits. Os pinos de entrada analógica e os canais ADC associados no ESP32 estão listados na tabela abaixo.
Ambas as classes ADC e ADCBlock podem ser usadas para conversão analógico-digital no ESP32. O objeto ADC ou ADCBlock deve ser instanciado para acessar o ADC no ESP32. A resolução do canal ADC instanciado pode ser definida chamando os métodos ADC.width ou ADCBlock.init . Se o objeto ADCBlock for instanciado, ele poderá ser conectado a um canal ou a um objeto pin. No ESP32, conexões arbitrárias entre canais ADC e GPIO não são permitidas. Portanto, o método ADCBlock.connect não aceitará ambos os parâmetros. Se ambos os argumentos forem passados, ADCBlock.connect gerará um erro se o canal ADC fornecido não estiver vinculado ao pino especificado. O id no método ADCBlock pode ser 1 ou 2 e a resolução pode ser 9~12. Os pinos ADC no ESP32 podem tolerar tensões de até 3,3V. No entanto, como a referência de tensão interna está definida para 1,1 V, eles podem ler tensões analógicas apenas até 1,1 V. A tensão mínima que ambos os periféricos podem detectar é 100 mV. Todas as tensões abaixo de 100 mV são lidas como 0. É importante observar que o ADC2 é compartilhado com o Wi-Fi, portanto a tensão analógica dos pinos associados ao ADC2 não pode ser lida se o Wi-Fi estiver ativo.
As leituras analógicas podem ser obtidas chamando os métodos ADC.read ou ADC.read_uv . Como os periféricos ADC do ESP32 leem tensões analógicas abaixo de 100 mV como 0, as leituras tendem a ser não lineares por estarem próximas da tensão de referência interna, ou seja, 1,1V, o ADC.read_uv é recomendado para obter leituras ADC . Se a resolução ADC estiver definida como 11 ou 12 bits, o método ADC.read_u16 deverá ser usado.
Pinos de entrada analógica no ESP32
Controlando a taxa de intermitência do LED com um potenciômetro
Agora equipados com o conhecimento das classes ADC e ADCBlock do MicroPython e sua aplicação nas placas ESP8266 e ESP32, vamos agora projetar uma aplicação simples demonstrando o uso da conversão analógico-digital. Nesta aplicação, controlaremos a taxa de intermitência de um LED tomando a tensão analógica como entrada de um potenciômetro.
Componentes necessários
- ESP8266x1
- LED de 5mm x1
- Resistência de 330Ω x1
- Pote de 1K x1
- Tábua de ensaio x1
- Conectando fios/fios de jumper
Conexões de circuito
Conecte o GPIO5 do ESP8266 ao ânodo do LED. Conecte o cátodo do LED com um resistor em série de 330 Ohms e aterre o outro terminal do resistor. Pegue um potenciômetro e conecte os terminais fixos 1 e 3 com terra e 3,3V, respectivamente. Conecte o terminal variável 2 do potenciômetro à entrada analógica A0 do ESP8266. A tensão de alimentação CC e o aterramento podem ser fornecidos ao circuito a partir da saída 3V3 e de um dos pinos de aterramento do ESP8266, respectivamente.
Observe que o firmware MicroPython já deve estar carregado no ESP8266. Saiba mais sobre o upload do firmware MicroPython no ESP8266 e ESP32.
Diagrama de circuito para controle da taxa de intermitência do LED usando ESP8266 ADC
Script MicroPython
da importação da máquina Pin, ADC
do tempo importar sono
pote = ADC(0)
led = Pino (5, Pino.OUT)
enquanto Verdadeiro:
pot_value=pot.read
imprimir(valor_do_pote)
led.on
dormir(pot_value/256)
led.off
dormir(pot_value/256)
Como funciona
O ESP8266 lê a tensão analógica de um potenciômetro em seu único pino de entrada analógica, A0. A tensão de leitura é impressa no console do uPyCraft IDE. A mesma leitura analógica é dividida por 256 e passada como um intervalo de tempo entre ligar e desligar a luz do LED.
O código
O código começa importando as classes Pin e ADC da máquina e as classes sleep dos módulos de tempo. O ADC é inicializado chamando o método ADC , criando um objeto ADC chamado 'pot'. O pino GPIO5 no qual o LED está conectado é definido como saída digital chamando o método Pin . Em um loop while infinito, a leitura do ADC do potenciômetro é lida chamando o método read e é armazenada em uma variável 'pot_value'. O mesmo valor é impresso no log do console chamando a função print . O LED é ligado chamando o método no objeto pino do LED. Um atraso de pot_value/256 é invocado chamando o método sleep . Em seguida, o LED é desligado cancelando o método no objeto pino do LED, e o mesmo atraso é fornecido. Isso se repete indefinidamente, de modo que a taxa de intermitência do LED é controlada pela entrada analógica em tempo real do ESP8266.
Resultado
