MicroPython – Lendo sinais analógicos em ESP8266 e ESP32

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.

Pino ADC em ESP8266

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.

Pino ADC no ESP32

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

  1. ESP8266x1
  2. LED de 5mm x1
  3. Resistência de 330Ω x1
  4. Pote de 1K x1
  5. Tábua de ensaio x1
  6. 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 ESP826

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

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.