500 נוריות קיר עם ESP32: 16 שלבים

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

שלום כולם! בסוף הדרכה זו תדע כיצד ליצור קיר LED משלך.

הדרכה זו מבוססת על תוכנית קיץ המוצעת באוניברסיטת הלב הקדוש.

תעשה חיים!

אספקה

חומרים מתכלים המפורטים להלן.

שלב 1: אספקה

נתחיל באיסוף כל מה שצריך להשלמת קיר הלד שלנו:

(הקישורים נוצרו בתאריך 7/10/2019)

תוכנת Arduino IDE

בקר מיקרו ESP32

אור פיקסל LED

ספק כוח

כבל חשמל

כלי הפשטת חוטים

כבלי מגשר ללוח לחם

חוט חשמלי

שלב 2: קביעת ספק הכוח הנכון עבור LedWall שלך

יש דרך מתמטית פשוטה לברר איזו ספק כוח היא הטובה ביותר עבורך.

אנו משתמשים בחוק ההספק של אוהם: P = IxV (הספק = עוצמה x מתח)

המתח נקבע על ידי הנורות שלנו: במקרה זה 5V.

העוצמה תלויה בחומרה, לד יחיד צורך 30mA.

לכן כל רצועה של 50 נוריות צורכת 50 x 30mA = 1250mA = 1.25A.

הקיר 500 לד שלנו צורך לפיכך פי 10 (10 רצועות): 12.5A.

צריכת החשמל היא אז 5V x 12.5A = 62.5W עבור ה- Leds.

כמובן שעל גבי ה- Leds אתה צריך לקחת בחשבון את ה- ESP וכל פריט אחר במעגל שלך.

יש לנו ספק כוח 60A, יש לנו הרבה יותר ממה שאנחנו צריכים.

שלב 3: כבל החשמל

ספק הכוח שלנו מגיע עם מחברי תיל. עלינו להתאים כבל חשמל לחיבורו לתקע של 110 וולט.

- נתק את מחבר הנקבה מכבל החשמל. אנו נשמור על החלק הגברי, אחרת מכנים NEMA 5-15P.

- הפשיטו את הכבל כך שנראה כ -3 מ מ נחושת על כל החוטים.

להלן סרטון הדרכה מהיר כיצד להפשיט חוטים:

שלב 4: חיבור ספק הכוח

כעת אנו מוכנים לחבר את ספק הכוח שלנו!

נתק תמיד את ספק הכוח כאשר אתה עובד עליו.

תִיוּל

• החוט השחור (שלב) מתחבר לסיכת ה- L של ספק הכוח
• החוט הלבן (נייטרלי) מתחבר לסיכת ה- N של ספק הכוח
• החוט הירוק מתחבר לסיכת 'הקרקע' של ספק הכוח

(אם החוטים הפנימיים של כבל החשמל שלך אינם באותם הצבעים כמו שלנו, היו בטוחים וחפשו את התרשימים באינטרנט.)

בדיקה

חבר את כבל החשמל של המחשב לשקע חשמלי כלשהו. הנורית הירוקה של ספק הכוח אמורה להידלק.

שלב 5: הפעלה ל- ESP32S

כשמסתכלים על ה- ESP שלכם אמורות להיות תוויות ליד כל סיכה. אם הוא לא מסומן, תוכלו לחפש את ה'פינאו 'של ה- ESP האישי שלכם באינטרנט.

באמצעות חוט מגשר של קרש לחם זכר או נקבה או חוט חשמלי, חבר:

• סיכה '5V' ESP32S ל- '+V' של ספק הכוח (כתום בתמונה למעלה)
• סיכה 'GND' ESP32S לחלק '-V' של ספק הכוח (שחור בתמונה למעלה)

(בחלק ממערכות ה- ESP סיכת '5V' מסומנת כ- 'VCC' במקום זאת, שניהם מתכוונים לאותו הדבר.)

שים לב של- ESP שלך עשוי להיות 'pinout' שונה מזה שבו אנו משתמשים. ככזה אתה עשוי לחבר את החוטים שלך למיקום אחר מאשר בתמונה למעלה. כל עוד אתה מתחבר לפינים הנכונים (5V & GND), המיקום הפיזי בלוח לא משנה.

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

שלב 6: הפעלת רצועות LED

שימוש בחוטי חשמל:

- חבר את החוט האדום של רצועת הנורית לד ל- V+ על ספק הכוח.

- חבר את החוט הכחול של רצועת הנורות לד ל- V- על ספק הכוח.

שלב 7: חיבור ה- ESP32 לרצועות האור LED

ה- ESP32 שלנו מורה לנהג WS2811 המחובר לכל אחד מהדרכים בצבע ובהירות שהם צריכים להיות. לשם כך, ESP32 שלנו זקוק לכבל "נתונים" לרצועות.

רצועות ה- Leds מגיעות עם מחבר בעל 3 חוטים:

- אדום: כוח- כחול: ניטרלי- לבן: נתונים

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

שלב 8: הכנת המחשב: מנהל התקן C2102

כעת, לאחר שהחומרה שלנו מחוברת, אנו רוצים להעלות את הקוד הראשון שלנו כדי לבדוק אותו. כברירת מחדל, Windows או MacO לא יכולים לתקשר עם ה- ESP32 שלנו. לשם כך, עלינו להוריד "מנהל התקן" עבור שבב התקשורת USB מסוג ESP: ה- C2102.

יש להוריד ולהתקין את מנהל ההתקן הזה:

- Windows 10: https://www.silabs.com/documents/public/software/C…- Windows 7/8/8.1: https://www.silabs.com/documents/public/software/C…- Mac:

(קישורים החל מה- 7/10/2019)

שלב 9: תוכנת Arduino - הוספת תמיכה ב- ESP32 - שלב 1

לפני שנוכל להשתמש ב- ESP32 שלנו עם תוכנת Arduino, עלינו לוודא שהיא מזוהה. כברירת מחדל, תוכנת Arduino לא יכולה לאסוף קוד עבור ה- ESP32 שלנו, בואו נתקן את זה:

שלב 1: הוספת לוחות למנהל

1 - לחץ ב- Arduino על האפשרות קובץ >> העדפות

2- בשדה "כתובות אתרים נוספות של מנהל לוחות", העתק את הקישור הבא:

שלב 10: תוכנת Arduino - הוספת תמיכה ב- ESP32 - שלב 2

כעת, לאחר שתוכנת Arduino "מכירה" לוחות נוספים, בואו להתקין את תמיכת ESP32 שלנו

שלב 2: התקנת התמיכה ב- ESP32

1 - בתפריט העליון בחר: כלים >> לוח >> מנהל לוחות

2 - יופיע חלון. השתמש בתיבת החיפוש הממוקמת בפינה הימנית העליונה כדי למצוא את "ESP32".

3 - אתר את זה המיוצר על ידי אספרסיף. התקן את זה. (ראה תמונה)

שלב 11: תוכנת Arduino - הוספת תמיכה ב- ESP32 - שלב 3

כעת, לאחר שתוכנת Arduino יכולה לתקשר עם ESP32 שלנו, בואו לחבר אותה למחשב ולוודא שהכל עובד.

1 - בואו לוודא שאנחנו עובדים על פלטפורמת ESP32:

לחץ על כלים >> לוח >> מודול Dev ESP32

1- בואו לוודא שתוכנת Arduino יודעת לתקשר ל- ESP שלנו:

לחץ על כלים >> יציאה ובחר את זה שצץ מחיבור הכבל הזה.

חָשׁוּב:

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

שלב 12: הוספת ספריות ל- IDE של Arduino

כעת אנו הולכים להוסיף ספרייה שתאפשר לנו לבדוק את קיר הלד שלנו!

1- לחץ על כלים >> נהל ספריות.

2- בפינה הימנית העליונה, חפש את NeoPixelBus. אתר את "NeoPixelBus by Makuna", התקן אותו (ראה תמונה)

ספריות מעניינות אחרות: (לא נדרש להדרכה זו)

- NeoMatrix

- FastLed

- ארטנט

- GFX

שלב 13: קוד ראשון: מבחן סטרנד

הקוד הראשון שלנו הוא דוגמה מהספרייה.

אתה יכול להעתיק / להדביק את הקוד למטה או ללחוץ על:

קובץ >> דוגמאות >> Adafruit NeoPixelBus >> מבחן Strand

אנא הקפד לשנות את ה- LED_PIN שלך לזה שבו השתמשת לחיבור פיזי של הנורות שלך. השתמשנו ב -13 במהלך כל הדרכה זו.

הקפד גם להתאים את גודל הגדיל בעזרת המשתנה LED_COUNT.

// תוכנית בסיסית יומיומית לסטריפ.

#include #ifdef _AVR_ #include // נדרש עבור תכשיט Adafruit 16 MHz #endif // איזה סיכה ב- Arduino מחוברת ל- NeoPixels? #define LED_PIN 13 // כמה NeoPixels מחוברים ל- Arduino? #define LED_COUNT 500 // הצהיר על אובייקט רצועת NeoPixel שלנו: רצועת Adafruit_NeoPixel (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // ארגומנט 1 = מספר הפיקסלים ברצועת NeoPixel // ארגומנט 2 = מספר סיכה Arduino (רובם תקפים) // ארגומנט 3 = דגלים מסוג פיקסל, הוסיפו יחד לפי הצורך: // NEO_KHZ800 800 KHz bitstream (רוב מוצרי NeoPixel w/ נוריות WS2812) // NEO_KHZ400 400 KHz ('v1' קלאסי (לא v2) פיקסלים של FLORA, מנהלי התקנים WS2811) // NEO_GRB פיקסלים מחוברים ל- bitstream GRB (רוב מוצרי NeoPixel) // NEO_RGB פיקסלים מחוברים ל- RGB bitstream (v1 FLORA פיקסלים, לא v2) // NEO_RGBW פיקסלים מחוברים עבור זרם ביט RGBW (מוצרי NeoPixel RGBW) // פונקציית setup ()-פועל פעם אחת בעת ההפעלה -------------------- ------------ הגדרת void () {// שורות אלה נועדו במיוחד לתמיכה ב- Adafruit Trinket 5V 16 MHz. // כל לוח אחר, אתה יכול להסיר את החלק הזה (אבל בלי לפגוע בו): #if מוגדר (_ AVR_ATtiny85_) && (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // END של קוד ספציפי ל- Trinket. strip.begin (); // התחל אובייקט רצועת NeoPixel (חובה) strip.show (); // כבה את כל הפיקסלים בהקדם האפשרי strip.setBrightness (50); // הגדר את הבהירות לכ -1/5 (מקסימום = 255)} // לולאה () פונקציה-פועל שוב ושוב כל עוד הלוח מופעל --------------- לולאת חלל () {// מלאו לאורך הרצועה בצבעים שונים … colorWipe (strip. Color (255, 0, 0), 50); // ColorWipe אדום (strip. Color (0, 255, 0), 50); // ירוק colorWipe (strip. Color (0, 0, 255), 50); // כחול // עשה אפקט תיאטרון בצבעים שונים … theaterChase (strip. Color (127, 127, 127), 50); // לבן, חצי בהירות תיאטרון צ'ייס (strip. Color (127, 0, 0), 50); // אדום, חצי בהירות תיאטרון צ'ייס (strip. Color (0, 0, 127), 50); // כחול, חצי בהירות קשת (10); // מחזור קשת זורם לאורך כל תיאטרון הרצועהChaseRainbow (50); // תיאטרון משופר בקשת Chase variant} // כמה פונקציות משלנו ליצירת אפקטים מונפשים ----------------- // ממלאים פיקסלים ברצועה בזה אחר זה בצבע. הרצועה אינה מסומנת // תחילה; כל דבר יכוסה פיקסל על פיקסל. העבר בצבע // (כערך יחיד של 32 סיביות 'ארוז', אותו תוכל לקבל על ידי קריאת // strip. Color (אדום, ירוק, כחול) כפי שמוצג בפונקציית הלולאה () למעלה), // ו- זמן עיכוב (באלפיות השנייה) בין הפיקסלים. void colorWipe (uint32_t color, int wait) {for (int i = 0; i strip.setPixelColor (i, color); // הגדר את צבע הפיקסל (ב- RAM) strip.show (); // עדכון רצועה כך שתתאים לעיכוב (המתן); // השהה לרגע}}} // אורות מרדף בסגנון תיאטרון. העבר בצבע (ערך 32 סיביות, // a la strip. Color (r, g, b) כאמור לעיל), וזמן עיכוב (ב- ms) // בין מסגרות. void theaterChase (uint32_t color, int wait) {for (int a = 0; a <10; a ++) {// חזור 10 פעמים … עבור (int b = 0; b <3; b ++) {// 'b' נספר מ 0 עד 2 … strip.clear (); // הגדר את כל הפיקסלים ב- RAM ל- 0 (כבוי) // 'c' נספר מ- 'b' לסוף רצועה בשלבים של 3 … עבור (int c = b; c strip.setPixelColor (c, color); // הגדר את הפיקסל 'c' לערך 'color'} strip.show (); // עדכן רצועה עם עיכוב תוכן חדש (המתן); // השהה לרגע}}} // מחזור הקשת לאורך כל הרצועה. העבר זמן עיכוב (במס) בין המסגרות. קשת חלל (המתן int) {// גוון הפיקסל הראשון מפעיל 5 לולאות שלמות דרך המסגרת גלגל הצבעים. // גלגל הצבעים יש טווח של 65536 אבל זה בסדר אם נתהפך, אז // פשוט נספור מ 0 עד 5*65536. הוספת 256 ל firstPixelHue בכל פעם // פירושה שנעשה 5*65536/256 = 1280 מעברים דרך הלולאה החיצונית הזו: for (long firstPixelHue = 0; firstPixelHue <5*65536; firstPixelHue += 256) {for (int i = 0; I // קיזוז גוון הפיקסלים בכמות לביצוע מהפכה אחת מלאה של גלגל הצבעים // (טווח של 65536) לאורך הרצועה // (רצועות strip.numPixels ()): int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels ()); // strip. ColorHSV () יכול לקחת 1 או 3 ארגומנטים: גוון (0 עד 65535) או // להוסיף אופציה רוויה וערך (בהירות) (כל 0 עד 255). // כאן אנו משתמשים רק בגרסת הגוון היחיד-ארגומנט. התוצאה // מועברת דרך strip.gamma32 () כדי לספק צבעים 'אמיתיים יותר' // לפני הקצאה לכל פיקסל: strip.setPixelColor (i, strip.gamma32 (strip. ColorHSV (pixelHue)));} strip.show (); // עדכון רצועה עם עיכוב תוכן חדש (המתן); // השהה לרגע}} // // קשת תיאטרון משופרת בקשת. עברו זמן עיכוב (ב ms) בין מסגרות. void theaterChaseRainbow (int wait) {i nt firstPixelHue = 0; // הפיקסל הראשון מתחיל באדום (גוון 0) עבור (int a = 0; a <30; a ++) {// חזור 30 פעמים … עבור (int b = 0; b RGB strip.setPixelColor (c, color); / / הגדר את הפיקסל 'c' לערך 'color'} strip.show (); // עדכן רצועה עם עיכוב תוכן חדש (המתן); // השהה לרגע קודם PixelHue += 65536 /90; // מחזור אחד של גלגל צבעים מעל 90 פריימים}}}

שלב 14: קוד לדוגמה של SHU

הקוד שלנו מפעיל את כל האורות אחד אחד כדי לוודא שהם עובדים:

// דוגמה זו תחלוף בין הצגת 500 פיקסלים כאדום

#includeconst uint16_t PixelCount = 500; // דוגמה זו מניחה 4 פיקסלים, הקטנה שלה תגרום לכישלון const uint8_t PixelPin = 13; // הקפד להגדיר את זה לפין הנכון, תוך התעלמות מ- Esp8266

#define colorSaturation 128 // שלושה פיקסלים של אלמנטים, בסדר ובמהירויות שונות

רצועת NeoPixelBus (PixelCount, PixelPin);

// רצועת NeoPixelBus (PixelCount, PixelPin); אדום RgbColor (0, colorSaturation, 0); ירוק RgbColor (colorSaturation, 0, 0); כחול RgbColor (0, 0, colorSaturation); לבן RgbColor (colorSaturation); RgbColor שחור (0); HslColor hslRed (אדום); HslColor hslGreen (ירוק); HslColor hslBlue (כחול); HslColor hslWhite (לבן); HslColor hslBlack (שחור); הגדרת void () {Serial.begin (115200) בעוד (! Serial); // המתן לצירוף סדרתי Serial.println (); Serial.println ("אתחול …"); Serial.flush (); // זה מאפס את כל הניאופיקסלים לרצועה של מצב כבוי. Begin (); strip. Show (); Serial.println (); Serial.println ("פועל …"); } לולאת חלל () {עיכוב (100); Serial.println ("צבעים R, G, B, W …"); עבור (int i = 0; i <= 499; i ++) {// הגדר את הצבעים, // אם הם לא תואמים לפי הסדר, עליך להשתמש ברצועת התכונות NeoGrbFeature. SetPixelColor (i, אדום); strip. Show (); עיכוב (100); strip. SetPixelColor (i, hslRed); strip. Show (); עיכוב (100); }}

שלב 15: העלאת קוד ל- ESP32

חָשׁוּב:

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

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

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

שלב 16: ציטוטים

הוראה זו נעשתה בעזרת הדרכות הבאות:

randomnerdtutorials.com/installing-the-esp…

משמש להתקנת ESP32 ב- Arduino IDE.

מחברים:

נתנאל ברון גבריאל קסטרו

עוֹרֵך:

סדריק בליימינג