OLED I2C Display Arduino/NodeMCU บทช่วยสอน: 15 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:06

โปรแกรมแรกสุดที่คุณเขียนเมื่อเริ่มเรียน a

ภาษาโปรแกรมใหม่คือ: "Hello World!"

ตัวโปรแกรมเองไม่ได้ทำอะไรมากไปกว่าการพิมพ์ข้อความ "Hello World" บนหน้าจอ

ดังนั้นเราจะให้ Arduino ของเราแสดง "Hello World!" ได้อย่างไร

ในวิดีโอนี้ ฉันจะแสดงวิธีเริ่มต้นใช้งานจอแสดงผล I2C OLED ขนาดเล็ก 0.91 (128x32) และ 0.96 (128x64)

มีบทเรียนกว่า 100 บทบนเว็บที่อธิบายสิ่งเดียวกันในรูปแบบต่างๆ แต่ฉันไม่พบบทเรียนที่บอกทุกอย่างเกี่ยวกับจอแสดงผล OLED และวิธีใช้งานในสถานการณ์ต่างๆ ฉันต้องใช้เวลาพอสมควรในการดำเนินการทั้งหมด ดังนั้น ฉันคิดว่าฉันควรสร้างบทช่วยสอนเกี่ยวกับสิ่งที่ฉันได้เรียนรู้ และรวมคุณสมบัติทั้งหมดและวิธีการใช้จอแสดงผล OLED ในโครงการของเรา

ขั้นตอนที่ 1: สิ่งที่เรากำลังจะเรียนรู้วันนี้

ในวิดีโอนี้เราจะพูดถึง:

- จอแสดงผล OLED คืออะไร?

- จากนั้นเราจะมาดูอย่างใกล้ชิดกับจอแสดงผล I2C OLED ขนาด 0.91 (128x32) และ 0.96 (128x64)

- ต่อไปเราจะพูดถึงการติดตั้ง Adafruit Library ใน Arduino IDE. ของคุณ

- จากนั้นเราจะเชื่อมต่อ NodeMCU และ Arduino กับจอแสดงผล OLED

- ต่อไปเราจะมาดูรหัสและแสดงกราฟิกและข้อความบางส่วนบนมัน

- เราจะพูดถึงการใช้แบบอักษรที่กำหนดเองและการแสดงรูปภาพ

- จากนั้นเราจะเชื่อมต่อ OLED หลายตัวกับไมโครคอนโทรลเลอร์โดยใช้ I2C Multiplexer

- สุดท้ายนี้ เราจะพูดถึงข้อผิดพลาดทั่วไปบางประการที่ผู้คนทำขณะใช้จอแสดงผล OLED

ขั้นตอนที่ 2: ข้อกำหนดฮาร์ดแวร์

สำหรับบทช่วยสอนนี้เราต้องการ:

- เขียงหั่นขนม

- จอแสดงผล OLED I2C ขนาด 0.91" (128x32) และ 0.96" (128x64)

- Arduino UNO/NANO (อะไรก็ได้ที่สะดวก)

- NodeMCU

- มัลติเพล็กเซอร์ TCA9548A I2C

- ต่อสายไม่กี่สาย

- และสาย USB เพื่ออัพโหลดโค้ด

ขั้นตอนที่ 3: จอแสดงผล OLED คืออะไร

OLED หรือไดโอดเปล่งแสงอินทรีย์เป็นไดโอดเปล่งแสง

ไดโอด (LED) ซึ่งชั้นอิเล็กโทรลูมิเนสเซนต์แบบเปล่งแสงเป็นฟิล์มของสารประกอบอินทรีย์ (ไฟ LED ขนาดเล็กหลายล้านดวง) ที่เปล่งแสงออกมาเพื่อตอบสนองต่อกระแสไฟฟ้า

OLED ถูกใช้เพื่อสร้างจอแสดงผลดิจิทัลในอุปกรณ์ต่างๆ เช่น หน้าจอโทรทัศน์ จอคอมพิวเตอร์ ระบบพกพา เช่น โทรศัพท์มือถือ เครื่องเล่นเกมแบบพกพา และพีดีเอ จอแสดงผล OLED ทำงานโดยไม่มีไฟแบ็คไลท์เพราะจะปล่อยแสงที่มองเห็นได้

ขั้นตอนที่ 4:

มีจอแสดงผล OLED หลายประเภทใน

ตลาดขึ้นอยู่กับพวกเขา

- ขนาด

- สี

- แบรนด์

- มาตรการ

- SPI (Serial Peripheral Interface) หรือ I2C

- รูปแบบการควบคุม Passive-matrix (PMOLED) หรือ active-matrix (AMOLED)

ในบทช่วยสอนนี้ ฉันจะพูดถึงการเชื่อมต่อ

สีน้ำเงิน 0.91 (128x32 OLED) และ 0.96 (128x64 OLED) I2C OLDE แสดงไปยัง Arduino NANO และ NodeMCU เทคโนโลยีบัส I2C ใช้ MCU เพียง 2 พิน ดังนั้นเราจึงมีฮีปสำหรับเซ็นเซอร์อื่นๆ

ขั้นตอนที่ 5: มองใกล้ขึ้น

มาดูจอภาพทั้งสองนี้กันดีกว่า

ที่ด้านหลังของจอแสดงผลเหล่านี้มีตัวเก็บประจุและตัวต้านทานแบบ SMD จำนวนมากที่บัดกรีไว้บนบอร์ด แต่เนื่องจากเป็นอุปกรณ์ I2C เราจึงสนใจแค่ 2 พินนี้เท่านั้น (SCL และ SDA)

จอแสดงผลเชื่อมต่อกับ Arduino โดยใช้สายเพียงสี่สาย - สองสายสำหรับจ่ายไฟ (VCC และ GND) และสองสายสำหรับข้อมูล (นาฬิกาอนุกรม SCL และ

ข้อมูลอนุกรม SDA) ทำให้การเดินสายง่ายมาก การเชื่อมต่อข้อมูลคือ I2C (I²C, IIC หรือ Inter-Integrated Circuit) และอินเทอร์เฟซนี้เรียกว่า TWI (Two Wire Interface)

- หมุดออนบอร์ดสามารถอยู่ในลำดับที่แตกต่างกันได้ ดังนั้นควรตรวจสอบสามครั้งก่อนที่จะเชื่อมต่อกับโปรเจ็กต์ของคุณ

- แรงดันใช้งานอยู่ระหว่าง 3v ถึง 5v แต่ควรใช้คำแนะนำจากแผ่นข้อมูลของผู้ผลิต

- บางครั้งเราจำเป็นต้องใช้จอแสดงผล 2 จอในโครงการของเรา แล้วเราจะบรรลุเป้าหมายนี้ได้อย่างไร?

เคล็ดลับคือการมีที่อยู่ที่กำหนดค่าได้บนจอแสดงผลของคุณ หน่วยนี้มีที่อยู่ที่กำหนดค่าได้ระหว่าง 0x78 ถึง 0x7A เพียงแค่ยกเลิกการขายตัวต้านทาน 0Ohm จากด้านหนึ่งและดึงมันขึ้นไปอีกด้านหนึ่ง หรือเพียงแค่วางตัวประสานทั่วโลก เราก็สามารถเปลี่ยนที่อยู่ได้ เราจะพูดถึงมันในเชิงลึกเมื่อเราเชื่อมต่อจอแสดงผลหลายจอกับ Arduino ในส่วนหลังของบทช่วยสอนนี้

ในภาพจอแสดงผลเหล่านี้ดูใหญ่มาก แต่ในทางปฏิบัติมันเล็กมาก พวกเขาทำมาจากพิกเซล OLED 128 x 32/64 แต่ละพิกเซลและไม่ต้องการแสงด้านหลัง เล็กขนาดนี้ ไปดูกันเลยดีกว่า แม้ว่าจะมีขนาดเล็ก แต่ก็มีประโยชน์มากในโครงการอิเล็กทรอนิกส์ใดๆ

ขั้นตอนที่ 6: ห้องสมุด

มีห้องสมุดหลายแห่งที่สามารถควบคุมสิ่งเหล่านี้ได้

แสดง ในอดีต ฉันเคยใช้ "ห้องสมุด u8glib" แต่ฉันพบว่าห้องสมุด AdaFruit เข้าใจง่ายและใช้งานในโครงการของเราได้ง่ายมาก ดังนั้น ฉันจะใช้ไลบรารี AdaFruit ในบทช่วยสอนนี้

ในการควบคุมจอแสดงผล OLED คุณจะต้องมีไลบรารี "adafruit_GFX.h" และไลบรารี "adafruit_SSD1306.h"

คุณสามารถดาวน์โหลดและติดตั้งไลบรารี่ลงใน Arduino IDE ของคุณได้สองวิธี

วิธีที่ 1

ไปที่ "Library manager" และค้นหา "adafruit_SSD1306" และ "adafruit_gfx"

เลือกเวอร์ชันล่าสุดและกดปุ่มติดตั้ง

เมื่อติดตั้งแล้ว คุณสามารถใช้ไลบรารีเหล่านี้ในโปรแกรมของคุณได้

วิธีที่ 2

ไลบรารีทั้งสองนี้สามารถดาวน์โหลดได้จาก github (คุณต้องการทั้งสองอย่าง):

ฉันจะให้ลิงก์ในคำอธิบายด้านล่าง

ไลบรารีแสดงผล:

ห้องสมุด GFX:

เมื่อดาวน์โหลดแล้ว ให้คัดลอกโฟลเดอร์ Adafruit_SSD1306-master จากไฟล์ซิปที่ดาวน์โหลดมาลงในโฟลเดอร์ไลบรารี Arduino โฟลเดอร์นี้มักจะพบที่เอกสาร > Arduino > ไลบรารีบนระบบ Windows บน Linux มักจะพบที่โฟลเดอร์หลัก > Arduino > ไลบรารี สุดท้ายในโฟลเดอร์ไลบรารี Arduino ให้เปลี่ยนชื่อโฟลเดอร์ Adafruit_SSD1306-master เป็น Adafruit_SSD1306 แม้ว่าคุณจะไม่เปลี่ยนชื่อก็ไม่เป็นไร

ขั้นตอนที่ 7:

ตอนนี้ มาดู "Adafruit_SSD1306.h" กัน

ไฟล์

สองสิ่งที่เราต้องรู้ในห้องสมุดนี้:

1. หากคุณต้องการใช้จอแสดงผลขนาดเล็ก ให้ใช้ค่าเริ่มต้น 128_32 มิฉะนั้นสำหรับจอแสดงผลขนาดใหญ่ ให้ใส่ความคิดเห็นที่ 128_32 และยกเลิกการใส่ความคิดเห็น 128_64

2. หากคุณบัดกรีที่อยู่ 0x7A บนบอร์ด (ซึ่งเราจะพูดถึงในภายหลัง) ให้ใช้ที่อยู่ 0x3D 7 บิตสำหรับจอแสดงผลที่ใหญ่กว่า มิฉะนั้น ให้ใช้ที่อยู่ 0x3C เริ่มต้น สำหรับจอแสดงผลขนาดเล็ก ที่อยู่คือ 0x3C

ขั้นตอนที่ 8: การเดินสายไฟ OLEDs 128 X 64/32

เริ่มต้นด้วยการเชื่อมต่อ NodeMCU กับจอแสดงผล

สิ่งแรกและสำคัญที่สุดที่ควรทราบคือจอแสดงผลบางจออาจมีพินไฟ GND และ VCC สลับไปมา ตรวจสอบจอแสดงผลของคุณเพื่อให้แน่ใจว่าเหมือนกับรูปภาพ หากมีการสลับพิน ตรวจสอบให้แน่ใจว่าได้เปลี่ยนการเชื่อมต่อกับ Arduino หรือ NodeMCU

- การเดินสายไฟ NodeMCU OLED

OLED VCC – NodeMCU 3.3V

OLED GND – NodeMCU GND

OLED SCL – NodeMCU D1

OLED SDA – NodeMCU D2

- การเดินสายไฟ Arduino Uno OLED

OLED VCC – Arduino 5V

OLED GND – Arduino GND

OLED SCL – Arduino Uno A5

OLED SDA – Arduino Uno A4

- Arduino MEGA 2560 OLED สายไฟ

OLED VCC – Arduino 5V

OLED GND – Arduino GND

OLED SCL – Arduino MEGA 2560 พิน 21

OLED SDA – Arduino MEGA 2560 พิน 20

ขั้นตอนที่ 9: รหัส

ห้องสมุดอดาฟรุตมาพร้อมตัวอย่างที่ดีทั้งคู่

จอแสดงผลขนาด 128x32 และ 128x64

ไลบรารีอยู่ภายใต้ File > Examples > Adafruit SSD1306 > แล้วประเภทการแสดงผลใน Arduino IDE

เราจะใช้ตัวอย่าง 128x32 I2C และจะปรับเปลี่ยนให้ใช้งานได้กับทั้งจอแสดงผลขนาด 128x64 และ 128x32 โดยเชื่อมต่อกับ Arduino แล้วต่อกับบอร์ด NodeMCU

รหัสเริ่มต้นด้วยการรวมห้องสมุด Adafruit ทั้งสองแห่ง ในบทช่วยสอนนี้ ฉันจะเน้นเฉพาะส่วนต่างๆ ของโค้ดที่จำเป็นสำหรับเราในการโหลดทั้งบนบอร์ดและจอแสดงผล หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับโค้ด โปรดแสดงความคิดเห็นในบล็อกของฉันหรือในส่วนความคิดเห็นด้านล่าง และเราจะพยายามติดต่อกลับหาคุณ

- อันดับแรก เราจะโหลดโค้ดไปยัง Arduino Nano ที่เชื่อมต่อกับจอแสดงผล 128x32

เราสามารถใช้รหัสตามที่เป็นอยู่โดยไม่มีการดัดแปลงใดๆ

128x32 ใช้ที่อยู่ 0x3C ดังนั้นบิตนี้จึงดูดีทั้งหมดที่นี่ ให้ตรวจสอบไลบรารีส่วนหัวอีกครั้ง ใช่ มันใช้ที่อยู่ 0x3C และประเภทการแสดงผลคือ 128x32

- ตอนนี้ให้เชื่อมต่อจอแสดงผล 128x64 ตามที่เราทราบดีว่าใช้ที่อยู่ 0x3C เป็นค่าเริ่มต้น ดังนั้นเราจึงไม่จำเป็นต้องอัปเดตที่อยู่ในโค้ดหรือไลบรารี

เราแค่ต้องการแสดงความคิดเห็น 128_32 และยกเลิกการใส่ความคิดเห็น 128_64 ในไลบรารีส่วนหัวและเปลี่ยน LCDHEIGHT เป็น 64 ในรหัสของเรา

- ตอนนี้ ในการรันโค้ดเดียวกันบน NodeMCU เราจำเป็นต้องเปลี่ยนอีกหนึ่งบรรทัดในโค้ดของเรา

โค้ดที่เหลือ "#define OLED_RESET 4" > "#define OLED_RESET LED_BUILTIN" เหมือนกับ Arduino

ค่อนข้างจะแสดงทุกอย่างที่เราต้องล้างหน้าจอก่อนหน้าโดยใช้

display.clearDisplay(); // ล้างบัฟเฟอร์

จากนั้นวาดวัตถุ

เส้นทดสอบ (); // ขีดเส้น

แสดงบนฮาร์ดแวร์

display.display(); // ทำให้มองเห็นได้บนฮาร์ดแวร์แสดงผล!

รอสักครู่ก่อนที่จะแสดงรายการถัดไป

ล่าช้า (2000); // รอ 2 วินาที

ในตัวอย่างนี้ เรากำลังแสดงรายการบางอย่าง เช่น ข้อความ เส้น วงกลม ข้อความเลื่อน สามเหลี่ยม และอื่นๆ ไปข้างหน้าและใช้จินตนาการของคุณและแสดงสิ่งที่คุณต้องการบนจอแสดงผลขนาดเล็กเหล่านี้

ขั้นตอนที่ 10: ปรับแต่งข้อความและการเพิ่มรูปภาพ

บางครั้งโค้ดของคุณต้องแสดงแบบอักษรที่กำหนดเองและ

ภาพ หากคุณเชี่ยวชาญในการทำบิตแมป คุณเพียงแค่ต้องสร้างอาร์เรย์ไบต์โดยเปิดหรือปิดไฟ LED เล็กๆ ของจอแสดงผลเพื่อสร้างแบบอักษรและรูปภาพที่กำหนดเอง

อย่างไรก็ตาม ฉันไม่เก่งในการทำแผนที่เหล่านี้ และไม่ต้องการใช้เวลาหลายชั่วโมงในการสร้างตารางบิตแมป

ดังนั้นตัวเลือกของฉันคืออะไร? โดยทั่วไปฉันใช้สองเว็บไซต์เพื่อสร้างแบบอักษรและรูปภาพที่กำหนดเอง ลิงก์มีอยู่ในคำอธิบายด้านล่าง

แบบอักษรที่กำหนดเอง

ไปที่เว็บไซต์ตัวแปลงฟอนต์ เลือกตระกูลฟอนต์ สไตล์ ขนาด เวอร์ชันไลบรารีเป็น "ฟอนต์ Adafruit GFX" จากนั้นกดปุ่ม "สร้าง" ทางด้านขวามือของหน้านี้ คุณจะเห็นว่าฟอนต์ของคุณจะเป็นอย่างไรบนหน้าจอจริง

ขึ้นอยู่กับการเลือกของคุณ หน้าเว็บจะสร้างไฟล์ส่วนหัวของแบบอักษร สร้างไฟล์ชื่อ "modified_font.h" ในโฟลเดอร์เดียวกับที่โค้ดของคุณอยู่ จากนั้นคัดลอกและบันทึกโค้ดที่สร้างลงในไฟล์ จากนั้น คุณเพียงแค่ต้องรวมไฟล์ส่วนหัวในโค้ดของคุณเพื่อใช้แบบอักษรที่กำหนดเอง

#รวม "modified_font.h"

จากนั้น คุณเพียงแค่ต้องตั้งค่าแบบอักษรก่อนที่จะแสดงข้อความเพื่อนำแบบอักษรที่กำหนดเองไปใช้กับแบบอักษรนั้น

display.setFont(&Your_Fonts_Name);

คุณสามารถรับชื่อฟอนต์จากไฟล์ส่วนหัวที่คุณเพิ่งเพิ่มลงในโปรเจ็กต์ของคุณ นั่นแหละ ง่าย

หน่วยความจำมักเป็นข้อกังวลเสมอเมื่อใช้แบบอักษรที่กำหนดเอง ดังนั้นให้พิจารณาไบต์ที่หน่วยความจำจะใช้เสมอ เพียงจำไว้ว่า Arduino UNO มีหน่วยความจำเพียง 32K

รูปภาพที่กำหนดเอง

ในการแสดงภาพบิตแมปบนหน้าจอของคุณ คุณต้องสร้างภาพขนาด 128 x 64/32 ก่อน

ฉันใช้ "MS Paint" แบบเก่าเพื่อสร้างรูปภาพบิตแมปขนาด 128 x 64 ซึ่งฉันจะอัปโหลดไปยังเว็บไซต์แปลงรูปภาพนี้ เว็บไซต์แปลงรูปภาพเป็นสตริงไบต์ซึ่งสามารถใช้กับจอแสดงผล Arduino และ OLED

เริ่มต้นด้วยการอัปโหลดภาพไปยังเว็บไซต์ จากนั้นทำเครื่องหมายที่ช่องทำเครื่องหมาย "สลับสีของภาพ" และเปลี่ยน "รูปแบบโค้ดเอาต์พุต" เป็น "โค้ด Arduino" จากนั้นเลือกการวางแนวและกดปุ่ม "สร้างโค้ด" เพื่อสร้างอาร์เรย์ไบต์ ส่วน "แสดงตัวอย่าง" จะแสดงให้คุณเห็นว่าภาพของคุณจะมีลักษณะอย่างไรบนจอแสดงผลจริง

ฉันได้รวมรหัสพร้อมกับบทช่วยสอนนี้ซึ่งคุณสามารถใช้เพื่อแสดงภาพของคุณ คุณเพียงแค่ต้องแทนที่อาร์เรย์ในโค้ดของฉันด้วยอาร์เรย์ที่คุณเพิ่งสร้างขึ้นแล้วโหลดลงใน Arduino ของคุณ

ขั้นตอนที่ 11: เชื่อมต่อ 2 จอแสดงผล

การเชื่อมต่อจอแสดงผล 128 x 64 สองจอเข้ากับโปรเจ็กต์ของคุณนั้นง่ายดาย

คุณเพียงแค่ต้องยกเลิกการขายตัวต้านทาน 0Ohm จากที่อยู่ 0x78 และวางไว้บน 0x7A จากนั้นใช้ที่อยู่ 0x3D ในรหัสของคุณแทน 0x3C เริ่มต้น

คุณต้องสงสัยว่าเหตุใดเราจึงใช้ที่อยู่ 0x3C และ 0x3D ไม่ใช่ 0x78 และ 0x7A จริง Arduino ยอมรับที่อยู่ 7 บิตและไม่ใช่ที่อยู่ฮาร์ดแวร์ 8 บิต ดังนั้น ก่อนอื่นเราต้องแปลงที่อยู่ 8 บิตเป็นไบนารี แล้วตัดบิตที่มีนัยสำคัญน้อยที่สุดออกเพื่อให้ได้ 7 บิต จากนั้นแปลง 7 บิตเป็น HEX เพื่อรับที่อยู่ 0x3C หรือ 0x3D ที่คุณป้อนในรหัสของคุณ

ขั้นแรก เริ่มต้นการแสดงผลโดยตั้งชื่อที่ไม่ซ้ำ:

Adafruit_SSD1306 display1 (OLED_REST);

Adafruit_SSD1306 display2 (OLED_REST);

จากนั้นในรหัสของคุณ ให้ใช้จอแสดงผล 1 และจอแสดงผล 2 เพื่อเรียกคำสั่งเริ่มต้นโดยมีที่อยู่อุปกรณ์อยู่ในนั้น:

display1.begin(SSD1306_SWITCHCAPVCC, 0x3C); // แสดง 1 ที่อยู่ปฏิบัติการ 0x3C

display2.begin(SSD1306_SWITCHCAPVCC, 0x3D); // แสดงที่อยู่ปฏิบัติการ 2 0x3D

เพียงเท่านี้ คุณก็สามารถทำสิ่งที่คุณต้องการได้โดยใช้ Display 1 หรือ Display 2 ในส่วนที่เหลือของโค้ด ฉันได้ให้ตัวอย่างกับบทช่วยสอนนี้

การเดินสายไฟนั้นเหมือนกับที่เราเคยทำมาทั้งหมด คุณเพียงแค่ต้องเพิ่มจอแสดงผลอื่นในพิน I2C เดียวกันของ Arduino หรือ NodeMCU ตามที่อยู่ MCU จะส่งข้อมูลบนสายข้อมูล I2C

ขั้นตอนที่ 12: เชื่อมต่อจอแสดงผลมากกว่า 2 จอ

จะทำอย่างไรถ้าคุณต้องการเชื่อมต่อจอภาพมากกว่า 2 จอ

Arduino มีพินจำนวนจำกัด และด้วยเหตุนี้คุณจึงไม่สามารถมีเกราะป้องกันได้เกินจำนวนที่กำหนด นอกจากนี้ยังมีรถบัส I2C เพียงคู่เดียว

แล้วเราจะแนบจอภาพ I2C มากกว่า 2 จอเข้ากับ Arduino ได้อย่างไร? เคล็ดลับคือการใช้ TCA9548 Multiplexer

TCA9548 ช่วยให้ไมโครคอนโทรลเลอร์ตัวเดียวสามารถสื่อสารกับ '64 เซ็นเซอร์' ทั้งหมดด้วยที่อยู่ I2C เดียวกันหรือต่างกันโดยกำหนดช่องสัญญาณที่ไม่ซ้ำกันให้กับบัสย่อยของเซ็นเซอร์แต่ละตัว

เมื่อเราพูดถึงการส่งข้อมูลมากกว่า 2 สายไปยังอุปกรณ์หลายเครื่อง เราจำเป็นต้องมีวิธีจัดการกับมัน เหมือนกับบุรุษไปรษณีย์ที่เดินบนถนนเส้นเดียวและส่งซองไปรษณีย์ไปยังบ้านต่างๆ กัน เพราะมีที่อยู่ที่แตกต่างกันเขียนไว้

Multiplexer เชื่อมต่อกับสาย 3V3, GND, SDA และ SCL ของไมโครคอนโทรลเลอร์ เซ็นเซอร์รองเชื่อมต่อกับพอร์ตรอง SCL/SDA หนึ่งในแปดพอร์ตบนบอร์ด เลือกช่องสัญญาณโดยส่งที่อยู่ I2C ให้ TCA9548A (0x70 {ค่าเริ่มต้น} - 0x77) ตามด้วยหมายเลขช่อง (0b00000001 - 0b10000000) คุณสามารถเชื่อมต่อมัลติเพล็กเซอร์เหล่านี้ได้สูงสุด 8 รายการบนที่อยู่ 0x70-0x77 เพื่อควบคุม 64 ของชิ้นส่วนที่อยู่ I2C เดียวกัน โดยการเชื่อมต่อบิตที่อยู่สามบิต A0, A1 และ A2 กับ VIN คุณจะได้รับที่อยู่ที่แตกต่างกัน ฉันจะอธิบายเชิงลึกนี้ในบทช่วยสอนครั้งต่อไปของฉันเกี่ยวกับกระดานฝ่าวงล้อม TCA9548A สำหรับตอนนี้ ให้เชื่อมต่อ OLED 8 ตัวเข้ากับบอร์ดนี้แล้วดูโค้ดอย่างรวดเร็ว

การเชื่อมต่อ:

VIN ถึง 5V (หรือ 3.3V)

GND ลงกราวด์

นาฬิกา SCL ถึง I2C

ข้อมูล SDA เป็น I2C

จากนั้นต่อเซ็นเซอร์กับ VIN, GND และใช้บัสมัลติเพล็กซ์ SCn / SDn ตัวใดตัวหนึ่ง

ตอนนี้ Int รหัสให้เริ่มต้นด้วยการรวมไลบรารี "Wire" และโดยการกำหนดที่อยู่มัลติเพล็กเซอร์

#รวม "Wire.h"

#รวม

#define MUX_Address 0x70 // ที่อยู่ตัวเข้ารหัส TCA9548A

จากนั้นเราต้องเลือกพอร์ตที่เราต้องการจะสื่อสารและส่งข้อมูลโดยใช้ฟังก์ชันนี้:

เป็นโมฆะ tcaselect (uint8_t i) {

ถ้า (i > 7) กลับมา;

Wire.beginTransmission(MUX_Address);

Wire.write(1 << ผม);

Wire.endTransmission();

}

ต่อไปเราจะเริ่มต้นการแสดงผลในส่วนการตั้งค่าโดยเรียก "u8g.begin();" สำหรับแต่ละจอแสดงผลที่แนบมากับ MUX "tcaselect(i);"

เมื่อเริ่มต้นแล้ว เราสามารถทำสิ่งที่ต้องการได้เพียงแค่เรียกใช้ฟังก์ชัน "tcaselect(i);" โดยที่ "i" คือค่าของบัสมัลติเพล็กซ์แล้วส่งข้อมูลและนาฬิกาตามลำดับ

ขั้นตอนที่ 13: ข้อดีและข้อเสีย

ภาพของ OLED นั้นสวยงาม อย่างไรก็ตาม OLED ก็มี

ข้อเสีย เนื่องจากหน้าจอ OLED ประกอบด้วยสารอินทรีย์ อายุการใช้งานจึงสั้นกว่าจอ LCD นอกจากนี้ จอภาพ OLED จำนวนมากยังถูกเบิร์นอินหลังจากแสดงภาพเดียวกันเป็นเวลานาน หลังจากการเบิร์นอิน รูปภาพจะยังคงอยู่บนหน้าจอแม้หลังจากแสดงรูปภาพอื่นแล้ว ดังนั้นอย่าลืมรีเฟรชหน้าจอทุกๆ สองสามวินาที น้ำสามารถทำลายวัสดุอินทรีย์ของจอแสดงผลเหล่านี้ได้ในทันที

ข้อดี

ไม่ต้องใช้ไฟแบ็คไลท์

จอภาพบางและเบามาก

การใช้พลังงานต่ำ

มุมมองภาพกว้างกว่า LCD

ความสว่างและคอนทราสต์ดีมาก

ความเร็วสูงและมีเวลาตอบสนองต่ำ

สีดำเข้ม

ข้อเสีย

เทคโนโลยีราคาแพง

วงจรชีวิตสั้น

OLEDS มีแนวโน้มที่จะเบิร์นอินมากขึ้น

ความเสียหายจากน้ำ

ขั้นตอนที่ 14: ข้อผิดพลาดทั่วไป

ในการสรุปบทช่วยสอน ให้พูดถึงข้อผิดพลาดทั่วไปเล็กน้อย

ผู้คนทำในขณะที่ใช้จอแสดงผลเหล่านี้:

- ตรวจสอบพินสามครั้งก่อนใช้ในโครงการของคุณเสมอ

- เลือกที่อยู่ห้องสมุดที่ถูกต้องในไฟล์ส่วนหัวและในรหัสของคุณ

#define SSD1306_I2C_ADDRESS 0x3C // ใน Adafruit_SSD1306.h

และ

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // ในรหัสของคุณ

หากที่อยู่ไม่ถูกต้อง OLED จะไม่แสดงอะไรเลย

- ต้องเปลี่ยนขนาดการแสดงผลในไดรเวอร์ก่อนจึงจะสามารถใช้งานได้ หากไม่เปลี่ยนแปลง คุณจะได้รับข้อความแสดงข้อผิดพลาดเมื่อพยายามยืนยันรหัส

#error ("ความสูงไม่ถูกต้อง โปรดแก้ไข Adafruit_SSD1306.h!");

- หากใช้ NodeMCU อย่าลืมเปลี่ยน OLED_RESET จาก 4 เป็น LED_BUILTIN

#define OLED_RESET LED_BUILTIN

ฉันมีฉากที่คนทำสิ่งต่าง ๆ โดยใช้จอแสดงผล OLED นี้ บางคนได้ทำวิดีโอเกมและทั้งหมด ฉันไม่สนใจที่จะสร้างวิดีโอเกมโดยใช้จอแสดงผลขนาดเล็กนี้ อย่างไรก็ตาม ตอนนี้ฉันจะให้คุณสำรวจจินตนาการของคุณและออกไอเดียที่น่าอัศจรรย์

ขั้นตอนที่ 15: ลิงค์

- บล็อก:

- เพิ่มรูปภาพ:

- ข้อความที่กำหนดเอง:

- ห้องสมุดแสดงผล Adafruit:

- ห้องสมุด Adafruit GFX:

- ห้องสมุด u8glib: https://code.google.com/archive/p/u8glib/ หรือ

หากคุณต้องการใช้จอแสดงผลขนาดเล็ก ให้ใช้ค่าเริ่มต้น 128_32 มิฉะนั้นสำหรับจอแสดงผลขนาดใหญ่ ให้แสดงความคิดเห็นที่ 128_32 และยกเลิกการใส่เครื่องหมาย 128X64 NO_ACK ในโค้ดของคุณ (เพียงยกเลิกการใส่ความคิดเห็นเกี่ยวกับประเภทของหน้าจอที่คุณใช้) (ฟอนต์อยู่ในไลบรารีฟอนต์)