IO Expander ESP32, ESP8266 და Arduino– სთვის: 24 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

გსურთ გააფართოვოთ თქვენი ESP32, ESP8266 ან Arduino- ს IO? და გიფიქრიათ 16 ახალი GPIO- ს შესაძლებლობაზე, რომელთა კონტროლი შესაძლებელია I2C ავტობუსის გამოყენებით? დღეს, მე გაგაცნობ GPIO გაფართოებას MCP23016. ასევე, მე გაჩვენებთ, თუ როგორ უნდა დაუკავშიროთ მიკროკონტროლერს MCP23016. მე ასევე ვისაუბრებ პროგრამის შექმნაზე, სადაც ჩვენ გამოვიყენებთ ამ მიკროკონტროლერის მხოლოდ 2 ქინძისთავს გაფართოებულთან დასაკავშირებლად. ჩვენ გამოვიყენებთ მათ LED- ებისა და ღილაკის გასაკონტროლებლად.

ნაბიჯი 1: შესავალი

MCP23016 მოწყობილობა უზრუნველყოფს 16 ბიტს GPIO გაფართოებისთვის I2C ავტობუსის გამოყენებით. თითოეული ბიტის კონფიგურაცია შესაძლებელია ინდივიდუალურად (შემავალი ან გამომავალი).

MCP23016 შედგება მრავალჯერადი 8 ბიტიანი პარამეტრებისაგან შემავალი, გამომავალი და პოლარობის შესარჩევად.

გაფართოებები უზრუნველყოფენ მარტივ გადაწყვეტას, როდესაც IO- ები საჭიროა სხვა მაგალითებთან ერთად კონცენტრატორებისთვის, სენსორებისთვის, ღილაკებისთვის და LED- ებისთვის.

ნაბიჯი 2: მახასიათებლები

16 შეყვანის / გამომავალი ქინძისთავები (16 შეყვანის სტანდარტი)

სწრაფი I2C ავტობუსის საათის სიხშირე (0-400 კბიტი/წმ)

სამი ტექნიკური მისამართის ქინძისთავი იძლევა რვა მოწყობილობის გამოყენებას

შეაჩერე პორტის გადაღების ჩამწერი

პოლარობის შემობრუნების რეგისტრი შეყვანის პორტის მონაცემების პოლარობის დასადგენად

თავსებადია უმეტეს მიკროკონტროლერებთან

ნაბიჯი 3: ESP01– ს შეიძლება ჰქონდეს 128 GPIO

მაგალითი, რომელიც აჩვენებს ამ გაფართოების სიდიდეს, არის მისი გამოყენება ESP01– ით, რომლის დაკავშირება შესაძლებელია რვა გაფართოებასთან მხოლოდ ორი IOS– ით და მიაღწევს 128 GPIO– ს.

ნაბიჯი 4: MCP23016

აქ ჩვენ გვაქვს გაფართოების სქემა, რომელსაც აქვს რვა ბიტიანი ორი ჯგუფი. ეს შეადგენს სულ 16 პორტს. გარდა შეწყვეტის პინისა, მას აქვს CLK პინი, რომელიც აკავშირებს კონდენსატორსა და რეზისტორს, რომლებიც შინაგანად არიან დაკავშირებული ლოგიკურ პორტში. ეს არის საათის შესაქმნელად, ბროლის ოსცილატორის იდეის გამოყენებით, რომელსაც სჭირდება 1 მჰც საათი. TP pin გამოიყენება საათის გასაზომად. ქინძისთავები A0, A1 და A2 არის ორობითი მისამართები.

ნაბიჯი 5: საათი

ამიტომ MCP23016 იყენებს გარე RC წრეს შიდა საათის სიჩქარის დასადგენად. მოწყობილობის გამართულად მუშაობისთვის საჭიროა (ჩვეულებრივ) შიდა საათი 1 მჰც. შიდა საათის გაზომვა შესაძლებელია TP პინზე. REXT და CEXT– ის რეკომენდებული მნიშვნელობები ნაჩვენებია ქვემოთ.

ნაბიჯი 6: მისამართი

MCP23016 მისამართის დასადგენად, ჩვენ ვიყენებთ ქინძისთავებს A0, A1 და A2. უბრალოდ დატოვეთ ისინი HIGH ან LOW მისამართის შესაცვლელად.

მისამართი ჩამოყალიბდება შემდეგნაირად:

MCP_ მისამართი = 20 + (A0 A1 A2)

სადაც A0 A1 A2- ს შეუძლია მიიღოს HIGH / LOW მნიშვნელობები, ეს ქმნის ორობითი რიცხვს 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 ორ პორტზე.

რეგისტრის კითხვა გვაწვდის ამ პორტზე ქინძისთავების სტატუსს.

ბიტი = 1> მაღალი ბიტი = 0> დაბალი

OLAT0 / OLAT1 - გამომავალი LACTCH რეესტრები

არსებობს ორი რეგისტრი, რომლებიც უზრუნველყოფენ წვდომას ორი პორტის გამომავალ პორტებზე.

IPOL0 / IPOL1 - შეყვანის პოლარობის რეგისტრები

ეს რეგისტრები საშუალებას აძლევს მომხმარებელს დააკონფიგურიროს შეყვანის პორტის მონაცემების პოლარობა (GP0 და GP1).

IODIR0 / IODIR1

არსებობს ორი რეგისტრი, რომლებიც აკონტროლებენ pin რეჟიმს. (შეყვანა ან გამომავალი)

Bit = 1> INPUT Bit = 0> OUTPUT

INTCAP0 / INTCAP1 - ჩაწერის რეგისტრაციის შეწყვეტა

ეს არის რეგისტრები, რომლებიც შეიცავს პორტის მნიშვნელობას, რომელმაც გამოიწვია შეწყვეტა.

IOCON0 / IOCON1 - I / O Expander Control Register

ეს აკონტროლებს MCP23016 ფუნქციონირებას.

ბიტი 0 (IARES> შეწყვეტის აქტივობის რეზოლუცია) აკონტროლებს GP პორტის ქინძისთავების შერჩევის სიხშირეს.

Bit0 = 0> (ნაგულისხმევი) პორტის აქტივობის გამოვლენის მაქსიმალური დროა 32ms (დაბალი ენერგომოხმარება)

Bit0 = 1> მაქსიმალური აქტივობის გამოვლენის დრო პორტში არის 200usec (უფრო მაღალი ენერგიის მოხმარება)

ნაბიჯი 9: სტრუქტურა კომუნიკაციისთვის

მე აქ ვაჩვენებ Wire კლასს, რომელიც არის ჩვენი ძირითადი Arduino– ს I2C კომუნიკაცია, რომელიც ასევე საშუალებას აძლევს გაფართოებას იმუშაოს Arduino Uno– სთან და მეგასთან. თუმცა, ამ უკანასკნელს უკვე აქვს რამდენიმე IO. ჩვენ აქ ვსაუბრობთ ჩიპის მისამართებზე, წვდომის კონტროლზე, რომლებიც არის რეგისტრების კოდები, ასევე მონაცემები.

ნაბიჯი 10: პროგრამა

ჩვენი პროგრამა მოიცავს ESP32– ს MCP23016– თან კომუნიკაციას, რათა გამოვიყენოთ მეტი GPIO. ჩვენ გვექნება ღილაკი და რამდენიმე LED- ები დაკავშირებული MCP23016- თან. ჩვენ ყველა მათ გავაკონტროლებთ მხოლოდ I2C ავტობუსის გამოყენებით. ამრიგად, გამოყენებული იქნება მხოლოდ ორი ESP32 პინი. თქვენ შეგიძლიათ ნახოთ სურათის წრე ქვემოთ ვიდეოში.

ნაბიჯი 11: ESP01

აქ მე ვაჩვენებ ESP01– ის Pinout– ს.

ნაბიჯი 12: მონტაჟი ESP01

ამ მაგალითში ჩვენ გვაქვს GPIO0 დაკავშირებული SDA- ში და GPIO2 დაკავშირებულია SCL- ში. ჩვენ ასევე გვაქვს სარელეო დაფა, ზუზუნი და LED. მეორე პორტზე, GP1.0– ში, ჩვენ გვაქვს კიდევ ერთი LED რეზისტორით.

ნაბიჯი 13: NodeMCU ESP-12E

აქ ჩვენ გვაქვს NodeMCU ESP-12E- ის Pinout.

ნაბიჯი 14: მონტაჟი NodeMCU ESP-12E

ამ შემთხვევაში, ერთადერთი განსხვავება პირველი მაგალითიდან არის ის, რომ თქვენ დაუკავშირეთ D1 და D2 SDA და SCL- ში, შესაბამისად.

ნაბიჯი 15: WiFi NodeMCU-32S ESP-WROOM-32

აქ არის WiFi NodeMCU-32S ESP-WROOM-32 Pinout.

ნაბიჯი 16: WiFi სამონტაჟო კვანძი MCU-32S ESP-WROOM-32

ამჯერად, სხვა ორი მაგალითიდან მთავარი განსხვავება არის ღილაკი და სამი მოციმციმე LED. აქ SDA უკავშირდება GPIO19- ს, ხოლო SCL GPIO23- ს.

ნაბიჯი 17: ბიბლიოთეკები და ცვლადები

პირველ რიგში, ჩვენ ჩავრთავთ Wire.h, რომელიც პასუხისმგებელია i2c კომუნიკაციაზე, ასევე MCP23016 i2c მისამართის დაყენებაზე. მე ვაჩვენებ რამდენიმე ბრძანებას, თუნდაც ზოგიერთს, რომელსაც ჩვენ არ ვიყენებთ ამ პროექტში.

#მოიცავს // მიუთითეთ Wire.h ბიბლიოთეკის გამოყენება. // 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 0x0 // DATA PORT 0X0 // DATA PORT პორტის რეგისტრაცია 1 #განსაზღვრეთ OLAT0 0x02 // OUTPUT LATCH REGISTER 0 #განსაზღვრეთ OLAT1 0x03 // OUTPUT LATCH REGISTER 1 #განსაზღვრეთ IPOL0 0x04 // INPUT POLARITY PORT REGISTER 0 #define IPOLde 0x05 // INPUT 025 /I/O DIRECTION REGISTER 0 #განსაზღვრეთ IODIR1 0x07 // I/O DIRECTION REGISTER 1 #განსაზღვრეთ INTCAP0 0x08 // INTERRUPT CAPTURE REGISTER 0 #განსაზღვრეთ INTCAP1 0x09 // INTERRUPT CAPTURE REGISTER 1 #0 რეგისტრაცია 0 #განსაზღვრეთ IOCON1 0x0B // I/O EXPANDER CONTROL REGISTER 1

ნაბიჯი 18: დაყენება

აქ ჩვენ გვაქვს ოთხი განსხვავებული ტიპის მიკროკონტროლერის ინიციალიზაციის ფუნქციები. ჩვენ ასევე ვამოწმებთ სიხშირეს, ვაყენებთ GPIO– ს და ვაყენებთ ქინძისთავებს. მარყუჟში, ჩვენ ვამოწმებთ ღილაკის სტატუსს.

void setup () {Serial.begin (9600); დაგვიანება (1000); მავთული. დასაწყისი (19, 23); // ESP32 // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (); // arduino // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frequencia // კონფიგურაცია ან GPIO0 comOUTUTUT (todos os pinos) configurePort (IODIR0, OUTPUT); // კონფიგურაცია o GPIO1 como INPUT o GP1.0 e como OUTPUT OS out out 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); } // ბოლო მარყუჟი

ნაბიჯი 19: კონფიგურაცია პორტი

ამ ეტაპზე, ჩვენ ვაკონტროლებთ GPIO ქინძისთავების რეჟიმს და ვადგენთ პორტების რეჟიმს.

// კონფიგურაცია 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 მიუთითეთ და შეიტანეთ პორტები (1 = INPUT, 0 = OUTPUT) // მაგ.: 0x01 ou B00000001 ან 1: მაჩვენებელი, რაც GPX.0 ტრაბალჰარ á como entrada, o restando como saida void configurePort (uint8_t პორტი, uint8_t საბაჟო) {if (საბაჟო == INPUT) {writeBlockData (პორტი, 0xFF); } else if (საბაჟო == OUTPUT) {writeBlockData (პორტი, 0x00); } else {writeBlockData (პორტი, საბაჟო); }}

ნაბიჯი 20: ჩაწერეთ BlockData & CheckButton

აქ, ჩვენ მონაცემებს ვაგზავნით MCP23016– ში i2c ავტობუსის საშუალებით, ვამოწმებთ ღილაკის სტატუსს და ვგულისხმობთ მომდევნო საფეხურს დაჭერის თუ არა მდგომარეობის გათვალისწინებით.

// 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 (მონაცემები); Wire.endTransmission (); დაგვიანება (10); }

// გადამოწმება, თუ რა უნდა გააკეთო, // პარამეტრი GP: GP0 ou GP1 ძალადაკარგულად შეამოწმეთ ღილაკი (uint8_t GP) {// faz a leitura do pino 0 არ არის GP fornecido uint8_t btn = readPin (0, GP); // დაარეგისტრირეთ, დააყენეთ HIGH როგორც პორტა 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 (); მავთული. მოთხოვნა (MCPA მისამართი, 1); // ler do ჩიპი 1 ბაიტი statusGP = Wire.read (); დაბრუნების მნიშვნელობაFromPin (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.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01

Აწყობა

გაითვალისწინეთ, რომ მშენებელი ჯერ კიდევ გამოხმაურებულია. ამიტომ, დატოვეთ კომენტარი თქვენი დაფის მიხედვით (ESP-01 ან nodeMCU ESP12-E).

void setup () {Serial.begin (9600); დაგვიანება (1000); // Wire.begin (D2, D1); // nodemcu ESP8266 // Wire.begin (0, 2); // ESP-01 Wire.setClock (200000); // frequencia // კონფიგურაცია o GPIO0 comO OUTPUT (todos os pinos) configurePort (IODIR0, OUTPUT); // კონფიგურაცია 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); }

მარყუჟი

მარყუჟში, ჩვენ ვცვლით ქინძისთავებს ყოველ 1 წამში. ამრიგად, როდესაც GP0 pin0 ჩართულია, GP1- ის ქინძისთავები გამორთულია. როდესაც GP1 pin0 ჩართულია, GP0 ქინძისთავები გამორთულია.

void loop () {// seta o pino 7 to GP0 como HIGH e os demais como LOW writeBlockData (GP0, B10000000); // seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000000); დაგვიანება (1000); // seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); // seta o pino 0 GP1– ით მაღალი და დაბალი დრო LOW writeBlockData (GP1, B00000001); დაგვიანება (1000); } // ბოლო მარყუჟი

ნაბიჯი 23: მნიშვნელოვანია

გამოყენებული ცვლადები და ბიბლიოთეკა იგივეა, რაც ESP32 პროგრამისთვის, ასევე კონფიგურაციისა და ჩაწერის ბლოკის მონაცემების მეთოდები.

ნაბიჯი 24: ფაილები

ჩამოტვირთეთ ფაილები:

PDF

INO (ESP8266)

INO (ESP32)