משוך את האור - מודול אור באמצעות Neopixel & מתג למעלה: 6 שלבים (עם תמונות)

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

תכונות של מודול האור

• ארדואינו אונו
• חומרה ומארז שנרכשו מהאינטרנט
• Neopixel & אספקת חשמל שאולה מבית הספר לאינפורמטיקה ועיצוב המוצר
• מודול אור הנשלט על ידי ספק כוח
• כל הפונקציות נשלטות על ידי אינטראקציה של משתמשים
• סוגי הנפשה של רצועת Neopixel: סוג גשם, סוג מקלחת, סוג ברק ניצוץ, סוג פופ, סוג לא סדיר
• מתג משיכה למעלה מחובר לרצועת Neopixel והאנימציה משתנה בעת משיכה ברצועת Neopixel

שלב 1: לפני שנתחיל

שלום הוראות ויוצרים.

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

כדי שלא יחזור לעבודה

שלב 2: דרושים חלקים

מבוסס על מודול אור אחד

*** Neopixels ואספקת חשמל שימשו בתמיכת המחלקה שלנו. ***

מכשירי חשמל:

1. ארדואינו אונו
2. חוט 3 צבעים (שחור, אדום, כל צבע)
3. מחבר 3 פינים (קישור לקנייה)
4. מתג למעלה 1 (קישור לקנייה)
5. צינור מתכווץ
6. רצועת LED ניתנת לרכישה WS2812b עם 74 LED (רצועת Neopixel)*2
7. ספק כוח (5V 350A) 1

*** יש צורך ב -50 סטים עבור Arduino, מתג המשיכה וה- NeoPixels. ***

חוּמרָה:

1. סרגל אקריליק 2t (10mm*1000mm) 1
2. לוח אקריליק 5t (60 מ"מ*60 מ"מ) 1
3. Foemax 10t (1200mm*1800mm) 1
4. תרסיס שחור
5. אזיקון
6. חוּט
7. לוח קשיח
8. לוח רשת

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

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

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

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

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

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

שלב 4: צור באמצעות 50 מודולי אור

עיצבנו חווית משתמש לאור עשיר יותר על ידי פריסת 50 מודולים בסך הכל

היה לנו מדף ברוחב 1, 800 מ"מ ואורך 200 מ"מ, וחיברנו כל מתג ומודול כך שתוכל לחוות את סביבת הגשם והגשם שתכננו בתחילה, והיה לנו כל מודול עצמאי כדי לאפשר ריבוי משימות..

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

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

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

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

בסך הכל נעשה שימוש ב- 10 arduino ו -50 מודולי LED וחמישה מודולי LED חוברו לכל arduino ליצירת ריבוי משימות יעילה וחלקה יותר. עיין בתכנית המצורפת לפרטים. קידוד ריבוי משימות של Neopixel באמצעות המתג המלא על פי תרשים העיצוב יידון בפירוט בשלב הבא.

שלב 5: Arduino Coding & Wiring

תִיוּל

• 50 מודולים חוברו בהתאם לפריסה של שלב 4.
• כל מודול חולק ל -10 סטים של 50 מודולים כדי לאפשר ריבוי משימות ולספק חיבור ברור.
• כפי שמוצג בתמונה 1 שלמעלה, חמישה מודולים חוברו לארדואינו בודד, וסיכות 5V של ניאופיקסל נקשרו בבת אחת כדי לחבר את ספק הכוח.
• ה- GND של הניאופיקסלים והמתגים נקשרו גם הם יחד, וכדי להקל על התפיסה, המחברים חוברו לפינים 2, 3, 4, 5, 6 והגושטים חוברו לסיכות 9, 10, 11, 12, 13.
• המתגים והנייפיקסלים היו מחוברים בדרכים 2-9, 3-10, 4-11, 5-12, 6-13, בהתאמה.
• יש לציין כי מאחר וחיבורי הקווים מורכבים וקיים סכנת שריפה עקב קצר חשמלי, הצינור המתכווץ התחמם כדי להבטיח שהחלקים החלשים לא יישברו.

קידוד ריבוי משימות של Neopixel עם מתג למעלה

אנימציה 5 אור (סוג גשם, סוג מקלחת, סוג ברק ניצוץ, סוג פופ, סוג לא סדיר)

#לִכלוֹל

/*사용 하고자 하는 패턴 을 추가/*/

דפוס enum {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, Scanner, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 을 설정 함*/ כיוון enum {קדימה, הפוך};

/*패턴 의 클래스 를 입력/*/

מחלקת NeoPatterns: public Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 /* / public: pattern ActivePattern; /*클레스 함수 에 패턴 의 방향 을/*/ כיוון כיוון;

/*변수 מרווח 을 추가*/ מרווח ארוך לא חתום; /*변수 lastUpdate 를 추가*/ unsUpdate ארוך לא חתום; /*변수 צבע 1, צבע 2 를 추가*/ uint32_t צבע 1, צבע 2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 אינדקס 를 추가*/ uint16_t אינדקס;

/*패턴 을 완료 했을 시 다시//*/ void (*OnComplete) (); /*네오 패턴 에서 네오 픽샐 의 핀, 핀 번호, 타입, 콜백 을 불러오는/*/ NeoPatterns (uint16_t pixels, uint8_t pin, uint8_t type, void (*callback) ()): Adafruit_NeoPixel (פיקסלים, סיכה, סוג) { OnComplete = callback; }

/*패턴 을 업데이트 하기 위한 케이스/*/

עדכון חלל () { /*패턴 의 시간 설정. 멀티 태스킹 을 구현 하는/*/ if ((millis () - lastUpdate)> Interval) {lastUpdate = millis (); /*ActivePattern 의 스위치 구문*/ switch (ActivePattern) {/*מקרה RAINBOW_CYCLE 에서는 RainbowCycleUpdate 를 실행 하라*/ case RAINBOW_CYCLE: RainbowCycleUpdate (); /*מקרה RAINBOW_CYCLE 에서 나와라*/ הפסקה;

/*מקרה THEATER_CHASE 에서는 TheatreChaseUpdate 를 실행 하라*/

מקרה THEATER_CHASE: TheaterChaseUpdate (); /*מקרה THEATER_CHASE 에서 나와라*/ הפסקה;

/*מארז COLOR_WIPE 에서는 ColorWipeUpdate 를 실행 하라*/

מקרה COLOR_WIPE: ColorWipeUpdate (); /*מארז COLOR_WIPE 에서 나와라*/ הפסקה; /*Case SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*מארז סורק 에서 나와라*/ הפסקה;

/*מקרה FADE 에서는 FadeUpdate 를 실행 하라*/

מקרה FADE: FadeUpdate (); /*מארז FADE 에서 나와라*/ הפסקה;

/*מקרה TWINKLE 에서는 TwinkleUpdate 를 실행 하라*/

מקרה TWINKLE: TwinkleUpdate (); /*מארז TWINKLE 에서 나와라*/ הפסקה;

/*מקרה STAR 에서는 StarUpdate 를 실행 하라*/

מקרה STAR: StarUpdate (); /*מקרה STAR 에서 나와라*/ הפסקה;

/*מארז RAINBOWSPARKLE 에서는 RainbowsparkleUpdate 를 실행 하라*/

מקרה RAINBOWSPARKLE: RainbowsparkleUpdate (); /*מארז RAINBOWSPARKLE 에서 나와라*/ הפסקה; /*מקרה METEOR 에서는 MeteorUpdate 를 실행 하라*/ case METEOR: MeteorUpdate (); /*מארז METEOR 에서 나와라*/ הפסקה;

/*מארז LIGHT 에서는 LightUpdate 를 실행 하라*/

מקרה LIGHT: LightUpdate (); /*מארז LIGHT 에서 나와라*/ הפסקה;

/*מארז BLOSSOM 에서는 BlossomUpdate 를 실행 하라*/

מקרה BLOSSOM: BlossomUpdate (); /*מארז BLOSSOM 에서 나와라*/ הפסקה; }}}

/*패턴 의 방향 을 설정 하는/*/

/*אינדקס 를 증가 시키고 초기화 하는 함수*/

תוספת חלל () { /*만약 정방향 이면 인덱스 를 증가 /* / if (כיוון == קדימה) {אינדקס ++; /*(אם אינדקס> = סך כל הצעדים) {אינדקס = 0; /*패턴 을 완료 시키는 함수*/ if (OnComplete! = NULL) {OnComplete (); }}}

/*만약 정방향 이 아니면 인덱스 를 감소/*/ אחר { -אינדקס; /*만약 인덱스 가 전체 네오 픽셀 갯수 갯수 와 거나 적 전체 전체 구동 갯수 을 1 을 빼라*/ if (אינדקס <= 0) {Index = TotalSteps - 1; /*패턴 을 완료 시키는 함수*/ if (OnComplete! = NULL) {OnComplete (); }}}}

/*반대 방향 으로 움직이게 하는/*/

void Reverse () { /*애니메이션 함수 에 Reverse 를 썼을 시, 만약 방향 이 정방향 이면* / if (כיוון == קדימה) { /*방향 은 그 와 반대 이며 구동 갯수 갯수 에서 일 /* / כיוון = הפוך; אינדקס = סה כ צעדים - 1; } /*그 외의 방향 이 정방향 이면 인덱스 를 0 으로 설정 /* / אחר {כיוון = קדימה; אינדקס = 0; }}

/*애니메이션 을 설정 하는 함수 들*

*RainbowCycle 의 시간 과 방향 을/*/

void RainbowCycle (uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 חלל RainbowCycle () 되는 입력 되는 מרווח 과 같음*/ Interval = interval; /*총 구동 갯수 는 255 임*/ TotalSteps = 255; /*인덱스 는 0 으로 설정 함*/ אינדקס = 0; /*방향 은 void RainbowCycle () 안에 입력 되는 dir = קדימה 과 같음*/ Direction = dir; }

/*RainbowCycle 를 업데이트 했을 경우*/

void RainbowCycleUpdate () { /*변수 i 가 네오 픽셀 개수 작 으면 를 i 를 증가 시켜라* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 증가 함 과 동시에 RGB 의 무지개 / 로 변화 하면서 해라 / * / setPixelColor (i, Wheel (((i * 256 / numPixels ()) + אינדקס) & 255)); } / *애니메이션 을 보여주는 함수 * / show (); תוֹסֶפֶת(); }

/*TheaterChase 의 컬러 와 시간 방향 을/*/

void TheaterChase (uint32_t color1, uint32_t color2, uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 חלל TheaterChase () 되는 입력 되는 מרווח 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Color1 = color1; צבע 2 = צבע 2; /*인덱스 는 0 으로 설정 함*/ אינדקס = 0; /*방향 은 void TheaterChase () 안에 입력 되는 dir = קדימה 과 같음*/ Direction = dir; }

/*TheaterChase 를 업데이트 했을 경우*/

void TheaterChaseUpdate () { /*변수 i 가 네오 픽셀 개수 작 으면 으면 i 를 증가 시켜라* /for (int i = 0; i <numPixels (); i ++) { /*만약 변수 i 에 인덱스 를 더해서 3 으로 나눈 것이 0 과 같다 면 i 를 צבע 로 변환 시켜라*/ if ((i + Index) % 3 == 0) {setPixelColor (i, Color1); } /*그렇지 않다면 i 를 Color 로 변환 시켜라* / else {setPixelColor (i, Color2); }} / *애니메이션 을 보여주는 함수 * / show (); תוֹסֶפֶת(); }

/*ColorWipe 의 컬러 와 시간 방향 을/*/

void ColorWipe (uint32_t color, uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 void ColorWipe () 되는 입력 되는 מרווח 과 같음*/ מרווח = מרווח; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Color1 = צבע; /*인덱스 는 0 으로 설정 함*/ אינדקס = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = קדימה 과 같음*/ Direction = dir; }

/*ColorWipeUpdate 를 업데이트 했을 경우*/

void ColorWipeUpdate () { /*אינדקס 를 컬러 1 로 변환 /* / setPixelColor (אינדקס, צבע 1); / *애니메이션 을 보여주는 함수 */ show (); תוֹסֶפֶת(); }

/*סורק 의 컬러 와 시간 을/*/

סורק חלל (uint32_t color1, מרווח uint8_t) { /*실행 되는 패턴 은 SCANNER* / ActivePattern = SCANNER; /*시간 은 סורק חלל () 되는 입력 되는 מרווח 과 같음*/ מרווח = מרווח; /*구동 갯수 는 총 갯수 을 1 을 빼고 2 를 곱/*/ TotalSteps = (numPixels () - 1)*2; /*컬러 1 을 설정*/ Color1 = color1; /*인덱스 는 0 으로 설정 함*/ אינדקס = 0; }

/*סורק עדכון 를 업데이트 했을 경우*/

void ScannerUpdate () { /*변수 i 는 영 이고 총 갯수 작을 경우 i 를 증가 시켜라* /for (int i = 0; i <numPixels (); i ++) { /*만약 변수 i 가 인덱스 와 같다 면 i 를 color1 로 변환 시켜라*/ if (i == אינדקס) {setPixelColor (i, Color1); } / *그렇지 않다면 변수 i 를 전체 구동 갯수 에서 인덱스 를 과 같다 / * / else if (i == TotalSteps - Index) {setPixelColor (i, Color1); } / *그 밖에는 i 를 디밍 시켜라 i 의 값 만큼 * / else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); תוֹסֶפֶת(); }

/*סורק 의 컬러 1, 2 와 스텝, 시간, 방향 을 입력*/

void Fade (uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 되는 입력 되는 מרווח 과 같음*/ מרווח = מרווח; /*구동 갯수 는 스텝/*/ TotalSteps = צעדים; /*컬러 1, 2 를 설정*/ Color1 = color1; צבע 2 = צבע 2; /*인덱스 는 0 으로 설정 함*/ אינדקס = 0; /*방향 은 void Fade () 안에 입력 되는 dir = קדימה 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 אדום 값 은 다음 과* / uint8_t red = ((אדום (צבע 1)*(סה"כ צעדים - אינדקס)) + (אדום (צבע 2)*אינדקס)) / TotalSteps; / * 변수 ירוק 값 은 다음 과 / * / uint8_t ירוק = ((ירוק (צבע 1) * (סה"כ צעדים - אינדקס)) + (ירוק (צבע 2) * אינדקס)) / סה"כ צעדים; / * 변수 כחול 값 은 다음 과 / * / uint8_t blue = ((Blue (Color1) * (TotalSteps - Index)) + (Blue (Color2) * Index)) / TotalSteps; /*위 의 אדום, ירוק, כחול 값 으로 컬러 를 셋팅/*/ ColorSet (צבע (אדום, ירוק, כחול)); / *애니메이션 을 보여주는 함수 */ show (); תוֹסֶפֶת(); }

/*모든 네오 픽셀 을 끄는/*/

void alloff () { /*총 네오 픽셀 갯수 는 74 개 이며* / int NPIXEL = 74; /*변수 i 가 증가 하며 모든 네오 픽셀 의 컬러 값 0 으로 변환 함*/ for (int i = 0; i <NPIXEL; i ++) {setPixelColor (i, 0, 0, 0); }}

/*נצנוץ 의 컬러 1 와 시간 을 입력*/

Twinkle void (uint32_t color1, uint8_t interval) { /*실행 되는 패턴 은 TWINKLE* / ActivePattern = TWINKLE; /*시간 은 חלל Twinkle () 되는 입력 되는 מרווח 과 같음*/ Interval = interval; /*컬러 1 를 설정*/ Color1 = color1; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); אינדקס = 0; }

/*TwinkleUpdate 를 업데이트 했을 경우*/

void TwinkleUpdate () { /*모든 네오 픽셀 의 컬러 으로 0 으로 셋팅* / setAll (0, 0, 0); /*변수 פיקסל 은 אקראי 74*/ int פיקסל = אקראי (74); /*אקראי 74 개 에서 2 로나 눈 수 를 랜덤//*/setPixelColor (Pixel/2, 50, 100, 255); setPixelColor (פיקסל, 250, 255, 250); setPixelColor (פיקסל/2, 200, 250, 255); setPixelColor (פיקסל, 255, 255, 255); setPixelColor (פיקסל, 250, 230, 250); setPixelColor (פיקסל/2, 150, 200, 255); / *애니메이션 을 보여주는 함수 */ show (); / *랜덤 하게 끄는 함수 */ setPixelColor (פיקסל, 0, 0, 0); / *애니메이션 을 보여주는 함수 */ show (); תוֹסֶפֶת(); }

/*כוכב 의 컬러 1 값 을 입력*/

void Star (uint32_t color1) { /*실행 되는 패턴 은 STAR* / ActivePattern = STAR; /*시간 은 חלל כוכב () 안에 입력 되는 מרווח 과 같음*/ מרווח = מרווח; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Color1 = color1; אינדקס = 0; }

/*StarUpdate 를 업데이트 했을 경우*/

void StarUpdate () { /*인덱스 와 컬러 를 /* / setPixelColor (אינדקס, צבע 1); הופעה(); /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 를 감소 시킴 = 한칸 씩 이동 하는/*/ for (int i = 0; i <numPixels (); i--) {setPixelColor (i, Color (0, 0, 0)); } / *애니메이션 을 보여주는 함수 * / תוספת (); }

/*Rainbowsparkle 의 시간 과 방향 을 입력*/

void Rainbowsparkle (uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 חלל Rainbowsparkle () 되는 입력 되는 מרווח 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); אינדקס = 0; /*방향 은 void Rainbowsparkle () 안에 입력 되는 כיוון 과 같음*/ Direction = dir; }

/*RainbowsparkleUpdate 를 업데이트 했을 경우*/

void RainbowsparkleUpdate () { /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데*/ if ((i + Index) % 2 == 0) {uint32_t c = אקראי (255); setPixelColor (i, c); } else {setPixelColor (i, אקראי (255)); }} / *애니메이션 을 보여주는 함수 * / show (); תוֹסֶפֶת(); } /*מטאור 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후 *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Color1 = color1; אינדקס = 0; }

/*MeteorUpdate 를 업데이트 했을 경우*/

void MeteorUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == Index) {setPixelColor (i, 100, אקראי (255), 255); } else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); תוֹסֶפֶת(); }

/*אור 의 시간 과 방향 을/*/

void Light (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후 *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Color1 = color1; אינדקס = 0; }

/*LightUpdate 를 업데이트 했을 경우*/

void LightUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 150, אקראי (200), 40); } else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); תוֹסֶפֶת(); }

/*פריחה 의 시간 과 방향 을/*/

void Blossom (uint32_t color1) { /*실행 되는 패턴 은 BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후 *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Color1 = color1; אינדקס = 0; }

/*BlossomUpdate 를 업데이트 했을 경우*/

void BlossomUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 255, אקראי (255), 100); } else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); תוֹסֶפֶת(); }

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/ *네오 픽셀 의 켜지 는 위치 와 색 을 지정/ */ void setAll (אדום בתים, ירוק בתים, כחול בתים) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, אדום, ירוק כחול); } הופעה(); }

/*네오 픽셀 의 디밍, 즉 밝기 를 조절 하는/*/

uint32_t DimColor (צבע uint32_t) {// Shift רכיבי R, G ו- B סיבוב אחד ימינה uint32_t dimColor = צבע (אדום (צבע) >> 1, ירוק (צבע) >> 1, כחול (צבע) >> 1); החזר dimColor; }

/*모든 네오 픽셀 의 칼라 를/*/

void ColorSet (uint32_t color) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, color); } הופעה(); }

/*레드 값 을 불러 옴*/

uint8_t אדום (צבע uint32_t) {return (צבע >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t ירוק (צבע uint32_t) {return (צבע >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t כחול (צבע uint32_t) {return color & 0xFF; }

/*קשת 컬러 를 불러 옴*/

uint32_t גלגל (בייט WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } אחרת אם (WheelPos <170) {WheelPos -= 85; החזר צבע (0, WheelPos * 3, 255 - WheelPos * 3); } אחר {WheelPos -= 170; החזר צבע (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

/*רצועה 을 불러 오기 위한 함수 /*사용 하는 스트립 별로 모두 지정 해주어야 / / /

void strip1Complete (); void strip2Complete (); void strip3Complete (); void strip4Complete (); void strip5Complete ();

/*네오 픽셀 의 갯수 설정*/

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 /* / #define B_NUM 5 /*ייבוא פס 1 ~ 5 까지, 는 74 개 스트립 연결 은 은 רצועה 은 8 ~ רצועה 5 까지 12* / רצועה NeoPatterns1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); NeoPatterns strip2 (74, 9, NEO_GRB + NEO_KHZ800, & strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800, & strip3Complete); NeoPatterns strip4 (74, 11, NEO_GRB + NEO_KHZ800, & strip4Complete); NeoPatterns strip5 (74, 12, NEO_GRB + NEO_KHZ800, & strip5Complete); /*배열 을 사용한 연결 버튼 핀/*/ const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; /*배열 을 사용 하여 버튼 상태 를 지정 해줌*/ int buttonState [B_NUM]; /*2 번핀 부터 6 번핀 까지 상태 는 순서 대로 LOW 임*/ int lastButtonState [B_NUM] = {LOW, LOW, LOW, LOW, LOW}; /*2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화/*/ int buttonCounter [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임*/ int buttonCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int קריאה [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 은 עיכוב50 과 같음*/ unsign long debounceDelay = 50;

הגדרת בטל () {

/*복잡 하게 저항 연결 이 필요 인풋 풀업 방식 의 GN GN: GND - 5V (התחבר למספר סיכה)*/ עבור (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Serial.begin (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1.begin (); strip2.begin (); strip3.begin (); strip4.begin (); strip5.begin ();

//strip1. TheaterChase(strip1. Color(255, 0, 255), strip1. Color (255, 50, 0), 20, קדימה);

}

/*버튼 카운터 변수 값 은 5 임*/

מונה int = 5; לולאת void () { /*버튼 수 보다 i 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (קריאה ! = buttonState ) {buttonState = קריאת ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = קריאת ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); strip2. Update (); strip3. Update (); strip4. Update (); strip5. Update ();

///// SWITCH_2 ////////////////////////////////////// ////////////////////////////////////////// ////////////////////////////////////////////

/*버튼 배열 의 0 번째 즉. 2 switch 에 연결된 버튼 을 활용 하여 애니메이션 이 구동 하는 스위치/// switch (buttonCounter [0]) {

/*첫번째 버튼 을 활동 시키면 구동 되는/*/

מקרה 0: strip1. ActivePattern = BLOSSOM; /*해당 애니메이션 의 시간 을/*/ strip1. Interval = 20; /*구동 되는 네오 픽셀 의 갯수 를/*/ strip1. TotalSteps = strip1.numPixels (); לשבור; /*두번째 버튼 을 활동 시키면 구동 되는 애니메이션*/ מקרה 1: strip1. ActivePattern = RAINBOWSPARKLE; רצועה 1. מרווח = 50; strip1. TotalSteps = strip1.numPixels (); לשבור; /*세번째 버튼 을 활동 시키면 구동 되는/*/ מקרה 2: strip1. ActivePattern = SCANNER; רצועה 1. מרווח = 10; strip1. TotalSteps = (strip1.numPixels () - 1) * 2; לשבור; /*네번째 버튼 을 활동 시키면 구동 되는/*/ מקרה 3: strip1. ActivePattern = TWINKLE; רצועה 1. מרווח = 1; strip1. TotalSteps = strip1.numPixels (); לשבור; /*다섯 번째 버튼 을 활동 시키면 구동 되는/*/ מקרה 4: strip1. ActivePattern = METEOR; רצועה 1. מרווח = 10; strip1. TotalSteps = strip1.numPixels (); לשבור; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SWITCH_3 ////////////////////////////////////// ////////////////////////////////////////// ////////////////////////////////////////////

switch (buttonCounter [1]) {case 0: strip2. ActivePattern = STAR; רצועה 2. מרווח = 50; strip2. TotalSteps = strip2.numPixels (); לשבור; מקרה 1: strip2. ActivePattern = RAINBOWSPARKLE; רצועה 2. מרווח = 100; strip2. TotalSteps = strip2.numPixels (); לשבור; מקרה 2: strip2. ActivePattern = SCANNER; רצועה 2. מרווח = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; לשבור; מקרה 3: strip2. ActivePattern = TWINKLE; רצועה 2. מרווח = 5; strip2. TotalSteps = strip2.numPixels (); לשבור; מקרה 4: strip2. ActivePattern = METEOR; רצועה 2. מרווח = 40; strip2. TotalSteps = strip2.numPixels (); לשבור; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SWITCH_4 ////////////////////////////////////// ////////////////////////////////////////// ////////////////////////////////////////////

switch (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; רצועה 3. מרווח = 50; strip3. TotalSteps = strip3.numPixels (); לשבור; מקרה 1: רצועת 3. ActivePattern = RAINBOWSPARKLE; רצועת 3. מרווח = 100; strip3. TotalSteps = strip3.numPixels (); לשבור; מקרה 2: strip3. ActivePattern = SCANNER; רצועת 3. מרווח = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; לשבור; מקרה 3: strip3. ActivePattern = TWINKLE; רצועה 3. מרווח = 5; strip3. TotalSteps = strip3.numPixels (); לשבור; מקרה 4: strip3. ActivePattern = METEOR; רצועת 3. מרווח = 25; strip3. TotalSteps = strip3.numPixels (); לשבור; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SWITCH_5 ////////////////////////////////////// ////////////////////////////////////////// ////////////////////////////////////////////

switch (buttonCounter [3]) {מקרה 0: strip4. ActivePattern = STAR; רצועה 4. מרווח = 50; strip4. TotalSteps = strip4.numPixels (); לשבור; מקרה 1: strip4. ActivePattern = RAINBOWSPARKLE; רצועה 4. מרווח = 100; strip4. TotalSteps = strip4.numPixels (); לשבור; מקרה 2: strip4. ActivePattern = SCANNER; רצועה 4. מרווח = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; לשבור; מקרה 3: strip4. ActivePattern = TWINKLE; רצועה 4. מרווח = 5; strip4. TotalSteps = strip4.numPixels (); לשבור; מקרה 4: strip4. ActivePattern = METEOR; רצועה 4. מרווח = 25; strip4. TotalSteps = strip4.numPixels (); לשבור; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SWITCH_6 //////////////////////////////////// ////////////////////////////////////////// ////////////////////////////////////////////

switch (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; רצועה 5. מרווח = 50; strip5. TotalSteps = strip5.numPixels (); לשבור; מקרה 1: רצועת 5. ActivePattern = RAINBOWSPARKLE; רצועה 5. מרווח = 100; strip5. TotalSteps = strip5.numPixels (); לשבור; מקרה 2: strip5. ActivePattern = SCANNER; רצועה 5. מרווח = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; לשבור; מקרה 3: רצועת 5. ActivePattern = TWINKLE; רצועה 5. מרווח = 5; strip5. TotalSteps = strip5.numPixels (); לשבור; מקרה 4: רצועת 5. ActivePattern = METEOR; רצועה 5. מרווח = 25; strip5. TotalSteps = strip5.numPixels (); לשבור; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// חזרה על סיום strip1

void strip1Complete () {strip1. Color1 = strip1. Wheel (אקראי (255)); strip1. Color2 = strip1. Wheel (אקראי (255)); strip1. Index = 0; }

// חזרה על סיום strip2

void strip2Complete () {strip2. Color1 = strip2. Wheel (אקראי (255)); strip2. Color2 = strip2. Wheel (אקראי (255)); strip2. Index = 0; }

// החזרה על strip3 השלמה

void strip3Complete () {strip3. Color1 = strip3. Wheel (אקראי (255)); strip3. Color2 = strip3. Wheel (אקראי (255)); strip3. Index = 0; }

// חזרה על strip4 השלמה

void strip4Complete () {strip4. Color1 = strip4. Wheel (אקראי (255)); strip4. Color2 = strip4. Wheel (אקראי (255)); strip4. Index = 0; }

// החזרה על strip5 השלמה

void strip5Complete () {strip5. Color1 = strip5. Wheel (אקראי (255)); strip5. Color2 = strip5. Wheel (אקראי (255)); strip5. Index = 0; }

שלב 6: תוצאה ויצירת סרט

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