RGB LED Matrix: 5 ขั้นตอน

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

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

ดังนั้นฉันจึงมุ่งมั่นที่จะบรรลุวิสัยทัศน์ของฉัน ขั้นตอนแรกคือการออกแบบฮาร์ดแวร์ นี่อาจเป็นสิ่งที่ท้าทายที่สุดสำหรับฉัน เนื่องจากพื้นหลังของฉันมีซอฟต์แวร์มากกว่า อีกครั้ง มีการออกแบบที่ทำไว้ล่วงหน้าจำนวนมาก และแน่นอนว่าฉันใช้มันเพื่อเป็นแรงบันดาลใจ แต่ฉันต้องการเรียนรู้ผ่านการทำ ดังนั้นฉันจึงสร้างต้นแบบเมทริกซ์ขนาด 4x4 บนเขียงหั่นขนม ฉันได้เรียนรู้มากมายจากกระบวนการนั้น เนื่องจากการทำซ้ำสองสามครั้งแรกของฉันไม่ได้ผล แต่ฉันได้ออกแบบฮาร์ดแวร์ที่ได้ผล ซึ่งทำให้ฉันสามารถเริ่มพัฒนาไดรเวอร์ได้

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

คำแนะนำนี้จัดทำเอกสารการออกแบบและการเรียนรู้ที่สำคัญบางส่วนจากโครงการของฉัน ข้อมูลเพิ่มเติมเกี่ยวกับโครงการนี้สามารถพบได้ที่เว็บไซต์ของฉันที่นี่ รวมถึงชุดอุปกรณ์เต็มรูปแบบที่คุณสามารถซื้อเพื่อสร้างเมทริกซ์ RGB LED ของคุณเอง

ขั้นตอนที่ 1: การออกแบบฮาร์ดแวร์

เป้าหมายหลักของการออกแบบฮาร์ดแวร์ของฉันคือการสร้างอาร์เรย์ของไฟ LED RGB ที่ฉันสามารถตั้งโปรแกรมได้ แต่ฉันก็ไม่ต้องการใช้เงินเป็นจำนวนมากเช่นกัน แนวทางที่ฉันใช้คือการใช้รีจิสเตอร์ 74HC595 เพื่อควบคุมไฟ LED เพื่อลดจำนวนกะที่ต้องการให้เหลือน้อยที่สุด ฉันได้จัด RGB LEDs ลงในเลย์เอาต์เมทริกซ์ที่แอโนดทั่วไปถูกผูกเข้าด้วยกันเป็นแถว และลีดแคโทดสีแดง สีเขียว และสีน้ำเงินถูกผูกเข้าด้วยกันเป็นคอลัมน์ สำหรับเมทริกซ์ 4x4 แผนภาพวงจรจะดูเหมือนแผนภาพวงจรที่แนบมา

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

เนื่องจากฉันใช้ LED ขั้วบวกทั่วไป นั่นหมายความว่าแถวต่างๆ จะให้พลังงานบวกและเสาจะจมลงสู่พื้น ข่าวดีก็คือการลงทะเบียนกะ 74HC595 สามารถทั้งแหล่งพลังงานและพลังงานจม แต่ข่าวร้ายก็คือพวกเขามีขีดจำกัดว่าจะสามารถจ่ายไฟหรือจมได้มากเพียงใด พินเดี่ยวของ 74HC595 มีการดึงกระแสไฟสูงสุดที่ 70 mA แต่ควรเก็บไว้ให้น้อยกว่า 20 mA แต่ละสีในไฟ LED RGB ของเราแต่ละสีมีการดึงประมาณ 20 mA ซึ่งหมายความว่า 74HC595 ไม่สามารถจ่ายไฟให้กับ LED ทั้งแถวได้โดยตรง หากฉันต้องการเปิดไฟทั้งหมด

ดังนั้นแทนที่จะจ่ายไฟให้กับแถวโดยตรง 74HC595 จะขับทรานซิสเตอร์สำหรับแต่ละแถวแทน และทรานซิสเตอร์จะเปิดหรือปิดกระแสไฟที่จ่ายกระแสไฟให้กับแถว เนื่องจากการออกแบบใช้ LED ขั้วบวกทั่วไป ทรานซิสเตอร์สวิตชิ่งจึงเป็น PNP หากเราใช้ LED แคโทดทั่วไป ทรานซิสเตอร์สวิตชิ่งจะเป็น NPN โปรดทราบว่าเมื่อใช้ทรานซิสเตอร์ PNP เพื่อขับเคลื่อนแถว การตั้งค่าของ shift register เพื่อเปิดใช้งานตอนนี้จะต่ำเนื่องจากทรานซิสเตอร์ PNP ต้องการแรงดันลบระหว่างตัวปล่อยและฐานที่จะเปิด ซึ่งจะทำให้กระแสบวกไหลเข้าสู่ แถว.

อีกสิ่งหนึ่งที่ต้องพิจารณาคือเลย์เอาต์บิตที่ต้องการของรีจิสเตอร์กะ นั่นคือ ในบรรดา shift register ซึ่งบิตควบคุมแถวหรือคอลัมน์ใดในเมทริกซ์ การออกแบบที่ฉันส่งด้วยคือตำแหน่งที่บิตแรกหรือ "บิตที่สำคัญที่สุด" ส่งไปยังรีจิสเตอร์กะเดซี่ที่ถูกล่ามโซ่ควบคุมคอลัมน์ขององค์ประกอบ LEDs สีแดง บิตที่สองควบคุมองค์ประกอบสีเขียวของคอลัมน์แรก บิตที่สามควบคุมคอลัมน์แรก องค์ประกอบสีน้ำเงิน บิตที่สี่ควบคุมองค์ประกอบสีแดงของคอลัมน์ที่สอง … รูปแบบนี้ซ้ำกันในคอลัมน์จากซ้ายไปขวา จากนั้นบิตถัดไปที่ส่งจะควบคุมแถวสุดท้ายหรือด้านล่าง แถวถัดไปในแถวที่สองถึงแถวสุดท้าย … ทำซ้ำจนกระทั่งบิตสุดท้ายส่งหรือ "บิตที่มีนัยสำคัญน้อยที่สุด" ควบคุมแถวแรกหรือบนสุดในเมทริกซ์.

ในที่สุด ฉันต้องกำหนดว่าจะใช้ตัวต้านทานใดสำหรับ LED แต่ละตัวใน RGB LED ในขณะที่คุณสามารถใช้สูตรมาตรฐานที่รวมแรงดันไปข้างหน้าและกระแสที่ต้องการเพื่อคำนวณตัวต้านทานที่ต้องการได้ ฉันพบว่าการตั้งค่ากระแสไฟ LED แต่ละดวงเป็น 20 มิลลิแอมป์จะทำให้เป็นสีขาวนวลเมื่อไฟ LED สีแดง สีเขียว และสีน้ำเงินทั้งหมดเปิดอยู่. ดังนั้นฉันจึงเริ่มจับตาดูมัน สีแดงมากเกินไปในสีขาวหมายถึงการเพิ่มโอห์มต้านทานของ LED สีแดงเพื่อลดกระแส ฉันสลับตัวต้านทานที่มีโอห์มต่างกันซ้ำๆ จนกระทั่งพบชุดค่าผสมที่สร้างสีขาวที่ฉันรู้สึกว่าถูกต้อง ชุดค่าผสมสุดท้ายคือ 180 Ω สำหรับ LED สีแดง 220 Ω สำหรับ LED สีเขียว และ 100 Ω สำหรับ LED สีน้ำเงิน

ขั้นตอนที่ 2: การสร้างฮาร์ดแวร์ - เขียงหั่นขนม

ขั้นตอนแรกของตัวสร้างฮาร์ดแวร์คือการขึ้นเครื่อง ที่นี่ฉันสร้างเมทริกซ์ 4x4 ด้วยไฟ LED RGB เมทริกซ์นี้ต้องใช้ 16 บิตในการควบคุม 12 บิตสำหรับคอลัมน์ RGB และ 4 สำหรับแต่ละแถว ทะเบียนกะ 74HC595 สองตัวสามารถจัดการได้ทั้งหมด ตอนแรกฉันค้นคว้าและออกแบบวงจรที่คิดว่าน่าจะใช้ได้ผล จากนั้นจึงสร้างวงจรขึ้นบนเขียงหั่นขนม

อาจเป็นความท้าทายที่ใหญ่ที่สุดของการสร้างเขียงหั่นขนมคือการจัดการสายไฟทั้งหมด ฉันหยิบชุดลวดสำเร็จรูปสำหรับเขียงหั่นขนม แต่เหตุการณ์นั้นค่อนข้างเทอะทะเล็กน้อย เคล็ดลับที่ฉันพบว่ามีประโยชน์คือการสร้าง "พอร์ต" สำหรับเชื่อมต่อกับบอร์ด Arduino นั่นคือแทนที่จะเชื่อมต่อหมุดบน Arduino โดยตรงกับหมุด IC ต่างๆบนเขียงหั่นขนม ให้อุทิศสองสามแถวบนเขียงหั่นขนมเพื่อเป็นจุดเชื่อมต่อสำหรับ Arduino แล้วเชื่อมต่อหมุด ID ที่เกี่ยวข้องกับแถวเหล่านั้น สำหรับโปรเจ็กต์นี้ คุณต้องมีการเชื่อมต่อ 5 ตัวกับ Arduino: +5V, กราวด์, ข้อมูล, นาฬิกา และสลัก

เมื่อสร้างเขียงหั่นขนมเสร็จแล้วฉันต้องทดสอบ อย่างไรก็ตาม ถ้าไม่มีไดรเวอร์บางประเภทในการส่งสัญญาณที่ถูกต้องไปยัง shift register ฉันไม่สามารถทดสอบเพื่อดูว่าเลย์เอาต์ของฮาร์ดแวร์ใช้งานได้หรือไม่

ขั้นตอนที่ 3: การออกแบบซอฟต์แวร์ไดรเวอร์

จากประสบการณ์การทำงานด้านการพัฒนาซอฟต์แวร์ของฉันเอง นี่จึงเป็นส่วนหนึ่งของโครงการที่ฉันน่าจะเข้าใจได้ชัดเจนที่สุดเกี่ยวกับเส้นทางที่ต้องทำ ฉันได้สำรวจไดรเวอร์ LED matrix ที่ใช้ Arduino หลายตัว แม้ว่าจะมีไดรเวอร์ที่ดี แต่ก็ไม่มีใครมีดีไซน์ที่ฉันต้องการ เป้าหมายการออกแบบของฉันสำหรับคนขับคือ:

• จัดเตรียม API ระดับสูงเพื่อให้สามารถสร้างรูปภาพและภาพเคลื่อนไหวโดยทางโปรแกรม ไดรเวอร์ส่วนใหญ่ที่ฉันเห็นเน้นไปที่รูปภาพที่ฮาร์ดโค้ดมากกว่า นอกจากนี้ เนื่องจากฉันเป็นโปรแกรมเมอร์ C++ โดยการค้าขาย ฉันต้องการใช้การออกแบบเชิงวัตถุที่ดีเพื่อใช้งานและจัดการกิจกรรมการวาดภาพไปยังเมทริกซ์ LED
• ใช้วิธีบัฟเฟอร์คู่เพื่อจัดการภาพบนหน้าจอ บัฟเฟอร์หนึ่งคือสิ่งที่ดึงเข้ามาโดยทางโปรแกรม ในขณะที่อีกบัฟเฟอร์หนึ่งแสดงถึงสถานะของพิกเซลเมทริกซ์ในช่วงเวลาที่กำหนด ข้อดีของวิธีนี้คือ คุณไม่จำเป็นต้องแสดงการอัปเดตเฟรมถัดไปสำหรับหน้าจออย่างสมบูรณ์ในระหว่างรอบการอัปเดตของมัลติเพล็กซ์
• ใช้ PWM เพื่อให้มีสีดั้งเดิมมากกว่าเจ็ดสีที่ RGB สามารถแสดงผ่านองค์ประกอบสีแดง สีเขียว และสีน้ำเงินอย่างง่าย
• เขียนไดรเวอร์เพื่อให้ "ใช้งานได้" กับเมทริกซ์ RGB LED ขนาดต่างกันซึ่งเป็นไปตามแนวทางการออกแบบเมทริกซ์ทั่วไปของฉัน โปรดทราบว่าในขณะที่การออกแบบฮาร์ดแวร์ของฉันใช้การลงทะเบียนกะ 74HC595 ฉันคาดว่าไดรเวอร์ของฉันจะทำงานกับกลไกการเปิด/ปิดรูปแบบการลงทะเบียนกะใดๆ ที่จัดวางโดยใช้เค้าโครงบิตที่คล้ายกับการออกแบบฮาร์ดแวร์ของฉัน ตัวอย่างเช่น ฉันคาดหวังว่าไดรเวอร์ของฉันจะทำงานกับการออกแบบฮาร์ดแวร์ที่ใช้ชิป DM13A เพื่อควบคุมคอลัมน์ และชิป 74HC595 เพื่อควบคุมแถว

หากคุณต้องการดูรหัสไดรเวอร์โดยตรง คุณสามารถค้นหาได้ใน GitHub ที่นี่

การวนซ้ำครั้งแรกของไดรเวอร์ของฉันเป็นช่วงการเรียนรู้เล็กน้อยเกี่ยวกับความสามารถของแพลตฟอร์ม Arduino ข้อจำกัดที่ชัดเจนที่สุดคือ RAM ซึ่งเท่ากับ 2K ไบต์สำหรับ Arduino Uno และ Nano บ่อยครั้งไม่แนะนำให้ใช้ออบเจ็กต์ C++ ในสถานการณ์เช่นนี้ เนื่องจากหน่วยความจำโอเวอร์เฮดของอ็อบเจ็กต์ อย่างไรก็ตาม ฉันรู้สึกว่าถ้าทำถูกต้อง ประโยชน์ของอ็อบเจ็กต์ใน C++ นั้นมีมากกว่าค่าใช้จ่าย (ใน RAM)

ความท้าทายหลักประการที่สองคือการหาวิธีใช้การปรับความกว้างพัลส์ผ่าน shift register เพื่อให้ฉันสามารถสร้างสีดั้งเดิมมากกว่าเจ็ดสีของ RGB LED หลังจากตั้งโปรแกรมบนแพลตฟอร์ม Linux มานานหลายปี ฉันเคยชินกับการใช้โครงสร้างเช่นเธรดเพื่อจัดการกระบวนการที่ต้องใช้เวลาสม่ำเสมอ เวลาของการดำเนินการอัปเดต shift register นั้นค่อนข้างสำคัญเมื่อสร้างไดรเวอร์สำหรับเมทริกซ์ LED ที่ใช้มัลติเพล็กซ์ เหตุผลก็คือแม้ว่ามัลติเพล็กซิ่งจะเกิดขึ้นเร็วมากจนดวงตาของคุณมองไม่เห็นไฟ LED แต่ละดวงที่กระพริบและดับ แต่คุณสามารถรับรู้ความแตกต่างในระยะเวลารวมทั้งหมดที่ไฟ LED ติดสว่าง หากไฟ LED แถวหนึ่งติดสม่ำเสมอเป็นเวลานานกว่าแถวอื่นๆ ไฟ LED แถวหนึ่งจะสว่างขึ้นในระหว่างการทำมัลติเพล็กซ์ ซึ่งอาจนำไปสู่ความสว่างที่ไม่สม่ำเสมอในเมทริกซ์หรือการแฟลชเป็นระยะๆ ของเมทริกซ์โดยรวม (ซึ่งเกิดขึ้นเมื่อรอบการอัปเดตหนึ่งใช้เวลานานกว่ารอบอื่นๆ)

เนื่องจากฉันต้องการกลไกการจับเวลาที่สอดคล้องกันเพื่อให้การอัปเดตรีจิสเตอร์ shift ได้รับความยินยอม แต่ Arduino ไม่สนับสนุนเธรดอย่างเป็นทางการ ฉันจึงต้องสร้างกลไกที่คล้ายกับเธรดของตัวเอง การทำซ้ำครั้งแรกของฉันคือการสร้างตัวจับเวลาแบบวนซ้ำที่ขึ้นอยู่กับฟังก์ชัน Arduino loop() และจะเริ่มทำงานเมื่อเวลาผ่านไประยะหนึ่งตั้งแต่ครั้งสุดท้ายที่การกระทำถูกไล่ออก นี่คือรูปแบบหนึ่งของ ฟังดูดี แต่ในทางปฏิบัติ สิ่งนี้พิสูจน์แล้วว่าไม่สอดคล้องกันเมื่อวัดอัตราการยิงเป็นไมโครวินาที เหตุผลก็คือว่าถ้าฉันให้ตัวจับเวลาวนซ้ำสองตัวนี้ทำงาน หนึ่งในการกระทำของพวกเขามักใช้เวลานานพอที่จะทำให้การทำงานที่สองเริ่มทำงานช้ากว่าที่ต้องการ

ฉันพบว่าวิธีแก้ปัญหานี้คือการใช้กลไกขัดจังหวะนาฬิกาดั้งเดิมของ Arduino กลไกนี้ช่วยให้คุณเรียกใช้โค้ดเล็กน้อยในช่วงเวลาที่สม่ำเสมอมาก ดังนั้นฉันจึงออกแบบรหัสไดรเวอร์รอบองค์ประกอบการออกแบบของการใช้นาฬิกาขัดจังหวะเพื่อเรียกรหัสสำหรับการส่งการลงทะเบียนการเปลี่ยนแปลงของเมทริกซ์การอัพเดทครั้งต่อไปในรอบมัลติเพล็กซ์ ในการทำเช่นนี้และอนุญาตให้การอัปเดตเกิดขึ้นกับรูปภาพของหน้าจอเพื่อไม่ให้รบกวนการถ่ายโอนข้อมูลที่ใช้งานอยู่ไปยัง shift register (สิ่งที่เราเรียกว่า "สภาวะการแข่งขัน") ฉันใช้วิธีการมีบัฟเฟอร์คู่สำหรับบิต shift register อย่างใดอย่างหนึ่ง สำหรับเขียนและสำหรับอ่าน เมื่อผู้ใช้กำลังอัปเดตอิมเมจเมทริกซ์ การดำเนินการเหล่านี้จะเกิดขึ้นกับบัฟเฟอร์การเขียน เมื่อการดำเนินการเหล่านั้นเสร็จสิ้น การขัดจังหวะจะถูกระงับชั่วคราว (ซึ่งหมายความว่าการขัดจังหวะของนาฬิกาไม่สามารถเริ่มทำงานได้) และบัฟเฟอร์การเขียนจะถูกสลับกับบัฟเฟอร์การอ่านก่อนหน้าและไม่ใช่บัฟเฟอร์การอ่านใหม่ จากนั้นการตีความจะเปิดใช้งานอีกครั้ง จากนั้น เมื่อนาฬิกาขัดจังหวะโดยระบุว่าถึงเวลาส่งการกำหนดค่าบิตถัดไปไปยัง shift register ข้อมูลนั้นจะถูกอ่านจากบัฟเฟอร์การอ่านปัจจุบัน ด้วยวิธีนี้ จะไม่มีการเขียนใดๆ เกิดขึ้นกับบัฟเฟอร์ที่อาจกำลังอ่านอยู่ในระหว่างการขัดจังหวะของนาฬิกา ซึ่งอาจทำให้ข้อมูลที่ส่งไปยัง shift register เสียหาย

การออกแบบส่วนที่เหลือของไดรเวอร์นั้นเป็นกรณีที่ค่อนข้างตรงไปตรงมาของการออกแบบเชิงวัตถุ ตัวอย่างเช่น ฉันสร้างออบเจ็กต์เพื่อจัดการอิมเมจ shift register bit สำหรับสถานะหน้าจอที่กำหนด ด้วยการห่อหุ้มโค้ดที่เกี่ยวข้องกับการจัดการบิตอิมเมจ การสร้างแนวทางบัฟเฟอร์คู่ดังกล่าวจึงเป็นแบบฝึกหัดที่ตรงไปตรงมา แต่ฉันไม่ได้เขียนคำแนะนำนี้เพื่อยกย่องคุณธรรมของการออกแบบเชิงวัตถุ องค์ประกอบการออกแบบอื่นๆ ได้แก่ แนวคิดของสัญลักษณ์และภาพ RGB Glyph เป็นโครงสร้างภาพพื้นฐานที่ไม่มีข้อมูลสีโดยกำเนิด คุณสามารถคิดได้ว่าเป็นภาพขาวดำ เมื่อสัญลักษณ์ถูกวาดไปที่หน้าจอ LED ข้อมูลสีจะได้รับเพื่อระบุว่าพิกเซล "สีขาว" ควรมีสีอย่างไร ภาพ RGB คือภาพที่ทุกพิกเซลมีข้อมูลสีเป็นของตัวเอง

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

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

ในเมทริกซ์ LED "ภาพซ้อน" เป็นปรากฏการณ์ของ LED ในเมทริกซ์ที่เรืองแสงเมื่อไม่ต้องการ ซึ่งมักจะเป็นระดับที่ลดลงอย่างมาก การออกแบบฮาร์ดแวร์ดั้งเดิมของฉันนั้นไวต่อแสงหลอก โดยเฉพาะอย่างยิ่งในแถวสุดท้าย สาเหตุของสิ่งนี้เกิดจากสองสิ่ง: ทรานซิสเตอร์ไม่ปิดทันทีและความจุกาฝากในไฟ LED RGB

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

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

ไฟ LED RGB มีความอ่อนไหวต่อปรากฏการณ์อื่นที่เรียกว่าความจุกาฝาก สาเหตุที่แท้จริงคือไฟ LED สามสีแต่ละดวงในหน่วย RGB LED แต่ละดวงมีแรงดันไฟฟ้าไปข้างหน้าต่างกัน ความแตกต่างของแรงดันไฟฟ้าไปข้างหน้านี้อาจทำให้เกิดผลกระทบของความจุไฟฟ้าระหว่างแต่ละสีของ LED แต่ละสี เนื่องจากประจุไฟฟ้าถูกสร้างขึ้นในหน่วย LED เมื่อจ่ายไฟ เมื่อถอดไฟ ความจุกาฝากจะต้องถูกคายประจุ หากคอลัมน์ LED นั้นเปิดอยู่สำหรับการจ่ายไฟของแถวอื่น ประจุที่เป็นกาฝากจะปล่อยผ่าน LED ของคอลัมน์นั้นและทำให้ไฟสว่างชั่วครู่ เอฟเฟกต์นี้อธิบายไว้อย่างดีในบทความนี้ วิธีแก้ไขคือการเพิ่มเส้นทางการปลดปล่อยสำหรับประจุที่เป็นกาฝากนี้นอกเหนือจากผ่าน LED เอง จากนั้นให้เวลา LED ในการคายประจุก่อนที่คอลัมน์จะถูกจ่ายไฟอีกครั้ง ในการออกแบบฮาร์ดแวร์ของฉัน ทำได้โดยการเพิ่มตัวต้านทานให้กับสายไฟของแต่ละแถวที่เชื่อมต่อความแข็งแรงกับกราวด์ สิ่งนี้จะทำให้กระแสไฟมากขึ้นโดยแถวถูกขับเคลื่อน แต่ให้เส้นทางการปลดปล่อยสำหรับความจุกาฝากเมื่อแถวไม่ได้ขับเคลื่อน

อย่างไรก็ตาม เป็นที่น่าสังเกตว่าในทางปฏิบัติ ฉันพบว่าผลกระทบของความจุกาฝากนั้นแทบจะสังเกตไม่เห็น (ถ้าคุณมองหา คุณจะพบมัน) ดังนั้นฉันจึงพิจารณาเพิ่มตัวต้านทานพิเศษนี้เป็นตัวเลือก ผลกระทบของการชะลอเวลาของทรานซิสเตอร์อิ่มตัวนั้นแข็งแกร่งกว่าและเห็นได้ชัดเจนมาก อย่างไรก็ตาม หากคุณตรวจสอบภาพถ่ายทั้งสามภาพที่ให้มาในส่วนนี้ คุณจะเห็นว่าตัวต้านทานจะลบภาพซ้อนที่ยังคงเกิดขึ้นเกินเวลาปิดทรานซิสเตอร์ที่ช้าโดยสิ้นเชิง

ขั้นตอนที่ 5: การผลิตขั้นสุดท้ายและขั้นตอนถัดไป

ขั้นตอนสุดท้ายของโครงการนี้คือการสร้างแผงวงจรพิมพ์ (PCB) ฉันใช้โปรแกรมโอเพ่นซอร์ส Fritzing เพื่อออกแบบ PCB ของฉัน แม้ว่าจะมีงานที่ต้องทำซ้ำๆ มากมายในการจัดวาง 100 LEDs บนบอร์ดขนาด 10x10 ให้สำเร็จ แต่จริงๆ แล้ว ฉันพบว่าระยะนี้ของโปรเจ็กต์น่าพอใจอย่างน่าประหลาด การค้นหาวิธีการจัดวางทางเดินไฟฟ้าแต่ละทางเป็นเหมือนปริศนา และการไขปริศนานั้นทำให้เกิดความรู้สึกสำเร็จ เนื่องจากฉันไม่ได้ถูกตั้งค่าให้ผลิตแผงวงจร ฉันจึงใช้แหล่งข้อมูลออนไลน์จำนวนมากที่ใช้ PCB แบบกำหนดเองขนาดเล็ก การบัดกรีชิ้นส่วนต่างๆ เข้าด้วยกันนั้นค่อนข้างตรงไปตรงมา เนื่องจากการออกแบบของฉันใช้ชิ้นส่วนที่เจาะทะลุได้ทั้งหมด

ในขณะที่เขียนคำแนะนำนี้ ฉันมีแผนต่อไปนี้สำหรับโครงการ RGB LED Matrix ของฉัน:

1. ดำเนินการปรับปรุงไดรเวอร์ที่เลเยอร์ API ต่อไปเพื่อเปิดใช้งานฟังก์ชันระดับสูงมากขึ้นสำหรับโปรแกรมเมอร์ โดยเฉพาะอย่างยิ่งการเลื่อนข้อความที่โดดเด่นที่สุด
2. สร้างการออกแบบเมทริกซ์ที่ใหญ่ขึ้น เช่น 16x16 หรือแม้แต่ 16x32
3. สำรวจการใช้ MOSFET แทน BJT สำหรับการสลับกำลังแถว
4. สำรวจโดยใช้ DM13A เป็นไดรเวอร์ปัจจุบันคงที่มากกว่า 74HC595 สำหรับการสลับคอลัมน์
5. สร้างไดรเวอร์สำหรับแพลตฟอร์มควบคุมขนาดเล็กอื่นๆ เช่น Teensy, ODROID C2 หรือ Raspberry Pi

โปรดทราบว่าทั้งการออกแบบฮาร์ดแวร์และไดรเวอร์ได้รับการเผยแพร่ภายใต้ใบอนุญาตโอเพ่นซอร์ส GPL v3 ที่ที่เก็บ GitHub นี้ นอกจากนี้ เนื่องจากแม้ว่าผู้ผลิต PCB จะทำการออกแบบ PCB ของฉัน "วิ่งน้อย" ฉันก็ยังได้รับมากกว่าที่ฉันต้องการโดยส่วนตัว ดังนั้นฉันจึงขายชุดอุปกรณ์เต็มรูปแบบสำหรับการออกแบบเมทริกซ์ RGB LED แบบต่างๆ (รวม PCB และทุกชิ้นส่วน) จากเว็บไซต์ของฉันที่นี่