Tirez la lumière - Module d'éclairage à l'aide de Neopixel & Pull Up Switch : 6 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Caractéristiques du module Lumière

• Arduino Uno
• Matériel et boîtier achetés sur Internet
• Néopixel et alimentation empruntés à la School of Informatics & Product Design
• Module d'éclairage contrôlé par alimentation
• Toutes les fonctions contrôlées via l'interaction des utilisateurs
• Types d'animation de bande Neopixel: type pluie, type douche, type éclair étincelle, type pop, type irrégulier
• L'interrupteur à tirette est connecté à la bande Neopixel et l'animation change lorsqu'elle est tirée sur la bande Neopixel

Étape 1: Avant de commencer

Bonjour Instructables et Makers.

Nous avons lancé un projet de conception interactive en termes de ce qui se passerait si nous pouvions ressentir l'émotion de la pluie à travers l'animation de la lumière. Je pensais que la sensibilité de l'utilisateur serait maximisée grâce à une interface qui tire directement la lumière.

Mettons-nous au travail

Étape 2: Pièces nécessaires

Basé sur un module d'éclairage

***Les néopixels et l'alimentation ont été utilisés avec le soutien de notre département.***

Électronique:

1. Arduino Uno
2. Fil 3 couleurs (noir, rouge, n'importe quelle couleur)
3. Connecteur 3pin (Lien pour acheter)
4. Tirez le commutateur 1 (Lien pour acheter)
5. tube rétractable
6. Bande LED adressable WS2812b avec 74 LED (bande néopixel) * 2
7. Alimentation (5V 350A) 1

***50 sets sont nécessaires pour l'Arduino, le Pull Switch et les NeoPixels.***

Matériel:

1. Barre acrylique 2t (10mm*1000mm) 1
2. Panneau acrylique 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Spray noir
5. Attache de câble
6. Chaîne de caractères
7. Panneau dur
8. Tableau de grille

Étape 3: Connectivité et construction du matériel

Tout d'abord, nous avons besoin de la découpe acrylique pour fabriquer un module d'éclairage.

• Pour vivre l'animation de la lumière, dessinez un module d'éclairage qui se fixe en fixant 74 LED sous forme de bande néopixel sur une barre acrylique de 2 mm d'épaisseur avec une surface de 1M. Nous avons produit deux types de modules d'éclairage: linéaire typique et spirale.
• Pour les types linéaires, les bandes de néopixel existantes peuvent être maintenues et sécurisées, mais les types en spirale nécessitent une opération manuelle. Chacune des 74 LED est divisée en morceaux, attachée à un acrylique en spirale et collée avec du plomb.

Fixez la bande Neopixel à l'acrylique et fixez chaque bande pour éviter qu'elle ne se propage par la chaleur, ou attachez avec une fine ligne de pêche. Dans le cas du type linéaire, la sphère devant être tirée sur l'extrémité du module a été installée pour concevoir l'aspect esthétique et nous avons fini la balle de ping-pong avec un spray noir. Ensuite, ils ont percé un petit trou dans la balle de ping-pong et l'ont connecté avec une corde. La prochaine partie la plus importante, le commutateur et le néopixel, est connectée comme indiqué. L'interrupteur est ensuite fixé à l'étagère de plafond.

Dans le cas du type spirale, il existe un risque que la traction directe du module spirale puisse casser l'acrylique sous pression, de sorte que la section de traction (Entrée) et le module (Sortie) ont été séparés. Pour maximiser la chute de lumière, des modules ont été installés verticalement au plafond, des modules linéaires ont été fixés à l'air, des spirales ont été fixées directement au plafond. Et nous avons connecté la balle de ping-pong et l'interrupteur à la ligne de pêche pour qu'elle puisse être actionnée.

La découpe acrylique comme indiqué dans le dessin ci-dessus est nécessaire pour fixer l'interrupteur à l'étagère. Un interrupteur carré de 6 cm mesure environ 5 mm d'épaisseur, avec l'interrupteur centré et une attache de câble insérée dans les trous des deux côtés pour fixer fermement l'interrupteur. Un trou circulaire au bas du centre expose la traction de l'interrupteur, en dessous duquel un câble à trois fils est tiré et connecté à la borne de câble du module. Et de même, à travers un trou aux quatre coins, l'étagère et l'acrylique sont fixés avec des attaches de câble. Comme décrit ci-dessus, le module linéaire est connecté directement à la traction, mais le module en spirale connecte la broche et le commutateur séparément.

Étape 4: Créez à l'aide de 50 modules d'éclairage

Nous avons conçu une expérience utilisateur pour une lumière plus riche en déployant un total de 50 modules

Nous avions une étagère de 1 800 mm de large et 1 200 mm de long, et nous avons connecté chaque commutateur et module afin que vous puissiez profiter de l'environnement de pluie et de pluie que nous avions initialement prévu, et nous avions chaque module autonome pour permettre le multitâche..

Selon le dessin de conception, un trou rond a été percé dans le foemax pour cacher l'installation et pour s'assurer que la zone connectée du module LED n'est pas visible. Étant donné que la distance entre le panneau acrylique et la connexion du module LED où l'interrupteur est fixé est d'environ 1 cm, un foemax de 1 cm d'épaisseur a été utilisé.

Le cadre carré en métal a été utilisé pour maintenir l'installation avec des vis et des attaches de câble tout en maintenant le poids et l'équilibre global. Si la longueur des connexions exposées est supérieure à celle lorsque le fabricant essaie, le panneau plus épais est inefficace et d'autres structures sont recommandées.

Pour faciliter l'expérience de l'utilisateur au niveau des yeux, l'installation terminée est posée sur un support d'environ 2m de haut, mais la prudence est de constater qu'il est très fastidieux d'installer le module LED embarqué avec l'interrupteur, donc toutes les connexions doivent être supprimées. Nous avons grimpé à l'échelle et connecté le module avec l'installation fixée sur le support.

La partie la plus importante de tout ce processus est de s'assurer que le travail est effectué de manière sécurisée et entièrement sécurisée pour garantir que l'expérience est rendue possible dans un environnement sûr

Un total de 10 modules arduino et 50 LED ont été utilisés et cinq modules LED ont été connectés par arduino pour un multitâche plus efficace et transparent. Voir le plan ci-joint pour plus de détails. Le codage multitâche Neopixel utilisant le commutateur complet selon le schéma de conception sera discuté en détail dans l'étape suivante.

Étape 5: Codage et câblage Arduino

Câblage

• 50 modules ont été connectés selon la disposition de l'étape 4.
• Chaque module a été divisé en 10 ensembles de 50 modules pour permettre le multitâche et fournir une connexion claire.
• Comme le montre l'image de l'ensemble 1 ci-dessus, cinq modules ont été connectés à un seul arduino et les broches 5v du néopixel ont été liées ensemble pour connecter l'alimentation.
• Le GND des néopixels et les commutateurs ont également été liés ensemble et, pour faciliter la perception, les commutateurs ont été branchés sur les broches 2, 3, 4, 5, 6 et les néopixels ont été branchés sur les broches 9, 10, 11, 12, 13.
• Les commutateurs et les néopixels ont été connectés respectivement de 2-9, 3-10, 4-11, 5-12, 6-13 manières.
• Il est à noter que les connexions des lignes étant complexes et qu'il existe un risque d'incendie dû aux courts-circuits, le tube rétractable a été chauffé pour éviter que les parties faibles ne se cassent.

Codage multi-tâches Neopixel avec bouton pull-up

5 animations lumineuses (type pluie, type douche, type éclair Spark, type pop, type irrégulier)

#comprendre

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

enum pattern { AUCUN, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM }; /*네오 픽셀을 방향을 설정함*/ enum direction { FORWARD, REVERSE };

/*패턴의 입력함*/

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

/*변수 Interval 추가*/ unsigned long Interval; /*변수 lastUpdate를 추가*/ unsigned long lastUpdate; /*변수 Couleur1, Couleur2를 추가*/ uint32_t Couleur1, Couleur2; /*변수 TotalSteps를 추가*/ uint16_t TotalSteps; /*변수 Index를 추가*/ uint16_t Index;

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

/*패턴을 구문*/

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

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

cas THEATER_CHASE: TheaterChaseUpdate(); /*cas THEATRE_CHASE에서 */ pause;

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

case COLOR_WIPE: ColorWipeUpdate(); /*case COLOR_WIPE에서 */ break; /*case SCANNER에서는 ScannerUpdate를 실행하라*/ case SCANNER: ScannerUpdate(); /*case SCANNER에서 */ break;

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

case FADE: FadeUpdate(); /*case FADE에서 */ break;

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

cas TWINKLE: TwinkleUpdate(); /*case TWINKLE에서 */ break;

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

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

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

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

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

cas LIGHT: LightUpdate(); /*case LIGHT에서 나와라*/ break;

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

cas BLOSSOM: BlossomUpdate(); /*case BLOSSOM에서 나와라*/ break; } } }

/*패턴의 구문 구문*/

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

void Incrément(){ /*만약 정방향이면 인덱스를 증가시켜라*/ if (Direction == FORWARD){ 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; Indice = Nombre total d'étapes - 1; } /*그 방향이 정방향이면 0으로 설정해라*/ else{ Direction = FORWARD; Indice = 0; } }

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

*RainbowCycle의 방향을 입력*/

void RainbowCycle(uint8_t interval, direction dir = FORWARD){ /*실행되는 패턴은 RainbowCycle임*/ ActivePattern = RAINBOW_CYCLE; /*시간은 void RainbowCycle()안에 입력되는 intervalle과 같음*/ Interval = intervalle; /*총 구동갯수는 255임*/ Nombre total de pas = 255; /*인덱스는 0으로 설정함*/ Indice = 0; /*방향은 void 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(); Incrément(); }

/*TheaterChase의 컬러와 시간 입력*/

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

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

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

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

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

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

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

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

void Scanner(uint32_t color1, uint8_t interval){ /*실행되는 패턴은 SCANNER*/ ActivePattern = SCANNER; /*시간은 void Scanner()안에 입력되는 intervalle과 같음*/ Intervalle = intervalle; /*구동갯수는 1을빼고 2를 곱해라*/ TotalSteps = (numPixels() - 1) * 2; /*컬러 1을 설정*/ Couleur1 = couleur1; /*인덱스는 0으로 설정함*/ Indice = 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(); Incrément(); }

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

void Fade(uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD){ /*실행되는 패턴은 FADE*/ ActivePattern = FADE; /*시간은 void Fondu()안에 입력되는 intervalle과 같음*/ Interval = intervalle; /*구동갯수는 스텝값임*/ TotalSteps = étapes; /*컬러 1, 2를 설정*/ Couleur1 = couleur1; Couleur2 = couleur2; /*인덱스는 0으로 설정함*/ Indice = 0; /*방향은 void Fondu()안에 입력되는 dir = FORWARD과 같음*/ Direction = dir; } /*FadeUpdate를 업데이트했을 경우*/ void FadeUpdate(){ /*변수 red값은 다음과 같음*/ uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / Nombre total d'étapes; /*변수 green값은 다음과 같음*/ uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps; /*변수 bleu값은 다음과 같음*/ uint8_t bleu = ((Bleu(Couleur1) * (TotalSteps - Index)) + (Bleu(Couleur2) * Index)) / TotalSteps; /*위의 rouge, vert, bleu 값으로 컬러를 셋팅함*/ ColorSet(Color(rouge, vert, bleu)); /*애니메이션을 함수 */ show(); Incrément(); }

/*모든 구문*/

void alloff() { /*총 네오픽셀 갯수는 74개이며*/ int NPIXEL = 74; /*변수 i가 증가하며 모든 네오픽셀의 컬러 값을 0으로 변환함*/ pour (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()안에 입력되는 intervalle과 같음*/ Interval = intervalle; /*컬러 1를 설정*/ Couleur1 = couleur1; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); Indice = 0; }

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

void TwinkleUpdate(){ /*모든 컬러를 0으로 셋팅*/ setAll(0, 0, 0); /*변수 Pixel은 aléatoire 74*/ int Pixel = aléatoire(74); /*aléatoire 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(); Incrément(); }

/*Étoile의 컬러1 값을 입력*/

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

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

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

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

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

/*Lumière의 시간과 방향을 입력*/

void Light(uint32_t color1){ /*실행되는 패턴은 LIGHT*/ ActivePattern = LIGHT; /*시간 설정*/ Intervalle = Intervalle; /*총 구동갯수는 numPixels갯수에서 1일뺀 후, *2를 한것과 같음*/ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 설정*/ Couleur1 = couleur1; Indice = 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(); Incrément(); }

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

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

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

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(); Incrément(); }

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

/*네오픽셀의 켜지는 위치와 색을 지정해주는 함수 */ void setAll(byte red, byte green, byte blue) { for(int i = 0; i < numPixels(); i++) { setPixelColor(i, red, vert bleu); } spectacle(); }

/*네오픽셀의, 조절하는 함수*/

uint32_t DimColor(uint32_t color){ // Décale les composants R, G et B d'un bit vers la droite uint32_t dimColor = Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1); return dimColor; }

/*모든 칼라를 */

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

/*레드값을 */

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

/*Arc-en-ciel 불러옴*/

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; return Color (0, WheelPos * 3, 255 - WheelPos * 3); } else{ WheelPos -= 170; return Color(WheelPos * 3, 255 - WheelPos * 3, 0); } } };

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

void strip1Complete(); void strip2Complete(); void strip3Complete(); void strip4Complete(); void 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번핀까지 상태는 순서대로 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 lecture[B_NUM]; non signé long lastDebounceTime[B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼핀을 읽는 시간간격은 delay50과 같음*/ long non signé antibounceDelay = 50;

void setup(){

/*복잡하게 저항 연결이 필요없도록 인풋 풀업방식의 버튼설정: GND - 5V(Connect to Pin number)*/ for (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, FORWARD);

}

/*버튼 변수값은 5임*/

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

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

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

/*첫번째 애니메이션*/

cas 0: strip1. ActivePattern = FLEUR; /*해당 시간을 설정*/ strip1. Interval = 20; /*구동되는 설정 */ strip1. TotalSteps = strip1.numPixels(); Pause; /*두번째 버튼을 활동시키면 구동되는 애니메이션*/ cas 1: strip1. ActivePattern = RAINBOWSPARKLE; bande1. Intervalle = 50; strip1. TotalSteps = strip1.numPixels(); Pause; /*세번째 버튼을 활동시키면 구동되는 애니메이션*/ cas 2: strip1. ActivePattern = SCANNER; bande1. Intervalle = 10; strip1. TotalSteps = (strip1.numPixels() - 1) * 2; Pause; /*네번째 버튼을 활동시키면 구동되는 애니메이션*/ cas 3: strip1. ActivePattern = TWINKLE; bande1. Interval = 1; strip1. TotalSteps = strip1.numPixels(); Pause; /*다섯번째 버튼을 활동시키면 구동되는 애니메이션*/ cas 4: strip1. ActivePattern = METEOR; bande1. Intervalle = 10; strip1. TotalSteps = strip1.numPixels(); Pause; } Serial.print(buttonCounter[0]); Serial.print(", "); Serial.println(boutonCompteur[1]);

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

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

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

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

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

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

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

switch (buttonCounter[4]) { case 0: strip5. ActivePattern = STAR; bande5. Intervalle = 50; strip5. TotalSteps = strip5.numPixels(); Pause; cas 1: strip5. ActivePattern = RAINBOWSPARKLE; bande5. Intervalle = 100; strip5. TotalSteps = strip5.numPixels(); Pause; cas 2: strip5. ActivePattern = SCANNER; bande5. Intervalle = 20; strip5. TotalSteps = (strip5.numPixels() - 1) * 2; Pause; cas 3: strip5. ActivePattern = TWINKLE; strip5. Interval = 5; strip5. TotalSteps = strip5.numPixels(); Pause; cas 4: strip5. ActivePattern = METEOR; bande5. Intervalle = 25; strip5. TotalSteps = strip5.numPixels(); Pause; } Serial.print(buttonCounter[0]); Serial.print(", "); Serial.println(boutonCompteur[1]); }

// Rappel d'achèvement strip1

void strip1Complete(){ strip1. Color1 = strip1. Wheel(random(255)); bande1. Couleur2 = bande1. Roue(aléatoire (255)); bande1. Index = 0; }

// Rappel d'achèvement strip2

void strip2Complete(){ strip2. Color1 = strip2. Wheel(random(255)); bande2. Couleur2 = bande2. Roue(aléatoire (255)); bande2. Index = 0; }

// Rappel d'achèvement strip3

void strip3Complete(){ strip3. Color1 = strip3. Wheel(random(255)); bande3. Couleur2 = bande3. Roue(aléatoire (255)); bande3. Index = 0; }

// Rappel d'achèvement strip4

void strip4Complete(){ strip4. Color1 = strip4. Wheel(random(255)); bande4. Couleur2 = bande4. Roue(aléatoire (255)); bande4. Index = 0; }

// Rappel d'achèvement strip5

void strip5Complete(){ strip5. Color1 = strip5. Wheel(random(255)); bande5. Couleur2 = bande5. Roue(aléatoire (255)); bande5. Index = 0; }

Étape 6: Résultat et réalisation du film

Merci de l'intérêt que vous portez à notre projet même si cela ne suffit pas.