გაიყვანეთ სინათლე - სინათლის მოდული ნეოპიქსელის გამოყენებით და გადაათრიეთ გადამრთველი: 6 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

სინათლის მოდულის მახასიათებლები

• არდუინო უნო
• ტექნიკა და დანართი შეძენილი ინტერნეტიდან
• ნეოპიქსელი და ელექტრომომარაგება ნასესხებია ინფორმატიკის სკოლისა და პროდუქტის დიზაინისგან
• სინათლის მოდული აკონტროლებს კვების ბლოკს
• ყველა ფუნქცია კონტროლდება მომხმარებლის ურთიერთქმედების საშუალებით
• ნეოპიქსელის ზოლის ანიმაციური ტიპები: წვიმის ტიპი, საშხაპე ტიპი, ნაპერწკალი ელვისებური ტიპი, პოპ ტიპი, არარეგულარული ტიპი
• გაყვანის გადამრთველი უკავშირდება ნეოპიქსელის ზოლს და ანიმაცია იცვლება ნეოპიქსელის ზოლის გაყვანისას

ნაბიჯი 1: სანამ დავიწყებთ

გამარჯობა ინსტრუქტორებო და შემქმნელებო.

ჩვენ დავიწყეთ და ინტერაქტიული დიზაინის პროექტი იმის მიხედვით, თუ რა მოხდებოდა, თუკი ჩვენ ვიგრძნობთ წვიმის ემოციას სინათლის ანიმაციის საშუალებით. ვიფიქრე, რომ მომხმარებლის მგრძნობელობა მაქსიმალურად იქნებოდა გაზრდილი ინტერფეისის საშუალებით, რომელიც პირდაპირ შუქს იზიდავს.

რომ დავიწყო მუშაობა

ნაბიჯი 2: საჭირო ნაწილები

ერთი სინათლის მოდულის საფუძველზე

*** ნეოპიქსელები და ელექტრომომარაგება გამოიყენეს ჩვენი განყოფილების მხარდაჭერით. ***

ელექტრონიკა:

1. არდუინო უნო
2. 3 ფერის მავთული (შავი, წითელი, ნებისმიერი ფერი)
3. 3 პინიანი კონექტორი (ყიდვის ბმული)
4. გაიყვანეთ გადამრთველი 1 (ყიდვა ბმულით)
5. შემცირებადი მილი
6. WS2812b დამატებითი LED ზოლები 74 LED (ნეოპიქსელის ზოლები)*2
7. კვების ბლოკი (5V 350A) 1

*** 50 კომპლექტი საჭიროა Arduino– სთვის, Pull Switch– ისთვის და NeoPixels– ისთვის. ***

აპარატურა:

1. აკრილის ბარი 2 ტ (10 მმ*1000 მმ) 1
2. აკრილის დაფა 5 ტ (60 მმ*60 მმ) 1
3. Foemax 10t (1200 მმ*1800 მმ) 1
4. შავი სპრეი
5. საკაბელო ჰალსტუხი
6. სიმებიანი
7. მყარი დაფა
8. ბადის დაფა

ნაბიჯი 3: დაკავშირება და აპარატურის შექმნა

პირველი, ჩვენ გვჭირდება აკრილის ჭრა ერთი განათების მოდულის შესაქმნელად.

• როგორც სინათლის ანიმაციის განცდის საშუალება, შეიმუშავეთ განათების მოდული, რომელიც დაფიქსირებულია 74 LED- ის მიმაგრებით ნეოპიქსელური ზოლის სახით 2 მმ სისქის აკრილის ზოლზე 1 მ ფართობით. ჩვენ შევქმენით ორი სახის განათების მოდული: ტიპიური ხაზოვანი და სპირალი.
• ხაზოვანი ტიპებისთვის, არსებული ნეოპიქსელის ზოლები შეიძლება იყოს დაცული და დაცული, მაგრამ სპირალური ტიპები მოითხოვს ხელით მუშაობას. თითოეული 74 LED გაყოფილია ნაწილებად, მიმაგრებულია სპირალურ აკრილზე და შეკრულია ტყვიასთან.

მიამაგრეთ ნეოპიქსელის ზოლები აკრილზე და მიამაგრეთ თითოეული ზოლი, რათა თავიდან აიცილოთ მისი გავრცელება სითბოთი, ან შეაკავშირეთ თხელი სათევზაო ხაზით. წრფივი ტიპის შემთხვევაში, სფეროს მოდულის ბოლოში გაყვანა საჭირო იყო ესთეტიკური იერსახის შესაქმნელად და პინგ -პონგის ბურთი შავი სპრეით დავამთავრეთ. შემდეგ მათ პატარა ხვრელი გახვრიტეს პინგ -პონგის ბურთში და თოკით დაუკავშირეს. შემდეგი ყველაზე მნიშვნელოვანი ნაწილი, გადამრთველი და ნეოპიქსელი, დაკავშირებულია ისე, როგორც ნაჩვენებია. შემდეგ გადამრთველი მიმაგრებულია ჭერის თაროზე.

სპირალური ტიპის შემთხვევაში, არსებობს რისკი, რომ სპირალურ მოდულის პირდაპირ დაჭიმვას შეუძლია აკრილის ზეწოლის ქვეშ დაარღვიოს, ამიტომ გამყოფი მონაკვეთი (შემავალი) და მოდული (გამომავალი) გამოყოფილია. შუქის მაქსიმალურად გაზრდის მიზნით, მოდულები დამონტაჟდა ვერტიკალურად ჭერზე, ხაზოვანი მოდულები დაფიქსირდა ჰაერში, სპირალები დაფიქსირდა უშუალოდ ჭერზე. ჩვენ დავუკავშირეთ პინგ -პონგის ბურთი და გადართვა თევზჭერის ხაზზე, რათა მისი მოქმედება შესაძლებელი იყოს.

აკრილის ჭრა, როგორც ნაჩვენებია ზემოთ ნახატზე, საჭიროა თაროზე გადასვლის უზრუნველსაყოფად. 6 სმ კვადრატული ფორმის ჩამრთველი არის დაახლოებით 5 მმ სისქის, გადამრთველი არის ორიენტირებული და საკაბელო ჰალსტუხი ორივე მხარეს ხვრელებშია ჩასმული, რომ გადამრთველი მყარად იყოს უზრუნველყოფილი. ცენტრის ქვედა ნაწილში მრგვალი ხვრელი ასახავს გადამრთველის მიზიდვას, რომლის ქვემოთაც სამი მავთულის კაბელი ამოღებულია და უკავშირდება მოდულის საკაბელო ტერმინალს. და ანალოგიურად, ოთხ კუთხეში არსებული ხვრელის მეშვეობით, თარო და აკრილი უზრუნველყოფილია საკაბელო კავშირებით. როგორც ზემოთ აღვნიშნეთ, ხაზოვანი მოდული უშუალოდ არის მიბმული, მაგრამ სპირალური მოდული აკავშირებს პინსა და გადამრთველს ცალკე.

ნაბიჯი 4: შექმენით 50 სინათლის მოდულის გამოყენებით

ჩვენ შევქმენით მომხმარებლის გამოცდილება უფრო მდიდარი შუქისთვის, სულ 50 მოდულის განლაგებით

ჩვენ გვქონდა 1, 800 მმ სიგანისა და 1, 200 მმ სიგრძის თარო, და ჩვენ დავუკავშირეთ თითოეული გადამრთველი და მოდული ისე, რომ თქვენ განიცადოთ წვიმისა და წვიმის გარემო, რომელიც თავიდან გვქონდა დაგეგმილი, და თითოეული მოდული ცალკე გვქონდა, რათა შესაძლებელი ყოფილიყო მრავალმხრივი ამოცანის შესრულება რა

დიზაინის ნახაზის მიხედვით, მრგვალი ხვრელი გაბურღული იქნა ფუმფულაში, რათა დაემალა ინსტალაცია და დარწმუნებულიყო, რომ LED მოდულის დაკავშირებული ტერიტორია არ ჩანს. ვინაიდან აკრილის დაფაზე მანძილი LED მოდულის შეერთებამდე, სადაც გადამრთველია მიმაგრებული, დაახლოებით 1 სმ -ია, გამოყენებულია 1 სმ სისქის ფომაქსი.

ლითონის კვადრატული ჩარჩო გამოიყენებოდა ინსტალაციისთვის ხრახნებთან და საკაბელო კავშირებთან ერთად, საერთო წონის და ბალანსის შენარჩუნებისას. თუ გამჟღავნებული კავშირების სიგრძე იმაზე მეტია, ვიდრე მწარმოებელი ცდილობს, სქელი დაფა არაეფექტურია და რეკომენდებულია სხვა სტრუქტურები.

თვალის დონეზე მომხმარებლის გამოცდილების გასაადვილებლად, დასრულებული ინსტალაცია მოთავსებულია დაახლოებით 2 მ სიმაღლის საყრდენზე, მაგრამ სიფრთხილეა, რომ ჩამონტაჟებული LED მოდულის გადამრთველთან დაყენება ძალიან რთულია. ამიტომ ყველა კავშირი უნდა მოიხსნას. ჩვენ ავდივართ კიბეზე და ვუერთდებით მოდულს საყრდენზე დაფიქსირებული ინსტალაციით.

მთელი ამ პროცესის უმნიშვნელოვანესი ნაწილია იმის უზრუნველყოფა, რომ სამუშაოები შესრულებულია უსაფრთხოდ და სრულად უზრუნველყოფილია იმის უზრუნველსაყოფად, რომ გამოცდილება შესაძლებელი გახდება უსაფრთხო გარემოში

სულ 10 arduino და 50 LED მოდული იქნა გამოყენებული და ხუთი LED მოდული იყო დაკავშირებული arduino– ს უფრო ეფექტური და შეუფერხებელი მრავალ დავალებისთვის. დეტალებისთვის იხილეთ თანდართული გეგმა. ნეოპიქსელის მრავალფუნქციური კოდირება სრული გადამრთველის გამოყენებით დიზაინის დიაგრამის მიხედვით დეტალურად იქნება განხილული შემდეგ ეტაპზე.

ნაბიჯი 5: Arduino კოდირება და გაყვანილობა

გაყვანილობა

• მე –4 ნაბიჯის განლაგების მიხედვით 50 მოდული იყო დაკავშირებული.
• თითოეული მოდული იყოფა 10 მოდულისგან 50 მოდულისგან, რაც საშუალებას მისცემდა მრავალ ამოცანას და უზრუნველყო მკაფიო კავშირი.
• როგორც ზემოთ ნაჩვენებია 1 სურათზე, ხუთი მოდული იყო დაკავშირებული ერთ არდუინოსთან, ხოლო ნეოპიქსელის 5 ვ ქინძისთავები ერთდროულად იყო მიბმული ერთმანეთთან კვების ბლოკის დასაკავშირებლად.
• ნეოპიქსელებისა და კონცენტრატორების GND ასევე ერთმანეთთან იყო მიბმული და, აღქმის სიმარტივისთვის, გადამრთველები ჩაერთო ქინძისთავებში 2, 3, 4, 5, 6 და ნეოპიქსელები შეაერთეს ქინძისთავებში 9, 10, 11, 12, 13 რა
• კონცენტრატორები და ნეოპიქსელები, შესაბამისად, 2-9, 3-10, 4-11, 5-12, 6-13 გზით იყო დაკავშირებული.
• უნდა აღინიშნოს, რომ ვინაიდან ხაზების კავშირები კომპლექსურია და ხანმოკლე საფრთხეა მოკლე ჩართვის გამო, შემცირებული მილი გაცხელდა იმის უზრუნველსაყოფად, რომ სუსტი ნაწილები არ გატეხილიყო.

ნეოპიქსელის მრავალფუნქციური კოდირება გაყვანის გადამრთველით

5 მსუბუქი ანიმაცია (წვიმის ტიპი, საშხაპე ტიპი, ნაპერწკალი ელვისებური ტიპი, პოპ ტიპი, არარეგულარული ტიპი)

#ჩართეთ

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

enum pattern {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 을 설정 함*/ enum მიმართულება {წინ, უკან}};

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

კლასი NeoPatterns: public Adafruit_NeoPixel { /* 패턴 을 추가 추가 업데이트 / /* / public: pattern ActivePattern; /*클레스 함수 에 패턴 방향 방향 입력/*/ მიმართულება მიმართულება;

/*변수 ინტერვალი 을 추가*/ ხელმოუწერელი გრძელი ინტერვალი; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 ფერი 1, ფერი 2 추가*/ uint32_t ფერი 1, ფერი 2; /*변수 TotalSteps 추가*/ uint16_t TotalSteps; /*변수 ინდექსი 를 추가*/ uint16_t ინდექსი;

/*패턴 을 완료 했을 시 다시 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 픽샐 갯수 핀, 번호 번호, 타입, 콜백 함수/*/ NeoPatterns (uint16_t პიქსელი, uint8_t pin, uint8_t ტიპი, void (*callback) ()): Adafruit_NeoPixel (pixels, pin, type) { დასრულებულია = გამოძახება; }

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

ბათილი განახლება () { /*의 시간 설정. If 태스킹 을 하는 구문*/ if ((millis () - lastUpdate)> ინტერვალი) {lastUpdate = millis (); /*ActivePattern 스위치 구문*/ switch (ActivePattern) {/*case RAINBOW_CYCLE 에서는 RainbowCycleUpdate 를 실행 하라*/ case RAINBOW_CYCLE: RainbowCycleUpdate (); /*საქმე RAINBOW_CYCLE 나와라*/ შესვენება;

/*საქმე THEATER_CHASE 에서는 TheaterChaseUpdate 실행 하라*/

საქმე 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 에서는 Rainbowsparkle განახლება 실행 하라*/

საქმე RAINBOWSPARKLE: RainbowsparkleUpdate (); /*საქმე RAINBOWSPARKLE 나와라*/ შესვენება; /*case METEOR 에서는 MeteorUpdate 를 실행 하라*/ case METEOR: MeteorUpdate (); /*საქმე METEOR 나와라*/ შესვენება;

/*საქმე LIGHT 에서는 LightUpdate 를 실행 하라*/

საქმე LIGHT: LightUpdate (); /*საქმე LIGHT 나와라*/ შესვენება;

/*საქმე BLOSSOM 에서는 BlossomUpdate 를 실행 하라*/

საქმე BLOSSOM: BlossomUpdate (); /*საქმე BLOSSOM 나와라*/ შესვენება; }}}

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

/*ინდექსი 를 증가 시키고 초기화 하는 함수*/

ბათილად გაზრდა () { /*만약 정방향 이면 인덱스 증가 시켜라* / თუ (მიმართულება == წინ) {ინდექსი ++; /*만약 인덱스 전체 if 면 면 면 면 if if//*/ if (ინდექსი> = სულ ნაბიჯები) {ინდექსი = 0; /*패턴 을 완료 함수/*/ if (OnComplete! = NULL) {OnComplete (); }}}

/*만약 정방향 이 else else else else*/ else { -ინდექსი; /*만약 인덱스 네오 네오 if if if if/// 을//*/ if (ინდექსი <= 0) {ინდექსი = სულ ნაბიჯები - 1; /*패턴 을 완료 함수/*/ თუ (დასრულებულია! = NULL) {დასრულებულია (); }}}}

/*반대 방향 으로 하는 하는 함수*/

void უკუ () { /*애니메이션 함수 에 უკუ 썼을 시, 방향 이 이면 /* / if (Direction == FORWARD) { /*방향 은 그 와 반대 이며 전체 구동 갯수 / 1 / 빼라 /* / მიმართულება = საპირისპირო; ინდექსი = სულ ნაბიჯები - 1; } /*그 방향 이 else 를 으로 0 으로 해라 해라* / else {Direction = FORWARD; ინდექსი = 0; }}

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

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

void RainbowCycle (uint8_t ინტერვალი, მიმართულება dir = FORWARD) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 void RainbowCycle () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*총 구동 갯수 5 255 임*/ სულ ნაბიჯები = 255; /*인덱스 는 0 으로 설정 함*/ ინდექსი = 0; /*방향 은 void RainbowCycle () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

void RainbowCycleUpdate () { /*변수 i 가 네오 픽셀 개수 /를 를 를 시켜라 /* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 증가 과 동시에 GB RGB 의 / 로 작동 해라 / * / setPixelColor (i, Wheel (((i * 256 / numPixels ()) + ინდექსი) & 255)); } / *애니메이션 을 보여주는 함수 * / შოუ (); გაზრდა (); }

/*TheaterChase 컬러 와 시간 방향 입력 입력/*/

void TheaterChase (uint32_t ფერი 1, uint32_t ფერი 2, uint8_t ინტერვალი, მიმართულება dir = წინ) { /*실행 되는 패턴 TH RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 void TheaterChase () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*총 구동 갯수 는 numPixels 임 임*/ TotalSteps = numPixels (); /*컬러 1, 2 설정*/ ფერი 1 = ფერი 1; ფერი 2 = ფერი 2; /*인덱스 는 0 으로 설정 함*/ ინდექსი = 0; /*방향 은 void TheaterChase () 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

void TheaterChaseUpdate () { /*변수 i 가 네오 개수 for for for 를 /시켜라* /for (int i = 0; i <numPixels (); i ++) { /*만약 변수 에 인덱스 으로 3 으로 것이 0 과 같다 면 i 를 ფერი 변환 변환 시켜라*/ თუ ((i + ინდექსი) % 3 == 0) {setPixelColor (i, ფერი 1); } /*그렇지 않다면 i 를 ფერი 로 변환 시켜라* / else {setPixelColor (i, ფერი 2); }} / *애니메이션 을 보여주는 함수 * / შოუ (); გაზრდა (); }

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

void ColorWipe (uint32_t ფერი, uint8_t ინტერვალი, მიმართულება dir = FORWARD) { /*실행 되는 패턴 L COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 oid void ColorWipe () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*총 구동 갯수 는 numPixels 임 임*/ TotalSteps = numPixels (); /*컬러 1 설정*/ ფერი 1 = ფერი; /*인덱스 는 0 으로 설정 함*/ ინდექსი = 0; /*방향 oid void ColorWipe () 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

void ColorWipeUpdate () { /*ინდექსი 를 컬러 1 로 변환 시켜라* / setPixelColor (ინდექსი, ფერი 1); / *애니메이션 을 보여주는 함수 */ შოუ (); გაზრდა (); }

/*სკანერი 입력 컬러 와 시간 을 입력*/

ბათილი სკანერი (uint32_t ფერი 1, uint8_t ინტერვალი) { /*실행 되는 패턴 AN სკანერი* / ActivePattern = სკანერი; /*시간 oid ბათილი სკანერი () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*구동 갯수 는 총 갯수 을 1 빼고 빼고 2 를 곱 해라*/ TotalSteps = (numPixels () - 1)*2; /*컬러 1 설정*/ ფერი 1 = ფერი 1; /*인덱스 는 0 으로 설정 함*/ ინდექსი = 0; }

/*სკანერი განახლება 를 업데이트 했을 경우*/

void ScannerUpdate () { /*변수 i 는 영 총 갯수 갯수 for 를 를 시켜라 시켜라* /for (int i = 0; i <numPixels (); i ++) { /*만약 변수 i 가 인덱스 면 면 i 를 ფერი 1 로 변환 시켜라*/ if (i == ინდექსი) {setPixelColor (i, ფერი 1); } / *그렇지 않다면 변수 i 를 전체 갯수 에서 를 뺀값 뺀값 같다 else / * / else if (i == TotalSteps - Index) {setPixelColor (i, ფერი 1); } / *그 밖에는 i 를 디밍 시켜라 의 만큼 만큼 * / else {setPixelColor (i, DimColor (getPixelColor (i)))); }} / *애니메이션 을 보여주는 함수 * / შოუ (); გაზრდა (); }

/*სკანერი 컬러 컬러 1, 2 와 스텝, 시간, 방향 을 입력*/

void Fade (uint32_t color1, uint32_t color2, uint16_t საფეხურები, uint8_t ინტერვალი, მიმართულება dir = FORWARD) { /*실행 되는 패턴 AD FADE* / ActivePattern = FADE; /*시간 은 void Fade () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*구동 갯수 는 값임/*/ სულ ნაბიჯები = ნაბიჯები; /*컬러 1, 2 설정*/ ფერი 1 = ფერი 1; ფერი 2 = ფერი 2; /*인덱스 는 0 으로 설정 함*/ ინდექსი = 0; /*방향 은 void Fade () 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 წითელი 값 은 다음 같음 같음* / uint8_t წითელი = ((წითელი (ფერი 1)*(სულ ნაბიჯები - ინდექსი)) + (წითელი (ფერი 2)*ინდექსი)) / TotalSteps; / * 변수 მწვანე 값 은 다음 과 같음 * / uint8_t მწვანე = ((მწვანე (ფერი 1) * (TotalSteps - ინდექსი)) + (მწვანე (ფერი 2) * ინდექსი)) / TotalSteps; / * 변수 ლურჯი 값 은 다음 과 같음 * / uint8_t ლურჯი = ((ლურჯი (ფერი 1) * (სულ ნაბიჯები - ინდექსი)) + (ლურჯი (ფერი 2) * ინდექსი)) / TotalSteps; /*위 의 წითელი, მწვანე, ლურჯი/ 으로 컬러 셋팅 함 함*/ ColorSet (ფერი (წითელი, მწვანე, ლურჯი)); / *애니메이션 을 보여주는 함수 */ შოუ (); გაზრდა (); }

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

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

/*მოციმციმე 컬러 컬러 1 와 시간 을 입력*/

void Twinkle (uint32_t ფერი 1, uint8_t ინტერვალი) { /*실행 되는 패턴 IN TWINKLE* / ActivePattern = TWINKLE; /*시간 oid void Twinkle () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*컬러 1 설정*/ ფერი 1 = ფერი 1; /*총 구동 갯수 는 numPixels 임 임*/ TotalSteps = numPixels (); ინდექსი = 0; }

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

void TwinkleUpdate () { /*모든 네오 픽셀 의 컬러 를 0 으로 셋팅* / setAll (0, 0, 0); /*변수 პიქსელი 은 შემთხვევითი 74*/ int პიქსელი = შემთხვევითი (74); /*შემთხვევითი 74 개 에서 2 로나 눈 수 를 하게 켜라/*/setPixelColor (პიქსელი/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); / *애니메이션 을 보여주는 함수 */ შოუ (); / *랜덤 하게 함수 함수 */ setPixelColor (პიქსელი, 0, 0, 0); / *애니메이션 을 보여주는 함수 */ შოუ (); გაზრდა (); }

/*ვარსკვლავი 컬러 컬러 1 값 을 입력*/

ბათილი ვარსკვლავი (uint32_t ფერი 1) { /*실행 되는 패턴 AR STAR* / ActivePattern = STAR; /*시간 은 void ვარსკვლავი () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*총 구동 갯수 는 numPixels 임 임*/ TotalSteps = numPixels (); /*컬러 1 설정*/ ფერი 1 = ფერი 1; ინდექსი = 0; }

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

void StarUpdate () { /*인덱스 와 컬러 셋팅 셋팅* / setPixelColor (ინდექსი, ფერი 1); ჩვენება (); /*변수 i 가 0 이고 구동 갯수 작 으면 를 를 시킴 시킴 = 한칸 씩 하는 애니메이션*/ for (int i = 0; i <numPixels (); i--) {setPixelColor (i, ფერი (0, 0, 0)); } / *애니메이션 을 보여주는 함수 * / გაზრდა (); }

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

void Rainbowsparkle (uint8_t ინტერვალი, მიმართულება dir = FORWARD) { /*실행 되는 패턴 IN RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 void Rainbowsparkle () 입력 되는 ინტერვალი 과 같음*/ ინტერვალი = ინტერვალი; /*총 구동 갯수 는 numPixels 임 임*/ TotalSteps = numPixels (); ინდექსი = 0; /*방향 은 void Rainbowsparkle () 안에 입력 되는 მიმართულება 과 같음*/ მიმართულება = რეჟ; }

/*Rainbowsparkle განახლება 를 업데이트 했을 경우*/

void RainbowsparkleUpdate () { /*변수 i 가 0 이고 구동 갯수 보다 으면 값 값 을 증가 하는데* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 0 이고 구동 갯수 If 으면 i 값 증가 하는데 하는데*/ if ((i + ინდექსი) % 2 == 0) {uint32_t c = შემთხვევითი (255); setPixelColor (i, c); } else {setPixelColor (i, შემთხვევითი (255)); }} / *애니메이션 을 보여주는 함수 * / შოუ (); გაზრდა (); } /*მეტეორი 의 시간 과 방향 을 입력* / void მეტეორი (uint32_t ფერი 1) { /*실행 되는 패턴 ET METEOR* / ActivePattern = METEOR; /*시간 설정*/ ინტერვალი = ინტერვალი; / *총 구동 갯수 는 numPixels 갯수 에서 1 후 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 설정*/ ფერი 1 = ფერი 1; ინდექსი = 0; }

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

void MeteorUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == ინდექსი) {setPixelColor (i, 100, შემთხვევითი (255), 255); } else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / შოუ (); გაზრდა (); }

/*მსუბუქი 의 시간 과 방향 을 입력/*/

void Light (uint32_t ფერი 1) { /*실행 되는 패턴 IGH LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ ინტერვალი = ინტერვალი; / *총 구동 갯수 는 numPixels 갯수 에서 1 후 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 설정*/ ფერი 1 = ფერი 1; ინდექსი = 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))); }} / *애니메이션 을 보여주는 함수 * / შოუ (); გაზრდა (); }

/*აყვავება/시간 과 방향 을 입력/*/

void Blossom (uint32_t ფერი 1) { /*실행 되는 패턴 OS BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ ინტერვალი = ინტერვალი; / *총 구동 갯수 는 numPixels 갯수 에서 1 후 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 설정*/ ფერი 1 = ფერი 1; ინდექსი = 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))); }} / *애니메이션 을 보여주는 함수 * / შოუ (); გაზრდა (); }

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

/ *ბათილი მითითებული ყველა/ ბათი წითელი, მწვანე, ლურჯი); } ჩვენება (); }

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

uint32_t DimColor (uint32_t ფერი) {// Shift R, G და B კომპონენტები ერთი ბიტი მარჯვნივ uint32_t dimColor = ფერი (წითელი (ფერი) >> 1, მწვანე (ფერი) >> 1, ლურჯი (ფერი) >> 1); დაბრუნება dimColor; }

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

void ColorSet (uint32_t ფერი) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, ფერი); } ჩვენება (); }

/*레드 값 을 불러 옴*/

uint8_t წითელი (uint32_t ფერი) {დაბრუნება (ფერი >> 16) & 0xFF; } /*그린 값 을 옴 /* / uint8_t მწვანე (uint32_t ფერი) {დაბრუნება (ფერი >> 8) & 0xFF; } /*블루 값 을 옴 /* / uint8_t ლურჯი (uint32_t ფერი) {დაბრუნების ფერი & 0xFF; }

/*ცისარტყელა 를 불러 옴*/

uint32_t ბორბალი (ბაიტი WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {დაბრუნების ფერი (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); }}};

/*ზოლები 을 불러 오기 함수* /*사용 하는 스트립 별로 모두 지정 / /* /

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

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

#განსაზღვრეთ NUMPIXELS 74 /*사용 하는 버튼 갯수 설정 설정* / #განსაზღვრეთ B_NUM 5 /*ზოლის იმპორტი 1 ~ 5 까지, 갯수 는 74 개 스트립 연결 은 p ზოლები 1 은 8 ზოლები 5 까지 12* / NeoPatterns strip1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); NeoPatterns ზოლები 2 (74, 9, NEO_GRB + NEO_KHZ800, & strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800, & strip3Complete); NeoPatterns ზოლები 4 (74, 11, NEO_GRB + NEO_KHZ800, & strip4Complete); NeoPatterns ზოლები 5 (74, 12, NEO_GRB + NEO_KHZ800, & strip5Complete); /*배열 을 사용한 버튼 핀 const/*/ const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; /*배열 을 사용 버튼 상태///*/ int ღილაკი სახელმწიფო [B_NUM]; /*2 부터 6 번핀 까지 상태 는 OW OW 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]; ხელმოუწერელი longDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 은 დაგვიანება 50 같음 같음*/ ხელმოუწერელი ხანგრძლივი დებიუანსიგვიანება = 50;

void setup () {

/*복잡 하게 이 이 방식 의 G G: GND - 5V (დაკავშირება პინის ნომერზე)*/ for (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Serial.begin (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1. დაიწყოს (); strip2.begin (); strip3.begin (); strip4.bigin (); strip5.bigin ();

//strip1. TaterChase(strip1. Color(255, 0, 255), strip1. Color (255, 50, 0), 20, FORWARD);

}

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

int counter = 5; void loop () { /*버튼 수 보다 i 가 으면 를 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (კითხულობს ! = buttonState ) {buttonState = კითხვა ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 მაქს 값 5 를 넘으면 0 으로 시켜라 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = კითხვა ; } /*모든 스트립 을 함.* / Strip1. Update (); ზოლები 2. განახლება (); strip3. განახლება (); ზოლები 4. განახლება (); ზოლები 5. განახლება ();

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

/*버튼 배열 의 0 번째. 2 번핀 에 을 하여 하여 되도록 하는 하는 하는 스위치//////*/ გადართვა (buttonCounter [0]) {

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

საქმე 0: strip1. ActivePattern = BLOSSOM; /*해당 애니메이션 의 을 설정/*/ ზოლები 1. ინტერვალი = 20; /*구동 되는 의 갯수 설정/*/ strip1. TotalSteps = strip1.numPixels (); შესვენება; /*두번째 버튼 을 활동 case//*/ საქმე 1: strip1. ActivePattern = RAINBOWSPARKLE; ზოლები 1. ინტერვალი = 50; strip1. TotalSteps = strip1.numPixels (); შესვენება; /*세번째 버튼 을 활동 구동/ case*/ საქმე 2: strip1. ActivePattern = სკანერი; ზოლები 1. ინტერვალი = 10; strip1. TotalSteps = (strip1.numPixels () - 1) * 2; შესვენება; /*네번째 버튼 을 활동 case//*/ საქმე 3: strip1. ActivePattern = TWINKLE; ზოლები 1. ინტერვალი = 1; strip1. TotalSteps = strip1.numPixels (); შესვენება; /*다섯 번째 버튼 활동 case case//*/ შემთხვევა 4: strip1. ActivePattern = METEOR; ზოლები 1. ინტერვალი = 10; strip1. TotalSteps = strip1.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 = სკანერი; ზოლები 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 ////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// /////////////////////////////////////////

გადართვა (buttonCounter [2]) {შემთხვევა 0: strip3. ActivePattern = STAR; strip3. Interval = 50; strip3. TotalSteps = strip3.numPixels (); შესვენება; საქმე 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); შესვენება; საქმე 2: strip3. ActivePattern = სკანერი; strip3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; შესვენება; საქმე 3: strip3. ActivePattern = TWINKLE; strip3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); შესვენება; შემთხვევა 4: strip3. ActivePattern = METEOR; strip3. Interval = 25; strip3. TotalSteps = strip3.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 = სკანერი; ზოლები 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 ////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// /////////////////////////////////////////

გადართვა (buttonCounter [4]) {შემთხვევა 0: strip5. ActivePattern = STAR; ზოლები 5. ინტერვალი = 50; strip5. TotalSteps = strip5.numPixels (); შესვენება; საქმე 1: strip5. ActivePattern = RAINBOWSPARKLE; ზოლები 5. ინტერვალი = 100; strip5. TotalSteps = strip5.numPixels (); შესვენება; საქმე 2: strip5. ActivePattern = სკანერი; ზოლები 5. ინტერვალი = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; შესვენება; საქმე 3: strip5. ActivePattern = TWINKLE; ზოლები 5. ინტერვალი = 5; strip5. TotalSteps = strip5.numPixels (); შესვენება; საქმე 4: strip5. 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)); ზოლები 1. ფერი 2 = ზოლები 1. ბორბალი (შემთხვევითი (255)); ზოლები 1. ინდექსი = 0; }

// strip2 დასრულების გამოძახება

void strip2Complete () {strip2. Color1 = strip2. Wheel (შემთხვევითი (255)); ზოლები 2. ფერი 2 = ზოლები 2. ბორბალი (შემთხვევითი (255)); ზოლები 2. ინდექსი = 0; }

// strip3 დასრულების Callback

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)); ზოლები 4. ინდექსი = 0; }

// strip5 დასრულების გამოძახება

void strip5Complete () {strip5. Color1 = strip5. Wheel (random (255)); ზოლები 5. ფერი 2 = ზოლები 5. ბორბალი (შემთხვევითი (255)); ზოლები 5. ინდექსი = 0; }

ნაბიჯი 6: შედეგი და ფილმის გადაღება

გმადლობთ, რომ დაინტერესდით ჩვენი პროექტით, თუმცა ეს საკმარისი არ არის.