MicroPython – Entrada/saída digital em ESP8266 e ESP32

O primeiro passo na programação de dispositivos embarcados é realizar entrada/saída digital. A entrada/saída digital refere-se à leitura de dados paralelos. Os mesmos sinais lógicos são utilizados para operações de comutação e controle. MicroPython, um firmware incorporado, inclui essencialmente bibliotecas para controlar entrada/saída digital e outras funções de hardware. MicroPython pode ser carregado e executado em uma variedade de plataformas de hardware, ou seja, microcontroladores. Esses microcontroladores são chamados de portas na terminologia MicroPython. Cada porta possui seus próprios recursos de hardware, periféricos integrados e configuração de pinos. Apesar do MicroPython suportar vários sistemas microcontroladores diferentes entre si, ele possui uma sintaxe universal para todas as funcionalidades de hardware. Neste artigo, discutiremos como podemos ler a entrada digital e gerar saída digital usando MicroPython. Como testaremos nossos códigos MicroPython em ESP8266 e ESP32, nos familiarizaremos com ambas as placas e mostraremos como funciona a entrada/saída digital.

Mesmo operações simples de entrada/saída digital envolvem conhecimento técnico sólido. Para conhecer os aspectos técnicos da entrada digital em microcontroladores e ter conhecimento aprofundado de LEDs, confira nosso artigo sobre entrada digital no Arduino. Para saber mais sobre switches e aspectos técnicos de saída digital em microcontroladores, recomendamos ler nosso artigo sobre saída digital em Arduino. Espera-se que você esteja familiarizado com o que é MicroPython. E sim, antes de experimentar a entrada/saída digital prática no ESP8266/ESP32 usando MicroPython, você deve fazer upload do firmware MicroPython no ESP8266/ESP32 e se preparar com o IDE uPyCraft/Thonny em seu computador.

Biblioteca de máquinas MicroPython
MicroPython fornece o módulo de máquina para diversas funções específicas relacionadas ao hardware do microcontrolador. O módulo contém classes 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, temporizador, RTC, temporizador Watchdog e gerenciamento de cartão SD . O módulo foi projetado para acessar diretamente diferentes blocos de hardware de vários microcontroladores sem qualquer restrição. Além de classes relacionadas a funções específicas de hardware, o módulo fornece métodos para habilitar/desabilitar interrupções, gerenciamento de energia, reset e bootloader. Normalmente, apenas as classes necessárias do módulo são importadas para um script MicroPython para manter o código curto e limpo.

Classe PIN na biblioteca de máquinas
A classe PIN do módulo da máquina é projetada para controlar entradas/saídas de uso geral (microcontrolador GPIO). Esta classe é importada em um script MicroPython usando a instrução a seguir.

do Pin de importação da máquina

A classe pin contém métodos para definir o modo do pino e obter e definir os níveis lógicos dos pinos digitais. Cada porta (microcontrolador compatível) possui uma configuração e atribuição de pinos diferentes. Um pino físico de uma porta é definido por um identificador, ou seja, uma variável. O identificador é uma instanciação do objeto Pin. Um pino físico específico de uma porta/microcontrolador é especificado por um número, string ou ID de tupla na instanciação do objeto pin. O id é específico para uma determinada porta/microcontrolador. A instanciação do pino é feita pelo método Pin da classe. Este método é definido como segue.
class machine.Pin(id, mode=- 1, pull=- 1, *, value=None, drive=0, alt=- 1)

Os parâmetros do método Pin são descritos a seguir.

eu ia: O parâmetro obrigatório identifica um pino físico específico em uma determinada porta/microcontrolador. O id pode ser fornecido como um número, string ou tupla.

modo: especifica o modo de pino do pino especificado. O modo é especificado pelas seguintes constantes – Pin.IN, Pin.OUT, Pin.OPEN_DRAIN, Pin.ALT, Pin.ALT_OPEN_DRAIN, Pin.ANALOG. Se o modo estiver definido como Pin.IN, o pino será configurado para entrada digital. Para dispositivos externos, este pino está em estado de alta impedância. Se o modo estiver definido como Pin.OUT, o pino será configurado para saída digital. Se o modo estiver definido como Pin.OPEN_DRAIN, o pino será configurado para saída de dreno aberto. Isso significa que se o pino estiver definido como 0, ele estará ativo em LOW. Se definido como 1, ele entra em um estado de alta impedância, onde fica em um estado flutuante até ser puxado para baixo ou para cima por um circuito externo. Nem todas as portas/microcontroladores suportam saída de dreno aberto. Se o modo estiver definido como Pin.ALT, o pino será configurado para funções alternativas como funções SPI, I2C ou UART atribuídas a ele em uma determinada porta. O modo Pin.ALT_OPEN_DRAIN é igual ao Pin.ALT, exceto que configura o pino open-drain. Se o modo estiver definido como Pin.ANALOG, o pino será configurado para entrada analógica.

puxar: Especifica o pull-up/pull-down interno quando o pino está configurado como entrada. É especificado pelas seguintes constantes – None, Pin.PULL_UP e Pin.PULL_DOWN. Se o pull estiver definido como Nenhum, nem o resistor pull-up nem o pull-down serão habilitados. Se pull estiver definido como Pin.PULL_UP, o resistor pull-up será habilitado no pino especificado. Se pull estiver definido como Pin.PULL_DOWN, o resistor pull-down será habilitado no pino especificado.

valor: Especifica o nível de sinal do pino se seu modo estiver definido como OUT ou OPEN_DRAIN. Se definido como 0, o sinal de saída é BAIXO. Se definido como 1, o sinal de saída será definido como ALTO.

dirigir: Especifica a potência de saída ou capacidade de transporte de corrente de saída de um determinado pino. Pode ser definido como Pin.DRIVE_0, Pin.DRIVE_1, Pin.DRIVE_2 ou Pin.DRIVE_3, correspondendo à potência de saída ascendente conforme mencionado na tabela abaixo.

Por exemplo, a instrução a seguir define o pino 2 de uma determinada porta como saída digital.
p2 = Pino (2, Pino.OUT)

Da mesma forma, a instrução a seguir define o pino 1 de uma determinada porta como uma entrada digital com pull-up interno habilitado.
p1 = Pino (1, Pino.IN, Pino.PULL_UP)

Ao contrário da programação típica de microcontroladores, o MicroPython permite alterar o modo e outros parâmetros de um pino no meio do programa. Isso é feito reinicializando o pino usando o método Pin.init . Este método é definido como segue.
Pin.init(modo=- 1, pull=- 1, *, valor=Nenhum, drive=0, alt=- 1)

Os parâmetros do método Pin.init são especificados da mesma forma que no método Pin . O modo de um objeto pin também pode ser definido explicitamente chamando o método Pin.mode . Se Pin.mode for chamado sem argumentos, ele retornará o modo atual do pino fornecido. Da mesma forma, o método Pin.pull permite definir ou obter o estado de tração do pino, e Pin.drive permite obter ou definir a força de acionamento do pino.

A lógica digital em um determinado pino é obtida ou definida usando o método Pin.value . É definido da seguinte forma.
Pino.valor((x))

Se chamado sem argumentos, retorna o nível lógico digital do pino. Se o pino estiver definido como Pin.IN, ele retornará o valor de entrada real atualmente presente no pino. Se o pino estiver definido como Pin.OUT, ele retornará um valor indefinido. Se o pino estiver definido como Pin.OPEN_DRAIN, retornará um valor indefinido se definido como 0, caso contrário, retornará o valor de entrada real atualmente presente no pino se definido como 1. Se Pin.value for fornecido com um argumento, ele deverá seja um booleano, ou seja, verdadeiro/1 ou falso/0. Se o pino fornecido for definido como Pin.OUT, o valor passado será imediatamente definido no buffer de saída. Se o pino for definido como Pin.IN, o valor será armazenado no buffer de saída e se tornará ativo quando o pino for definido como Pin.OUT ou Pin.OPEN_DRAIN. Até então, o pino permanece em estado de alta impedância. Se o pino estiver definido como Pin.OPEN_DRAIN, um valor 0/falso define o pino para um estado de baixa tensão, enquanto um valor 1/verdadeiro define o pino para um estado de alta impedância, onde um circuito externo aciona o pino. O método Pin.__call__ é semelhante ao método Pin.value , exceto que é mais rápido que o método Pin.value .

A saída em um pino também pode ser definida como 1 chamando os métodos Pin.high ou Pin.on . Da mesma forma, a saída em um pino pode ser definida como 0 chamando os métodos Pin.low ou Pin.off . O método Pin.irq serve para lidar com as interrupções dos pinos.

Alguns métodos também possuem alguns parâmetros específicos de porta. Por exemplo, no ESP32, o parâmetro hold nos métodos Pin e Pin.init permite ativar o recurso pad hold do ESP32. Se a retenção estiver definida como True, a configuração do pino será mantida e quaisquer alterações adicionais não serão aplicadas. Quaisquer configurações de pinos definidas após definir o hold como True serão aplicadas somente quando o hold for definido como False. Se a retenção for novamente definida como True, quaisquer alterações recentes na configuração serão aplicadas e o pino será configurado para retenção novamente.

Recursos do ESP8266 e configuração de pinos
Estaremos executando nossos códigos MicroPython em placas ESP8266 e ESP32. ESP8266 possui 17 GPIO, uma interface SPI e HSPI, um I2C, dois UART, uma interface de entrada e saída I2S com DMA e um ADC de 10 bits. O I2C é implementado em software que pode ser multiplexado em qualquer GPIO. ESP8266 está disponível em uma variedade de placas de breakout. A forma como os diferentes pinos e periféricos são expostos difere entre as diferentes placas ESP8266. As placas ESP8266 mais populares são ESP8266-01 e ESP8266-12E. A pinagem do ESP8266-01 é mostrada na imagem abaixo.

Diagrama de pinos do módulo ESP01 ESP8266

Diagrama de pinos do chip bare ESP8266-12E

Diagrama de pinos do kit ESP8266-12E NodeMCU

O chip ESP8266-12E possui a seguinte pinagem.
A placa breakout ESP8266-12E tem a seguinte pinagem.

Entrada/saída digital em ESP8266
GPIOs ESP8266 são compatíveis com 3V3 e podem drenar ou fornecer no máximo 40 mA. Como podemos ver, GPIO6, GPIO7, GPIO8 e GPIO11 não estão disponíveis para entrada/saída na placa breakout ESP-12E, que normalmente está disponível como um kit NodeMCU. O GPIO6 é exposto como ADC0 na placa breakout. O GPIO6 ~ GPIO11 está conectado ao chip Flash. É por isso que não é recomendado usá-los para entrada/saída digital. Ficamos então com GPIO0~GPIO5 e GPIO12~GPIO16.

O GPIO0 é usado para configurar o ESP8266 no modo bootloader. É por isso que o GPIO0 só pode ser usado após gravar o firmware MicroPython no ESP8266. Da mesma forma, GPIO16 é usado para despertar o ESP8266 de um sl profundo; portanto, deve ser evitado para entrada/saída digital se o modo de suspensão profunda for utilizado no aplicativo incorporado.

Ao montar um circuito externo com ESP8266, o comportamento de inicialização de seus pinos GPIO precisa ser considerado. Quando o ESP8266 é inicializado, a placa usa GPIO0, GPIO1, GPIO2, GPIO3, GPIO9, GPIO10, GPIO15 e GPIO16. O GPIO1, GPIO3, GPIO9, GPIO10 e GPIO16 são puxados para ALTO na inicialização, enquanto outros GPIOs, exceto GPIO4 e GPIO5, emitem um sinal BAIXO. Portanto, se algum relé for acionado no circuito conectado ao ESP8266, apenas GPIO4 e GPIO5 serão adequados para conectar os relés. Todos os outros GPIOs podem resultar em operações de relé autônomas devido ao comportamento estranho dos GPIOs com o circuito de acionamento do relé durante a inicialização. Também deve ser observado que a inicialização falhará se GPIO0, GPIO1 e GPIO2 forem puxados externamente para baixo no circuito. A inicialização também falhará se o GPIO15 for puxado externamente para cima no circuito. Portanto, os seguintes cuidados devem ser tomados ao montar um circuito externo com ESP8266.

  1. Qualquer driver de relé, se conectado ao circuito, deve ter interface apenas em GPIO4 e GPIO5.
  2. O GPIO0, GPIO1 e GPIO2 nunca devem ser reduzidos pelo circuito externo.
  3. O GPIO15 nunca deve ser elevado pelo circuito externo.
  4. O GPIO16 não deve ser usado para E/S digital se o modo de hibernação profunda do ESP8266 for utilizado no aplicativo incorporado.
  5. O GPIO0 deve ser evitado se o ESP8266 precisar de carregamento de inicialização várias vezes durante o desenvolvimento do aplicativo.

Por fim, deve-se lembrar que a interface I2C do ESP8266 está disponível no GPIO4 (I2C SDA) e GPIO5 (I2C SCL) no kit NodeMCU. A interface SPI está disponível em GPIO12 (MISO), GPIO13 (MOSI), GPIO14 (SCK) e GPIO15 (CS). O PWM está disponível em todos os GPIO, enquanto as interrupções estão disponíveis em todos os GPIOs, exceto GPIO16.

Recursos ESP32 e configuração de pinos
ESP32 é uma placa de desenvolvimento Wi-Fi superior em comparação com ESP8266. Possui 39 GPIOs, dos quais 34 GPIO são entradas/saídas digitais normais. Ele vem com 18 canais ADC, 16 canais de saída PWM, 3 UART, 3 interfaces SPI, 2 interfaces I2C, 2 DAC, 2 interfaces I2S e 10 GPIOs de detecção capacitiva. O chip ESP-WROOM-32 simples possui o seguinte diagrama de pinos.

O ESP32-DevKit V1 possui o seguinte diagrama de pinos.

Diagrama de pinos do chip ESP-WROOM-32

O ESP32-DevKit V1 possui o seguinte diagrama de pinos.

Diagrama de pinos do módulo ESP32 DevKit V1

Entrada/saída digital no ESP32
Os GPIOs ESP32 são compatíveis com 3V3 e podem fornecer ou absorver no máximo 40 mA. Porém, a placa de desenvolvimento também pode ser alimentada por uma fonte de 5V, pois possui um regulador de tensão integrado. Existem 39 GPIOs no ESP32. Estes GPIO6 ~ GPIO11 estão conectados ao flash SPI interno; portanto, é melhor evitá-los. O GPIO28 ~ GPIO31 não está exposto na placa de desenvolvimento. O GPIO34, GPIO35, GPIO36 e GPIO39 são apenas de entrada. Resto todos os GPIOs podem ser usados ​​tanto para entrada quanto para saída digital.

Assim como o ESP8266, o ESP32 também mostra algum comportamento estranho em alguns de seus GPIO durante a inicialização. O GPIO1, GPIO3, GPIO5, GPIO6 ~ GPIO11, GPIO14 e GPIO15 são puxados para ALTO durante a inicialização, e o sinal PWM de saída GPIO0, GPIO5 GPIO14 e GPIO15 durante a inicialização. Durante a inicialização, o GPIO1 está ativado para depurar a saída. Portanto, se houver interface no circuito, nenhum driver de relé deverá ser conectado a esses pinos. Caso contrário, o circuito de acionamento do relé exibirá comportamento autônomo devido ao estado estranho desses GPIOs durante a inicialização.

Também deve ser lembrado que o UART está disponível nos seguintes pinos.

Existem dois canais I2C no ESP32. Os pinos I2C padrão no ESP32 são GPIO21 e GPIO22. Porém, o software I2C pode ser implementado em qualquer GPIO.

Existem 3 canais SPI no ESP32, dos quais um é reservado para comunicação com memória flash e dois canais estão disponíveis para uso. Esses dois canais são SPI de hardware (HSPI) e SPI virtual (VSPI). Os canais SPI estão disponíveis nos seguintes pinos.

Existem 16 canais PWM no ESP32. Eles podem ser multiplexados para gerar saída PWM em todos os pinos, exceto GPIO34 ~ GPIO39. As interrupções de pinos estão disponíveis em todos os GPIOs. Os GPIOs capacitivos são GPIO4 (T0), GPIO0 (T1), GPIO2 (T2), GPIO15 (T3), GPIO13 (T4), GPIO12 (T5), GPIO14 (T6), GPIO27 (T7), GPIO33 (T8) e GPIO32 (T9). Os GPIOs RTC são GPIO36 (RTC_GPIO0), GPIO39 (RTC_GPIO3), GPIO34 (RTC_GPIO4), GPIO35 (RTC_GPIO5), GPIO25 (RTC_GPIO6), GPIO26 (RTC_GPIO7), GPIO33 (RTC_GPIO8), GPIO32 (RTC_GPIO9), GPIO4 (RTC_GPIO10), GPIO0 (RTC_GPIO11), GPIO2 (RTC_GPIO12), GPIO15 (RTC_GPIO13), GPIO13 (RTC_GPIO14), GPIO12 (RTC_GPIO15), GPIO14 (RTC_GPIO16) e GPIO27 (RTC_GPIO17).Os canais ADC são multiplexados para GPIO36 (ADC1_CH0), GPIO37 (ADC1_CH1), GPIO38 (ADC1_CH2), GPIO39 (ADC1_CH3), GPIO32 (ADC1_CH4), GPIO33 (ADC1_CH5), GPIO34 (ADC1_CH6), GPIO35 (ADC1_CH7), GPIO4 (ADC2_CH0) , GPIO0 (ADC2_CH1), GPIO2 (ADC2_CH2), GPIO15 (ADC2_CH3), GPIO13 (ADC2_CH4), GPIO12 (ADC2_CH5), GPIO14 (ADC2_CH6), GPIO27 (ADC2_CH7), GPIO25 (ADC2_CH8) e GPIO26 (ADC2_CH9). Os canais DAC estão disponíveis em GPIO25 (DAC1) e GPIO26 (DAC2).

Acionando um LED ligando ESP8266/ESP32
Agora equipados com o conhecimento de entrada/saída digital em MicroPython e familiarizados com a configuração de pinos e recursos do ESP8266/ESP32, podemos acionar componentes como LEDs do ESP8266/ESP32 e controlar sua comutação usando botões. Vamos ligar/desligar um LED por meio de um interruptor tátil no ESP8266 usando o código MicroPython.

Componentes necessários

  1. ESP8266x1
  2. LEDx1
  3. Resistência de 330Ω x2
  4. Botão de pressão x1
  5. Conectando fios/fios de jumper
  6. Tábua de ensaio

Conexões de circuito
Conecte o ânodo do LED ao GPIO5 do ESP8266 e conecte seu cátodo ao terra através de um resistor em série de 330 ohm. Conecte o botão no GPIO4 do ESP8266 puxado para baixo por um resistor de 330 ohm.

Observe que o firmware MicroPython deve ser carregado no ESP8266. O código Python pode ser escrito e enviado para ESP8266 usando uPyCraft ou Thonny IDE.

Código Python
do Pin de importação da máquina
do tempo importar sono
led = Pino (5, Pino.OUT)
botão = Pino (4, Pino.IN)
enquanto Verdadeiro:
led.valor(botão.valor )
dormir (0,5)

Trabalhando
O script começa importando a classe Pin do módulo de máquina e a classe sleep do módulo de tempo. O GPIO5 é configurado como saída digital para acionar LED. O GPIO4 é configurado como uma entrada digital com um botão conectado em uma configuração baixa puxada. No loop while, a saída do GPIO5 é definida como a entrada do GPIO4. O GPIO4 é reduzido por padrão, então o LED permanece apagado. Sempre que o botão é pressionado, o GPIO4 vai para HIGH, um sinal HIGH é passado no GPIO5 simultaneamente e o LED começa a brilhar.

Resultado

(Link para vídeo de demonstração ESP04-DV)

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

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