ดึง Light - Light Module โดยใช้ Neopixel & Pull Up Switch: 6 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:05

คุณสมบัติของโมดูลไฟ

• Arduino Uno
• ฮาร์ดแวร์และกล่องหุ้มที่ซื้อจากอินเทอร์เน็ต
• Neopixel & Power supply ยืมมาจาก School of Informatics & Product Design
• โมดูลไฟควบคุมโดยแหล่งจ่ายไฟ
• ฟังก์ชั่นทั้งหมดควบคุมผ่านการโต้ตอบกับผู้ใช้
• ประเภทแอนิเมชั่นของแถบนีโอพิกเซล: แบบฝน, แบบฝักบัว, แบบสปาร์ค ไลท์นิ่ง, แบบป๊อป, แบบผิดปกติ
• สวิตช์ดึงขึ้นเชื่อมต่อกับแถบ Neopixel และภาพเคลื่อนไหวจะเปลี่ยนไปเมื่อดึงแถบ Neopixel

ขั้นตอนที่ 1: ก่อนที่เราจะเริ่มต้น

สวัสดีผู้สอนและผู้สร้าง

เราเริ่มต้นและโครงการออกแบบเชิงโต้ตอบในแง่ของสิ่งที่จะเกิดขึ้นหากเราสัมผัสได้ถึงอารมณ์ของฝนผ่านภาพเคลื่อนไหวของแสง ฉันคิดว่าความรู้สึกของผู้ใช้จะถูกขยายให้ใหญ่สุดผ่านอินเทอร์เฟซที่ดึงแสงโดยตรง

ไปทำงานกันเถอะ

ขั้นตอนที่ 2: ชิ้นส่วนที่จำเป็น

ขึ้นอยู่กับหนึ่งโมดูลแสง

***นีโอพิกเซลและพาวเวอร์ซัพพลายถูกใช้โดยฝ่ายสนับสนุนของเรา***

อิเล็กทรอนิกส์:

1. Arduino Uno
2. ลวด 3 สี (ดำ, แดง, สีใดก็ได้)
3. ขั้วต่อ 3pin (ลิงค์สำหรับซื้อ)
4. ดึงสวิตช์ 1 (ลิงค์สำหรับซื้อ)
5. ท่อหด
6. WS2812b แถบ LED แบบเพิ่มได้พร้อม 74 LED (แถบนีโอพิกเซล)*2
7. แหล่งจ่ายไฟ (5V 350A) 1

***50 ชุดจำเป็นสำหรับ Arduino, Pull Switch และ NeoPixels***

ฮาร์ดแวร์:

1. แท่งอะคริลิค 2t (10mm*1000mm) 1
2. แผ่นอะคริลิก 5t(60mm*60mm) 1
3. Foemax 10t (1200 มม. * 1800 มม.) 1
4. สเปรย์สีดำ
5. เคเบิ้ลไทร์
6. สตริง
7. ฮาร์ดบอร์ด
8. กระดานกริด

ขั้นตอนที่ 3: การเชื่อมต่อและการสร้างฮาร์ดแวร์

ขั้นแรก เราต้องตัดอะคริลิกเพื่อสร้างโมดูลไฟหนึ่งโมดูล

• เพื่อสัมผัสประสบการณ์ภาพเคลื่อนไหวของแสง ร่างโมดูลไฟที่ได้รับการแก้ไขโดยติดไฟ LED 74 ดวงในรูปแบบของแถบนีโอพิกเซลบนแถบอะคริลิกหนา 2 มม. ที่มีพื้นที่ 1 เมตร เราได้ผลิตโมดูลแสงสองประเภท: เชิงเส้นทั่วไปและเกลียว
• สำหรับประเภทเชิงเส้นตรง แถบนีโอพิกเซลที่มีอยู่สามารถยึดและยึดให้แน่นหนาได้ แต่ประเภทเกลียวต้องดำเนินการด้วยตนเอง LED 74 ดวงแต่ละดวงถูกแยกออกเป็นชิ้น ๆ ติดกับอะครีลิคเกลียวและผูกมัดด้วยตะกั่ว

ติดแถบ Neopixel กับอะคริลิกและยึดแถบแต่ละเส้นไว้เพื่อป้องกันไม่ให้ถูกความร้อนกระจาย หรือผูกด้วยสายเบ็ดเส้นเล็ก ในกรณีของประเภทเชิงเส้น ต้องดึงลูกปิงปองไปที่ส่วนท้ายของโมดูลเพื่อออกแบบรูปลักษณ์ที่สวยงาม และเราทำลูกปิงปองเสร็จแล้วด้วยสเปรย์สีดำ จากนั้นพวกเขาก็เจาะรูเล็กๆ ในลูกปิงปองแล้วต่อด้วยเชือก ส่วนที่สำคัญที่สุดถัดไป สวิตช์และนีโอพิกเซล เชื่อมต่อตามที่แสดง จากนั้นจึงยึดสวิตช์เข้ากับชั้นวางบนเพดาน

ในกรณีของประเภทเกลียว มีความเสี่ยงที่การดึงโดยตรงของโมดูลเกลียวอาจทำให้อะคริลิกแตกภายใต้แรงกด ดังนั้นส่วนดึง (อินพุต) และโมดูล (เอาต์พุต) จึงแยกออกจากกัน เพื่อเพิ่มแสงที่ตกกระทบให้สูงสุด มีการติดตั้งโมดูลในแนวตั้งบนเพดาน โมดูลเชิงเส้นถูกยึดกับอากาศ เกลียวถูกยึดเข้ากับเพดานโดยตรง และเราเชื่อมต่อลูกปิงปองกับสวิตซ์กับสายเบ็ดเพื่อให้สามารถใช้งานได้

การตัดอะคริลิกตามที่แสดงในภาพวาดด้านบนจำเป็นต้องยึดสวิตช์เข้ากับชั้นวาง สวิตช์รูปสี่เหลี่ยมจัตุรัสขนาด 6 ซม. หนาประมาณ 5 มม. โดยที่สวิตช์อยู่ตรงกลางและรัดสายผ่านรูทั้งสองด้านเพื่อยึดสวิตช์ให้แน่น รูกลมที่ด้านล่างของจุดศูนย์กลางเผยให้เห็นการดึงของสวิตช์ ซึ่งด้านล่างจะดึงสายไฟสามเส้นออกและเชื่อมต่อกับขั้วต่อสายเคเบิลของโมดูล และในทำนองเดียวกัน ชั้นวางและอะคริลิคผ่านรูที่มุมทั้งสี่นั้นยึดด้วยสายรัด ตามที่อธิบายไว้ข้างต้น โมดูลเชิงเส้นตรงเชื่อมต่อกับตัวดึงโดยตรง แต่โมดูลแบบเกลียวจะเชื่อมต่อพินและสวิตช์แยกจากกัน

ขั้นตอนที่ 4: สร้างโดยใช้ 50 โมดูลแสง

เราได้ออกแบบประสบการณ์ผู้ใช้สำหรับแสงที่สมบูรณ์ยิ่งขึ้นโดยการปรับใช้โมดูลทั้งหมด 50 โมดูล

เรามีชั้นวางที่กว้าง 1,800 มม. และยาว 1, 200 มม. และเราเชื่อมต่อสวิตช์และโมดูลแต่ละตัวเพื่อให้คุณได้สัมผัสกับสภาพแวดล้อมฝนและฝนที่เราวางแผนไว้ในตอนแรก และเราให้แต่ละโมดูลแยกกันเพื่อเปิดใช้งานการทำงานหลายอย่างพร้อมกัน.

ขึ้นอยู่กับภาพวาดการออกแบบ รูกลมถูกเจาะเข้าไปใน foemax เพื่อซ่อนการติดตั้งและเพื่อให้แน่ใจว่ามองไม่เห็นพื้นที่ที่เชื่อมต่อของโมดูล LED เนื่องจากระยะห่างจากแผ่นอะคริลิกถึงจุดเชื่อมต่อโมดูล LED ที่ติดสวิตช์อยู่ประมาณ 1 ซม. จึงใช้โฟแม็กซ์หนา 1 ซม.

โครงโลหะทรงสี่เหลี่ยมใช้สำหรับยึดการติดตั้งร่วมกับสกรูและสายรัดสายไฟ โดยที่ยังคงน้ำหนักและความสมดุลโดยรวม หากความยาวของจุดเชื่อมต่อที่เปิดเผยมากกว่าตอนที่ผู้ผลิตพยายาม บอร์ดที่หนากว่าจะไม่มีประสิทธิภาพ และแนะนำให้ใช้โครงสร้างอื่นๆ

เพื่อความสะดวกในการใช้งานของผู้ใช้ในระดับสายตา การติดตั้งที่เสร็จสมบูรณ์จะถูกวางไว้บนฐานรองรับสูงประมาณ 2 เมตร แต่ข้อควรระวังก็คือ การติดตั้งโมดูล LED แบบฝังด้วยสวิตช์นั้นยุ่งยากมาก ดังนั้นควรถอดการเชื่อมต่อทั้งหมดออก เราปีนขึ้นบันไดและเชื่อมต่อโมดูลด้วยการติดตั้งที่ยึดกับส่วนรองรับ

ส่วนที่สำคัญที่สุดของกระบวนการทั้งหมดนี้คือเพื่อให้แน่ใจว่างานเสร็จสิ้นอย่างปลอดภัยและปลอดภัยอย่างเต็มที่เพื่อให้แน่ใจว่าประสบการณ์นั้นเป็นไปได้ในสภาพแวดล้อมที่ปลอดภัย

ใช้โมดูล Arduino ทั้งหมด 10 โมดูลและ LED 50 โมดูล และเชื่อมต่อโมดูล LED ห้าโมดูลต่อ Arduino เพื่อการทำงานหลายอย่างที่มีประสิทธิภาพและราบรื่นยิ่งขึ้น ดูพิมพ์เขียวที่แนบมาสำหรับรายละเอียด การเขียนโค้ดมัลติทาสกิ้ง Neopixel โดยใช้สวิตช์เต็มรูปแบบตามไดอะแกรมการออกแบบจะกล่าวถึงในรายละเอียดในขั้นตอนต่อไป

ขั้นตอนที่ 5: การเข้ารหัสและการเดินสาย Arduino

การเดินสายไฟ

• 50 โมดูลถูกเชื่อมต่อตามโครงร่างของขั้นตอนที่ 4
• แต่ละโมดูลถูกแบ่งออกเป็น 10 ชุด 50 โมดูลเพื่อเปิดใช้งานการทำงานหลายอย่างพร้อมกันและเพื่อให้การเชื่อมต่อที่ชัดเจน
• ดังที่แสดงในภาพชุดที่ 1 ด้านบน โมดูลห้าโมดูลเชื่อมต่อกับ Arduino ตัวเดียว และหมุดนีโอพิกเซล 5v ถูกผูกเข้าด้วยกันในคราวเดียวเพื่อเชื่อมต่อแหล่งจ่ายไฟ
• GND ของนีโอพิกเซลและสวิตช์ยังเชื่อมโยงเข้าด้วยกัน และเพื่อความสะดวกในการรับรู้ สวิตช์ถูกเสียบเข้ากับพิน 2, 3, 4, 5, 6 และนีโอพิกเซลถูกเสียบเข้ากับพิน 9, 10, 11, 12, 13.
• สวิตช์และนีโอพิกเซลเชื่อมต่อด้วยวิธี 2-9, 3-10, 4-11, 5-12, 6-13 ตามลำดับ
• ควรสังเกตว่าเนื่องจากการเชื่อมต่อของสายไฟมีความซับซ้อนและมีความเสี่ยงที่จะเกิดไฟไหม้เนื่องจากการลัดวงจร ท่อหดจึงถูกทำให้ร้อนเพื่อให้แน่ใจว่าชิ้นส่วนที่อ่อนแอจะไม่แตก

การเข้ารหัสมัลติทาสกิ้ง Neopixel พร้อมสวิตช์ดึงขึ้น

แอนิเมชั่นแสง 5 แบบ (แบบ Rain, แบบฝักบัว, แบบ Spark Lightning, แบบ Pop, แบบ Irregular)

#รวม

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

รูปแบบ enum { NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM }; /*네오 향을 방향을 설정함*/ ทิศทาง enum { ไปข้างหน้า ย้อนกลับ };

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

คลาส NeoPatterns: สาธารณะ Adafruit_NeoPixel { /* 패턴을 추가하고 업데이트하기위한 함수*/ สาธารณะ: รูปแบบ ActivePattern; /*클레스 함수에 패턴의 방향을 입력*/ ทิศทาง ทิศทาง;

/*변수 Interval을 추가*/ unsigned long Interval; /*변수lastUpdate를 추가*/ unsigned long lastUpdate; /*변수 Color1, Color2를 추가*/ uint32_t Color1, Color2; /*변수 TotalSteps를 추가*/ uint16_t TotalSteps; /*변수 ดัชนี를 추가*/ uint16_t ดัชนี;

/*패턴을 완료했을시 다시 불러오는 함수*/ เป็นโมฆะ (*OnComplete)(); /*네오패턴에서 네오픽샐의 갯수, 핀번호, 타입, 콜백을 불러오는 함수*/ NeoPatterns(uint16_t pixels, uint8_t pin, uint8_t type, void (*callback)()): Adafruit_NeoPixel(pixels, pin, type){ OnComplete = โทรกลับ; }

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

เป็นโมฆะ Update(){ /*패턴의 시간 설정. 멀티태스킹을 구현하는 구문*/ if ((มิลลิวินาที) - อัปเดตล่าสุด) > ช่วงเวลา){ อัปเดตล่าสุด = มิลลิวินาที (); /*ActivePattern의 스위치구문*/ สวิตช์ (ActivePattern) { /*case RAINBOW_CYCLE에서는 RainbowCycleUpdate를 실행하라*/ case RAINBOW_CYCLE: RainbowCycleUpdate(); /*case RAINBOW_CYCLE에서 나와라*/ break;

/*case THEATER_CHASE에서는 TheaterChaseUpdate를 실행하라*/

กรณี THEATER_CHASE: TheaterChaseUpdate(); /*case THEATER_CHASE에서 나와라*/ แตก;

/*case COLOR_WIPE에서는 ColorWipeUpdate를 실행하라*/

กรณี COLOR_WIPE: ColorWipeUpdate(); /*case COLOR_WIPE에서 나와라*/ break; /*case SCANNER에서는 ScannerUpdate를 실행하라*/ case SCANNER: ScannerUpdate(); /*case SCANNER에서 나와라*/ แตก;

/*case FADE에서는 FadeUpdate를 실행하라*/

กรณี FADE: FadeUpdate(); /*case FADE에서 나와라*/ แตก;

/*case TWinkle에서는 TwinkleUpdate를 실행하라*/

กรณี Twinkle: TwinkleUpdate(); /*case TWINKLE에서 나와라*/ เบรค;

/*case STAR에서는 StarUpdate를 실행하라*/

กรณี STAR: StarUpdate(); /*case STAR에서 나와라*/ break;

/*case RAINBOWSPARKLE에서는 RainbowsparkleUpdate를 실행하라*/

กรณี RAINBOWSPARKLE: RainbowsparkleUpdate(); /*case RAINBOWSPARKLE에서 나와라*/ break; /*case METEOR에서는 MeteorUpdate를 실행하라*/ case METEOR: MeteorUpdate(); /*case METEOR에서 나와라*/ แตก;

/*case LIGHT에서는 LightUpdate를 실행하라*/

กรณี LIGHT: LightUpdate(); /*case LIGHT에서 나와라*/ แตก;

/*case BLOSSOM에서는 BlossomUpdate를 실행하라*/

กรณี BLOSSOM: BlossomUpdate(); /*case BLOSSOM에서 나와라*/ เบรค; } } }

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

/*ดัชนี를 증가시키고 초기화하는 함수*/

โมฆะ Increment(){ /*만약 정방향이면 인덱스를 증가시켜라*/ if (Direction == FORWARD){ Index++; /*만약 인덱스가 전체 구 구동 갯수와 같거나 많다면 0으로 초기화시켜라*/ ถ้า (ดัชนี >= TotalSteps){ ดัชนี = 0; /*패턴을 완료시키는 함수*/ ถ้า (OnComplete != NULL){ OnComplete(); } } }

/*만약 정방향이 아니면 인덱스를 감소시켜라*/ else{ --ดัชนี; /*만약 인덱스가 전체 구 구동 갯수와 같거나 적다면 전체 구동 갯수에서 1을빼라*/ ถ้า (ดัชนี <= 0){ ดัชนี = TotalSteps - 1; /*패턴을 완료시키는 함수*/ ถ้า (OnComplete != NULL){ OnComplete(); } } } }

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

void Reverse(){ /*애니메이션 함수에 Reverse를 썼을시, 만약 방향이 정방향이면*/ if (Direction == FORWARD){ /*방향은 그와 반대이며 전체 구동 갯수에서 1일빼라*/ Direction = REVERSE; ดัชนี = TotalSteps - 1; } /*그 외의 방향이 정방향이면 인덱스를 0으로 설정해라*/ else{ Direction = FORWARD; ดัชนี = 0; } }

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

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

เป็นโมฆะ RainbowCycle (ช่วง uint8_t, dir ทิศทาง = FORWARD){ /*실행되는 패턴은 RainbowCycle임*/ ActivePattern = RAINBOW_CYCLE; /*시간은 เป็นโมฆะ RainbowCycle()안에 입력되는 ช่วงเวลา과 같음*/ ช่วงเวลา = ช่วงเวลา; /*총 구동갯수는 255임*/ TotalSteps = 255; /*인덱스는 0으로 설정함*/ ดัชนี = 0; /*방향은 เป็นโมฆะ RainbowCycle()안에 입력되는 dir = FORWARD과 같음*/ Direction = dir; }

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

void RainbowCycleUpdate(){ /*변수 i가 네오픽셀 개수보다 작으면 i를 증가시켜라*/ for (int i = 0; i < numPixels(); i++){ /*변수 i가 증가함과 동시에 RGB의 무지개 컬러로 변화하면서 작동해라 */ setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255)); } /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

/*โรงละครเชส 컬러와 시간 방향을 입력*/

เป็นโมฆะ TheaterChase (uint32_t color1, uint32_t color2, uint8_t ช่วง, dir ทิศทาง = FORWARD) { /*실행되는 패턴은 RTHEATER_CHASE*/ ActivePattern = THEATER_CHASE; /*시간은 เป็นโมฆะ TheaterChase()안에 입력되는 ช่วงเวลา과 같음*/ ช่วงเวลา = ช่วงเวลา; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1, 2를 설정*/ Color1 = color1; สี2 = สี2; /*인덱스는 0으로 설정함*/ ดัชนี = 0; /*방향은 เป็นโมฆะ TheaterChase()안에 입력되는 dir = FORWARD과 같음*/ Direction = dir; }

/*โรงละครเชส를 업데이트했을 경우*/

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

/*ColorWipe 컬러와 시간 방향을 입력*/

เป็นโมฆะ ColorWipe (สี uint32_t, ช่วง uint8_t, dir ทิศทาง = ไปข้างหน้า) { /*실행되는 패턴은 COLOR_WIPE*/ ActivePattern = COLOR_WIPE; /*시간은 เป็นโมฆะ ColorWipe()안에 입력되는 ช่วงเวลา과 같음*/ ช่วงเวลา = ช่วงเวลา; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1을 설정*/ Color1 = สี; /*인덱스는 0으로 설정함*/ ดัชนี = 0; /*방향은 เป็นโมฆะ ColorWipe()안에 입력되는 dir = FORWARD과 같음*/ Direction = dir; }

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

เป็นโมฆะ ColorWipeUpdate(){ /*index를 컬러1로 변환시켜라*/ setPixelColor(ดัชนี, Color1); /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

/*สแกนเนอร์ 컬러와 시간을 입력*/

โมฆะสแกนเนอร์ (uint32_t color1, uint8_t ช่วงเวลา){ /*실행되는 패턴은 SCANNER*/ ActivePattern = SCANNER; /*시간은 void Scanner()안에 입력되는 ช่วงเวลา과 같음*/ ช่วงเวลา = ช่วงเวลา; /*구동갯수는 총갯수에서 1을빼고 2를 곱해라*/ TotalSteps = (numPixels() - 1) * 2; /*컬러 1을 설정*/ Color1 = สี1; /*인덱스는 0으로 설정함*/ ดัชนี = 0; }

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

void ScannerUpdate(){ /*변수 i는 영이고 총갯수보다 작을경우 i를 증가시켜라*/ for (int i = 0; i < numPixels(); i++){ /*만약 변수 i가 인덱스와 같다면 i 를 color1로 변환시켜라*/ ถ้า (i == ดัชนี){ setPixelColor(i, Color1); } /*그렇지 않다면 변수 i를 전체구동갯수에서 인덱스를 뺀값과 같다 */ else if (i == TotalSteps - Index){ setPixelColor(i, Color1); } /*그 밖에는 i를 디밍시켜라 ฉัน 의 */ else { setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

/*สแกนเนอร์ 컬러1, 2와 스텝, 시간, 방향을 입력*/

โมฆะ Fade (uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, dir dir = FORWARD) { /*실행되는 패턴은 FADE*/ ActivePattern = FADE; /*시간은 void Fade()안에 입력되는 ช่วงเวลา과 같음*/ ช่วงเวลา = ช่วงเวลา; /*구동갯수는 스텝값임*/ TotalSteps = ขั้นตอน; /*컬러 1, 2를 설정*/ Color1 = color1; สี2 = สี2; /*인덱스는 0으로 설정함*/ ดัชนี = 0; /*방향은 เป็นโมฆะ Fade()안에 입력되는 dir = FORWARD과 같음*/ Direction = dir; } /*FadeUpdate를 업데이트했을 경우*/ void FadeUpdate(){ /*변수 red값은 다음과 같음*/ uint8_t red = ((Red(Color1) * (TotalSteps - Index))) + (Red(Color2) * Index)) / TotalSteps; /*변수 green값은 다음과 같음*/ uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps; /*변수 blue값은 다음과 같음*/ uint8_t blue = ((สีน้ำเงิน(Color1) * (TotalSteps - ดัชนี)) + (สีน้ำเงิน(Color2) * ดัชนี)) / TotalSteps; /*위의 แดง เขียว น้ำเงิน 값으로 컬러를 셋팅함*/ ColorSet(สี(แดง เขียว น้ำเงิน)); /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

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

ถือเป็นโมฆะ alloff() { /*총 네오픽셀 갯수는 74개이며*/ int NPIXEL = 74; /*변수 i가 증가하며 모든 네오픽셀의 컬러 값을 0으로 변환함*/ สำหรับ (int i = 0; i < NPIXEL; i++) { setPixelColor(i, 0, 0, 0); } }

/*Twinkle의 컬러1와 시간을 입력*/

เป็นโมฆะ Twinkle (uint32_t color1, uint8_t interval) { /*실행되는 패턴은 TWINKLE*/ ActivePattern = TWINKLE; /*시간은 โมฆะ Twinkle()안에 입력되는 ช่วงเวลา과 같음*/ ช่วงเวลา = ช่วงเวลา; /*컬러 1를 설정*/ Color1 = สี1; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); ดัชนี = 0; }

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

ถือเป็นโมฆะ TwinkleUpdate(){ /*모든 네오픽셀의 컬러를 0으로 셋팅*/ setAll(0, 0, 0); /*변수 Pixel은 สุ่ม 74*/ int Pixel = สุ่ม (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(Pixel, 0, 0, 0); /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

/*Star의 컬러1 값을 입력*/

เป็นโมฆะ Star (uint32_t color1) { /*실행되는 패턴은 STAR*/ ActivePattern = STAR; /*시간은 เป็นโมฆะ Star()안에 입력되는 interval과 같음*/ Interval = Interval; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1을 설정*/ Color1 = สี1; ดัชนี = 0; }

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

เป็นโมฆะ StarUpdate(){ /*인덱스와 컬러를 셋팅*/ setPixelColor(ดัชนี, Color1); แสดง(); /*변수 i가 0이고 구동 갯수보다 작으면 i를 감소시킴 = 한칸씩 이동하는 애니메이션*/ สำหรับ (int i = 0; i < numPixels(); i--) { setPixelColor(i, Color(0, 0, 0)); } /*애니메이션을 보여주는 함수 */ Increment(); }

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

เป็นโมฆะ Rainbowsparkle (ช่วง uint8_t, dir ทิศทาง = FORWARD){ /*실행되는 패턴은 RAINBOWSPARKLE*/ ActivePattern = RAINBOWSPARKLE; /*시간은 เป็นโมฆะ Rainbowsparkle()안에 입력되는 ช่วงเวลา과 같음*/ ช่วงเวลา = ช่วงเวลา; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); ดัชนี = 0; /*방향은 โมฆะ Rainbowsparkle()안에 입력되는 ทิศทาง과 같음*/ Direction = dir; }

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

void RainbowsparkleUpdate(){ /*변수 i가 0이고 구동 갯수보다 작으면 i값을 증가하는데*/ สำหรับ (int i = 0; i < numPixels(); i++){ /*변수 i가 0이고 구동 갯수보다 작으면 i값을 증가하는데*/ if ((i + Index) % 2 == 0){ uint32_t c = random(255); setPixelColor(i, c); } อื่น ๆ { setPixelColor(i, สุ่ม (255)); } } /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); } /*Meteor의 시간과 방향을 입력*/ void Meteor(uint32_t color1){ /*실행되는 패턴은 METEOR*/ ActivePattern = METEOR; /*시간 설정*/ ช่วง = ช่วง; /*총 구동갯수는 numPixels갯수에서 1일뺀 후, *2를 한것과 같음*/ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 설정*/ Color1 = สี1; ดัชนี = 0; }

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

เป็นโมฆะ MeteorUpdate(){ สำหรับ (int i = 0; i < numPixels(); i++){ if (i == Index){ setPixelColor(i, 100, random(255), 255); } อื่น ๆ { setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

/*แสง 시간과 방향을 입력*/

โมฆะ Light (uint32_t color1) { /*실행되는 패턴은 LIGHT*/ ActivePattern = LIGHT; /*시간 설정*/ ช่วง = ช่วง; /*총 구동갯수는 numPixels갯수에서 1일뺀 후, *2를 한것과 같음*/ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 설정*/ Color1 = สี1; ดัชนี = 0; }

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

เป็นโมฆะ LightUpdate(){ สำหรับ (int i = 0; i < numPixels(); i++){ if (i == TotalSteps - Index){ setPixelColor(i, 150, random(200), 40); } อื่น ๆ { setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

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

โมฆะ Blossom (uint32_t color1) { /*실행되는 패턴은 BLOSSOM*/ ActivePattern = BLOSSOM; /*시간 설정*/ ช่วง = ช่วง; /*총 구동갯수는 numPixels갯수에서 1일뺀 후, *2를 한것과 같음*/ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 설정*/ Color1 = สี1; ดัชนี = 0; }

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

void BlossomUpdate(){ สำหรับ (int i = 0; i < numPixels(); i++){ if (i == TotalSteps - Index){ setPixelColor(i, 255, random(255), 100); } อื่น ๆ { setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 보여주는 함수 */ show(); เพิ่มขึ้น (); }

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

/*네오픽셀의 켜지는 위치와 지 지정해주는 함수 */ void setAll(byte red, byte green, byte blue) { for(int i = 0; i < numPixels(); i++) { setPixelColor(i, red, เขียว, น้ำเงิน); } แสดง(); }

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

uint32_t DimColor (uint32_t color) { // Shift R, G และ B ส่วนประกอบไปทางขวาหนึ่งบิต uint32_t dimColor = สี (แดง (สี) >> 1, เขียว (สี) >> 1, น้ำเงิน (สี) >> 1); ส่งคืน dimColor; }

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

เป็นโมฆะ ColorSet (สี uint32_t){ สำหรับ (int i = 0; i < numPixels (); i++) { setPixelColor (i, สี); } แสดง(); }

/*레드값을 불러옴*/

uint8_t สีแดง (สี uint32_t) { ผลตอบแทน (สี >> 16) & 0xFF; } /*그린값을 불러옴*/ uint8_t Green(uint32_t color){ return (color >> 8) & 0xFF; } /*블루값을 불러옴*/ uint8_t Blue (สี uint32_t) { สีกลับ & 0xFF; }

/*สายรุ้ง 컬러를 불러옴*/

uint32_t Wheel (ไบต์ WheelPos) { WheelPos = 255 - WheelPos; ถ้า (WheelPos <85){ return Color (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos < 170) { WheelPos -= 85; ส่งคืนสี(0, WheelPos * 3, 255 - WheelPos * 3); } อื่น ๆ { WheelPos -= 170; ส่งคืนสี (WheelPos * 3, 255 - WheelPos * 3, 0); } } };

/*สตริป을 불러오기위한 함수 / *사용하는 스트립별로 모두 지정해주어야함*/

เป็นโมฆะ strip1Complete(); เป็นโมฆะ strip2Complete(); เป็นโมฆะ strip3Complete(); เป็นโมฆะ strip4Complete(); เป็นโมฆะ strip5Complete();

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

#define NUMPIXELS 74 /*사용하는 버튼의 갯수 설정*/ #define B_NUM 5 /*Import strip1~5까지, 갯수는 74개 스트립 연결핀은 strip1은 8 ~ strip5까지12*/ NeoPatterns strip1(74, 8, NEO_GRB + NEO_KHZ800 &แถบ1เสร็จสมบูรณ์); 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 reading[B_NUM]; LastDebounceTime แบบยาวที่ไม่ได้ลงชื่อ[B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼핀을 읽는 시간간격은 ดีเลย์50과 같음*/ debounceDelay แบบยาวที่ไม่ได้ลงนาม Delay = 50;

การตั้งค่าเป็นโมฆะ (){

/*복잡하게 저항 연결이 필요없도록 인풋 풀업방식의 버튼설정: GND - 5V (เชื่อมต่อกับหมายเลขพิน)*/ สำหรับ (int i = 0; i < B_NUM; i++) { pinMode(buttonPin, INPUT_PULLUP); } Serial.begin(9600); /*스트립 1~5를 셋팅*/ strip1.begin(); strip2.begin(); แถบ3.begin(); strip4.begin(); แถบ 5.begin();

//strip1. TheaterChase(strip1. Color(255, 0, 255), strip1. Color(255, 50, 0), 20, ไปข้างหน้า);

}

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

ตัวนับ int = 5; void loop(){ /*버튼 수보다 i가 작으면 i를 증가시키고*/ สำหรับ (int i = 0; i debounceDelay) { if (reading != 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번핀에 연결된 활용하여 애니메이션이 구동되도록 하는 스위치 케이스 구문*/ สวิตช์ (buttonCounter[0]) {

/*첫번째 버튼을 활동시키면 구동되는 애니메이션*/

กรณี 0: strip1. ActivePattern = BLOSSOM; /*해당 애니메이션의 시간을 설정*/ strip1. Interval = 20; /*구동되는 네오픽셀의 갯수를 설정*/ strip1. TotalSteps = strip1.numPixels(); หยุดพัก; /*두번째 버튼을 활동시키면 구동되는 애니메이션*/ กรณีที่ 1: strip1. ActivePattern = RAINBOWSPARKLE; แถบ1.ช่วงเวลา = 50; strip1. TotalSteps = แถบ 1.numPixels (); หยุดพัก; /*세번째 버튼을 활동시키면 구동되는 애니메이션*/ กรณีที่ 2: strip1. ActivePattern = SCANNER; แถบ1.ช่วงเวลา = 10; strip1. TotalSteps = (แถบ 1.numPixels () - 1) * 2; หยุดพัก; /*네번째 버튼을 활동시키면 구동되는 애니메이션*/ กรณีที่ 3: strip1. ActivePattern = TWINKLE; แถบ1.ช่วงเวลา = 1; strip1. TotalSteps = แถบ 1.numPixels (); หยุดพัก; /*다섯번째 버튼을 활동시키면 구동되는 애니메이션*/ กรณีที่ 4: strip1. ActivePattern = METEOR; แถบ1.ช่วงเวลา = 10; strip1. TotalSteps = แถบ 1.numPixels (); หยุดพัก; } Serial.print (buttonCounter[0]); Serial.print(", "); Serial.println (buttonCounter [1]);

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

สวิตช์ (buttonCounter [1]) { กรณี 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 = (แถบ2.numPixels() - 1) * 2; หยุดพัก; กรณีที่ 3: strip2. ActivePattern = กระพริบตา; แถบ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//////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////

สวิตช์ (buttonCounter [2]) { กรณี 0: strip3. ActivePattern = STAR; แถบ3.ช่วงเวลา = 50; strip3. TotalSteps = แถบ 3.numPixels (); หยุดพัก; กรณีที่ 1: strip3. ActivePattern = RAINBOWSPARKLE; แถบ3.ช่วงเวลา = 100; strip3. TotalSteps = แถบ 3.numPixels (); หยุดพัก; กรณีที่ 2: strip3. ActivePattern = SCANNER; แถบ3.ช่วงเวลา = 20; strip3. TotalSteps = (แถบ 3.numPixels () - 1) * 2; หยุดพัก; กรณีที่ 3: strip3. ActivePattern = กระพริบตา; แถบ3.ช่วงเวลา = 5; strip3. TotalSteps = แถบ 3.numPixels (); หยุดพัก; กรณีที่ 4: strip3. ActivePattern = METEOR; แถบ3.ช่วงเวลา = 25; strip3. TotalSteps = แถบ 3.numPixels (); หยุดพัก; } Serial.print (buttonCounter[0]); Serial.print(", "); Serial.println (buttonCounter [1]);

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

สวิตช์ (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 = (แถบ 4.numPixels () - 1) * 2; หยุดพัก; กรณีที่ 3: strip4. ActivePattern = กระพริบตา; แถบ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//////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////

สวิตช์ (buttonCounter [4]) { กรณี 0: strip5. ActivePattern = STAR; แถบ 5.ช่วงเวลา = 50; strip5. TotalSteps = แถบ 5.numPixels (); หยุดพัก; กรณีที่ 1: strip5. ActivePattern = RAINBOWSPARKLE; แถบ 5.ช่วงเวลา = 100; strip5. TotalSteps = แถบ 5.numPixels (); หยุดพัก; กรณีที่ 2: strip5. ActivePattern = SCANNER; แถบ 5.ช่วงเวลา = 20; strip5. TotalSteps = (แถบ 5.numPixels () - 1) * 2; หยุดพัก; กรณีที่ 3: strip5. ActivePattern = กระพริบตา; แถบ 5.ช่วงเวลา = 5; strip5. TotalSteps = แถบ 5.numPixels (); หยุดพัก; กรณีที่ 4: strip5. ActivePattern = METEOR; แถบ 5.ช่วงเวลา = 25; strip5. TotalSteps = แถบ 5.numPixels (); หยุดพัก; } Serial.print(buttonCounter[0]); Serial.print(", "); Serial.println (buttonCounter [1]); }

// strip1 เสร็จสิ้นการโทรกลับ

โมฆะ strip1Complete () { strip1. Color1 = strip1. Wheel (สุ่ม (255)); แถบ1.สี2 = แถบ1.ล้อ(สุ่ม(255)); แถบ1.ดัชนี = 0; }

// strip2 เสร็จสิ้นการโทรกลับ

เป็นโมฆะ strip2Complete () { strip2. Color1 = strip2. Wheel (สุ่ม (255)); แถบ2.สี2 = แถบ2.ล้อ(สุ่ม(255)); แถบ2.ดัชนี = 0; }

// แถบ 3 การโทรกลับเสร็จสมบูรณ์

เป็นโมฆะ strip3Complete () { strip3. Color1 = strip3. Wheel (สุ่ม (255)); แถบ3.สี2 = แถบ3.ล้อ(สุ่ม(255)); แถบ3.ดัชนี = 0; }

// strip4 เสร็จสิ้นการโทรกลับ

เป็นโมฆะ strip4Complete () { strip4. Color1 = strip4. Wheel (สุ่ม (255)); strip4. Color2 = strip4. Wheel(สุ่ม(255)); แถบ4.ดัชนี = 0; }

// strip5 การโทรกลับเสร็จสมบูรณ์

โมฆะ strip5Complete () { strip5. Color1 = strip5. Wheel (สุ่ม (255)); strip5. Color2 = strip5. Wheel(สุ่ม(255)); แถบ 5.ดัชนี = 0; }

ขั้นตอนที่ 6: ผลลัพธ์และการสร้างภาพยนตร์

ขอบคุณที่ให้ความสนใจในโครงการของเราแม้ว่าจะยังไม่เพียงพอ