אלקטרוניקה ומחשבים – יצחק, ברקת ושוהם כהן אתר מגמת אלקטרוניקה ומחשבים
תצוגת מטריצה MAX7219 – מדריך מלא להפעלה עם ESP32 ו־Arduino
תוכן עניינים
מה מחכה לכם בפוסט?
במדריך הזה נלמד שלב־אחר־שלב איך להפעיל תצוגת מטריצה חכמה מבוססת MAX7219 עם לוח ESP32 או Arduino.
יחד נבנה תצוגת טקסט מרשימה, נבין איך המודול עובד מאחורי הקלעים, ונקבל קוד לדוגמה שפשוט עובד.
מה תמצאו בפנים?
🔌 הסבר מלא על חיבורים – צעד אחר צעד.
🧩 היכרות עם המודול והשימושים שלו.
⚙️ מפרט טכני ברור ומנוסח בגובה העיניים.
💡 הסבר פשוט ומעמיק של עיקרון הפעולה (כולל multiplexing!)
🧪 קוד בסיסי להפעלת הטקסט הראשון שלכם.
✨ הרחבות עם אפקטים כמו טקסט רץ ועוד.
🧠 טיפים חשובים למי שנתקל בג’יבריש, בעיות מתח או תצוגה הפוכה.
היכרות עם המודל
דמיינו שאתם בונים פרויקט, וממש מתחשק לכם להוסיף לו חיים.
לא סתם לד מהבהב – אלא תצוגה אמיתית: כזו שמציגה טקסטים, התראות, תפריטים או אולי סתם הודעת “HELLO” רצה עם חיוך.
כאן נכנס לתמונה הרכיב שלנו – מודול MAX7219.
זהו אחד הרכיבים השימושיים ביותר למי שרוצה להוסיף תצוגת מטריצה חכמה לפרויקט, בלי להסתבך, ובלי לבזבז הרבה חיבורים.
אז מה זה בעצם MAX7219?
מודול MAX7219 הוא תצוגת לדים מסוג מטריצה – רשת של נורות קטנות (LEDs) בגודל 8 על 8, שמחוברות למעגל בקרה פנימי שמבצע את כל עבודת השליטה.
במקרה שלנו – יש ארבעה מודולים כאלה שמחוברים יחד בטור, ויוצרים תצוגה מרשימה בגודל 32 פיקסלים לרוחב × 8 פיקסלים לגובה.
אם נסתכל מאחור – נמצא את שבב ה־MAX7219, שהוא הלב של המודול.
זהו בקר תצוגה חכם שמקבל מידע דיגיטלי מהבקר (כמו ESP32 או Arduino), ומדליק את הלדים לפי הפקודות שאנחנו שולחים לו – בצורה חכמה, מהירה, וללא מאמץ מצדנו.
מה זה נותן לנו?
✅ לא צריך לשלוח פקודה לכל לד בנפרד
✅ לא צריך הרבה חוטים – רק 3 קווים לשליטה
✅ לא צריך לחשב לבד את הסריקות או הקצב – הכול כבר בפנים
✅ התוצאה: תצוגה מבריקה, חכמה, פשוטה
בפועל – ברגע שתשלחו את הפקודה הנכונה, המודול יציג בדיוק את מה שתבקשו – ואפילו תתלהבו לגלות כמה קל לגרום לו לעשות את זה.
לסיכום
מודול MAX7219 נותן לכם כוח תצוגה מתקדם, באריזה קטנה, נוחה וזולה.
הוא מתחבר בקלות ל־Arduino, ESP32 ודומיהם, תומך בספריות עוצמתיות כמו MD_Parola, ונותן מענה מושלם למי שרוצה להציג מידע – לא רק לחוש, אלא גם להרשים.
וזה בדיוק מה שנעשה כאן בפוסט הזה – שלב אחר שלב.
מפרט טכני מלא
⚙️ גודל התצוגה: 32×8 פיקסלים (4 מטריצות מחוברות, כל אחת בגודל 8×8).
⚙️ בקר תצוגה: MAX7219 – שולט על כל לדי המטריצה בצורה חכמה.
⚙️ תדר פעולה: המידע נשלח למודול דרך ממשק SPI בתדר שעון של עד כ־10 מגה־הרץ.
⚙️ מתח עבודה: 5 וולט (לעיתים עובד גם עם 3.3 וולט, אך לא מומלץ לאורך זמן).
⚙️ זרם עבודה: תלוי בכמות הלדים הדלוקים – כל לד צורך כ־10–20 מילי־אמפר.
⚙️ ממשק תקשורת: SPI שלוש קווים בלבד (DIN, CLK, CS).
⚙️ תמיכה בבקרים: מתאים ל־ESP32, Arduino Uno, Mega, Nano, וכל לוח תואם.
⚙️ כיווניות פיזית: יש לשים לב למיקום המחבר (IN ↔ OUT) בצד ימין/שמאל.
⚙️ פין חיבור: מחבר זכר 5 פינים – VCC, GND, DIN, CS, CLK
⚙️ צריכת חשמל: בערך 160–320 מילי־אמפר בעת תצוגה מלאה.
⚙️ תכונת Multiplexing פנימית: מאפשר הצגת מאות לדים דרך 3 קווים בלבד.
ממה מורכב מודול MAX7219 וכיצד הוא פועל בפועל?
אחרי שהבנו מהו MAX7219 ולמה הוא שימושי, זה הזמן להבין באמת – איך הוא פועל מאחורי הקלעים.
איך כל נורה נדלקת, מה בדיוק שולח הבקר, ואיך נוצר אפקט תצוגה זורמת וחכמה על המטריצה.
המטרה: שתוכלו להסביר גם לעצמכם, גם לחבר מהכיתה, וגם לבוחן – איך הרכיב הזה עובד חשמלית, לוגית ומעשית.
נתחיל מהבסיס: מה זה בכלל מטריצת לדים?
מטריצה היא רשת של נורות (LEDs) שמסודרות בצורה של שורות ועמודות – כמו טבלת אקסל.
בכל "תא" בטבלה הזו – יש נורת לד אחת.
לדוגמה, במטריצה של 8 שורות × 8 עמודות יש בדיוק 64 לדים.
במודול שלנו – יש ארבעה כאלה מחוברים בטור, כך שנקבל 32 עמודות ו־8 שורות. כלומר, 256 נורות לד בסך הכול.
איך אפשר לשלוט על כל כך הרבה נורות עם כל כך מעט חוטים?
פה נכנס לפעולה גיבור הסיפור שלנו: שבב MAX7219.
זהו רכיב אלקטרוני חכם שמקבל מאיתנו הוראות ומבצע את הפעולה בפועל – מדליק, מכבה, מריץ.
אבל איך?
עיקרון Multiplexing – איך הוא מדליק את הלדים?
השבב לא מדליק את כל הלדים בבת אחת. במקום זה, הוא עובד בטכניקה שנקראת Multiplexing (ריבוב):
1. הוא מדליק שורה אחת בלבד בכל פעם.
2. באותה שורה, הוא בוחר אילו עמודות ידלקו – כלומר, אילו נורות באותה שורה.
3. אחרי כמה מיקרו־שניות, הוא עובר לשורה הבאה, עושה שם את אותו הדבר.
4. כך הלאה – עד שורה 8, ואז חוזר להתחלה.
המעבר הזה בין שורות מתרחש מאות פעמים בשנייה, ולכן העין שלנו לא רואה את הכיבוי וההדלקה, אלא תצוגה רציפה.
זו בדיוק אותה אשליה כמו בסרטים – שהמוח משלים את הפערים בין פריימים.
מה זה רגיסטר ולמה זה חשוב?
רגיסטר (Register) זה כמו תא זיכרון קטן בתוך השבב – תא שמחזיק ערך מסוים, כמו מספר או תבנית ביטים.
במקרה של MAX7219:
1. יש לו 8 רגיסטרים – אחד לכל שורה.
2. כל רגיסטר שומר את מצב העמודות בשורה שלו – אילו עמודות דלוקות ואילו כבויות.
3. כל רגיסטר מקבל ערך של 8 ביטים – כל ביט מייצג עמודה אחת.
לדוגמא:
שורה ראשונה (רגיסטר אחד): 0b10000001 -> תידלק נורה בעמודה הראשונה ונורה בעמודה השמינית.
שורה שנייה (רגיסטר שתיים): 0b11111111 -> כל הנורות בשורה זו יידלקו בו־זמנית.
דוגמה מוחשית: איך נראית האות "H"?
אייך זה יראה בפועל?
אז מה עושה השבב?
א. מדליק את שורה 1 ← מציג 10000001
ב. מיד אחריה מדליק את שורה 2 ← 10000001
וכך הלאה עד שורה 8 ואז חוזר לשורה 1 – ושוב, ושוב… עשרות פעמים בשנייה
והבקר? איך הוא שולח את כל זה?
ה־ESP32/Arduino שולח פקודות לשבב MAX7219 דרך תקשורת שנקראת SPI – שזו שיטה לשלוח מידע דיגיטלי במהירות.
כל פקודה כוללת:
1. מספר רגיסטר (שורה) ← 1 עד 8
2. ערך בינארי (8 ביטים) ← אילו לדים נדלקים בשורה הזו
לדוגמה:
אם נשלח את הערך הבינארי 01011010 אל השורה השלישית במטריצה, יידלקו בה הנורות שבעמודות 2, 4, 5 ו־7.
ומה עם המילה HELLO?
נניח שרוצים להציג את המילה HELLO – הספרייה (כמו MD_Parola) מתרגמת כל אות למערך של ביטים שמייצג את הצורה הגרפית שלה.
לדוגמה – האות H, כמו שראינו, תתרגם ל־8 ביטים עבור כל שורה.
כדי להציג את המילה HELLO, הספרייה תיצור מערך ארוך של ביטים, ותגלול אותם כל פעם צעד אחד שמאלה – וכך תיווצר אשליה של תנועה.
סיכום פשוט
| פעולה | מה קורה בפועל |
| שולחים טקסט | הספרייה מתרגמת אותו לביטים |
| שולחים ביטים לשבב | כל פקודה כוללת: מספר שורה + אילו לדים להדליק |
| השבב שומר את המידע | בזיכרון הפנימי (רגיסטרים) |
| הוא מריץ שורה אחר שורה | כל פעם מדליק שורה אחרת במהירות גבוהה |
| העין רואה תצוגה מלאה | בגלל מהירות החילוף – נורת אפקט רציף |
חיבורים ובקר – איך מחברים את המודול ל־ESP32 או ל־Arduino?
אחד הדברים הכי יפים במודול MAX7219 הוא שהוא דורש רק שלושה חוטים לשליטה – וזה נכון גם ל־ESP32 וגם ל־Arduino Uno.
החיבור פשוט, ישיר, ונעשה דרך ממשק תקשורת שנקרא SPI – תקשורת סדרתית מהירה להעברת פקודות. (להרחבה על SPI)
מה נמצא על המודול?
בצד אחד של המודול תראו שורת פינים עם הסימון הבא (לעיתים בצד שמאל או ימין):
VCC – כניסת מתח הזנה (5V).
GND – אדמה (שלילית).
DIN – קו הנתונים (Data In) – דרכו נשלחים הביטים.
CS – בחירת שבב (Chip Select) – מורה למודול מתי להקשיב.
CLK – קו שעון (Clock) – מתזמן מתי לקרוא כל ביט.
חיבור ל ESP32
חיבור במודול | פין ב-ESP32 |
VCC | 5V |
הארקה | הארקה |
מִן | GPIO 23 |
מדעי המחשב | GPIO 5 |
CLK | GPIO 18 |
💡 הערה: אפשר לשנות את הפינים האלה בקוד, אבל זו ברירת המחדל של SPI ב־ESP32 – מהירה ויעילה.
חיבור לארדואינו – UNO
חיבור במודול | פין ב-ESP32 |
VCC | 5V |
הארקה | הארקה |
מִן | פין 11 (MOSI) |
מדעי המחשב | פין 10 |
CLK | פין 13 |
💡 גם כאן – מדובר בחיבור SPI סטנדרטי של הארדואינו.
איך נזהה את הכיוון?
בצד אחד של המודול כתוב לרוב:
IN ← הכניסה מהבקר
OUT ← להמשך למודול נוסף
תמיד חברו את ה־ESP32 או Arduino לכניסה (IN)!
קוד לדוגמה בסיסי – הצגת טקסט פשוט ללא אפקטים
קוד להצגת המילה HELLO בESP32
#include <MD_Parola.h> // ספרייה לשליטה קלה בטקסטים ואפקטים על המטריצה
#include <MD_MAX72xx.h> // ספרייה שעובדת מול השבב MAX7219
#include <SPI.h> // ספריית תקשורת SPI – דרכה נשלחות הפקודות למודול
// נגדיר את סוג החומרה – FC16 זה הסוג הנפוץ של המודולים הסיניים
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
// כמה מודולים (8×8) מחוברים בטור – במקרה שלנו 4 כאלה
#define MAX_DEVICES 4
// הגדרות חיבורים ל־ESP32
#define DATA_PIN 23 // חיבור DIN – דרכו נשלחים הביטים
#define CLK_PIN 18 // חיבור CLK – שעון שמסנכרן את המידע
#define CS_PIN 5 // חיבור CS – מורה לשבב מתי לקרוא את הפקודה
// יצירת מופע של התצוגה עם ההגדרות שלנו
MD_Parola display = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);
void setup() {
display.begin(); // הפעלת התצוגה
display.setIntensity(2); // קביעת עוצמת תאורה (0 = כהה, 15 = בהיר)
display.displayClear(); // ניקוי המסך מכל תצוגה קודמת
display.print("HELLO"); // מציג את המילה HELLO באופן מיידי, בלי אנימציות
}
void loop() {
// אין צורך בקוד כאן – התצוגה נשארת יציבה
}
קוד להצגת המילה HELLO בESP32
#include <MD_Parola.h> // ספרייה להצגת טקסטים בצורה נוחה על מטריצת לדים
#include <MD_MAX72xx.h> // ספרייה לשליטה ישירה בשבב MAX7219
#include <SPI.h> // ספריית תקשורת SPI – דרכה מועבר המידע לשבב
// סוג המודול שלנו – ברוב המקרים זה FC16
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
// מספר לוחות מטריצה (8x8) שמחוברים ברצף – לדוגמה, 4 כאלה
#define MAX_DEVICES 4
// חיבורי SPI בארדואינו Uno (לא לשנות אלא אם חייבים)
#define DATA_PIN 11 // MOSI – קו הנתונים
#define CLK_PIN 13 // SCK – קו השעון
#define CS_PIN 10 // Chip Select – מורה לשבב מתי להאזין
// יצירת מופע של התצוגה עם כל ההגדרות
MD_Parola display = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);
void setup() {
display.begin(); // אתחול התצוגה
display.setIntensity(2); // קביעת עוצמת התאורה (0 עד 15)
display.displayClear(); // ניקוי כל הלדים לפני ההצגה
display.print("HELLO"); // מציג מיידית את המילה HELLO – בלי אפקטים
}
void loop() {
// לא צריך כלום בלולאה – התצוגה נשארת יציבה
}
התקנת הספריות הדרושות
כדי שהקוד יעבוד כמו שצריך – נצטרך להתקין שתי ספריות עיקריות שעובדות יחד עם מודול MAX7219:
MD_MAX72XX – הספרייה שמאפשרת תקשורת עם השבב MAX7219– MD_Parola – ספרייה מתקדמת להצגת טקסטים ואפקטים
שלבי ההתקנה – צעד אחר צעד
בשורת התפריטים של Arduino IDE:
1. לחצו על Sketch (סקיצה)
2. בחרו Include Library → Manage Libraries…
3. בחלון שייפתח – כתבו בתיבת החיפוש:
MD_Parola
4. התקינו את הספרייה של MajicDesigns (היא תתקין אוטומטית גם את הספרייה MD_MAX72XX כתלות)
טיפ:
אם אתם רואים ששום דבר לא מוצג בתצוגה – ודאו:
1. שהספריות מותקנות באמת
2. שאין ספריות דומות אחרות (כמו "LedControl") שפועלות במקביל
רוצים לבדוק שהכול מותקן כמו שצריך?
פשוט העתיקו את הקוד הפשוט ביותר שכתבנו למעלה – וצפו שהמילה HELLO תוצג מיד בתצוגה.
אם זה עובד – הספריות הותקנו בהצלחה!
