IO Expander per ESP32, ESP8266 i Arduino: 24 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

Voleu ampliar les E / S del vostre ESP32, ESP8266 o Arduino? I heu pensat en la possibilitat de 16 nous GPIO que es puguin controlar mitjançant el bus I2C? Bé, avui us presentaré l’expansor GPIO MCP23016. A més, us mostraré com comunicar un microcontrolador amb l’MCP23016. També parlaré de la creació d’un programa on només utilitzarem 2 pins d’aquest microcontrolador per comunicar-nos amb l’expansor. Els utilitzarem per controlar els LED i el botó.

Pas 1: Introducció

El dispositiu MCP23016 proporciona 16 bits per a l'expansió GPIO mitjançant el bus I2C. Cada bit es pot configurar individualment (entrada o sortida).

El MCP23016 consisteix en diversos paràmetres de 8 bits per a la selecció d’entrada, sortida i polaritat.

Els expansors proporcionen una solució senzilla quan es necessiten E / S per a commutadors, sensors, botons i LED, entre altres exemples.

Pas 2: Característiques

16 pins d'entrada / sortida (16 estàndards d'entrada)

Freqüència de rellotge de bus I2C ràpida (0-400 kbits / s)

Tres pins d'adreces de maquinari permeten l'ús de fins a vuit dispositius

Gravador de captures de ports d’interrupció

Registre d'inversió de polaritat per configurar la polaritat de les dades del port d'entrada

Compatible amb la majoria de microcontroladors

Pas 3: ESP01 pot tenir 128 GPIO

Un exemple que mostra la magnitud d’aquest expansor és el seu ús amb ESP01, que es pot connectar a fins a vuit expandidors amb només dos IOS, arribant a 128 GPIO.

Pas 4: MCP23016

Aquí tenim l'esquema de l'expansor, que té dos grups de vuit bits. Això suposa un total de 16 ports. A més d’un pin d’interrupció, té el pin CLK, que connecta el condensador i la resistència, que es connecten internament en un port lògic. Es tracta de formar el rellotge, utilitzant la idea d’un oscil·lador de cristall, que necessita un rellotge d’1 MHz. El pin TP serveix per mesurar el rellotge. Els pins A0, A1 i A2 són adreces binàries.

Pas 5: RELLOTGE

Per tant, el MCP23016 utilitza un circuit RC extern per determinar la velocitat del rellotge intern. Cal un rellotge intern d'1 MHz (normalment) perquè el dispositiu funcioni correctament. El rellotge intern es pot mesurar amb el pin TP. Els valors recomanats per a REXT i CEXT es mostren a continuació.

Pas 6: adreça

Per definir l'adreça de l'MCP23016, fem servir els pins A0, A1 i A2. Deixeu-los a HIGH o LOW per canviar l'adreça.

L'adreça es formarà de la següent manera:

MCP_Address = 20 + (A0 A1 A2)

Quan A0 A1 A2 pot prendre valors ALT / BAIX, es forma un número binari del 0 al 7.

Per exemple:

A0> GND, A1> GND, A2> GND (vol dir 000, llavors 20 + 0 = 20)

O sino, A0> HIGH, A1> GND, A2> HIGH (que significa 101, llavors 20 + 5 = 25)

Pas 7: ordres

A continuació es mostra una taula amb les ordres de comunicació. Utilitzem GP0 i GP1, així com IODIR0 i IODIR1.

Pas 8: categories:

GP0 / GP1: registres de ports de dades

Hi ha dos registres que proporcionen accés als dos ports GPIO.

La lectura del registre proporciona l'estat dels pins d'aquest port.

Bit = 1> ALT Bit = 0> BAIX

OLAT0 / OLAT1 - REGISTRES DE LACTCH de sortida

Hi ha dos registres que proporcionen accés als ports de sortida dels dos ports.

IPOL0 / IPOL1: registres de polaritat d’entrada

Aquests registres permeten a l'usuari configurar la polaritat de les dades del port d'entrada (GP0 i GP1).

IODIR0 / IODIR1

Hi ha dos registres que controlen el mode pin. (Entrada o sortida)

Bit = 1> INPUT Bit = 0> OUTPUT

INTCAP0 / INTCAP1 - Registres de captura d’interrupcions

Es tracta de registres que contenen el valor del port que va generar la interrupció.

IOCON0 / IOCON1 - Registre de control d’expansió d’E / S

Això controla la funcionalitat de l'MCP23016.

La configuració del bit 0 (IARES> Interrupt Activity Resolution) controla la freqüència de mostreig dels pins del port GP.

Bit0 = 0> (per defecte) El temps màxim de detecció de l'activitat del port és de 32 ms (consum baix d'energia)

Bit0 = 1> El temps màxim de detecció d’activitat al port és de 200 segons (consum d’energia superior)

Pas 9: Estructura per a la comunicació

Aquí mostro la classe Wire, que és la comunicació I2C al nostre nucli Arduino, que també permet que l'expansor funcioni amb l'Arduino Uno i Mega. Tot i això, aquest últim ja té diverses E / S. Aquí tractem les adreces del xip, el control d’accés, que són els codis dels registres, així com les dades.

Pas 10: programa

El nostre programa consisteix a comunicar l’ESP32 amb l’MCP23016 per tenir més GPIO a utilitzar. Aleshores tindrem un botó i alguns LED connectats al MCP23016. Els controlarem tots utilitzant només el bus I2C. Així, només s’utilitzaran dos pins ESP32. Podeu veure el circuit d’imatges a continuació al vídeo.

Pas 11: ESP01

Aquí mostro el Pinout d’ESP01.

Pas 12: muntatge de ESP01

En aquest exemple, tenim el GPIO0 connectat al SDA i el GPIO2 connectat al SCL. També tenim una placa de relés, un brunzidor i un LED. A l’altre port, a GP1.0, tenim un LED més amb una resistència.

Pas 13: NodeMCU ESP-12E

Aquí tenim el Pinout del NodeMCU ESP-12E.

Pas 14: muntatge de NodeMCU ESP-12E

En aquest cas, l'única diferència respecte al primer exemple és que heu connectat D1 i D2 a l'SDA i SCL, respectivament.

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

Aquí teniu el Pinout del WiFi NodeMCU-32S ESP-WROOM-32.

Pas 16: Node de muntatge WiFi MCU-32S ESP-WROOM-32

Aquesta vegada, la diferència principal dels altres dos exemples és el botó i els tres LED parpellejants. Aquí, l'SDA està connectat al GPIO19, mentre que el SCL està connectat al GPIO23.

Pas 17: biblioteques i variables

En primer lloc, inclourem Wire.h, que s’encarrega de la comunicació i2c, així com establir l’adreça i2c de MCP23016. Mostro diverses ordres, fins i tot algunes que no fem servir en aquest projecte.

#include // especifica l’ús de la biblioteca Wire.h. // endereço I2C do MCP23016 #define MCPAddress 0x20 // COMMAND BYTE TO REGISTER RELATION: Table: 1-3 of Microchip MCP23016 - DS20090A // ENDEREÇOS DE REGISTRADORES #define GP0 0x00 // DATA PORT REGISTER 0 #define GP1 0x01 // DATA PORT REGISTER 1 #define OLAT0 0x02 // OUTPUT LATCH REGISTER 0 #define OLAT1 0x03 // OUTPUT LATCH REGISTER 1 #define IPOL0 0x04 // INPUT POLARITY PORT REGISTER 0 #define IPOL1 0x05 // INPUT POLARITY PORT REGISTER 1 #de0 IODIR0 0 / REGISTRE DIRECCIÓ E / S 0 # definir IODIR1 0x07 // REGISTRE DIRECCIÓ E / S 1 # definir INTCAP0 0x08 // REGISTRE CAPTURA INTERRUPCIÓ 0 # definir INTCAP1 0x09 // REGISTRE CAPTURA INTERRUPT 1 # definir IOCON0 0x0A // CONTROL EXPANDIDOR I / O REGISTRE 0 #define IOCON1 0x0B // REGISTRE DE CONTROL D'EXPANDIDOR I / O 1

Pas 18: configuració

Aquí tenim les funcions per inicialitzar quatre tipus diferents de microcontroladors. També comprovem la freqüència, configurem els GPIO i configurem els pins. Al bucle, comprovem l’estat del botó.

configuració nul·la () {Serial.begin (9600); retard (1000); Wire.begin (19, 23); // ESP32 // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (); // arduino // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // freqüència // configuració o GPIO0 com OUTPUT (tots els pinos) configurePort (IODIR0, OUTPUT); // configura o GPIO1 com INPUT o GP1.0 i com a SORTIDA com altres GP1 configurePort (IODIR1, 0x01); // set all os pinos do GPIO0 com LOW writeBlockData (GP0, B00000000); // set all os pinos do GPIO1 com LOW writeBlockData (GP1, B00000000); } void loop () {// verificació i botó GP que es va pressionar checkButton (GP1); } // final de bucle

Pas 19: ConfigurePort

En aquest pas, configurem el mode dels pins GPIO i identifiquem el mode dels ports.

// configura o GPIO (GP0 o GP1) // com a paràmetre passem: // port: GP0 o GP1 // personalitzat: INPUT per a totes les portes del GP treballant com a entrada // OUTPUT per a totes les portes del GP treballant com a saida / / custom um valor de 0-255 indicando o modo das portas (1 = INPUT, 0 = OUTPUT) // ex: 0x01 ou B00000001 ou 1: indica que apenas o GPX.0 treballant com a entrada, o restant com saida void configurePort (uint8_t port, uint8_t custom) {if (custom == INPUT) {writeBlockData (port, 0xFF); } else if (personalitzat == OUTPUT) {writeBlockData (port, 0x00); } else {writeBlockData (port, personalitzat); }}

Pas 20: WriteBlockData i CheckButton

Aquí, enviem dades al MCP23016 a través del bus i2c, comprovem l’estat del botó i indiquem el pas següent tenint en compte la condició de ser premut o no.

// 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 (dades); Wire.endTransmission (); retard (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); } // cas contrari deixa totes en estat LOW else {writeBlockData (GP0, B00000000); }}

Pas 21: ReadPin i ValueFromPin

Ens ocupem aquí de la lectura d’un pin específic i del retorn del valor de bit a la posició desitjada.

// faz a leitura de um pino específico // pin: 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 desejada // pin: posição do bit (0-7) // statusGP: valor lido do GP (0-255) uint8_t valueFromPin (uint8_t pin, uint8_t statusGP) {return (statusGP & (0x0001 << pin)) == 0? 0: 1; }

Pas 22: programa ESP8266

A partir d’aquí, veurem com es va crear el programa que vam utilitzar a ESP-01 i al nodeMCU ESP-12E, cosa que ens permet comprendre com les diferències entre elles són mínimes.

Només modificarem la línia del constructor de comunicació i2c, que és el mètode inicial de l'objecte Wire.

Simplement descomenteu la línia segons la placa que anem a compilar.

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

Configuració

Fixeu-vos que el constructor encara es comenta. Per tant, descomenteu segons el vostre tauler (ESP-01 o nodeMCU ESP12-E).

configuració nul·la () {Serial.begin (9600); retard (1000); // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frequencia // configura o GPIO0 com a OUTPUT (tots els pinos) configurePort (IODIR0, OUTPUT); // configura o GPIO1 com OUTPUT (tots els pinos) configurePort (IODIR1, OUTPUT); // seta tots os pinos do GPIO0 com LOW writeBlockData (GP0, B00000000); // seta tots os pinos do GPIO1 com LOW writeBlockData (GP1, B00000001); }

Bucle

Al bucle, canviem els pins cada 1 segon. Per tant, quan el pin0 de GP0 està activat, els pins de GP1 estan apagats. Quan el pin0 de GP1 està activat, els pins GP0 estan apagats.

void loop () {// seta o pino 7 do GP0 com HIGH e os dememais com LOW writeBlockData (GP0, B10000000); // set all os pinos do GPIO1 com LOW writeBlockData (GP1, B00000000); retard (1000); // seta tots os pinos do GPIO0 com LOW writeBlockData (GP0, B00000000); // seta o pino 0 do GP1 com HIGH e os dememais com LOW writeBlockData (GP1, B00000001); retard (1000); } // final de bucle

Pas 23: IMPORTANT

Les variables i la biblioteca utilitzades són les mateixes que les del programa que vam fer per a ESP32, així com els mètodes configurePort i writeBlockData.

Pas 24: fitxers

Descarregueu els fitxers:

PDF

INO (ESP8266)

INO (ESP32)