IO Expander för ESP32, ESP8266 och Arduino: 24 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Vill du utöka IO: erna för din ESP32, ESP8266 eller Arduino? Och har du tänkt på möjligheten för 16 nya GPIO: er som kan styras med I2C -bussen? Tja idag, jag ska presentera dig för GPIO expander MCP23016. Jag visar dig också hur du kommunicerar en mikrokontroller med MCP23016. Jag kommer också att prata om att skapa ett program där vi bara använder två stift av denna mikrokontroller för att kommunicera med expanderaren. Vi använder dessa för att styra lysdioderna och knappen.

Steg 1: Introduktion

MCP23016 -enheten tillhandahåller 16 bitar för GPIO -expansion med I2C -bussen. Varje bit kan konfigureras individuellt (input eller output).

MCP23016 består av flera 8-bitars inställningar för ingång, utgång och polaritetsval.

Expanderarna ger en enkel lösning när IO: erna behövs för switchar, sensorer, knappar och lysdioder, bland andra exempel.

Steg 2: Egenskaper

16 ingångs- / utgångsstiften (16 ingångsstandard)

Snabb I2C buss klockfrekvens (0-400 kbits/s)

Tre hårdvaruadressnålar tillåter användning av upp till åtta enheter

Avbryt Port Capture Recorder

Polaritetsomvändningsregister för inställning av polariteten för ingångsportdata

Kompatibel med de flesta mikrokontroller

Steg 3: ESP01 kan ha 128 GPIO

Ett exempel som visar storleken på denna expander är dess användning med ESP01, som kan anslutas till upp till åtta expanderare med bara två IOS och nå 128 GPIO.

Steg 4: MCP23016

Här har vi schemat över expanderaren, som har två grupper med åtta bitar. Detta ger totalt 16 portar. Förutom en avbrottsstift har den CLK -stiftet, som förbinder kondensatorn och motståndet, som är internt anslutna i en logisk port. Detta för att bilda klockan med hjälp av idén om en kristalloscillator, som behöver 1MHz klocka. TP -stiftet används för att mäta klockan. Stiften A0, A1 och A2 är binära adresser.

Steg 5: KLOCKA

MCP23016 använder därför en extern RC -krets för att bestämma hastigheten på den interna klockan. En intern klocka på 1 MHz krävs (vanligtvis) för att enheten ska fungera korrekt. Den interna klockan kan mätas på TP -stiftet. De rekommenderade värdena för REXT och CEXT visas nedan.

Steg 6: Adress

För att definiera adressen till MCP23016 använder vi sedan stiften A0, A1 och A2. Lämna dem bara på HIGH eller LOW för adressändringen.

Adressen kommer att formas enligt följande:

MCP_Address = 20 + (A0 A1 A2)

Där A0 A1 A2 kan ta HIGH / LOW -värden, bildar detta ett binärt tal från 0 till 7.

Till exempel:

A0> GND, A1> GND, A2> GND (betyder 000, då 20 + 0 = 20)

Annars, A0> HÖG, A1> GND, A2> HÖG (betyder 101, sedan 20 + 5 = 25)

Steg 7: Kommandon

Nedan visas en tabell med kommandon för kommunikation. Låt oss använda GP0 och GP1, liksom IODIR0 och IODIR1.

Steg 8: Kategorier:

GP0 / GP1 - Dataportregister

Det finns två register som ger åtkomst till de två GPIO -portarna.

Registeravläsningen ger status för stiften på den porten.

Bit = 1> HIGH Bit = 0> LÅG

OLAT0 / OLAT1 - Output LACTCH REGISTRE

Det finns två register som ger åtkomst till de två portarnas utgångsportar.

IPOL0 / IPOL1 - Inmatningspolaritetsregister

Dessa register tillåter användaren att konfigurera polariteten för ingångsportdata (GP0 och GP1).

IODIR0 / IODIR1

Det finns två register som styr stiftläget. (Ingång eller utmatning)

Bit = 1> INPUT Bit = 0> OUTPUT

INTCAP0 / INTCAP1 - Avbryt registreringsregister

Dessa är register som innehåller värdet på porten som genererade avbrottet.

IOCON0 / IOCON1 - I / O Expander Control Register

Detta styr funktionen hos MCP23016.

Inställningsbit 0 (IARES> Avbryt aktivitetsupplösning) styr samplingsfrekvensen för GP -portstiften.

Bit0 = 0> (standard) Detekteringstid för maximal portaktivitet är 32 ms (låg strömförbrukning)

Bit0 = 1> maximal aktivitetsdetekteringstid på porten är 200usec (högre strömförbrukning)

Steg 9: Struktur för kommunikation

Jag visar här Wire -klassen, som är I2C -kommunikationen i vår kärna Arduino, som också gör att expanderaren kan arbeta med Arduino Uno och Mega. Den senare har dock redan flera IO: er. Vi behandlar här adresserna till chipet, åtkomstkontrollen, som är koder för registren, liksom data.

Steg 10: Program

Vårt program består av att kommunicera ESP32 med MCP23016 för att ha fler GPIO: er att använda. Vi kommer då att ha en knapp och några lysdioder anslutna till MCP23016. Vi kommer att styra dem alla med endast I2C -bussen. Således kommer endast två ESP32 -stift att användas. Du kan se bildkretsen nedan i videon.

Steg 11: ESP01

Här visar jag Pinout av ESP01.

Steg 12: Montering av ESP01

I det här exemplet har vi GPIO0 ansluten i SDA och GPIO2 ansluten i SCL. Vi har också en reläbräda, en summer och en LED. På den andra porten, i GP1.0, har vi ytterligare en LED med ett motstånd.

Steg 13: NodeMCU ESP-12E

Här har vi Pinout av NodeMCU ESP-12E.

Steg 14: MonteringsnodMCU ESP-12E

I detta fall är den enda skillnaden från det första exemplet att du har anslutit D1 och D2 i SDA respektive SCL.

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

Här är Pinout av WiFi NodeMCU-32S ESP-WROOM-32.

Steg 16: WiFi-monteringsnodMCU-32S ESP-WROOM-32

Den här gången är den största skillnaden från de två andra exemplen knappen och de tre blinkande lysdioderna. Här är SDA ansluten till GPIO19, medan SCL är ansluten till GPIO23.

Steg 17: Bibliotek och variabler

Först kommer vi att inkludera Wire.h, som är ansvarig för i2c -kommunikation, samt att ställa in i2c -adressen för MCP23016. Jag visar flera kommandon, även några som vi inte använder i det här projektet.

#include // ange användning av Wire.h -biblioteket. // endereço I2C do MCP23016 #define MCPAddress 0x20 // COMMAND BYTE TO REGISTER RELATIONS: Table: 1-3 of Microchip MCP23016 - DS20090A // ENDEREÇOS DE REGISTRADORES #define GP0 0x00 // DATA PORT REGISTER 0 #define GP1 0 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 #INfUT POLARITY /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 // REGISTER 0 #define IOCON1 0x0B // I/O EXPANDER CONTROL REGISTER 1

Steg 18: Inställning

Här har vi funktionerna för att initiera fyra olika typer av mikrokontroller. Vi kontrollerar också frekvensen, ställer in GPIO: erna och sätter stiften. I Loop kontrollerar vi status på knappen.

void setup () {Serial.begin (9600); fördröjning (1000); Wire.begin (19, 23); // ESP32 // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (); // arduino // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frekvens // konfiguration o GPIO0 som OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // konfigura o GPIO1 como INPUT o GP1.0 e como OUTPUT os outros GP1 configurePort (IODIR1, 0x01); // seta todos os pinos gör GPIO0 som LOW writeBlockData (GP0, B00000000); // seta todos os pinos gör GPIO1 som LOW writeBlockData (GP1, B00000000); } void loop () {// verifica e o botão GP foi pressionado checkButton (GP1); } // slutslinga

Steg 19: ConfigurePort

I det här steget konfigurerar vi läget för GPIO -stiften och identifierar portens läge.

// konfigura o GPIO (GP0 ou GP1) // como parametro passamos: // port: 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 = INPUT, 0 = OUTPUT) // ex: 0x01 ou B00000001 ou 1: indica que apenas o GPX.0 trabalhará como entrada, o restando como saida void configurePort (uint8_t port, uint8_t custom) {if (custom == INPUT) {writeBlockData (port, 0xFF); } annars if (custom == OUTPUT) {writeBlockData (port, 0x00); } annat {writeBlockData (port, anpassad); }}

Steg 20: WriteBlockData & CheckButton

Här skickar vi data till MCP23016 via i2c -bussen, kontrollerar status för knappen och anger nästa steg samtidigt som man tar hänsyn till villkoret för att bli nedtryckt eller inte.

// 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 (data); Wire.endTransmission (); fördröjning (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); }}

Steg 21: ReadPin & ValueFromPin

Vi behandlar här läsningen av en specifik stift och återgången av bitvärdet till önskad position.

// 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; }

Steg 22: ESP8266 -program

Härifrån kommer vi att se hur programmet vi använde i ESP-01 och i nodenMCU ESP-12E skapades, vilket gör att vi kan förstå hur skillnaderna mellan dem är minimala.

Vi kommer bara att ändra linjen för i2c -kommunikationskonstruktorn, som är början -metoden för Wire -objektet.

Bara att kommentera raden enligt plattan som vi ska sammanställa.

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

Uppstart

Lägg märke till att byggaren fortfarande kommenteras. Därför, lämna en kommentar enligt din tavla (ESP-01 eller nodeMCU ESP12-E).

void setup () {Serial.begin (9600); fördröjning (1000); // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frekvens // konfiguration o GPIO0 som OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // konfigura o GPIO1 som OUTPUT (todos os pinos) configurePort (IODIR1, OUTPUT); // seta todos os pinos gör GPIO0 som LOW writeBlockData (GP0, B00000000); // seta todos os pinos gör GPIO1 som LOW writeBlockData (GP1, B00000001); }

Slinga

I slingan byter vi stiften var 1: e sekund. När pin0 på GP0 är på är stiften i GP1 alltså avstängda. När pin0 på GP1 är på är GP0 -stiften avstängda.

void loop () {// seta o pino 7 do GP0 como HIGH e os demais como LOW writeBlockData (GP0, B10000000); // seta todos os pinos gör GPIO1 som LOW writeBlockData (GP1, B00000000); fördröjning (1000); // seta todos os pinos gör GPIO0 som LOW writeBlockData (GP0, B00000000); // seta o pino 0 do GP1 como HIGH e os demais como LOW writeBlockData (GP1, B00000001); fördröjning (1000); } // slutslinga

Steg 23: VIKTIGT

Variablerna och biblioteket som används är desamma som för programmet vi gjorde för ESP32, samt metoderna configurePort och writeBlockData.

Steg 24: Filer

Ladda ner filerna:

PDF

INO (ESP8266)

INO (ESP32)