IO Expander for ESP32, ESP8266 og Arduino: 24 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Vil du utvide IO -ene til ESP32, ESP8266 eller Arduino? Og har du tenkt på muligheten for 16 nye GPIO -er som kan kontrolleres ved hjelp av I2C -bussen? Vel, i dag skal jeg introdusere deg for GPIO -ekspandereren MCP23016. Jeg vil også vise deg hvordan du kommuniserer en mikrokontroller med MCP23016. Jeg vil også snakke om å lage et program hvor vi bare bruker to pins av denne mikrokontrolleren for å kommunisere med ekspanderen. Vi bruker disse til å kontrollere lysdiodene og knappen.

Trinn 1: Introduksjon

MCP23016 -enheten gir 16 bits for GPIO -utvidelse ved hjelp av I2C -bussen. Hver bit kan konfigureres individuelt (input eller output).

MCP23016 består av flere 8-biters innstillinger for input, output og polaritetsvalg.

Utviderne gir en enkel løsning når IO -er er nødvendige for brytere, sensorer, knapper og lysdioder, blant andre eksempler.

Trinn 2: Kjennetegn

16 Input / Output pins (16 input standard)

Rask I2C buss klokkefrekvens (0-400 kbits/s)

Tre maskinvareadresspinner tillater bruk av opptil åtte enheter

Avbryt Port Capture Recorder

Polaritets reverseringsregister for innstilling av polariteten til inngangsportdataene

Kompatibel med de fleste mikrokontrollere

Trinn 3: ESP01 kan ha 128 GPIO -er

Et eksempel som viser størrelsen på denne ekspanderen, er bruken med ESP01, som kan kobles til opptil åtte utvidere med bare to IOS og nå 128 GPIO.

Trinn 4: MCP23016

Her har vi skjematikken til ekspanderen, som har to grupper på åtte bits. Dette gir totalt 16 porter. I tillegg til en avbruddspinne har den CLK -pinnen, som forbinder kondensatoren og motstanden, som er internt koblet til en logisk port. Dette er for å danne klokken, ved å bruke ideen om en krystalloscillator, som trenger 1MHz klokke. TP -pinnen brukes til å måle klokken. Pins A0, A1 og A2 er binære adresser.

Trinn 5: KLOKKE

MCP23016 bruker derfor en ekstern RC -krets for å bestemme hastigheten på den interne klokken. En intern klokke på 1 MHz kreves (vanligvis) for at enheten skal fungere skikkelig. Den interne klokken kan måles på TP -pinnen. De anbefalte verdiene for REXT og CEXT er vist nedenfor.

Trinn 6: Adresse

For å definere adressen til MCP23016 bruker vi deretter pinnene A0, A1 og A2. Bare la dem stå på HIGH eller LOW for adresseendringen.

Adressen vil bli dannet som følger:

MCP_Address = 20 + (A0 A1 A2)

Der A0 A1 A2 kan ta HIGH / LOW verdier, danner dette et binært tall fra 0 til 7.

For eksempel:

A0> GND, A1> GND, A2> GND (betyr 000, deretter 20 + 0 = 20)

Ellers, A0> HØY, A1> GND, A2> HØY (betyr 101, deretter 20 + 5 = 25)

Trinn 7: Kommandoer

Nedenfor er en tabell med kommandoer for kommunikasjon. La oss bruke GP0 og GP1, så vel som IODIR0 og IODIR1.

Trinn 8: Kategorier:

GP0 / GP1 - Dataportregistre

Det er to registre som gir tilgang til de to GPIO -portene.

Registeravlesningen gir status for pinnene på den porten.

Bit = 1> HIGH Bit = 0> LAV

OLAT0 / OLAT1 - Output LACTCH REGISTRES

Det er to registre som gir tilgang til utgangsportene til de to portene.

IPOL0 / IPOL1 - Inngangspolaritetsregistre

Disse registrene lar brukeren konfigurere polariteten til inngangsportdataene (GP0 og GP1).

IODIR0 / IODIR1

Det er to registre som styrer pin -modus. (Inngang eller utgang)

Bit = 1> INNGANG Bit = 0> UTGANG

INTCAP0 / INTCAP1 - Avbryt registreringsregistre

Dette er registre som inneholder verdien av porten som genererte avbruddet.

IOCON0 / IOCON1 - I / O Expander Control Register

Dette styrer funksjonaliteten til MCP23016.

Innstillingsbit 0 (IARES> Avbryt aktivitetsoppløsning) styrer samplingsfrekvensen til GP -portpinnene.

Bit0 = 0> (standard) Maksimal oppdagelsestid for portaktivitet er 32 ms (lavt strømforbruk)

Bit0 = 1> maksimal aktivitet påvisningstid på porten er 200usec (høyere strømforbruk)

Trinn 9: Struktur for kommunikasjon

Jeg viser her Wire -klassen, som er I2C -kommunikasjonen i vår kjerne Arduino, som også lar ekspanderen jobbe med Arduino Uno og Mega. Imidlertid har sistnevnte allerede flere IOer. Vi behandler her adressene til brikken, tilgangskontrollen, som er registrenes koder, så vel som dataene.

Trinn 10: Program

Programmet vårt består av å kommunisere ESP32 med MCP23016 for å ha flere GPIO -er å bruke. Vi vil da ha en knapp og noen lysdioder koblet til MCP23016. Vi vil kontrollere dem alle bare ved hjelp av I2C -bussen. Dermed vil bare to ESP32 -pinner bli brukt. Du kan se bildekretsen nedenfor i videoen.

Trinn 11: ESP01

Her viser jeg Pinout av ESP01.

Trinn 12: Montering av ESP01

I dette eksemplet har vi GPIO0 koblet til SDA, og GPIO2 koblet til SCL. Vi har også et relébrett, en summer og en LED. På den andre porten, i GP1.0, har vi enda en LED med en motstand.

Trinn 13: NodeMCU ESP-12E

Her har vi Pinout av NodeMCU ESP-12E.

Trinn 14: Montering NodeMCU ESP-12E

I dette tilfellet er den eneste forskjellen fra det første eksemplet at du har koblet D1 og D2 i henholdsvis SDA og SCL.

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

Her er pinout av WiFi NodeMCU-32S ESP-WROOM-32.

Trinn 16: WiFi-monteringsnodeMCU-32S ESP-WROOM-32

Denne gangen er hovedforskjellen fra de to andre eksemplene knappen og de tre blinkende lysdiodene. Her er SDA koblet til GPIO19, mens SCL er koblet til GPIO23.

Trinn 17: Biblioteker og variabler

Først vil vi inkludere Wire.h, som er ansvarlig for i2c -kommunikasjon, samt å sette i2c -adressen til MCP23016. Jeg viser flere kommandoer, til og med noen som vi ikke bruker i dette prosjektet.

#include // spesifiser bruk av Wire.h -biblioteket. // endereço I2C do MCP23016 #define MCPAddress 0x20 // COMMAND BYTE TO REGISTER RELATIONSHIP: 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 // REGISTRER 0 #define IOCON1 0x0B // I/O EXPANDER CONTROL REGISTER 1

Trinn 18: Oppsett

Her har vi funksjonene til å initialisere fire forskjellige typer mikrokontrollere. Vi sjekker også frekvensen, setter opp GPIO -er og setter pinnene. I løkken sjekker vi statusen til knappen.

ugyldig oppsett () {Serial.begin (9600); forsinkelse (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 // konfigurasjon av 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 do GPIO0 como LOW writeBlockData (GP0, B00000000); // seta todos os pinos gjør GPIO1 som LOW writeBlockData (GP1, B00000000); } void loop () {// verifica e o botão GP foi pressionado checkButton (GP1); } // ende sløyfe

Trinn 19: ConfigurePort

I dette trinnet konfigurerer vi modusen til GPIO -pinnene og identifiserer portens modus.

// 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 value of 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 tilpasset) {if (custom == INPUT) {writeBlockData (port, 0xFF); } annet hvis (tilpasset == OUTPUT) {writeBlockData (port, 0x00); } annet {writeBlockData (port, tilpasset); }}

Trinn 20: WriteBlockData & CheckButton

Her sender vi data til MCP23016 gjennom i2c -bussen, sjekker statusen til knappen og angir neste trinn mens vi tar hensyn til tilstanden for å bli trykket eller ikke.

// 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 (); forsinkelse (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); }}

Trinn 21: ReadPin & ValueFromPin

Vi handler her om avlesning av en bestemt pin, og tilbakeføring av bitverdien til ønsket posisjon.

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

Trinn 22: ESP8266 -program

Herfra vil vi se hvordan programmet vi brukte i ESP-01 og i nodenMCU ESP-12E ble opprettet, noe som lar oss forstå hvordan forskjellene mellom dem er minimale.

Vi vil bare endre linjen til i2c -kommunikasjonskonstruktøren, som er begynnelsesmetoden for Wire -objektet.

Bare kommenter linjen i henhold til platen som vi skal kompilere.

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

Oppsett

Legg merke til at byggherren fortsatt er kommentert. Derfor må du ikke kommentere i henhold til styret ditt (ESP-01 eller nodeMCU ESP12-E).

ugyldig oppsett () {Serial.begin (9600); forsinkelse (1000); // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frekvens // konfigurasjon av GPIO0 som OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // konfigura o GPIO1 som OUTPUT (todos os pinos) configurePort (IODIR1, OUTPUT); // seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); // seta todos os pinos gjør GPIO1 som LOW writeBlockData (GP1, B00000001); }

Løkke

I sløyfen bytter vi pinnene hvert 1. sekund. Således, når pin0 på GP0 er på, er pinnene til GP1 av. Når pin0 på GP1 er på, er GP0 -pinnene slått av.

void loop () {// seta o pino 7 do GP0 como HIGH e os demais como LOW writeBlockData (GP0, B10000000); // seta todos os pinos gjør GPIO1 som LOW writeBlockData (GP1, B00000000); forsinkelse (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); forsinkelse (1000); } // ende sløyfe

Trinn 23: VIKTIG

Variablene og biblioteket som brukes er de samme som for programmet vi gjorde for ESP32, samt configurePort- og writeBlockData -metodene.

Trinn 24: Filer

Last ned filene:

PDF

INO (ESP8266)

INO (ESP32)