כובע LED מפואר: 5 שלבים (עם תמונות)

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

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

המטרה עם הכובע הייתה הבאה:

1. תנו למערכת אורות לנוע מהחזית המרכזית של הכובע לגב, אור אחד מכל צד
2. שנה את מהירות הנסיעה של האור שמוכתבת על ידי הטיית הכובע מלפנים לאחור
3. אפשר לאורות להתהפך כאשר רצועת הכובע נטתה כלפי מטה (כלומר לחקות את השפעת הכבידה על האורות)
4. שנה צבע בהתאם להטיה של הכובע משמאל לימין
5. חשים זעזועים ומציגים אפקט מיוחד
6. חש את הלובש מסתובב והצג אפקט מיוחד
7. יש להכיל אותו לגמרי בכובע

שלב 1: יש צורך בחלקים

השתמשתי במרכיבים העיקריים הבאים (כולל קישורים לא-שותפים של אמזון):

• מיקרו -בקר Teensy LC - בחרתי זאת על פני ארדואינו רגיל בשל גודלו הקטן, ויש לו חיבור מיוחד לשליטה בלדים שלי, כמו גם תמיכה חזקה בספרייה וקהילה.
• חיישן מיקום מבוסס Bosch BNO055 - בכנות אחד הראשונים שמצאתי תיעוד עליהם. ישנן אפשרויות הרבה פחות יקרות, אולם ברגע שאתה מבין את בוש זה עושה הרבה עבורך שאחרת היית צריך לעשות בקוד
• פס LED כתובת WS2812 - בחרתי באורך של 1 מטר עם 144 נוריות לד למטר. צפיפות זו עוזרת לאור להיראות כאילו הוא זז, ולא לאלמנטים בודדים המוארים ברצף.

והרכיבים הקטנים הבאים:

• כובע - כל כובע עם כובע יסתדר. זהו כובע של 6 $ מחנות מקומית. אם יש לו תפר מאחור יהיה קל יותר לעבור את החיווט. שימו לב אם רצועת הכובע מודבקת מכיוון שזה גם יגרום לקושי נוסף. זה תפור לאורך החלק העליון, אך התחתון משך כלפי מעלה בקלות.
• נגדי 4.7K אוהם
• מארז סוללות AAA 3x - שימוש ב- 3 סוללות AAA פלט מתח בדיוק בטווח שהאלקטרוניקה רוצה, מה שמפשט את העניינים. AAA נכנס לכובע קל יותר מ- AA ועדיין יש לו זמן ריצה נהדר.
• חוט מד קטן - השתמשתי בחוט מוצק שהייתי מונח מפרוייקט LED קודם.
• מלחם והלחמה
• קצת סטרץ שתואם את הצבע הפנימי של הכובע והחוט

מוצע אך אופציונלי:

• מחברים מהירים לחוטי הסוללה
• הדברים העוזרים בכפות הידיים הם קטנים מאוד וקשה להלחמה

שלב 2: שנה את הכובע

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

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

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

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

שלב 3: חיבור זה

לוח ה- Teensy והנוריות יעבדו בכל מקום בין 3.3v ל- 5v לצורך הספק. זו הסיבה שבחרתי להשתמש ב -3 סוללות AAA, מתח היציאה של 4.5v הוא יפה בטווח הזה, ויש להם הרבה זמן ריצה לאופן שבו תיכננתי את נוריות ה- LED לפעול. אתה אמור להיות מסוגל לקבל הרבה יותר משמונה שעות ריצה.

חיווט החשמל

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

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

חיווט הלדים

בחרתי ב- Teensy LC לפרויקט זה מכיוון שיש לו סיכה שמקלת הרבה יותר על חיבור נוריות כתובות. בתחתית הלוח הסיכה שנייה מהמראות השמאליות Pin #17, אך יש עליה גם 3.3v. זה נקרא משיכה, ועל לוחות אחרים יהיה עליך לחבר נגד כדי לספק את המתח הזה. במקרה של ה- Teensy LC אתה יכול פשוט לחבר מהסיכה הזו ישר לחוט הנתונים של נוריות ה- LED שלך.

חיווט חיישן המיקום

חלק מלוחות ה- BNO055 הזמינים מחמירים הרבה יותר את המתח ורוצים רק 3.3v. בגלל זה, חיברתי את ה Vin על הלוח BNO055 מהפלט הייעודי של 3.3v ב- Teensy, שהוא הפין השלישי למטה מימין. לאחר מכן תוכל לחבר את ה- GND ב- BNO055 לכל GND ב- Teensy.

חיישן המיקום BNO055 משתמש ב- I2c כדי לדבר עם ה- Teensy. I2c דורש משיכה, אז חיברתי שני נגדים של 4.7K אוהם מפלט של 3.3V על ה- Teensy לפינים 18 ו- 19. לאחר מכן חיברתי את סיכה 19 לסיכת SCL בלוח BNO055, ו- 18 לסיכה SDA.

טיפים/טריקים לחיווט

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

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

שלב 4: תכנות

עכשיו כשהכל מורכב תזדקק לכלי תכנות תואם Arduino. השתמשתי ב- Arduino IDE בפועל (עובד עם לינוקס, Mac ו- PC). תצטרך גם את תוכנת Teensyduino כדי להתממשק עם הלוח של Teensy. פרויקט זה משתמש בכבדות בספריית FastLED לביצוע תכנות הצבע והמיקום של הלדים.

כיול

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

תחילת העבודה עם סקיצת LED מהודרת

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

שורה 24: #הגדר NUM_LEDS 89 - שנה את זה למספר הלדים בפועל ברצועת הלדים שלך

שורה 28: #הגדר SERIAL_DEBUG שקר - סביר להניח שתרצה להפוך את זה לאמת, כך שתוכל לראות פלט על הצג הטורי

קוד זיהוי מיקום

זיהוי המיקום ורוב ההתאמות שלך מתחילות בקו 742 ועוברות דרך 802. אנו מקבלים נתוני Pitch, Roll ו- Yaw מחיישן המיקום ומשתמשים בו לקביעת ערכים. בהתאם לאופן הרכבה של האלקטרוניקה שלך ייתכן שיהיה עליך לשנות אלה. אם תעלה את חיישן המיקום כשהשבב לכיוון החלק העליון של הכובע, והחץ ליד X המודפס על הלוח הצביע לכיוון חזית הכובע, אתה אמור לראות את הדברים הבאים:

• פיץ 'מהנהן בראשך
• רול נוטה את הראש שלך, למשל לגעת באוזן אל הכתף שלך
• יאו הוא לאיזה כיוון. אתה פונה (צפון, מערב וכו ').

אם הלוח שלך מותקן בכיוון אחר, יהיה עליך להחליף Pitch/Roll/Yaw כדי שיתנהגו איך שהיית רוצה.

כדי להתאים את הגדרות הרול תוכלו לשנות את #define ערכים הבאים:

• ROLLOFFSET: כשהכובע שלך יציב ומרוכז ככל שהוא יכול להיות, אם הגליל אינו 0, שנה זאת בהפרש. כְּלוֹמַר. אם אתה רואה רול ב -20 כאשר הכובע שלך מרוכז, עשה את זה 20.
• ROLLMAX: הערך המרבי לשימוש למדידת גלילים. הכי קל למצוא אותו על ידי חבישת הכובע והזזת אוזן ימין לכיוון כתף ימין. לשם כך תצטרך כבל USB ארוך בעת השימוש במסך הטורי.
• ROLLMIN: הערך הנמוך ביותר לשימוש למדידת גלילים, כאשר אתה מטה את הראש שמאלה

באופן דומה, עבור המגרש:

• MAXPITCH - הערך המרבי כאשר אתה מסתכל למעלה
• MINPITCH - הערך המינימלי כאשר אתה מסתכל למטה
• PITCHCENTER - ערך המגרש כאשר אתה מסתכל ישר קדימה

אם אתה מגדיר את SERIALDEBUG כ- true בראש הקובץ, אתה אמור לראות את הערכים הנוכחיים עבור פלט Roll/Pitch/Yaw למסך הטורי כדי לעזור לשנות את הערכים האלה.

פרמטרים אחרים שתרצה לשנות

• MAX_LED_DELAY 35 - האיטי ביותר שחלקיק הלד יכול לנוע. זה באלפיות השנייה. זהו העיכוב ממעבר בין LED אחד לשני במחרוזת.
• MIN_LED_DELAY 10 - הצום שחלקיק הלד יכול להזיז. כמו למעלה הוא באלפיות השנייה.

סיכום

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

שלב 5: מתקדם ואופציונאלי: בתוך הקוד

זיהוי השפעה וספין

זיהוי השפעה/ספין מתבצע באמצעות פונקציות החיישן הגבוהות של BNO055. אתה יכול לשנות את הרגישות של זה עם השורות הבאות ב- initBNO055 ():

• שורה 316: BNO055_ACC_HG_DURATION - כמה זמן האירוע צריך להימשך
• שורה 317: BNO055_ACC_HG_THRESH - עד כמה ההשפעה צריכה להיות קשה
• שורה #319: BNO055_GYR_HR_Z_SET - סף מהירות הסיבוב
• שורה #320: BNO055_GYR_DUR_Z - כמה זמן הסיבוב אפילו צריך להימשך

שני הערכים הם בינאריים של 8 ביט, כיום ההשפעה מוגדרת ל- B11000000, שהם 192 מתוך 255.

כאשר מתגלה השפעה או ספין ה- BNO055 קובע ערך שהקוד מחפש ממש בתחילת הלולאה:

// איתור כל הפרעות המופעלות, כלומר בשל int byte G byte = readByte (BNO055_ADDRESS, BNO055_INT_STATUS); if (intStatus> 8) {impact (); } אחרת אם (intStatus> 0) {spin (); }

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

עוזרים

יצרתי פונקציית עזר פשוטה (void setAllLeds ()) להגדיר במהירות את כל הנורות לצבע אחד. אחד להשתמש בו כדי לכבות את כולם:

setAllLeds (CRGB:: שחור);

או שאתה יכול לבחור כל צבע המוכר על ידי ספריית FastLED:

setAllLeds (CRGB:: אדום);

יש גם פונקציה fadeAllLeds () שתעמעם את כל הלדים ב- 25%.

שיעור החלקיקים

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

/ * * משתנה ומכולות לנורות */ נוריות CRGB [NUM_LEDS]; סטטי ללא חתימה int curLedDelay = MAX_LED_DELAY; סטטי int centerLed = NUM_LEDS / 2; static int maxLedPos = NUM_LEDS / 2; stol bool oddLeds = 0; particle bool particle = 1; bool static speedDir = 1; dirCount ארוך ללא סימן; hueCount לא חתום;

וקוד כלשהו בהגדרות ():

אם (NUM_LEDS % 2 == 1) {oddLeds = 1; maxLedPos = NUM_LEDS/2; } אחר {oddLeds = 0; maxLedPos = NUM_LEDS/2 - 1; }

אם יש לנו מספרים אי -זוגיים, אנו רוצים להשתמש בנקודה 1/2 כאמצע, אחרת אנו רוצים את נקודת 1/2 - 1. קל לראות זאת עם 10 או 11 נוריות LED:

• 11 נוריות LED: 11/2 עם מספרים שלמים אמורות להעריך עד 5. והמחשבים נספרים מ 0. אז 0 - 4 הוא חצי אחד, 6 - 10 הוא החצי השני, ו -5 ביניהם. אנו מתייחסים למספר 5 במקרה זה כאילו הוא היה חלק משניהם, כלומר הוא מספר 1 עבור שני המחרוזות הווירטואליות של נוריות LED.
• 10 נוריות: 10/2 הוא 5. אך מכיוון שמחשבים נספרים מ -0 עלינו להסיר אחד. אז יש לנו 0 - 4 למחצית אחת, ו -5 - 9 לשני. מספר 1 למחרוזת הווירטואלית הראשונה יהיה 4, ומספר 1 למחרוזת הווירטואלית השנייה יהיה מספר 5.

אז בקוד החלקיקים שלנו עלינו לבצע מספר ספירה מהמיקום הכולל שלנו למיקומים בפועל על מחרוזת ה- LED:

אם (oddLeds) {Pos1 = centerLed + currPos; Pos2 = centerLed - currPos; } אחר {Pos1 = centerLed + currPos; Pos2 = (centerLed -1) - currPos; }

לקוד יש גם תנאים שבהם החלקיק יכול לשנות כיוונים, ולכן עלינו לקחת זאת בחשבון גם:

if (particleDir) {if ((currPos == NUM_LEDS/2) && oddLeds) {currPos = 0; } אחרת אם ((currPos == NUM_LEDS/2 - 1) && (! oddLeds)) {currPos = 0; } אחר {currPos ++; }} else {if ((currPos == 0) && oddLeds) {currPos = centerLed; } אחרת אם ((currPos == 0) && (! oddLeds)) {currPos = centerLed - 1; } אחר {currPos--; }}

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

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

if (particleDir) {if (oddLeds) {Pos1 = centerLed + currPos; Pos2 = centerLed - currPos; } אחר {Pos1 = centerLed + currPos; Pos2 = (centerLed -1) - currPos; }} else {if (oddLeds) {Pos1 = centerLed - currPos; Pos2 = centerLed + currPos; } אחר {Pos1 = centerLed - currPos; Pos2 = (centerLed -1) + currPos; }} leds [Pos1] = CHSV (currHue, 255, 255); leds [Pos2] = CHSV (currHue, 255, 255); FastLED.show ();}

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