IO-Expander für ESP32, ESP8266 und Arduino - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Möchten Sie die IOs Ihres ESP32, ESP8266 oder Arduino erweitern? Und haben Sie an die Möglichkeit von 16 neuen GPIOs gedacht, die über den I2C-Bus gesteuert werden können? Heute stelle ich Ihnen den GPIO-Expander MCP23016 vor. Außerdem zeige ich Ihnen, wie Sie einen Mikrocontroller mit dem MCP23016 kommunizieren. Ich werde auch über das Erstellen eines Programms sprechen, bei dem wir nur 2 Pins dieses Mikrocontrollers verwenden, um mit dem Expander zu kommunizieren. Wir verwenden diese zur Steuerung der LEDs und der Taste.

Schritt 1: Einführung

Das Gerät MCP23016 bietet 16 Bit für die GPIO-Erweiterung über den I2C-Bus. Jedes Bit kann individuell konfiguriert werden (Eingang oder Ausgang).

Der MCP23016 besteht aus mehreren 8-Bit-Einstellungen für Eingang, Ausgang und Polaritätsauswahl.

Die Expander bieten eine einfache Lösung, wenn die IOs unter anderem für Schalter, Sensoren, Taster und LEDs benötigt werden.

Schritt 2: Eigenschaften

16 Input / Output-Pins (16 Input-Standard)

Schnelle I2C-Bus-Taktfrequenz (0-400 kbit/s)

Drei Hardware-Adress-Pins ermöglichen die Verwendung von bis zu acht Geräten

Port-Capture-Recorder unterbrechen

Polaritätsumkehrregister zum Einstellen der Polarität der Eingangsportdaten

Kompatibel mit den meisten Mikrocontrollern

Schritt 3: ESP01 kann 128 GPIOs haben

Ein Beispiel, das die Größe dieses Expanders zeigt, ist der Einsatz mit ESP01, der mit nur zwei IOS an bis zu acht Expander angeschlossen werden kann und 128 GPIOs erreicht.

Schritt 4: MCP23016

Hier haben wir den Schaltplan des Expanders, der zwei Gruppen von acht Bits hat. Das ergibt insgesamt 16 Ports. Neben einem Interrupt-Pin hat es den CLK-Pin, der den Kondensator und den Widerstand verbindet, die intern in einem Logikport verbunden sind. Dies dient dazu, die Uhr zu bilden, wobei die Idee eines Quarzoszillators verwendet wird, der einen 1-MHz-Takt benötigt. Der TP-Pin wird verwendet, um die Uhr zu messen. Die Pins A0, A1 und A2 sind binäre Adressen.

Schritt 5: UHR

Der MCP23016 verwendet daher eine externe RC-Schaltung, um die Geschwindigkeit der internen Uhr zu bestimmen. Damit das Gerät richtig funktioniert, ist (normalerweise) ein interner Takt von 1 MHz erforderlich. Am TP-Pin kann die interne Uhr gemessen werden. Die empfohlenen Werte für REXT und CEXT sind unten aufgeführt.

Schritt 6: Adresse

Um die Adresse des MCP23016 zu definieren, verwenden wir dann die Pins A0, A1 und A2. Lassen Sie sie für die Adressänderung einfach auf HIGH oder LOW.

Die Adresse wird wie folgt gebildet:

MCP_Adresse = 20 + (A0 A1 A2)

Wo A0 A1 A2 HIGH / LOW-Werte annehmen kann, bildet dies eine Binärzahl von 0 bis 7.

Zum Beispiel:

A0> GND, A1> GND, A2> GND (bedeutet 000, dann 20 + 0 = 20)

Oder aber, A0> HIGH, A1> GND, A2> HIGH (bedeutet 101, dann 20 + 5 = 25)

Schritt 7: Befehle

Nachfolgend finden Sie eine Tabelle mit den Befehlen für die Kommunikation. Lassen Sie uns GP0 und GP1 sowie IODIR0 und IODIR1 verwenden.

Schritt 8: Kategorien:

GP0 / GP1 - Datenportregister

Es gibt zwei Register, die den Zugriff auf die beiden GPIO-Ports ermöglichen.

Das Lesen des Registers liefert den Status der Pins an diesem Port.

Bit = 1> HOCH Bit = 0> NIEDRIG

OLAT0 / OLAT1 - Ausgabe LACTCH REGISTERS

Es gibt zwei Register, die den Zugriff auf die Ausgangsports der beiden Ports ermöglichen.

IPOL0 / IPOL1 - Eingangspolaritätsregister

Mit diesen Registern kann der Benutzer die Polarität der Eingangsportdaten (GP0 und GP1) konfigurieren.

IODIR0 / IODIR1

Es gibt zwei Register, die den Pin-Modus steuern. (Eingabe oder Ausgabe)

Bit = 1> EINGANG Bit = 0> AUSGANG

INTCAP0 / INTCAP1 - Interrupt-Capture-Register

Dies sind Register, die den Wert des Ports enthalten, der den Interrupt erzeugt hat.

IOCON0 / IOCON1 - E / A-Erweiterungssteuerregister

Dies steuert die Funktionalität des MCP23016.

Das Setzen von Bit 0 (IARES> Interrupt Activity Resolution) steuert die Abtastfrequenz der GP-Port-Pins.

Bit0 = 0> (Standard) Die maximale Portaktivitätserkennungszeit beträgt 32 ms (geringer Stromverbrauch)

Bit0 = 1> maximale Aktivitätserkennungszeit am Port beträgt 200usec (höherer Stromverbrauch)

Schritt 9: Struktur für die Kommunikation

Ich zeige hier die Wire-Klasse, die die I2C-Kommunikation in unserem Kern-Arduino ist, die es dem Expander auch ermöglicht, mit dem Arduino Uno und Mega zu arbeiten. Letztere hat jedoch bereits mehrere IOs. Wir beschäftigen uns hier mit den Adressen des Chips, der Zugangskontrolle, das sind die Codes der Register, sowie den Daten.

Schritt 10: Programm

Unser Programm besteht darin, den ESP32 mit dem MCP23016 zu kommunizieren, um mehr GPIOs zu verwenden. Wir werden dann eine Taste und einige LEDs mit dem MCP23016 verbunden haben. Wir werden sie alle nur über den I2C-Bus steuern. Somit werden nur zwei ESP32-Pins verwendet. Sie können die Bildschaltung unten im Video sehen.

Schritt 11: ESP01

Hier zeige ich die Pinbelegung von ESP01.

Schritt 12: Montage ESP01

In diesem Beispiel haben wir GPIO0 im SDA und GPIO2 im SCL verbunden. Wir haben auch eine Relaisplatine, einen Summer und eine LED. Am anderen Port, in GP1.0, haben wir eine weitere LED mit einem Widerstand.

Schritt 13: NodeMCU ESP-12E

Hier haben wir die Pinbelegung des NodeMCU ESP-12E.

Schritt 14: NodeMCU ESP-12E montieren

Der einzige Unterschied zum ersten Beispiel besteht in diesem Fall darin, dass Sie D1 und D2 im SDA bzw. SCL verbunden haben.

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

Hier ist die Pinbelegung des WiFi NodeMCU-32S ESP-WROOM-32.

Schritt 16: WLAN-MontageknotenMCU-32S ESP-WROOM-32

Der Hauptunterschied zu den anderen beiden Beispielen ist diesmal die Taste und die drei blinkenden LEDs. Hier ist der SDA mit dem GPIO19 verbunden, während der SCL mit dem GPIO23 verbunden ist.

Schritt 17: Bibliotheken und Variablen

Zuerst binden wir Wire.h ein, das für die i2c-Kommunikation zuständig ist, sowie die Einstellung der i2c-Adresse von MCP23016. Ich zeige mehrere Befehle, sogar einige, die wir in diesem Projekt nicht verwenden.

#include // Verwendung der Wire.h-Bibliothek angeben. //endereço I2C do MCP23016 #define MCPaddress 0x20 // BEFEHLSBYTE ZUM REGISTRIEREN DER BEZIEHUNG: Tabelle: 1-3 von Microchip MCP23016 - DS20090A //ENDEREÇOS DE REGISTRADORES #define GP0 0x00 // DATENPORT REGISTER 0 #define DATA. 0x01 // DATEN PORTREGISTER 1 #define OLAT0 0x02 // AUSGANGS-LATCH-REGISTER 0 #define OLAT1 0x03 // AUSGANGS-LATCH-REGISTER 1 #define IPOL0 0x04 // EINGANGSPOLARITÄTS-PORT-REGISTER 0 #define IPOL1 0x05 // EINGANGS-POLARITÄTS-PORTREGISTER 0 0x06 IOD / 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 REGISTER 0 #define IOCON1 0x0B // I/O EXPANDER CONTROL REGISTER 1

Schritt 18: Einrichtung

Hier haben wir die Funktionen, um vier verschiedene Arten von Mikrocontrollern zu initialisieren. Wir überprüfen auch die Frequenz, richten die GPIOs ein und setzen die Pins. Im Loop überprüfen wir den Status des Buttons.

Void setup () { Serial.begin (9600); Verzögerung (1000); Draht. Begin(19, 23); // ESP32 // Wire.begin (D2, D1); //nodemcu ESP8266 // Wire.begin(); // Arduino // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // Frequenz //configura o GPIO0 como AUSGANG (todos os pinos) configurePort (IODIR0, AUSGANG); //configura o GPIO1 como INPUT o GP1.0 und como OUTPUT os outros GP1 configurePort (IODIR1, 0x01); // seta todos os pinos tun GPIO0 como LOW writeBlockData (GP0, B00000000); // seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000000); aufrechtzuerhalten. Void Schleife () {//Verifica e o botão GP foi pressionado checkButton (GP1); } // Schleife beenden

Schritt 19: ConfigurePort

In diesem Schritt konfigurieren wir den Modus der GPIO-Pins und identifizieren den Modus der Ports.

//configura o GPIO (GP0 oder GP1)//como parametro passamos: //port: GP0 oder GP1 //custom: INPUT para todos as portas do GP trabalharem como entrada // OUTPUT para todos as portas do GP trabalharem como sagtea / / custom um valor de 0-255 indicando o modo das portas (1=INPUT, 0=OUTPUT) // ex: 0x01 ou B00000001 oder 1: indica que apenas o GPX.0 trabalhará como entrada, o resto como sagtea void configurePort(uint8_t port, uint8_t custom) { if (custom == INPUT) { writeBlockData (port, 0xFF); aufrechtzuerhalten. Sonst if (custom == OUTPUT) { writeBlockData (Port, 0x00); aufrechtzuerhalten. Else { writeBlockData (Port, Benutzerdefiniert); } }

Schritt 20: WriteBlockData & CheckButton

Hier senden wir Daten über den i2c-Bus an den MCP23016, überprüfen den Status der Taste und zeigen den nächsten Schritt an, wobei wir den Zustand des Drückens berücksichtigen oder nicht.

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

// verifica se o botão foi pressionado // parametro GP: GP0 oder 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 else {writeBlockData (GP0, B00000000); } }

Schritt 21: ReadPin & ValueFromPin

Wir beschäftigen uns hier mit dem Lesen eines bestimmten Pins und der Rückgabe des Bitwertes an die gewünschte Position.

//faz a leitura de um pino específico // pin: pino desejado (0-7) // gp: GP0 oder GP1 // retorno: 0 oder 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 tun Chip 1 Byte statusGP = Wire.read (); RückgabewertFromPin(pin, statusGP); aufrechtzuerhalten. (0x0001 << Pin)) == 0 ? 0: 1; }

Schritt 22: ESP8266-Programm

Von hier aus werden wir sehen, wie das Programm, das wir in ESP-01 und in der nodeMCU ESP-12E verwendet haben, erstellt wurde, wodurch wir verstehen können, wie minimal die Unterschiede zwischen ihnen sind.

Wir werden nur die Zeile des i2c-Kommunikationskonstruktors ändern, die die Anfangsmethode des Wire-Objekts ist.

Entkommentieren Sie einfach die Zeile entsprechend der Platte, die wir kompilieren werden.

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

Aufstellen

Beachten Sie, dass der Builder immer noch auskommentiert ist. Entkommentieren Sie daher entsprechend Ihrem Board (ESP-01 oder nodeMCU ESP12-E).

Void setup () { Serial.begin (9600); Verzögerung (1000); // Wire.begin (D2, D1); //nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // Frequenz //configura o GPIO0 como AUSGANG (todos os pinos) configurePort (IODIR0, AUSGANG); //configura o GPIO1 como AUSGANG (todos os pinos) configurePort (IODIR1, AUSGANG); // seta todos os pinos tun GPIO0 como LOW writeBlockData (GP0, B00000000); // seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000001); }

Schleife

In der Schleife wechseln wir die Pins alle 1 Sekunde. Wenn also Pin0 von GP0 eingeschaltet ist, sind die Pins von GP1 ausgeschaltet. Wenn Pin0 von GP1 eingeschaltet ist, sind die GP0-Pins ausgeschaltet.

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); Verzögerung (1000); // seta todos os pinos tun GPIO0 como LOW writeBlockData (GP0, B00000000); // seta o pino 0 do GP1 como HIGH e os demais como LOW writeBlockData (GP1, B00000001); Verzögerung (1000); } // Schleife beenden

Schritt 23: WICHTIG

Die verwendeten Variablen und Bibliotheken entsprechen denen des Programms, das wir für ESP32 erstellt haben, sowie die Methoden configurePort und writeBlockData.

Schritt 24: Dateien

Laden Sie die Dateien herunter:

PDF

INO (ESP8266)

INO (ESP32)