מטריקס LED RGB: 5 שלבים

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

חפש Instructable ותוכל למצוא פרויקטים רבים של מטריצת LED. אף אחד מהם לא היה בדיוק מה שרציתי, כלומר לחקור את האינטראקציות של עיצוב חומרה ותוכנה כדי לייצר משהו, ולייצר את המוצר הסופי במשטח PCB מסודר עם דרייבר, בואו נצייר ל"מסך LED "באמצעות רמה גבוהה מבנים (למשל, ציור קו בניגוד להגדרת פיקסלים ספציפיים). החלק הזה היה חשוב לי, מכיוון שרבים מנהלי ההתקנים של מטריצות LED הם עצמות חשופות ואינם מספקים הרבה דרך ליצור תוכנה או הנפשה. זה לא אומר שאתה לא יכול ליצור תמונות והנפשות עם מנהלי ההתקנים האחרים, רק שתצטרך לבצע יותר עבודות חוזרות ונשנות מפרויקט לפרויקט.

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

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

מדריך זה מתעד את העיצוב וכמה למידות מרכזיות מהפרויקט שלי. מידע נוסף על פרויקט זה ניתן למצוא באתר שלי כאן, כולל ערכות מלאות שתוכל לרכוש לבניית מטריצת LED משלך ב- RGB.

שלב 1: עיצוב חומרה

המטרה העיקרית של עיצוב החומרה שלי הייתה ליצור מערך של נוריות RGB שאני יכול לתכנת, אבל גם לא רציתי להוציא הרבה כסף. הגישה שהתבססתי עליה הייתה להשתמש ברשמי משמרות 74HC595 לשליטה בנורות הלדים. על מנת למזער את מספר רשמי המשמרות הנדרשים, סידרתי את נוריות ה- RGB לפריסת מטריצה שבה האנודות הנפוצות נקשרו בשורות והליכים הקתודה האדומים, הירוקים והכחולים נקשרו בעמודים. עבור מטריצת 4x4, תרשים המעגלים נראה כמו תרשים המעגל המצורף.

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

מכיוון שאני משתמש נוריות אנודה נפוצות, זה אומר שהשורות מספקות כוח חיובי והעמודים שוקעים לקרקע. החדשות הטובות הן שרשמי המשמרות 74HC595 יכולים גם למקור וגם לשקוע כוח, אך החדשות הרעות הן שיש להן מגבלה על כמות הכוח שהן יכולות להפיק או לשקוע. לפינים בודדים של 74HC595 יש ציור זרם מקסימלי של 70 mA, אך עדיף לשמור על פחות מ -20 mA. הצבעים האישיים בנורות ה- RGB שלנו כל אחד מהם כ- 20 mA. המשמעות היא ש- 74HC595 אינו יכול להפעיל ישירות שורה שלמה של נוריות LED אם ארצה להדליק את כולן.

אז במקום להפעיל את השורה ישירות, ה- 74HC595 יניע במקום זאת טרנזיסטור לכל שורה, והטרנזיסטור יפעיל או יכבה את הזרם המפעיל את השורה. מכיוון שהעיצוב משתמש בנורות אנודה נפוצות, טרנזיסטור המיתוג יהיה PNP. אם היינו משתמשים בנורית קתודה נפוצה, טרנזיסטור המיתוג יהיה NPN. שים לב שבעזרת שימוש בטרנזיסטור PNP להנעת שורה, הגדרת מרשם המשמרות להפעלה כעת הופכת נמוכה מכיוון שטרנזיסטור PNP זקוק למתח שלילי בין הפולט לבסיס, מה שיאפשר זרם חיובי לזרום לתוך שׁוּרָה.

דבר נוסף שיש לקחת בחשבון הוא פריסת הסיביות הרצויה של רשמי המשמרות. כלומר, בין רשמי המשמרות, אילו ביטים שולטים באילו שורות או עמודות במטריצה. העיצוב ששלחתי איתו הוא המקום בו הסיביה הראשונה, או "הסיביה המשמעותית ביותר", שנשלחה לרשמי המשמרות המרושתים הדייסי שולטת בעמודה של האלמנט האדום של נוריות הלדים, הביט השני שולט ביסוד הירוק של העמודה הראשונה, הביט השלישי שולט בעמודה הראשונה של העמודה הראשונה אלמנט כחול, הסיביה הרביעית שולטת על האלמנט האדום של העמודה השנייה, … דפוס זה חוזר על פני העמודות משמאל לימין. ואז הסיבית הבאה שנשלחת שולטת בשורה האחרונה או התחתונה, הבאה הבאה בשורה השנייה עד האחרונה, … זה חזר על עצמו עד שהסיבוב האחרון שנשלח, או "הסיביות הכי פחות משמעותית", שולט בשורה הראשונה או העליונה במטריצה.

לבסוף, הייתי צריך לקבוע באילו נגדים אשתמש עבור כל אחד מנורות ה- LED של ה- RGB. אמנם תוכל להשתמש בנוסחה הסטנדרטית המשלבת מתח קדימה וזרם רצוי כדי לחשב את הנגד הנדרש, אך גיליתי שהגדרת זרם של כל לד ל- 20 מיליאמפר מביאה לצבע לבן כאשר כל הנורות האדומות, הירוקות והכחולות היו דולקות.. אז התחלתי לגלוש אותו בעיניים. יותר מדי אדום בלבן פירושו הגדלת אוהם הנגד של הלד האדום כדי להפחית את הזרם. חזרתי על החלפת נגדים של אוהם שונים עד שמצאתי שילוב שמייצר צבע לבן שהרגשתי שהוא נכון. השילוב הסופי היה 180 Ω עבור ה- LED האדום, 220 Ω עבור ה- LED הירוק ו- 100 Ω עבור ה- LED הכחול.

שלב 2: בניית חומרה - קרש

השלב הראשון של מבנה החומרה היה עליית הלחם. כאן הכנתי מטריצה 4x4 עם נוריות ה- RGB. מטריצה זו תדרוש 16 סיביות לשליטה, 12 עבור עמודות ה- RGB ו -4 לכל שורה. שני רישומי משמרת 74HC595 יכולים להתמודד עם הכל. תחילה חקרתי ועיצבתי מעגל שחשבתי שיעבוד, ואז בניתי אותו על לוח הלחם.

האתגר הגדול ביותר של בניית לוח הלחם היה כנראה ניהול כל החוטים. הרמתי ערכת תיל מעוצבת ללוחות לחם, אבל אז זה היה קצת לא מסובך. טריק שמצאתי מועיל היה ליצור "יציאה" לחיבור ללוח Arduino. כלומר, במקום לחבר את הסיכות על הארדואינו ישירות לסיכות ה- IC השונות בלוח הלחם, הקדישו כמה שורות בלוח הלחם להיות נקודת החיבור של הארדואינו, ולאחר מכן חבר את סיכות הזיהוי הרלוונטיות לשורות אלה. לפרויקט זה, אתה צריך רק חמישה חיבורים ל- Arduino: +5V, קרקע, נתונים, שעון ותפס.

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

שלב 3: עיצוב תוכנת דרייבר

בהתחשב בניסיון הקריירה שלי בפיתוח תוכנה, זה היה החלק בפרויקט שכנראה היה לי הכי ברור לגבי הדרך. סקרתי רבים ממנהלי המטריצות LED המבוססים על Arduino אחרים. אמנם בהחלט ישנם דרייברים טובים, אך לאף אחד לא היה העיצוב שרציתי. מטרות העיצוב שלי של הנהג היו:

• ספק API ברמה גבוהה כדי להיות מסוגל ליצור תמונות ואנימציות מבחינה תכנותית. רוב הנהגים שראיתי היו ממוקדים יותר בתמונות מקודדות. כמו כן, מכיוון שאני מתכנת C ++ במקצועי, רציתי להשתמש בעיצוב טוב מונחה עצמים כדי ליישם ולנהל את פעילויות הציור למטריצת LED.
• השתמש בגישה שנאגרה כפולה לניהול התמונה על המסך. חיץ אחד הוא מה שנמשך לתכנות, ואילו השני מייצג את מצב הפיקסלים של המטריצה בכל רגע נתון. היתרון בגישה זו הוא שאינך נדרש לבצע לחלוטין את עדכון המסגרת הבא למסך בין מחזורי העדכון של הכפל.
• השתמש ב- PWM כדי לאפשר יותר משבעת הצבעים הפרימיטיביים ש- RGB יכול לעבד באמצעות שילובים פשוטים של האלמנטים האדומים, הירוקים והכחולים.
• כתוב את מנהל ההתקן כך שהוא "פשוט יעבוד" עם מטריצות LED מסוג RGB בגודל אחר שעקבו אחר גישת עיצוב המטריצות הכללית שלי. שים לב שבעוד שעיצוב החומרה שלי משתמש ברשומות משמרות 74HC595, הייתי מצפה מהנהג שלי לעבוד עם כל מנגנון הפעלה/כיבוי של סגנון רישום משמרות המונח באמצעות פריסת סיביות דומה לעיצוב החומרה שלי. לדוגמה, הייתי מצפה מהנהג שלי לעבוד עם עיצוב חומרה שהשתמש בשבבי DM13A לשליטה בעמודות ובשבב 74HC595 לשליטה בשורות.

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

האיטרציה הראשונה של הנהג שלי הייתה קצת עקומת למידה על היכולות של פלטפורמת ה- Arduino. המגבלה הברורה ביותר היא ה- RAM, שהוא 2K בתים עבור ה- Arduino Uno ו- Nano. לעתים קרובות לא מומלץ להשתמש באובייקטים C ++ בתרחיש כזה בשל תקרת הזיכרון של אובייקטים. עם זאת, הרגשתי שאם נעשה נכון, היתרון של אובייקטים ב- C ++ עולה על עלותם (ב- RAM).

האתגר העיקרי השני היה להבין כיצד ליישם את אפנון רוחב הדופק באמצעות רשמי המשמרות כדי שאוכל ליצור יותר משבעת הצבעים הפרימיטיביים של ה- RGB LED. לאחר שתכנתתי שנים רבות בפלטפורמות לינוקס, הייתי רגיל להשתמש במבנים כמו שרשורים לניהול תהליכים הדורשים תזמון עקבי. העיתוי של פעולת עדכון רישום המשמרות בסופו של דבר די קריטי בעת יצירת מנהל התקן עבור מטריצת LED המשתמשת בריבוי כפולות. הסיבה לכך היא שלמרות שהריבוי המרבבים מתרחש כל כך מהר, עד שהעיניים שלך לא יכולות לראות את נוריות הלבן הבודדות מהבהבות וכיבוי, האייות שלך יכולות להבחין בהבדלים בזמן המצרפי הכולל שבו כל אחת מהנוריות דולקות. אם שורה אחת של נוריות נוריות דולקת באופן עקבי למשך פרק זמן ארוך יותר מהאחרות, היא תיראה בהירה יותר במהלך הריבוב. זה יכול להוביל לבהירות לא אחידה במטריצה או לליטוף תקופתי של המטריצה בכללותה (זה קורה כאשר מחזור עדכון אחד לוקח יותר זמן מהאחרים).

מכיוון שהייתי צריך מנגנון תזמון עקבי כדי לגרום לעדכוני רישום המשמרות להיות הסכמה, אך הארדואינו אינו תומך רשמית בשרשור, נאלצתי ליצור מנגנון דמוי הברגה משלי. האיטרציה הראשונה שלי לזה הייתה פשוט ליצור טיימר לולאה שתלוי בפונקציית הלולאה () של Arduino ויפעיל פעולה כאשר הזמן שחלף זמן מסוים מאז הפעם האחרונה שהפעולה הופעלה. זוהי צורה של "ריבוי משימות שיתופיות". נשמע טוב אבל בפועל זה הוכח כלא עקבי כאשר קצב הירי נמדד במיקרו שניות. הסיבה לכך היא שאם היו לי שניים מהטיימרים של הלולאה האלה, אחת מהפעולות שלהם ארכה לעתים קרובות מספיק זמן כדי לגרום לפעולה השנייה לירות מאוחר מהרצוי.

גיליתי שהפתרון לבעיה זו הוא שימוש במנגנון ההפרעה לשעון המקורי של הארדואינו. מנגנון זה מאפשר לך להריץ מעט קוד במרווחים עקביים מאוד. אז עיצבתי את קוד הנהג סביב האלמנט העיצובי של שימוש בפסיקה בשעון כדי להפעיל את הקוד לשליחת המשמרת של המטריצה רושם את העדכון הבא במחזור המולטיפלקס. כדי לעשות זאת ולאפשר לעדכונים להתרחש בתמונת המסך כדי לא להפריע לזרימה פעילה לרשומות המשמרות (משהו שהיינו מכנים "תנאי גזע"), השתמשתי בגישה של קיום מאגרי תאומים עבור סיביות רישום המשמרות, אחד לכתיבה ואחד לקריאה. כאשר המשתמש מעדכן את תמונת המטריצה, פעולות אלה מתרחשות במאגר הכתיבה. כאשר פעולות אלה הושלמו, הפרעות מושעות באופן זמני (פירוש הדבר שהפרעת השעון אינה יכולה לירות) ומאגר הכתיבה מוחלף במאגר הקריאה הקודם והוא אינו מאגר הקריאה החדש, ואז הפירושים מופעלים מחדש. לאחר מכן, כאשר השעון מפריע לירות המציין שהגיע הזמן לשלוח את תצורת הסיביות הבאה לרשומות המשמרות, המידע הזה נקרא ממאגר הקריאה הנוכחי. בדרך זו, אף פעם לא מתרחשת כתיבה למאגר שעשוי להקריא אותו בזמן הפסקת שעון, מה שעלול להשחית את המידע שנשלח לרשומות המשמרות.

עיצוב שאר הנהג היה מקרה פשוט יחסית של עיצוב מונחה עצמים. לדוגמה, יצרתי אובייקט לניהול תמונת הסיביות של Register Register בכל מצב מסך נתון. על ידי קיבול הקוד הנוגע לניהול תמונת ביט, יצירת גישת מאגרים התאומים הנ"ל הייתה בעצמה תרגיל פשוט. אבל לא כתבתי את ההנחיה הזו להוקיר את סגולותיו של עיצוב מונחה עצמים. אלמנט עיצובי אחר כולל את הרעיון של Glyph ותמונת RGB. Glyph הוא מבנה דימוי בסיסי שאין בו מידע צבע מולד. אתה יכול לחשוב על זה כתמונה בשחור לבן. כאשר הגליף נמשך למסך ה- LED, ניתן מידע על הצבע כדי לציין כיצד יש לצבוע את הפיקסלים ה"לבנים ". תמונת RGB היא תמונה שבה לכל פיקסל יש מידע צבע משלו.

אני ממליץ לך לעיין בדוגמאות הסקיצות של Arduino ולעיין בתיעוד של כותרת הנהג כדי להכיר כיצד להשתמש במנהל ההתקן ליצירת תמונות והנפשות על מטריצת RGB LED.

שלב 4: Ghosting LED

במטריצת LED, "רפאים" היא התופעה של נורית LED במטריצה זוהרת כשהיא לא רצויה, בדרך כלל רמה מופחתת מאוד. עיצוב החומרה המקורי שלי היה חשוף לרפאים, בעיקר בשורה האחרונה. הסיבה לכך נובעת משני דברים: טרנזיסטורים אינם נכבים מיד וקיבול טפילי בנוריות ה- RGB.

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

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

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

עם זאת ראוי לציין כי בפועל אני מוצא את ההשפעה של הקיבול הטפילי בקושי מורגש (אם אתה מחפש אותו, אתה יכול למצוא אותו), ולכן אני מחשיב את הוספת הנגד הנוסף הזה כאופציונלית. ההשפעה של זמן ההאטה של טרנזיסטורים רוויים היא הרבה יותר חזקה ובולטת. עם זאת, אם תבדוק את שלושת התמונות המסופקות בחלק זה, תוכל לראות שהנגדים מסירים לחלוטין כל רוחות רפאים שעדיין מתרחשות מעבר לזמן הטרנזיסטור האיטי.

שלב 5: ייצור סופי והשלבים הבאים

השלב האחרון של הפרויקט הזה היה בשבילי ליצור לוח מעגלים מודפסים (PCB). השתמשתי בתוכנית הקוד הפתוח Fritzing לעיצוב ה- PCB שלי. אמנם היו הרבה משימות שחוזרות על עצמן לביצוע פריסת 100 נוריות על לוח 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 וכל החלקים כלולים) מהאתר שלי כאן.