Inhoudsopgave:

Pull the Light - Light Module met Neopixel & Pull Up Switch - Ajarnpa
Pull the Light - Light Module met Neopixel & Pull Up Switch - Ajarnpa

Video: Pull the Light - Light Module met Neopixel & Pull Up Switch - Ajarnpa

Video: Pull the Light - Light Module met Neopixel & Pull Up Switch - Ajarnpa
Video: Neopixel strip module with pull up switch 2024, Juli-
Anonim
Image
Image
Pull the Light - Light Module met Neopixel & Pull Up Switch
Pull the Light - Light Module met Neopixel & Pull Up Switch

Kenmerken van de Lichtmodule

  • Arduino Uno
  • Hardware & behuizing gekocht via internet
  • Neopixel & voeding geleend van School of Informatics & Product Design
  • Lichtmodule aangestuurd door voeding
  • Alle functies bestuurd via gebruikersinteractie
  • Animatietypes van Neopixel-strip: Regentype, Douchetype, Vonkenbliksemtype, Poptype, Onregelmatig type
  • De pull-up-schakelaar is verbonden met de Neopixel-strip en de animatie verandert wanneer de Neopixel-strip wordt getrokken

Stap 1: Voordat we beginnen

Voordat we beginnen
Voordat we beginnen

Hallo Instructables en makers.

We begonnen een interactief ontwerpproject in termen van wat er zou gebeuren als we de emotie van regen zouden kunnen voelen door middel van animatie van licht. Ik dacht dat de gevoeligheid van de gebruiker zou worden gemaximaliseerd door een interface die direct licht trekt.

Laten we aan het werk gaan

Stap 2: benodigde onderdelen

Onderdelen nodig
Onderdelen nodig
Onderdelen nodig
Onderdelen nodig
Onderdelen nodig
Onderdelen nodig

Gebaseerd op één lichtmodule

***Neopixels en voeding werden gebruikt met de steun van onze afdeling.***

Elektronica:

  1. Arduino Uno
  2. 3 kleuren draad (zwart, rood, elke kleur)
  3. 3-pins connector (Link om te kopen)
  4. Trek schakelaar 1 omhoog (Link om te kopen)
  5. krimpkous
  6. WS2812b adresseerbare ledstrip met 74 leds (Neopixelstrip)*2
  7. Voeding (5V 350A) 1

***50 sets zijn nodig voor de Arduino, de Pull Switch en de NeoPixels.***

Hardware:

  1. Acrylstaaf 2t (10mm*1000mm) 1
  2. Acrylbord 5t (60 mm * 60 mm) 1
  3. Foemax 10t (1200mm*1800mm) 1
  4. Zwarte nevel
  5. Kabelbinder
  6. Snaar
  7. hardboard
  8. Roosterbord

Stap 3: Connectiviteit en het bouwen van de hardware

Connectiviteit en het bouwen van de hardware
Connectiviteit en het bouwen van de hardware
Connectiviteit en het bouwen van de hardware
Connectiviteit en het bouwen van de hardware
Connectiviteit en het bouwen van de hardware
Connectiviteit en het bouwen van de hardware

Eerst hebben we de Acryl Cutting nodig om één verlichtingsmodule te maken.

  • Om de animatie van licht te ervaren, stelt u een verlichtingsmodule op die wordt bevestigd door 74 LED's in de vorm van een neopixelstrip op een 2 mm dikke acrylstaaf met een oppervlakte van 1M te bevestigen. We hebben twee soorten verlichtingsmodules geproduceerd: typisch lineair en spiraalvormig.
  • Voor lineaire typen kunnen de bestaande neopixel-strips worden vastgehouden en vastgezet, maar spiraaltypen vereisen handmatige bediening. Elk van de 74 LED's is in stukken gesplitst, bevestigd aan een spiraalvormige acryl en aan elkaar gehecht met lood.

Bevestig de Neopixel-strip aan het acryl en zet elke strip vast om te voorkomen dat deze door hitte wordt verspreid, of bind hem vast met een dunne vislijn. In het geval van een lineair type, werd de bol die op het uiteinde van de module moest worden getrokken, geïnstalleerd om de esthetische look te ontwerpen en we hebben de pingpongbal afgewerkt met een zwarte spray. Daarna boorden ze een klein gaatje in de pingpongbal en verbond het met een touw. Het volgende belangrijkste onderdeel, de schakelaar en de neopixel, wordt aangesloten zoals weergegeven. De schakelaar wordt dan vastgemaakt aan de plafondplank.

In het geval van het spiraaltype bestaat het risico dat direct trekken aan de spiraalmodule het acryl onder druk zou kunnen breken, dus het trekgedeelte (invoer) en de module (uitvoer) werden gescheiden. Om het invallende licht te maximaliseren, werden modules verticaal op het plafond geïnstalleerd, werden lineaire modules aan de lucht bevestigd, werden spiralen rechtstreeks aan het plafond bevestigd. En we hebben de pingpongbal en de schakelaar op de vislijn aangesloten zodat deze kon worden bediend.

De acrylsnede zoals weergegeven in de bovenstaande tekening is nodig om de schakelaar op de plank te bevestigen. Een vierkante schakelaar van 6 cm is ongeveer 5 mm dik, met de schakelaar in het midden en een kabelbinder die door gaten aan beide zijden is gestoken om de schakelaar stevig vast te zetten. Een rond gat aan de onderkant van het midden maakt de trekkracht van de schakelaar zichtbaar, waaronder een drieaderige kabel wordt uitgetrokken en verbonden met de kabelaansluiting van de module. En op dezelfde manier worden de plank en het acryl door een gat in de vier hoeken vastgezet met kabelbinders. Zoals hierboven beschreven, wordt de lineaire module rechtstreeks op de trekkracht aangesloten, maar de spiraalmodule verbindt de pen en de schakelaar afzonderlijk.

Stap 4: Creëer met behulp van 50 lichtmodules

Creëer met 50 lichtmodules
Creëer met 50 lichtmodules
Creëer met 50 lichtmodules
Creëer met 50 lichtmodules
Creëer met 50 lichtmodules
Creëer met 50 lichtmodules

We hebben een gebruikerservaring ontworpen voor rijker licht door in totaal 50 modules te implementeren

We hadden een plank van 1.800 mm breed en 1.200 mm lang, en we hebben elke schakelaar en module aangesloten zodat je de regen- en regenomgeving kon ervaren die we aanvankelijk hadden gepland, en we hadden elke module op zichzelf staand om multitasking mogelijk te maken.

Afhankelijk van de ontwerptekening is er een rond gat in de foemax geboord om de installatie te verbergen en ervoor te zorgen dat het aangesloten gebied van de LED-module niet zichtbaar is. Aangezien de afstand van de acrylplaat tot de LED-moduleaansluiting waar de schakelaar is bevestigd ongeveer 1 cm is, werd een 1 cm dikke foemax gebruikt.

Het metalen vierkante frame werd gebruikt om de installatie bij elkaar te houden met schroeven en kabelbinders met behoud van het totale gewicht en evenwicht. Als de lengte van de blootgestelde verbindingen meer is dan wanneer de maker het probeert, is het dikkere bord inefficiënt en worden andere structuren aanbevolen.

Om de gebruikerservaring op ooghoogte te vergemakkelijken, wordt de voltooide installatie op een steun van ongeveer 2 m hoog geplaatst, maar de waarschuwing is dat het erg omslachtig is om de ingebouwde LED-module met de schakelaar te installeren, dus alle verbindingen moeten worden verwijderd. We klommen de ladder op en verbond de module met de installatie op de steun.

Het belangrijkste onderdeel van dit hele proces is ervoor te zorgen dat het werk veilig en volledig beveiligd wordt gedaan om ervoor te zorgen dat de ervaring mogelijk wordt gemaakt in een veilige omgeving

Er werden in totaal 10 arduino- en 50 LED-modules gebruikt en per arduino werden vijf LED-modules aangesloten voor efficiëntere en naadloze multitasking. Zie bijgevoegde blauwdruk voor details. Neopixel multitasking-codering met behulp van de volledige schakelaar volgens het ontwerpdiagram zal in de volgende stap in detail worden besproken.

Stap 5: Arduino-codering en bedrading

Arduino-codering en bedrading
Arduino-codering en bedrading
Arduino-codering en bedrading
Arduino-codering en bedrading

Bedrading

  • 50 modules werden aangesloten volgens de lay-out van stap 4.
  • Elke module was opgedeeld in 10 sets van 50 modules om multitasking mogelijk te maken en een duidelijke verbinding te bieden.
  • Zoals te zien is in de afbeelding van set 1 hierboven, waren vijf modules verbonden met een enkele Arduino en werden de 5v-pinnen van neopixel tegelijk aan elkaar vastgemaakt om de voeding aan te sluiten.
  • De GND van de neopixels en de schakelaars waren ook samengebonden en voor het gemak werden de schakelaars op pinnen 2, 3, 4, 5, 6 gestoken en de neopixels op pinnen 9, 10, 11, 12, 13.
  • De schakelaars en neopixels waren respectievelijk op 2-9, 3-10, 4-11, 5-12, 6-13 manieren verbonden.
  • Opgemerkt moet worden dat aangezien de verbindingen van de leidingen complex zijn en er brandgevaar bestaat door kortsluiting, de krimpbuis werd verwarmd om ervoor te zorgen dat de zwakke delen niet zouden breken.

Neopixel multitasking-codering met optrekschakelaar

5 lichtanimatie (regentype, douchetype, vonkbliksemtype, poptype, onregelmatig type)

#erbij betrekken

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

enum patroon { GEEN, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM }; /*네오 픽셀을 방향을 설정함*/ enum richting { VOORUIT, ACHTERUIT };

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

class NeoPatterns: openbaar Adafruit_NeoPixel { /* 패턴을 추가하고 업데이트하기위한 함수 */ openbaar: patroon ActivePattern; /*클레스 함수에 패턴의 방향을 입력*/ richting Richting;

/*변수 Interval을 추가*/ unsigned long Interval; /*변수 lastUpdate를 추가*/ unsigned long lastUpdate; /*변수 Kleur1, Kleur2를 추가*/ uint32_t Kleur1, Kleur2; /*변수 TotalSteps를 추가*/ uint16_t TotalSteps; /*변수 Index를 추가*/ uint16_t Index;

/*패턴을 완료했을시 다시 불러오는 함수*/ ongeldig (*OnComplete)(); /*네오패턴에서 네오픽샐의 갯수, 핀번호, 타입, 콜백을 불러오는 함수*/ NeoPatterns(uint16_t pixels, uint8_t pin, uint8_t type, void (*callback)()): Adafruit_NeoPixel(pixels, pin, type){ OnComplete = terugbellen; }

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

void Update(){ /*패턴의 시간 설정. 멀티태스킹을 구현하는 구문*/ if ((millis() - lastUpdate) > Interval){ lastUpdate = millis(); /*ActivePattern의 스위치구문*/ switch (ActivePattern) { /*case RAINBOW_CYCLE에서는 RainbowCycleUpdate를 실행하라*/ case RAINBOW_CYCLE: RainbowCycleUpdate(); /*case RAINBOW_CYCLE에서 나와라*/ pauze;

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

geval THEATER_CHASE: TheaterChaseUpdate(); /*case THEATER_CHASE에서 나와라*/ breken;

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

geval COLOR_WIPE: ColorWipeUpdate(); /*case COLOR_WIPE에서 나와라*/ breken; /*case SCANNER에서는 ScannerUpdate를 실행하라*/ case SCANNER: ScannerUpdate(); /*case SCANNER에서 나와라*/ breken;

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

geval FADE: FadeUpdate(); /*case FADE에서 나와라*/ breken;

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

geval TWINKLE: TwinkleUpdate(); /*case TWINKLE에서 나와라*/ breken;

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

geval STAR: StarUpdate(); /*case STAR에서 나와라*/ breken;

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

geval RAINBOWSPARKLE: RainbowsparkleUpdate(); /*case RAINBOWSPARKLE에서 나와라*/ pauze; /*case METEOR에서는 MeteorUpdate를 실행하라*/ case METEOR: MeteorUpdate(); /*geval METEOR에서 나와라*/ pauze;

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

behuizing LICHT: LightUpdate(); /*case LIGHT에서 나와라*/ breken;

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

geval BLOSSOM: BlossomUpdate(); /*case BLOSSOM에서 나와라*/ pauze; } } }

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

/*Index를 증가시키고 초기화하는 함수*/

void Increment(){ /*만약 정방향이면 인덱스를 증가시켜라*/ if (Richting == VOORUIT){ Index++; /*만약 인덱스가 전체 네오픽셀 구동 갯수와 같거나 많다면 0으로 초기화시켜라*/ if (Index >= TotalSteps){ Index = 0; /*패턴을 완료시키는 함수*/ if (OnComplete != NULL){ OnComplete(); } } }

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

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

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

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

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

void RainbowCycle(uint8_t interval, direction dir = FORWARD){ /*실행되는 패턴은 RainbowCycle임*/ ActivePattern = RAINBOW_CYCLE; /*시간은 void RainbowCycle()안에 입력되는 interval과 같음*/ Interval = interval; /*총 구동갯수는 255임*/ TotalSteps = 255; /*인덱스는 0으로 설정함*/ Index = 0; /*방향은 void RainbowCycle()안에 입력되는 dir = VOORUIT과 같음*/ Richting = dir; }

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

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

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

void TheaterChase(uint32_t color1, uint32_t color2, uint8_t interval, direction dir = FORWARD){ /*실행되는 패턴은 RTHEATER_CHASE*/ ActivePattern = THEATER_CHASE; /*시간은 void TheaterChase()안에 입력되는 interval과 같음*/ Interval = interval; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1, 2를 설정*/ Kleur1 = kleur1; Kleur2 = kleur2; /*인덱스는 0으로 설정함*/ Index = 0; /*방향은 void TheaterChase()안에 입력되는 dir = VOORUIT과 같음*/ Direction = dir; }

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

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

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

void ColorWipe (uint32_t kleur, uint8_t interval, richting dir = VOORUIT) { /*실행되는 패턴은 COLOR_WIPE*/ ActivePattern = COLOR_WIPE; /*시간은 void ColorWipe()안에 입력되는 interval과 같음*/ Interval = interval; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1을 설정*/ Kleur1 = kleur; /*인덱스는 0으로 설정함*/ Index = 0; /*방향은 void ColorWipe()안에 입력되는 dir = VOORUIT과 같음*/ Richting = dir; }

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

void ColorWipeUpdate(){ /*index를 컬러1로 변환시켜라*/ setPixelColor(Index, Color1); /*애니메이션을 보여주는 함수 */ show(); Verhogen(); }

/*Scanner의 컬러와 시간을 입력*/

void Scanner (uint32_t color1, uint8_t interval){ /*실행되는 패턴은 SCANNER*/ ActivePattern = SCANNER; /*시간은 void Scanner()안에 입력되는 interval과 같음*/ Interval = interval; /*구동갯수는 총갯수에서 1을빼고 2를 곱해라*/ TotalSteps = (numPixels() - 1) * 2; /*컬러 1을 설정*/ Kleur1 = kleur1; /*인덱스는 0으로 설정함*/ Index = 0; }

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

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

/*Scanner의 컬러1, 2와 스텝, 시간, 방향을 입력*/

void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD){ /*실행되는 패턴은 FADE*/ ActivePattern = FADE; /*시간은 void Fade()안에 입력되는 interval과 같음*/ Interval = interval; /*구동갯수는 스텝값임*/ TotalSteps = stappen; /*컬러 1, 2를 설정*/ Kleur1 = kleur1; Kleur2 = kleur2; /*인덱스는 0으로 설정함*/ Index = 0; /*방향은 void Fade()안에 입력되는 dir = VOORUIT과 같음*/ Richting = dir; } /*FadeUpdate를 업데이트했을 경우*/ void FadeUpdate(){ /*변수 red값은 다음과 같음*/ uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / TotalSteps; /*변수 groen값은 다음과 같음*/ uint8_t groen = ((Groen(Kleur1) * (TotalSteps - Index)) + (Groen(Kleur2) * Index)) / TotalSteps; /*변수 blauw값은 다음과 같음*/ uint8_t blauw = ((Blauw(Kleur1) * (TotalSteps - Index)) + (Blauw(Kleur2) * Index)) / TotalSteps; /*위의 rood, groen, blauw 값으로 컬러를 셋팅함*/ ColorSet(Color(rood, groen, blauw)); /*애니메이션을 보여주는 함수 */ show(); Verhogen(); }

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

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

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

void Twinkle(uint32_t color1, uint8_t interval){ /*실행되는 패턴은 TWINKLE*/ ActivePattern = TWINKLE; /*시간은 void Twinkle()안에 입력되는 interval과 같음*/ Interval = interval; /*컬러 1를 설정*/ Kleur1 = kleur1; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); Index = 0; }

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

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

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

void Star(uint32_t color1){ /*실행되는 패턴은 STAR*/ ActivePattern = STAR; /*시간은 void Star()안에 입력되는 interval과 같음*/ Interval = Interval; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1을 설정*/ Kleur1 = kleur1; Index = 0; }

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

void StarUpdate(){ /*인덱스와 컬러를 셋팅 */ setPixelColor(Index, Color1); laten zien(); /*변수 i가 0이고 구동 갯수보다 작으면 i를 감소시킴 = 한칸씩 이동하는 애니메이션*/ for (int i = 0; i < numPixels(); i--) { setPixelColor(i, Color(0, 0, 0)); } /*애니메이션을 보여주는 함수 */ Increment(); }

/*Regenboog schittering의 시간과 방향을 입력*/

void Rainbowsparkle(uint8_t interval, direction dir = FORWARD){ /*실행되는 패턴은 RAINBOWSPARKLE*/ ActivePattern = RAINBOWSPARKLE; /*시간은 void Rainbowsparkle()안에 입력되는 interval과 같음*/ Interval = interval; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); Index = 0; /*방향은 void Rainbowsparkle()안에 입력되는 richting과 같음*/ Richting = 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 = willekeurig(255); setPixelColor(i, c); } else{ setPixelColor(i, random(255)); } } /*애니메이션을 보여주는 함수 */ show(); Verhogen(); } /*Meteor의 시간과 방향을 입력*/ void Meteor(uint32_t color1){ /*실행되는 패턴은 METEOR*/ ActivePattern = METEOR; /*시간 설정*/ Interval = Interval; /*총 구동갯수는 numPixels갯수에서 1일뺀 후, *2를 한것과 같음*/ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 설정*/ Kleur1 = kleur1; Index = 0; }

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

void MeteorUpdate(){ for (int i = 0; i < numPixels(); i++){ if (i == Index){ setPixelColor(i, 100, random(255), 255); } else { setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 보여주는 함수 */ show(); Verhogen(); }

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

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

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

void LightUpdate(){ for (int i = 0; i < numPixels(); i++){ if (i == TotalSteps - Index){ setPixelColor(i, 150, random(200), 40); } else { setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 보여주는 함수 */ show(); Verhogen(); }

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

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

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

void BlossomUpdate(){ for (int i = 0; i <numPixels(); i++){ if (i == TotalSteps - Index){ setPixelColor(i, 255, random(255), 100); } else { setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 보여주는 함수 */ show(); Verhogen(); }

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

/*네오픽셀의 켜지는 위치와 색을 지정해주는 함수 */ void setAll(byte rood, byte groen, byte blauw) { for(int i = 0; i <numPixels(); i++) { setPixelColor(i, red, groen Blauw); } laten zien(); }

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

uint32_t DimColor (uint32_t color) { // Verschuif R-, G- en B-componenten een beetje naar rechts uint32_t dimColor = Color (Rood (kleur) >> 1, Groen (kleur) >> 1, Blauw (kleur) >> 1); terug dimColor; }

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

void ColorSet(uint32_t color){ for (int i = 0; i <numPixels(); i++){ setPixelColor(i, color); } laten zien(); }

/*레드값을 불러옴*/

uint8_t Rood(uint32_t kleur){ return (kleur >> 16) & 0xFF; } /*그린값을 불러옴*/ uint8_t Groen(uint32_t kleur){ return (kleur >> 8) & 0xFF; } /*블루값을 불러옴*/ uint8_t Blue(uint32_t color){ return color & 0xFF; }

/*Regenboog 컬러를 불러옴*/

uint32_t Wheel(byte WheelPos){ WheelPos = 255 - WheelPos; if (WheelPos < 85) { return Color (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170){ WheelPos -= 85; retourneer Kleur (0, WheelPos * 3, 255 - WheelPos * 3); } else{ WheelPos -= 170; kleur retourneren (WheelPos * 3, 255 - WheelPos * 3, 0); } } };

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

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

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

#define NUMPIXELS 74 /*사용하는 버튼의 갯수 설정*/ #define B_NUM 5 /*Import strip1~5까지, 갯수는 74개 스트립 연결핀은 strip1은 8 ~ strip5까지12*/ NeoPatterns strip1(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번핀까지 상태는 순서대로 LAAG임*/ int lastButtonState[B_NUM] = {LAAG, LAAG, LAAG, LAAG, LAAG}; /*2번핀부터 6번핀까지 버튼 카운터를 초기화시킴*/ int buttonCounter[B_NUM] = {0, 0, 0, 0, 0}; /*2번핀부터 6번핀까지 최대 버튼 카운터는 5임*/ int buttonCounterMax = 5; /*모든 버튼핀을 읽일수있도록 변수 추가*/ int lezen [B_NUM]; unsigned long lastDebounceTime[B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼핀을 읽는 시간간격은 delay50과 같음*/ unsigned long debounceDelay = 50;

ongeldige setup(){

/*복잡하게 저항 연결이 필요없도록 인풋 풀업방식의 버튼설정: GND - 5V (verbinden met pinnummer)*/ for (int i = 0; i < B_NUM; i++) { pinMode (buttonPin , INPUT_PULLUP); } Serieel.begin(9600); /*스트립 1~5를 셋팅*/ strip1.begin(); strip2.begin(); strip3.begin(); strip4.begin(); strip5.begin();

//strip1. TheaterChase (strip1. Kleur (255, 0, 255), strip1. Kleur (255, 50, 0), 20, VOORUIT);

}

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

int-teller = 5; void loop(){ /*버튼 수보다 i가 작으면 i를 증가시키고*/ for (int i = 0; i debounceDelay) { if (reading != buttonState) { buttonState = lezen; buttonCounter++; /*버튼 카운팅이 위에서 설정한 Max값 5를 넘으면 0으로 초기화 시켜라.*/ if (buttonCounter > buttonCounterMax) buttonCounter = 0; } } lastButtonState = lezen; } /*모든 스트립을 업데이트함.*/ strip1. Update(); strip2. Update(); strip3. Update(); strip4. Update(); strip5. Update();

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

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

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

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

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

switch (buttonCounter[1]) { case 0: strip2. ActivePattern = STAR; strip2. Interval = 50; strip2. TotalSteps = strip2.numPixels(); pauze; geval 1: strip2. ActivePattern = RAINBOWSPARKLE; strip2. Interval = 100; strip2. TotalSteps = strip2.numPixels(); pauze; geval 2: strip2. ActivePattern = SCANNER; strip2. Interval = 20; strip2. TotalSteps = (strip2.numPixels() - 1) * 2; pauze; geval 3: strip2. ActivePattern = TWINKLE; strip2. Interval = 5; strip2. TotalSteps = strip2.numPixels(); pauze; geval 4: strip2. ActivePattern = METEOR; strip2. Interval = 40; strip2. TotalSteps = strip2.numPixels(); pauze; } Serial.print(buttonCounter[0]); Serieel.print(", "); Serial.println(buttonCounter[1]);

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

switch (buttonCounter[2]) { case 0: strip3. ActivePattern = STAR; strip3. Interval = 50; strip3. TotalSteps = strip3.numPixels(); pauze; geval 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels(); pauze; geval 2: strip3. ActivePattern = SCANNER; strip3. Interval = 20; strip3. TotalSteps = (strip3.numPixels() - 1) * 2; pauze; geval 3: strip3. ActivePattern = TWINKLE; strip3. Interval = 5; strip3. TotalSteps = strip3.numPixels(); pauze; geval 4: strip3. ActivePattern = METEOR; strip3. Interval = 25; strip3. TotalSteps = strip3.numPixels(); pauze; } Serial.print(buttonCounter[0]); Serieel.print(", "); Serial.println(buttonCounter[1]);

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

switch (buttonCounter[3]) { case 0: strip4. ActivePattern = STAR; strip4. Interval = 50; strip4. TotalSteps = strip4.numPixels(); pauze; geval 1: strip4. ActivePattern = RAINBOWSPARKLE; strip4. Interval = 100; strip4. TotalSteps = strip4.numPixels(); pauze; geval 2: strip4. ActivePattern = SCANNER; strip4. Interval = 20; strip4. TotalSteps = (strip4.numPixels() - 1) * 2; pauze; geval 3: strip4. ActivePattern = TWINKLE; strip4. Interval = 5; strip4. TotalSteps = strip4.numPixels(); pauze; geval 4: strip4. ActivePattern = METEOR; strip4. Interval = 25; strip4. TotalSteps = strip4.numPixels(); pauze; } Serial.print(buttonCounter[0]); Serieel.print(", "); Serial.println(buttonCounter[1]);

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

schakelaar (buttonCounter [4]) { geval 0: strip5. ActivePattern = STAR; strip5. Interval = 50; strip5. TotalSteps = strip5.numPixels(); pauze; geval 1: strip5. ActivePattern = RAINBOWSPARKLE; strip5. Interval = 100; strip5. TotalSteps = strip5.numPixels(); pauze; geval 2: strip5. ActivePattern = SCANNER; strip5. Interval = 20; strip5. TotalSteps = (strip5.numPixels() - 1) * 2; pauze; geval 3: strip5. ActivePattern = TWINKLE; strip5. Interval = 5; strip5. TotalSteps = strip5.numPixels(); pauze; geval 4: strip5. ActivePattern = METEOR; strip5. Interval = 25; strip5. TotalSteps = strip5.numPixels(); pauze; } Serial.print(buttonCounter[0]); Serieel.print(", "); Serial.println(buttonCounter[1]); }

// strip1 voltooiing terugbellen

void strip1Complete(){ strip1. Color1 = strip1. Wheel(willekeurig(255)); strip1. Kleur2 = strip1. Wiel(willekeurig(255)); strip1. Index = 0; }

// strip2 voltooiing terugbellen

void strip2Complete(){ strip2. Color1 = strip2. Wheel(willekeurig(255)); strip2. Kleur2 = strip2. Wiel (willekeurig (255)); strip2. Index = 0; }

// strip3 voltooiing terugbellen

void strip3Complete(){ strip3. Color1 = strip3. Wheel(willekeurig(255)); strip3. Color2 = strip3. Wheel(willekeurig(255)); strip3. Index = 0; }

// strip4 voltooiing terugbellen

void strip4Complete(){ strip4. Color1 = strip4. Wheel(willekeurig(255)); strip4. Color2 = strip4. Wheel(willekeurig(255)); strip4. Index = 0; }

// strip5 voltooiing terugbellen

void strip5Complete(){ strip5. Color1 = strip5. Wheel(willekeurig(255)); strip5. Color2 = strip5. Wheel(willekeurig(255)); strip5. Index = 0; }

Stap 6: Resultaat en Film maken

Image
Image
Resultaat en Film maken
Resultaat en Film maken

Bedankt voor uw interesse in ons project, hoewel het niet genoeg is.

Aanbevolen: