IO Expander voor ESP32, ESP8266 en Arduino - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Wil je de IO's van je ESP32, ESP8266 of Arduino uitbreiden? En heb je nagedacht over de mogelijkheid van 16 nieuwe GPIO's die via de I2C-bus kunnen worden aangestuurd? Welnu, vandaag ga ik u kennis laten maken met de GPIO-expander MCP23016. Ook laat ik je zien hoe je een microcontroller communiceert met de MCP23016. Ik zal het ook hebben over het maken van een programma waarbij we slechts 2 pinnen van deze microcontroller gebruiken om met de uitbreiding te communiceren. Deze gebruiken we voor het aansturen van de LED's en de knop.

Stap 1: Inleiding

Het MCP23016-apparaat biedt 16 bits voor GPIO-uitbreiding met behulp van de I2C-bus. Elke bit kan afzonderlijk worden geconfigureerd (ingang of uitgang).

De MCP23016 bestaat uit meerdere 8-bit instellingen voor invoer, uitvoer en polariteitsselectie.

De uitbreidingen bieden een eenvoudige oplossing wanneer de IO's nodig zijn voor onder andere schakelaars, sensoren, knoppen en LED's.

Stap 2: Kenmerken

16 input/output pinnen (16 input standaard)

Snelle I2C-busklokfrequentie (0-400 kbits/s)

Drie hardware-adrespinnen maken het gebruik van maximaal acht apparaten mogelijk

Interrupt Port Capture Recorder

Polariteitsomkeerregister voor het instellen van de polariteit van de invoerpoortgegevens

Compatibel met de meeste microcontrollers

Stap 3: ESP01 kan 128 GPIO's hebben

Een voorbeeld dat de omvang van deze uitbreiding laat zien, is het gebruik ervan met ESP01, die kan worden aangesloten op maximaal acht uitbreidingen met slechts twee IOS, tot 128 GPIO's.

Stap 4: MCP23016

Hier hebben we het schema van de expander, die twee groepen van acht bits heeft. Dit zorgt voor een totaal van 16 poorten. Naast een interrupt-pin heeft het de CLK-pin, die de condensator en de weerstand verbindt, die intern zijn verbonden in een logische poort. Dit is om de klok te vormen, gebruikmakend van het idee van een kristaloscillator, die een klok van 1 MHz nodig heeft. De TP-pin wordt gebruikt om de klok te meten. Pinnen A0, A1 en A2 zijn binaire adressen.

Stap 5: KLOK

De MCP23016 gebruikt daarom een externe RC-schakeling om de snelheid van de interne Clock te bepalen. Een interne klok van 1 MHz is (meestal) vereist om het apparaat goed te laten werken. De interne klok kan worden gemeten op de TP-pin. De aanbevolen waarden voor REXT en CEXT worden hieronder weergegeven.

Stap 6: Adres

Om het adres van de MCP23016 te definiëren, gebruiken we vervolgens pinnen A0, A1 en A2. Laat ze gewoon op HOOG of LAAG staan voor de adreswijziging.

Het adres wordt als volgt gevormd:

MCP_Adres = 20 + (A0 A1 A2)

Waar A0 A1 A2 HIGH/LOW waarden kan aannemen, vormt dit een binair getal van 0 tot 7.

Bijvoorbeeld:

A0> GND, A1> GND, A2> GND (betekent 000, dan 20 + 0 = 20)

Of anders, A0> HOOG, A1> GND, A2> HOOG (betekent 101, dan 20 + 5 = 25)

Stap 7: Opdrachten

Hieronder staat een tabel met de commando's voor communicatie. Laten we GP0 en GP1 gebruiken, evenals IODIR0 en IODIR1.

Stap 8: Categorieën:

GP0 / GP1 - Gegevenspoortregisters

Er zijn twee registers die toegang geven tot de twee GPIO-poorten.

De registeruitlezing geeft de status van de pinnen op die poort weer.

Bit = 1> HOOG Bit = 0> LAAG

OLAT0 / OLAT1 - Uitgang LACTCH REGISTERS

Er zijn twee registers die toegang geven tot de uitgangspoorten van de twee poorten.

IPOL0 / IPOL1 - Invoerpolariteitsregisters

Met deze registers kan de gebruiker de polariteit van de invoerpoortgegevens (GP0 en GP1) configureren.

IODIR0 / IODIR1

Er zijn twee registers die de pin-modus regelen. (Ingang of Uitgang)

Bit = 1> INGANG Bit = 0> UITGANG

INTCAP0 / INTCAP1 - Opvangregisters onderbreken

Dit zijn registers die de waarde bevatten van de poort die de interrupt heeft gegenereerd.

IOCON0 / IOCON1 - I / O-expanderbesturingsregister

Dit regelt de functionaliteit van de MCP23016.

Bit 0 instellen (IARES> Interrupt Activity Resolution) regelt de bemonsteringsfrequentie van de GP-poortpinnen.

Bit0 = 0> (standaard) Maximale detectietijd voor poortactiviteit is 32 ms (laag stroomverbruik)

Bit0 = 1> maximale activiteitsdetectietijd op de poort is 200usec (hoger stroomverbruik)

Stap 9: Structuur voor communicatie

Ik laat hier de Wire-klasse zien, de I2C-communicatie in onze kern Arduino, waardoor de uitbreiding ook kan werken met de Arduino Uno en Mega. Deze laatste heeft echter al meerdere IO's. We behandelen hier de adressen van de chip, de toegangscontrole, dat zijn de codes van de registers, evenals de gegevens.

Stap 10: Programmeren

Ons programma bestaat uit het communiceren van de ESP32 met de MCP23016 om meer GPIO's te gebruiken. We hebben dan een knop en enkele LED's aangesloten op de MCP23016. We zullen ze allemaal besturen met alleen de I2C-bus. Er worden dus slechts twee ESP32-pinnen gebruikt. Je kunt het beeldcircuit hieronder in de video zien.

Stap 11: ESP01

Hier laat ik de pinout van ESP01 zien.

Stap 12: ESP01. monteren

In dit voorbeeld hebben we de GPIO0 aangesloten op de SDA en de GPIO2 aangesloten op de SCL. We hebben ook een relaisbord, een zoemer en een LED. Op de andere poort, in GP1.0, hebben we nog een LED met een weerstand.

Stap 13: NodeMCU ESP-12E

Hier hebben we de pinout van de NodeMCU ESP-12E.

Stap 14: NodeMCU ESP-12E monteren

In dit geval is het enige verschil met het eerste voorbeeld dat u respectievelijk D1 en D2 in de SDA en SCL hebt aangesloten.

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

Hier is de pinout van de WiFi NodeMCU-32S ESP-WROOM-32.

Stap 16: WiFi-montagenodeMCU-32S ESP-WROOM-32

Dit keer is het belangrijkste verschil met de andere twee voorbeelden de knop en de drie knipperende LED's. Hier is de SDA aangesloten op de GPIO19, terwijl de SCL is aangesloten op de GPIO23.

Stap 17: Bibliotheken en variabelen

Eerst nemen we Wire.h op, dat verantwoordelijk is voor i2c-communicatie, evenals het instellen van het i2c-adres van MCP23016. Ik laat verschillende commando's zien, zelfs enkele die we niet gebruiken in dit project.

#include // specificeer het gebruik van de Wire.h-bibliotheek. //endereço I2C do MCP23016 #define MCPAddress 0x20 // COMMAND BYTE OM RELATIE TE REGISTREREN: Tabel: 1-3 van Microchip MCP23016 - DS20090A //ENDEREÇOS DE REGISTRADORES #define GP0 0x00 // DATA PORT REGISTER 0x01 / DEfine/ DATA POORT REGISTER 1 #define OLAT0 0x02 // OUTPUT LATCH REGISTER 0 #define OLAT1 0x03 // OUTPUT LATCH REGISTER 1 #define IPOL0 0x04 // INPUT POLARITEIT POORT REGISTER 0 #define IPOL1 0x05 // INPUT POLARITEIT 1 #define INPUT POLARITEIT 1 #define INPUT POLARITEIT / I/O RICHTING REGISTER 0 #define IODIR1 0x07 // I/O RICHTING REGISTER 1 #define INTCAP0 0x08 // INTERRUPT CAPTURE REGISTER 0 #define INTCAP1 0x09 // INTERRUPT CAPTURE REGISTER 1 #define IOCON0 0x0A // I/O EXPAN REGISTREER 0 #define IOCON1 0x0B // I/O UITBREIDINGSCONTROLE REGISTREER 1

Stap 18: Instellen

Hier hebben we de functies om vier verschillende soorten microcontrollers te initialiseren. We controleren ook de frequentie, stellen de GPIO's in en stellen de pinnen in. In de Loop controleren we de status van de knop.

void setup() { Serial.begin(9600); vertraging (1000); Draad.begin(19, 23); // ESP32 // Draad.begin (D2, D1); //nodemcu ESP8266 // Wire.begin(); //arduino // Wire.begin (0, 2);//ESP-01 Wire.setClock (200000); //frequencia //configuratie van GPIO0 como OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); //configuratie van GPIO1 como INPUT o GP1.0 en como OUTPUT en 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); } // eindlus

Stap 19: Poort configureren

In deze stap configureren we de modus van de GPIO-pinnen en identificeren we de modus van de poorten.

//configura o GPIO (GP0 of GP1)//como parametro passamos: //port: GP0 of 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 of modo das portas (1=INPUT, 0=OUTPUT) // ex: 0x01 of B00000001 of 1: indica que apenas of GPX.0 trabalhará como entrada, of resto como saida void configurePort(uint8_t poort, uint8_t aangepast) {if(aangepast == INPUT) {writeBlockData(poort, 0xFF); } else if(custom == OUTPUT) {writeBlockData(poort, 0x00); } else {writeBlockData(poort, aangepast); } }

Stap 20: WriteBlockData & CheckButton

Hier sturen we gegevens naar de MCP23016 via de i2c-bus, controleren we de status van de knop en geven we de volgende stap aan, rekening houdend met de voorwaarde om al dan niet ingedrukt te worden.

//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 (gegevens); Wire.endTransmission(); vertraging(10); }

//verifica se o botão foi pressionado//parametro GP: GP0 of 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 als portas GP0 if (btn) {writeBlockData (GP0, B11111111); } //caso contrario deixa todas em estado LOW anders {writeBlockData(GP0, B00000000); } }

Stap 21: ReadPin & ValueFromPin

We behandelen hier het uitlezen van een specifieke pin, en het terugbrengen van de bitwaarde naar de gewenste positie.

//faz a leitura de um pino específico//pin: pino desejado (0-7) //gp: GP0 of GP1 //retorno: 0 of 1 uint8_t readPin(uint8_t pin, uint8_t gp) {uint8_t statusGP = 0; Wire.beginTransmission (MCPA-adres); Draad.schrijven (gp); Wire.endTransmission(); Wire.requestFrom (MCPA-adres, 1); // ler do chip 1 byte statusGP = Wire.read(); retourwaardeFromPin (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; }

Stap 22: ESP8266-programma

Vanaf hier zullen we zien hoe het programma dat we gebruikten in ESP-01 en in de nodeMCU ESP-12E is gemaakt, wat ons in staat stelt te begrijpen hoe de verschillen tussen beide minimaal zijn.

We zullen alleen de regel van de i2c-communicatieconstructor wijzigen, wat de beginmethode is van het Wire-object.

Uncommenteer de regel volgens de plaat die we gaan compileren.

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

Opstelling

Merk op dat de bouwer nog steeds commentaar heeft. Daarom, uncomment volgens uw bord (ESP-01 of nodeMCU ESP12-E).

void setup() { Serial.begin(9600); vertraging (1000); // Draad.begin (D2, D1); //nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); //frequencia //configuratie van GPIO0 como OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); //configur 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); }

Lus

In de lus wisselen we de pinnen elke 1 seconde. Dus als pin0 van GP0 aan staat, zijn de pinnen van GP1 uit. Als pin0 van GP1 aan staat, zijn de GP0-pinnen uit.

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

Stap 23: BELANGRIJK

De gebruikte variabelen en bibliotheek zijn dezelfde als die van het programma dat we voor ESP32 hebben gedaan, evenals de methoden configurePort en writeBlockData.

Stap 24: Bestanden

Download de bestanden:

PDF

INO (ESP8266)

INO (ESP32)