IO Expander pentru ESP32, ESP8266 și Arduino: 24 de pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Doriți să extindeți IO-urile ESP32, ESP8266 sau Arduino? Și v-ați gândit la posibilitatea a 16 noi GPIO-uri care pot fi controlate folosind magistrala I2C? Ei bine, astăzi, vă voi prezenta expansorul GPIO MCP23016. De asemenea, vă voi arăta cum să comunicați un microcontroler cu MCP23016. Voi vorbi și despre crearea unui program în care vom folosi doar 2 pini ai acestui microcontroler pentru a comunica cu expansorul. Le vom folosi pentru controlul LED-urilor și al butonului.

Pasul 1: Introducere

Dispozitivul MCP23016 oferă 16 biți pentru extinderea GPIO utilizând magistrala I2C. Fiecare bit poate fi configurat individual (intrare sau ieșire).

MCP23016 constă din mai multe setări de 8 biți pentru intrare, ieșire și selectarea polarității.

Extensiile oferă o soluție simplă atunci când sunt necesare IO-uri pentru comutatoare, senzori, butoane și LED-uri, printre alte exemple.

Pasul 2: Caracteristici

16 pini de intrare / ieșire (16 intrări standard)

Frecvență rapidă a ceasului autobuzului I2C (0-400 kbits / s)

Trei pini de adresă hardware permit utilizarea a până la opt dispozitive

Întrerupere Port Capture Recorder

Registrul de inversare a polarității pentru setarea polarității datelor portului de intrare

Compatibil cu majoritatea microcontrolerelor

Pasul 3: ESP01 poate avea 128 GPIO

Un exemplu care arată amploarea acestui expansor este utilizarea sa cu ESP01, care poate fi conectat la până la opt expansoare cu doar două IOS, ajungând la 128 GPIO.

Pasul 4: MCP23016

Aici avem schema expansorului, care are două grupuri de opt biți. Acest lucru face pentru un total de 16 porturi. În plus față de un pin de întrerupere, acesta are pinul CLK, care conectează condensatorul și rezistorul, care sunt conectate intern într-un port logic. Aceasta este pentru a forma ceasul, folosind ideea unui oscilator de cristal, care are nevoie de ceas de 1 MHz. Pinul TP este folosit pentru a măsura ceasul. Pinii A0, A1 și A2 sunt adrese binare.

Pasul 5: CLOCK

Prin urmare, MCP23016 utilizează un circuit RC extern pentru a determina viteza ceasului intern. Un ceas intern de 1 MHz este necesar (de obicei) pentru ca dispozitivul să funcționeze corect. Ceasul intern poate fi măsurat pe pinul TP. Valorile recomandate pentru REXT și CEXT sunt prezentate mai jos.

Pasul 6: Adresă

Pentru a defini adresa MCP23016, vom folosi apoi pinii A0, A1 și A2. Lăsați-le la HIGH sau LOW pentru schimbarea adresei.

Adresa va fi formată după cum urmează:

MCP_Address = 20 + (A0 A1 A2)

Unde A0 A1 A2 poate lua valori HIGH / LOW, acesta formează un număr binar de la 0 la 7.

De exemplu:

A0> GND, A1> GND, A2> GND (înseamnă 000, apoi 20 + 0 = 20)

Sau, A0> HIGH, A1> GND, A2> HIGH (adică 101, apoi 20 + 5 = 25)

Pasul 7: Comenzi

Mai jos este un tabel cu comenzile pentru comunicare. Să folosim GP0 și GP1, precum și IODIR0 și IODIR1.

Pasul 8: Categorii:

GP0 / GP1 - Registre de porturi de date

Există două registre care oferă acces la cele două porturi GPIO.

Citirea registrului oferă starea pinilor de pe acel port.

Bit = 1> HIGH Bit = 0> LOW

OLAT0 / OLAT1 - ieșire REGISTRE LACTCH

Există două registre care oferă acces la porturile de ieșire ale celor două porturi.

IPOL0 / IPOL1 - Registre de polaritate de intrare

Aceste registre permit utilizatorului să configureze polaritatea datelor portului de intrare (GP0 și GP1).

IODIR0 / IODIR1

Există două registre care controlează modul pin. (Intrare sau ieșire)

Bit = 1> INPUT Bit = 0> OUTPUT

INTCAP0 / INTCAP1 - Registre de captură de întrerupere

Acestea sunt registre care conțin valoarea portului care a generat întreruperea.

IOCON0 / IOCON1 - Registrul de control al expansiunii I / O

Aceasta controlează funcționalitatea MCP23016.

Setarea bitului 0 (IARES> Interrupt Activity Resolution) controlează frecvența de eșantionare a pinilor portului GP.

Bit0 = 0> (implicit) Timpul maxim de detectare a activității portului este de 32 ms (consum redus de energie)

Bit0 = 1> timpul maxim de detectare a activității pe port este de 200usec (consum mai mare de energie)

Pasul 9: Structura pentru comunicare

Arăt aici clasa Wire, care este comunicația I2C în nucleul nostru Arduino, care permite, de asemenea, expansorului să lucreze cu Arduino Uno și Mega. Cu toate acestea, acesta din urmă are deja mai multe IO-uri. Ne ocupăm aici de adresele cipului, controlul accesului, care sunt codurile registrelor, precum și datele.

Pasul 10: Program

Programul nostru constă în comunicarea ESP32 cu MCP23016 pentru a avea mai multe GPIO-uri de utilizat. Vom avea apoi un buton și câteva LED-uri conectate la MCP23016. Le vom controla pe toate folosind doar magistrala I2C. Astfel, vor fi folosiți doar doi pini ESP32. Puteți vedea circuitul de imagine de mai jos în videoclip.

Pasul 11: ESP01

Aici, arăt Pinout-ul ESP01.

Pasul 12: Montarea ESP01

În acest exemplu, avem GPIO0 conectat în SDA și GPIO2 conectat în SCL. Avem, de asemenea, o placă de releu, un buzzer și un LED. Pe celălalt port, în GP1.0, mai avem încă un LED cu rezistor.

Pasul 13: NodeMCU ESP-12E

Aici avem Pinout-ul NodeMCU ESP-12E.

Pasul 14: Montarea NodeMCU ESP-12E

În acest caz, singura diferență față de primul exemplu este că ați conectat D1 și D2 în SDA și, respectiv, SCL.

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

Iată Pinout-ul WiFi NodeMCU-32S ESP-WROOM-32.

Pasul 16: nod de montare WiFi MCU-32S ESP-WROOM-32

De această dată, diferența principală față de celelalte două exemple este butonul și cele trei LED-uri care clipesc. Aici, SDA este conectat la GPIO19, în timp ce SCL este conectat la GPIO23.

Pasul 17: Biblioteci și variabile

Mai întâi, vom include Wire.h, care este responsabil pentru comunicarea i2c, precum și setarea adresei i2c a MCP23016. Arăt mai multe comenzi, chiar și unele pe care nu le folosim în acest proiect.

#include // specifică utilizarea bibliotecii Wire.h. // endereço I2C do MCP23016 #define MCPAddress 0x20 // COMANDĂ BYTE PENTRU ÎNREGISTRAREA RELAȚIEI: Tabel: 1-3 din 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 #defin IODIR0 0x / 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 ÎNREGISTRARE 0 #define IOCON1 0x0B // I / O EXPANDER CONTROL REGISTER 1

Pasul 18: Configurare

Aici avem funcțiile de inițializare a patru tipuri diferite de microcontrolere. De asemenea, verificăm frecvența, configurăm GPIO-urile și setăm pinii. În buclă, verificăm starea butonului.

void setup () {Serial.begin (9600); întârziere (1000); Wire.begin (19, 23); // ESP32 // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (); // arduino // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frecvență // configurare GPIO0 ca OUTPUT (toți pinii) configurePort (IODIR0, OUTPUT); // configura o GPIO1 ca INPUT sau GP1.0 și ca OUTPUT ca și alte GP1 configurePort (IODIR1, 0x01); // seta toți pinii do GPIO0 ca LOW writeBlockData (GP0, B00000000); // seta toți pinii do GPIO1 ca LOW writeBlockData (GP1, B00000000); } void loop () {// verificarea e-a botei GP a fost presat checkButton (GP1); } // sfârșitul buclei

Pasul 19: ConfigurePort

În acest pas, configurăm modul pinilor GPIO și identificăm modul porturilor.

// configura o GPIO (GP0 sau GP1) // ca parametru pasam: // port: GP0 sau GP1 // personalizat: INPUT pentru toți ca porti de GP de lucru ca intrare // OUTPUT pentru toți ca porti de GP de lucru ca saida / / custom um valor de 0-255 indicando o modo das portas (1 = INPUT, 0 = OUTPUT) // ex: 0x01 ou B00000001 ou 1: indica ce apenas o GPX.0 lucrare ca intrare, sau restand ca saida void configurePort (uint8_t port, uint8_t custom) {if (custom == INPUT) {writeBlockData (port, 0xFF); } else if (custom == OUTPUT) {writeBlockData (port, 0x00); } else {writeBlockData (port, personalizat); }}

Pasul 20: WriteBlockData & CheckButton

Aici, trimitem date către MCP23016 prin magistrala i2c, verificăm starea butonului și indicăm următorul pas ținând cont de starea de a fi apăsat sau nu.

// 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 (date); Wire.endTransmission (); întârziere (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); } // caz contrar lasă toate em stare LOW else {writeBlockData (GP0, B00000000); }}

Pasul 21: ReadPin & ValueFromPin

Ne ocupăm aici de citirea unui pin specific și de revenirea valorii bitului în poziția dorită.

// faz a leitura de um pino specific // 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 octet 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; }

Pasul 22: Programul ESP8266

De aici, vom vedea cum a fost creat programul pe care l-am folosit în ESP-01 și în nodul MCU ESP-12E, ceea ce ne permite să înțelegem cum diferențele dintre ele sunt minime.

Vom modifica doar linia constructorului de comunicații i2c, care este metoda de început a obiectului Wire.

Decomentați linia conform plăcii pe care o vom compila.

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

Înființat

Observați că constructorul este încă comentat. Prin urmare, decomentați în funcție de placa dvs. (ESP-01 sau nod MCU ESP12-E).

void setup () {Serial.begin (9600); întârziere (1000); // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frecvență // configurare GPIO0 ca OUTPUT (toți pinii) configurePort (IODIR0, OUTPUT); // configura o GPIO1 ca OUTPUT (todos os pinos) configurePort (IODIR1, OUTPUT); // seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); // seta toți pinii do GPIO1 ca LOW writeBlockData (GP1, B00000001); }

Buclă

În buclă, schimbăm pinii la fiecare 1 secundă. Astfel, atunci când pin0 din GP0 este activat, pinii GP1 sunt opriți. Când pin-ul GP1 este activat, pinii GP0 sunt opriți.

void loop () {// seta o pino 7 do GP0 como HIGH e os demais como LOW writeBlockData (GP0, B10000000); // seta toți pinii do GPIO1 ca LOW writeBlockData (GP1, B00000000); întârziere (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); întârziere (1000); } // sfârșitul buclei

Pasul 23: IMPORTANT

Variabilele și biblioteca utilizate sunt aceleași cu cele din programul pe care l-am făcut pentru ESP32, precum și metodele configurePort și writeBlockData.

Pasul 24: Fișiere

Descărcați fișierele:

PDF

INO (ESP8266)

INO (ESP32)