IO Expander para ESP32, ESP8266 e Arduino: 24 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Você gostaria de expandir os IOs de seu ESP32, ESP8266 ou Arduino? E você já pensou na possibilidade de 16 novos GPIOs que podem ser controlados usando o barramento I2C? Bem, hoje vou apresentar o expansor GPIO MCP23016. Além disso, vou mostrar como comunicar um microcontrolador com o MCP23016. Também falarei sobre a criação de um programa onde usaremos apenas 2 pinos deste microcontrolador para nos comunicarmos com o expansor. Vamos usá-los para controlar os LEDs e o botão.

Etapa 1: Introdução

O dispositivo MCP23016 fornece 16 bits para expansão GPIO usando o barramento I2C. Cada bit pode ser configurado individualmente (entrada ou saída).

O MCP23016 consiste em várias configurações de 8 bits para entrada, saída e seleção de polaridade.

Os expansores fornecem uma solução simples quando os IOs são necessários para interruptores, sensores, botões e LEDs, entre outros exemplos.

Etapa 2: Características

16 pinos de entrada / saída (padrão de 16 entradas)

Frequência de clock do barramento I2C rápido (0-400 kbits / s)

Três pinos de endereço de hardware permitem o uso de até oito dispositivos

Interromper o gravador de captura de porta

Registro de inversão de polaridade para definir a polaridade dos dados da porta de entrada

Compatível com a maioria dos microcontroladores

Etapa 3: ESP01 pode ter 128 GPIOs

Um exemplo que mostra a magnitude deste expansor é a sua utilização com o ESP01, que pode ser conectado a até oito expansores com apenas dois IOS, chegando a 128 GPIOs.

Etapa 4: MCP23016

Aqui, temos o esquema do expansor, que possui dois grupos de oito bits. Isso perfaz um total de 16 portas. Além de um pino de interrupção, possui o pino CLK, que conecta o capacitor e o resistor, que são conectados internamente em uma porta lógica. Isso é para formar o relógio, usando a ideia de um oscilador de cristal, que precisa de um relógio de 1MHz. O pino TP é usado para medir o relógio. Os pinos A0, A1 e A2 são endereços binários.

Etapa 5: RELÓGIO

O MCP23016, portanto, usa um circuito RC externo para determinar a velocidade do relógio interno. Um clock interno de 1 MHz é necessário (geralmente) para que o dispositivo funcione corretamente. O relógio interno pode ser medido no pino TP. Os valores recomendados para REXT e CEXT são mostrados abaixo.

Etapa 6: Endereço

Para definir o endereço do MCP23016, usamos os pinos A0, A1 e A2. Basta deixá-los em HIGH ou LOW para a mudança de endereço.

O endereço será formado da seguinte forma:

MCP_Address = 20 + (A0 A1 A2)

Onde A0 A1 A2 pode assumir valores ALTOS / BAIXOS, isso forma um número binário de 0 a 7.

Por exemplo:

A0> GND, A1> GND, A2> GND (significa 000, então 20 + 0 = 20)

Se não, A0> HIGH, A1> GND, A2> HIGH (significando 101, então 20 + 5 = 25)

Etapa 7: Comandos

Abaixo está uma tabela com os comandos para comunicação. Vamos usar GP0 e GP1, bem como IODIR0 e IODIR1.

Etapa 8: Categorias:

GP0 / GP1 - Registros de porta de dados

Existem dois registros que fornecem acesso às duas portas GPIO.

A leitura do registro fornece o status dos pinos nessa porta.

Bit = 1> HIGH Bit = 0> LOW

OLAT0 / OLAT1 - Saída LACTCH REGISTERS

Existem dois registros que fornecem acesso às portas de saída das duas portas.

IPOL0 / IPOL1 - Registros de polaridade de entrada

Esses registros permitem que o usuário configure a polaridade dos dados da porta de entrada (GP0 e GP1).

IODIR0 / IODIR1

Existem dois registros que controlam o modo de pin. (Entrada ou saída)

Bit = 1> Bit INPUT = 0> OUTPUT

INTCAP0 / INTCAP1 - Interromper registros de captura

São registros que contêm o valor da porta que gerou a interrupção.

IOCON0 / IOCON1 - Registro de controle do expansor de E / S

Isso controla a funcionalidade do MCP23016.

Definir o bit 0 (IARES> Resolução da atividade de interrupção) controla a frequência de amostragem dos pinos da porta GP.

Bit0 = 0> (padrão) O tempo máximo de detecção de atividade da porta é 32 ms (baixo consumo de energia)

Bit0 = 1> tempo máximo de detecção de atividade na porta é 200usec (maior consumo de energia)

Etapa 9: Estrutura para comunicação

Mostro aqui a classe Wire, que é a comunicação I2C em nosso Arduino central, que também permite que o expansor funcione com o Arduino Uno e Mega. No entanto, este último já possui vários IOs. Tratamos aqui dos endereços do chip, do controle de acesso, que são os códigos dos registradores, bem como dos dados.

Etapa 10: Programa

Nosso programa consiste em comunicar o ESP32 com o MCP23016 para ter mais GPIOs para usar. Teremos então um botão e alguns LEDs conectados ao MCP23016. Vamos controlar todos eles usando apenas o barramento I2C. Assim, apenas dois pinos ESP32 serão usados. Você pode ver o circuito de imagens abaixo no vídeo.

Etapa 11: ESP01

Aqui, mostro o Pinout do ESP01.

Etapa 12: Montagem do ESP01

Neste exemplo, temos o GPIO0 conectado no SDA e o GPIO2 conectado no SCL. Também temos uma placa de relé, uma campainha e um LED. Na outra porta, no GP1.0, temos mais um LED com resistor.

Etapa 13: NodeMCU ESP-12E

Aqui, temos o Pinout do NodeMCU ESP-12E.

Etapa 14: Montagem do NodeMCU ESP-12E

Nesse caso, a única diferença em relação ao primeiro exemplo é que você conectou D1 e D2 no SDA e no SCL, respectivamente.

Etapa 15: WiFi NodeMCU-32S ESP-WROOM-32

Aqui está a pinagem do WiFi NodeMCU-32S ESP-WROOM-32.

Etapa 16: Montagem WiFi NodeMCU-32S ESP-WROOM-32

Desta vez, a principal diferença em relação aos outros dois exemplos é o botão e os três LEDs piscando. Aqui, o SDA está conectado ao GPIO19, enquanto o SCL está conectado ao GPIO23.

Etapa 17: Bibliotecas e variáveis

Primeiro, incluiremos Wire.h, que é responsável pela comunicação i2c, bem como definir o endereço i2c de MCP23016. Mostro vários comandos, mesmo alguns que não usamos neste projeto.

#include // especifica o uso da biblioteca Wire.h. // endereço I2C do MCP23016 #define MCPAddress 0x20 // BYTE DE COMANDO PARA REGISTRO DE RELACIONAMENTO: Tabela: 1-3 do Microchip MCP23016 - DS20090A // ENDEREÇOS DE REGISTRADORES #define GP0 0x00 // REGISTRO DE PORTA DE DADOS 0 #define GP1 0x01 // DADOS PORT REGISTER 1 #define OLAT0 0x02 // OUTPUT LATCH REGISTER 0 #define OLAT1 0x03 // OUTPUT LATCH REGISTRO 1 #define IPOL0 0x04 // INPUT POLARITY PORT REGISTER 0 #define IPOL1 0x05 // INPUT POLARITY PORT REGISTER 1 #define IODIR0 0x06 / / I / O DIRECTION REGISTER 0 #define IODIR1 0x07 // I / O DIRECTION REGISTER 1 #define INTCAP0 0x08 // INTERRUPT CAPTURE REGISTER 0 #define INTCAP1 0x09 // INTERRUPT CAPTURE REGISTER 1 #define IOCON0 0x0A // I / O EXPANDER CONTROL REGISTRO 0 #define IOCON1 0x0B // REGISTRO DE CONTROLE DO EXPANDER I / O 1

Etapa 18: Configuração

Aqui temos as funções para inicializar quatro tipos diferentes de microcontroladores. Também verificamos a frequência, configuramos os GPIOs e configuramos os pinos. No Loop, verificamos o status do botão.

void setup () {Serial.begin (9600); atraso (1000); Wire.begin (19, 23); // ESP32 // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (); // arduino // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frequência // configura o GPIO0 como OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // configura o GPIO1 como INPUT o GP1.0 e como OUTPUT os outros GP1 configurePort (IODIR1, 0x01); // seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); // seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000000); } void loop () {// verifica e o botão GP foi pressionado checkButton (GP1); } // fim do loop

Etapa 19: ConfigurePort

Nesta etapa, configuramos o modo dos pinos GPIO e identificamos o modo das portas.

// configura o GPIO (GP0 ou GP1) // como parametro passamos: // porta: GP0 ou GP1 // custom: INPUT para todos as portas do GP trabalharem como entrada // OUTPUT para todos as portas do GP trabalharem como saida / / custom um valor de 0-255 indicando o modo das portas (1 = ENTRADA, 0 = SAÍDA) // ex: 0x01 ou B00000001 ou 1: indica que apenas o GPX.0 trabalhará como entrada, ou restando como saida void configurePort (porta uint8_t, uint8_t custom) {if (custom == INPUT) {writeBlockData (port, 0xFF); } else if (custom == OUTPUT) {writeBlockData (port, 0x00); } else {writeBlockData (porta, personalizado); }}

Etapa 20: WriteBlockData e CheckButton

Aqui, enviamos dados para o MCP23016 através do bus i2c, verificamos o estado do botão e indicamos o próximo passo levando em consideração a condição de estar pressionado ou não.

// envia dados para o MCP23016 através do barramento i2c // cmd: COMANDO (registrador) // data: dados (0-255) void writeBlockData (uint8_t cmd, uint8_t data) {Wire.beginTransmission (MCPAddress); Wire.write (cmd); Wire.write (dados); Wire.endTransmission (); atraso (10); }

// verifica se o botão foi pressionado // parametro GP: GP0 ou GP1 void checkButton (uint8_t GP) {// faz a leitura do pino 0 no GP fornecido uint8_t btn = readPin (0, GP); // se botão pressionado, seta para HIGH as portas GP0 if (btn) {writeBlockData (GP0, B11111111); } // caso contrario deixa todas em estado LOW else {writeBlockData (GP0, B00000000); }}

Etapa 21: ReadPin e ValueFromPin

Tratamos aqui da leitura de um pino específico e do retorno do valor do bit à posição desejada.

// faz uma leitura de um pino específico // pino: pino desejado (0-7) // gp: GP0 ou GP1 // retorno: 0 ou 1 uint8_t readPin (uint8_t pin, uint8_t gp) {uint8_t statusGP = 0; Wire.beginTransmission (MCPAddress); Wire.write (gp); Wire.endTransmission (); Wire.requestFrom (MCPAddress, 1); // ler do chip 1 byte statusGP = Wire.read (); return valueFromPin (pin, statusGP); } // retorna o valor do bit na posição // pin: posição do bit (0-7) // statusGP: valor lido do GP (0-255) uint8_t valorFromPin (uint8_t pin, uint8_t statusGP) {return (statusGP & (0x0001 << pino)) == 0? 0: 1; }

Etapa 22: Programa ESP8266

A partir daqui, veremos como foi criado o programa que usamos no ESP-01 e no nodeMCU ESP-12E, o que nos permite entender como as diferenças entre eles são mínimas.

Modificaremos apenas a linha do construtor de comunicação i2c, que é o método inicial do objeto Wire.

Apenas descomente a linha de acordo com a placa que iremos compilar.

// Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01

Configurar

Observe que o construtor ainda está comentado. Portanto, descomente de acordo com sua placa (ESP-01 ou nodeMCU ESP12-E).

void setup () {Serial.begin (9600); atraso (1000); // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frequência // configura o GPIO0 como OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // configura o GPIO1 como OUTPUT (todos os pinos) configurePort (IODIR1, OUTPUT); // seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); // seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000001); }

Ciclo

No loop, trocamos os pinos a cada 1 segundo. Portanto, quando o pino0 do GP0 está ativado, os pinos do GP1 estão desligados. Quando o pino0 do GP1 está ativado, os pinos do GP0 estão desligados.

void loop () {// seta o pino 7 do GP0 como HIGH e os demais como LOW writeBlockData (GP0, B10000000); // seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000000); atraso (1000); // seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); // seta o pino 0 do GP1 como HIGH e os demais como LOW writeBlockData (GP1, B00000001); atraso (1000); } // fim do loop

Etapa 23: IMPORTANTE

As variáveis e a biblioteca usadas são as mesmas do programa que fizemos para ESP32, bem como os métodos configurePort e writeBlockData.

Etapa 24: Arquivos

Baixe os arquivos:

PDF

INO (ESP8266)

INO (ESP32)