IO Expander עבור ESP32, ESP8266 ו- Arduino: 24 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

האם תרצה להרחיב את IOs של ה- ESP32, ESP8266 או Arduino שלך? והאם חשבת על האפשרות של 16 מכשירי GPIO חדשים שניתן לשלוט בהם באמצעות אוטובוס I2C? ובכן היום, אני עומד להציג בפניך את מרחיב ה- GPIO MCP23016. כמו כן, אראה לך כיצד לתקשר מיקרו -בקר עם MCP23016. אדבר גם על יצירת תוכנית שבה נשתמש רק ב -2 סיכות של המיקרו -בקר הזה כדי לתקשר עם המרחיב. נשתמש בהם לשליטה על נוריות הלדים והלחצן.

שלב 1: מבוא

מכשיר MCP23016 מספק 16 סיביות להרחבת GPIO באמצעות אוטובוס I2C. ניתן להגדיר כל ביט בנפרד (קלט או פלט).

MCP23016 מורכב מהגדרות 8 סיביות מרובות עבור קלט, פלט ובחירת קוטביות.

המרחיבים מספקים פתרון פשוט כאשר יש צורך במערכות ה- IO למתגים, חיישנים, לחצנים ולדים, בין דוגמאות אחרות.

שלב 2: מאפיינים

16 סיני כניסה / יציאה (תקן כניסה 16)

תדר שעון אוטובוס מהיר I2C מהיר (0-400 kbits/s)

שלושה סיכות כתובת חומרה מאפשרות שימוש בעד שמונה מכשירים

הפסק מקליט לכידת יציאות

קוטר היפוך קוטביות להגדרת הקוטביות של נתוני יציאת הקלט

תואם עם רוב המיקרו -בקרים

שלב 3: ESP01 יכול להכיל 128 GPIOs

דוגמה המראה את גודל המרחיב הזה היא השימוש בו עם ESP01, שניתן לחבר אותו עד שמונה מרחיבים באמצעות שני IOS בלבד, ולהגיע ל -128 GPIO.

שלב 4: MCP23016

כאן, יש לנו את הסכימה של המרחיב, הכולל שתי קבוצות של שמונה סיביות. זה יוצר סך של 16 יציאות. בנוסף לסיכה להפסקה, יש לה סיכת CLK, המחברת את הקבל והנגד, המחוברים פנימית ביציאת לוגיקה. זה כדי ליצור את השעון, תוך שימוש ברעיון של מתנד קריסטל, שצריך שעון של 1 מגה -הרץ. סיכת ה- TP משמשת למדידת השעון. סיכות A0, A1 ו- A2 הן כתובות בינאריות.

שלב 5: שעון

לכן MCP23016 משתמש במעגל RC חיצוני כדי לקבוע את מהירות השעון הפנימי. נדרש (בדרך כלל) שעון פנימי של 1 מגה -הרץ כדי שהמכשיר יפעל כראוי. ניתן למדוד את השעון הפנימי על סיכת ה- TP. הערכים המומלצים עבור REXT ו- CEXT מוצגים להלן.

שלב 6: כתובת

כדי להגדיר את הכתובת של MCP23016, לאחר מכן אנו משתמשים בסיכות A0, A1 ו- A2. פשוט השאר אותם ב- HIGH או LOW לשינוי הכתובת.

הכתובת תיווצר כדלקמן:

MCP_Address = 20 + (A0 A1 A2)

כאשר A0 A1 A2 יכול לקחת ערכים גבוהים / נמוכים, זה יוצר מספר בינארי מ -0 עד 7.

לדוגמה:

A0> GND, A1> GND, A2> GND (פירושו 000, ואז 20 + 0 = 20)

אחרת, A0> HIGH, A1> GND, A2> HIGH (כלומר 101, ואז 20 + 5 = 25)

שלב 7: פקודות

להלן טבלה עם פקודות התקשורת. בואו נשתמש ב- GP0 ו- GP1, כמו גם ב- IODIR0 וב- IODIR1.

שלב 8: קטגוריות:

GP0 / GP1 - רשימות יציאות נתונים

ישנם שני רגיסטרים המספקים גישה לשתי יציאות ה- GPIO.

קריאת הרישום מספקת את מצב הפינים ביציאה זו.

Bit = 1> HIGH Bit = 0> נמוך

OLAT0 / OLAT1 - רישומי LACTCH פלט

ישנם שני רגיסטרים המספקים גישה ליציאות הפלט של שתי היציאות.

IPOL0 / IPOL1 - רשימות קוטביות קלט

רישומים אלה מאפשרים למשתמש להגדיר את הקוטביות של נתוני יציאת הקלט (GP0 ו- GP1).

IODIR0 / IODIR1

ישנם שני אוגרים השולטים במצב הסיכה. (קלט או פלט)

Bit = 1> INPUT Bit = 0> OUTPUT

INTCAP0 / INTCAP1 - קטע רשימות לכידה

אלה הם רשמים המכילים את ערך היציאה שיצרה את ההפרעה.

IOCON0 / IOCON1 - מרשם בקרת מרחיבי קלט / פלט

זה שולט על הפונקציונליות של MCP23016.

הגדרת ביט 0 (IARES> רזולוציה של פעילות קטיעה) שולטת בתדירות הדגימה של סיכות יציאת GP.

Bit0 = 0> (ברירת מחדל) זמן זיהוי פעילות היציאה המרבי הוא 32ms (צריכת חשמל נמוכה)

Bit0 = 1> זמן זיהוי הפעילות המרבי ביציאה הוא 200 usec (צריכת חשמל גבוהה יותר)

שלב 9: מבנה לתקשורת

אני מציג כאן את מחלקת Wire, שהיא תקשורת I2C בליבה הארדואינו שלנו, המאפשרת גם למרחיב לעבוד עם ה- Arduino Uno ו- Mega. עם זאת, לאחרונים יש כבר מספר IO. אנו עוסקים כאן בכתובות השבב, בקרת הגישה, שהם הקודים של הרשמים, כמו גם הנתונים.

שלב 10: תכנית

התוכנית שלנו מורכבת מתקשורת של ESP32 עם MCP23016 כדי שיהיו יותר GPIO לשימוש. לאחר מכן יהיה לנו כפתור וכמה נוריות המחוברות ל- MCP23016. נשלוט בכולם באמצעות האוטובוס I2C בלבד. לפיכך, ישמשו רק שני סיכות ESP32. אתה יכול לראות את מעגל התמונה למטה בסרטון.

שלב 11: ESP01

כאן, אני מציג את Pinout של ESP01.

שלב 12: הרכבה של ESP01

בדוגמה זו, יש לנו את ה- GPIO0 מחובר ב- SDA, ואת ה- GPIO2 מחובר ב- SCL. יש לנו גם לוח ממסר, זמזם ונורית LED. ביציאה השנייה, ב- GP1.0, יש לנו עוד LED אחד עם נגד.

שלב 13: NodeMCU ESP-12E

כאן, יש לנו את Pinout של ה- NodeMCU ESP-12E.

שלב 14: הרכבה של NodeMCU ESP-12E

במקרה זה, ההבדל היחיד מהדוגמה הראשונה הוא שחיברת D1 ו- D2 ב- SDA וב- SCL, בהתאמה.

שלב 15: WiFi NodeMCU-32S ESP-WROOM-32

להלן Pinout של ה- WiFi NodeMCU-32S ESP-WROOM-32.

שלב 16: צומת הרכבה של WiFiMCU-32S ESP-WROOM-32

הפעם, ההבדל העיקרי משתי הדוגמאות האחרות הוא הכפתור, ושלושת הנורות המהבהבות. כאן, ה- SDA מחובר ל- GPIO19, בעוד ה- SCL מחובר ל- GPIO23.

שלב 17: ספריות ומשתנים

ראשית, נכלול את Wire.h, האחראי לתקשורת i2c, וכן הגדרת כתובת i2c של MCP23016. אני מציג מספר פקודות, אפילו כמה שאיננו משתמשים בהן בפרויקט זה.

#include // ציין שימוש בספריית Wire.h. // endereço I2C do MCP23016 #define MCPAddress 0x20 // COMMAND BYTE לרישום מערכות יחסים: טבלה: 1-3 של Microchip MCP23016 - DS20090A // ENDEREÇOS DE REGISTRADORES #define GP0 0x00 // DATA PORT REGISTER 0 #define GP1 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 /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 // רישום 0 #define IOCON1 0x0B // I/O EXPANDER CONTROL REGISTER 1

שלב 18: התקנה

כאן יש לנו את הפונקציות לאתחול ארבעה סוגים שונים של בקרי מיקרו. אנו גם בודקים את התדירות, מגדירים את ה- GPIO ומגדירים את הסיכות. בלולאה, אנו בודקים את מצב הכפתור.

הגדרת void () {Serial.begin (9600); עיכוב (1000); Wire.begin (19, 23); // ESP32 // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (); // arduino // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frequencia // konfigura o GPIO0 כמו OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // תצורה של GPIO1 כניסת כניסת כניסת GP1.0 והרכב OUTPUT של מערכת ההפעלה GP1 configurePort (IODIR1, 0x01); // seta todos os pinos לעשות GPIO0 כמו LOW writeBlockData (GP0, B00000000); // seta todos os pinos עושים GPIO1 כמו LOW writeBlockData (GP1, B00000000); } לולאת void () {// verifica e o botão GP foi pressionado checkButton (GP1); } // לולאת סיום

שלב 19: ConfigurePort

בשלב זה אנו מגדירים את מצב סיכות ה- GPIO ומזהים את מצב היציאות.

// תצורה של GPIO (GP0 או GP1) / custom um value of 0-255 indicando o modo das portas (1 = INPUT, 0 = OUTPUT) // ex: 0x01 ou B00000001 ou 1: indica que apenas of GPX.0 trabalhará como entrada, or restando como saida void configurePort (uint8_t port, uint8_t custom) {if (custom == INPUT) {writeBlockData (יציאה, 0xFF); } אחרת אם (custom == OUTPUT) {writeBlockData (יציאה, 0x00); } else {writeBlockData (יציאה, מותאם אישית); }}

שלב 20: WriteBlockData & CheckButton

כאן אנו שולחים נתונים ל- MCP23016 דרך האוטובוס i2c, בודקים את מצב הכפתור ומציינים את השלב הבא תוך התחשבות במצב הלחיצה או לא.

// envia dados para o MCP23016 através do barramento i2c // cmd: COMANDO (רשם) // data: dados (0-255) void writeBlockData (uint8_t cmd, uint8_t data) {Wire.beginTransmission (MCPAddress); Wire.write (cmd); Wire.write (נתונים); Wire.endTransmission (); עיכוב (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); }}

שלב 21: ReadPin & ValueFromPin

אנו עוסקים כאן בקריאת סיכה ספציפית, והחזרת ערך הסיביות למיקום הרצוי.

// 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 << סיכה)) == 0? 0: 1; }

שלב 22: תוכנית ESP8266

מכאן נראה כיצד נוצרה התוכנית בה השתמשנו ב- ESP-01 ובצומת nodeMCU ESP-12E, מה שמאפשר לנו להבין כיצד ההבדלים ביניהם מינימליים.

נשנה רק את הקו של בונה התקשורת i2c, המהווה את השיטה ההתחלתית של אובייקט Wire.

פשוט בטל את התגובה של השורה לפי הלוח שאנו הולכים להרכיב.

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

להכין

שים לב שהבנאי עדיין זכה להערות. לכן, אין להגיב על פי הלוח שלך (ESP-01 או nodeMCU ESP12-E).

הגדרת void () {Serial.begin (9600); עיכוב (1000); // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frequencia // konfigura o GPIO0 כמו OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // configura o GPIO1 כמו OUTPUT (todos os pinos) configurePort (IODIR1, OUTPUT); // seta todos os pinos לעשות GPIO0 כמו LOW writeBlockData (GP0, B00000000); // seta todos os pinos עושים GPIO1 כמו LOW writeBlockData (GP1, B00000001); }

לוּלָאָה

בלולאה, אנו מחליפים את הסיכות כל שנייה אחת. לכן, כאשר pin0 של GP0 מופעל, הסיכות של GP1 כבויות. כאשר pin0 של GP1 מופעל, סיכות GP0 כבויות.

לולאת void () {// seta o pino 7 do GP0 como HIGH e os demais como LOW writeBlockData (GP0, B10000000); // seta todos os pinos עושים GPIO1 כמו LOW writeBlockData (GP1, B00000000); עיכוב (1000); // seta todos os pinos לעשות GPIO0 כמו LOW writeBlockData (GP0, B00000000); // seta o pino 0 do GP1 como HIGH e os demais como LOW writeBlockData (GP1, B00000001); עיכוב (1000); } // לולאת סיום

שלב 23: חשוב

המשתנים והספרייה שבהם נעשה שימוש זהים לאלו של התוכנית שעשינו עבור ESP32, כמו גם של שיטות configurePort ו- writeBlockData.

שלב 24: קבצים

הורד את הקבצים:

PDF

INO (ESP8266)

INO (ESP32)