Tire de la luz - Módulo de luz usando Neopixel & Pull Up Switch: 6 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Características del módulo Light

• Arduino Uno
• Hardware y gabinete comprados en Internet
• Neopixel y fuente de alimentación prestada de la Escuela de Informática y Diseño de Producto
• Módulo de luz controlado por fuente de alimentación
• Todas las funciones controladas a través de la interacción de los usuarios
• Tipos de animación de la tira de Neopixel: tipo lluvia, tipo ducha, tipo relámpago chispa, tipo pop, tipo irregular
• El interruptor de elevación está conectado a la tira de Neopixel y la animación cambia cuando se tira de la tira de Neopixel.

Paso 1: antes de comenzar

Hola instructables y creadores.

Iniciamos un proyecto de diseño interactivo en términos de lo que sucedería si pudiéramos sentir la emoción de la lluvia a través de la animación de la luz. Pensé que la sensibilidad del usuario se maximizaría a través de una interfaz que atrae la luz directamente.

Para que no se ponga a trabajar

Paso 2: Piezas necesarias

Basado en un módulo de luz

*** Se utilizaron Neopixels y Fuente de alimentación con el apoyo de nuestro departamento. ***

Electrónica:

1. Arduino Uno
2. Cable de 3 colores (negro, rojo, cualquier color)
3. Conector de 3 pines (enlace para comprar)
4. Tire hacia arriba del interruptor 1 (enlace para comprar)
5. tubo retráctil
6. Tira de LED direccionable WS2812b con 74 LED (tira de Neopixel) * 2
7. Fuente de alimentación (5V 350A) 1

*** Se necesitan 50 juegos para Arduino, Pull Switch y NeoPixels. ***

Hardware:

1. Barra de acrílico 2t (10 mm * 1000 mm) 1
2. Tablero de acrílico 5t (60 mm * 60 mm) 1
3. Foemax 10t (1200 mm * 1800 mm) 1
4. Spray negro
5. Brida
6. Cuerda
7. Tableros duros
8. Tablero de cuadrícula

Paso 3: conectividad y construcción del hardware

Primero, necesitamos el corte acrílico para hacer un módulo de iluminación.

• Para experimentar la animación de la luz, diseñe un módulo de iluminación que se fija colocando 74 LED en forma de tira de neopixel en una barra acrílica de 2 mm de espesor con un área de 1M. Hemos producido dos tipos de módulos de iluminación: típicos lineales y espirales.
• Para los tipos lineales, las tiras de neopixel existentes se pueden sujetar y asegurar, pero los tipos en espiral requieren operación manual. Cada uno de los 74 LED se divide en pedazos, se une a un acrílico en espiral y se une con plomo.

Fije la tira de Neopixel al acrílico y asegure cada tira para evitar que se extienda por el calor, o ate con un hilo de pescar fino. En el caso del tipo lineal, se instaló la esfera que se debía tirar en el extremo del módulo para diseñar el aspecto estético y terminamos la pelota de ping pong con un spray negro. Luego perforaron un pequeño agujero en la pelota de ping pong y lo conectaron con una cuerda. La siguiente parte más importante, el interruptor y el neopixel, se conecta como se muestra. Luego, el interruptor se fija al estante del techo.

En el caso del tipo espiral, existe el riesgo de que la tracción directa del módulo en espiral pueda romper el acrílico bajo presión, por lo que la sección de tracción (Entrada) y el módulo (Salida) se separaron. Para maximizar la caída de luz, los módulos se instalaron verticalmente en el techo, los módulos lineales se fijaron al aire, las espirales se fijaron directamente al techo. Y conectamos la pelota de ping pong y el interruptor al hilo de pescar para que pudiera ser operado.

Se requiere el corte acrílico como se muestra en el dibujo anterior para asegurar el interruptor al estante. Un interruptor de forma cuadrada de 6 cm tiene aproximadamente 5 mm de grosor, con el interruptor centrado y una brida insertada a través de los orificios en ambos lados para asegurar el interruptor firmemente. Un orificio circular en la parte inferior del centro expone el tirón del interruptor, debajo del cual se extrae un cable de tres hilos y se conecta al terminal del cable del módulo. Y de manera similar, a través de un orificio en las cuatro esquinas, el estante y el acrílico se aseguran con bridas. Como se describió anteriormente, el módulo lineal está conectado directamente al tirón, pero el módulo en espiral conecta el pin y el interruptor por separado.

Paso 4: Crea usando 50 módulos de luz

Hemos diseñado una experiencia de usuario para una luz más rica mediante la implementación de un total de 50 módulos

Teníamos un estante de 1, 800 mm de ancho y 1, 200 mm de largo, y conectamos cada interruptor y módulo para que pudiera experimentar el entorno de lluvia y lluvia que planeamos inicialmente, y teníamos cada módulo independiente para permitir la multitarea..

Dependiendo del dibujo de diseño, se taladró un orificio redondo en el foemax para ocultar la instalación y asegurarse de que el área conectada del módulo LED no sea visible. Dado que la distancia desde la placa acrílica hasta la conexión del módulo LED donde se conecta el interruptor es de aproximadamente 1 cm, se utilizó un foemax de 1 cm de grosor.

El marco cuadrado de metal se usó para mantener la instalación unida con tornillos y bridas para cables mientras se mantenía el peso y el equilibrio general. Si la longitud de las conexiones expuestas es mayor que cuando el fabricante lo intenta, la tabla más gruesa es ineficaz y se recomiendan otras estructuras.

Para facilitar la experiencia del usuario a la altura de los ojos, la instalación completa se coloca sobre un soporte de aproximadamente 2 m de altura, pero la precaución es que es muy engorroso instalar el módulo LED integrado con el interruptor, por lo que se deben quitar todas las conexiones. Subimos por la escalera y conectamos el módulo con la instalación fijada al soporte.

La parte más importante de todo este proceso es garantizar que el trabajo se realice de forma segura y totalmente protegida para garantizar que la experiencia sea posible en un entorno seguro

Se utilizaron un total de 10 módulos arduino y 50 LED y se conectaron cinco módulos LED por arduino para una multitarea más eficiente y sin problemas. Consulte el plano adjunto para obtener más detalles. La codificación multitarea de Neopixel utilizando el conmutador completo de acuerdo con el diagrama de diseño se discutirá en detalle en el siguiente paso.

Paso 5: Codificación y cableado de Arduino

Alambrado

• Se conectaron 50 módulos de acuerdo con el diseño del paso 4.
• Cada módulo se dividió en 10 conjuntos de 50 módulos para permitir la multitarea y proporcionar una conexión clara.
• Como se muestra en la imagen del conjunto 1 anterior, cinco módulos se conectaron a un solo arduino, y los pines de 5v de neopixel se unieron a la vez para conectar la fuente de alimentación.
• La GND de los neopíxeles y los interruptores también se unieron y, para facilitar la percepción, los interruptores se conectaron a los pines 2, 3, 4, 5, 6 y los neopíxeles se conectaron a los pines 9, 10, 11, 12, 13..
• Los interruptores y neopíxeles se conectaron en 2-9, 3-10, 4-11, 5-12, 6-13 vías, respectivamente.
• Cabe señalar que dado que las conexiones de las líneas son complejas y existe riesgo de incendio por cortocircuitos, se calentó el tubo retráctil para asegurar que las partes débiles no se rompieran.

Codificación multitarea Neopixel con interruptor pull up

Animación de 5 luces (tipo lluvia, tipo ducha, tipo relámpago con chispa, tipo pop, tipo irregular)

#incluir

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

patrón de enumeración {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; / * 네오 픽셀 을 방향 을 설정 함 * / enum direction {FORWARD, REVERSE};

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

clase NeoPatterns: public Adafruit_NeoPixel {/ * 패턴 을 추가 하고 업데이트 하기 위한 함수 * / public: patrón ActivePattern; / * 클레스 함수 에 패턴 의 방향 을 입력 * / dirección Dirección;

/ * 변수 Intervalo 을 추가 * / unsigned long Interval; / * 변수 lastUpdate 를 추가 * / unsigned long lastUpdate; / * 변수 Color1, Color2 를 추가 * / uint32_t Color1, Color2; / * 변수 Pasos totales 를 추가 * / uint16_t Pasos totales; / * 변수 Índice 를 추가 * / uint16_t Índice;

/ * 패턴 을 완료 했을 시 다시 불러오는 함수 * / void (* OnComplete) (); / * 네오 패턴 에서 네오 픽샐 의 갯수, 핀 번호, 타입, 콜백 을 불러오는 함수 * / NeoPatterns (uint16_t píxeles, uint8_t pin, uint8_t tipo, void (* devolución de llamada) ()): Adafruit_NeoPixel (píxeles, pin, tipo) { OnComplete = devolución de llamada; }

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

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

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

case THEATER_CHASE: TheaterChaseUpdate (); / * caso THEATER_CHASE 에서 나와라 * / break;

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

case COLOR_WIPE: ColorWipeUpdate (); / * case COLOR_WIPE 에서 나와라 * / break; / * ESCÁNER de casos 에서는 Actualización del escáner 를 실행 하라 * / ESCÁNER de casos: Actualización del escáner (); / * ESCÁNER de casos 에서 나와라 * / break;

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

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

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

caso TWINKLE: TwinkleUpdate (); / * caso TWINKLE 에서 나와라 * / romper;

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

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

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

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

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

LUZ del caso: LightUpdate (); / * caso LIGHT 에서 나와라 * / break;

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

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

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

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

vacío Incremento () {/ * 만약 정방향 이면 인덱스 를 증가 시켜라 * / if (Dirección == ADELANTE) {Index ++; / * 만약 인덱스 가 전체 네오 픽셀 구동 갯수 와 같 거나 많다 면 0 으로 초기화 시켜라 * / if (Índice> = Pasos totales) {Índice = 0; / * 패턴 을 완료 시키는 함수 * / if (OnComplete! = NULL) {OnComplete (); }}}

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

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

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

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

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

void RainbowCycle (intervalo uint8_t, dirección dir = ADELANTE) {/ * 실행 되는 패턴 은 RainbowCycle 임 * / ActivePattern = RAINBOW_CYCLE; / * 시간 은 void RainbowCycle () 안에 입력 되는 intervalo 과 같음 * / Intervalo = intervalo; / * 총 구동 갯수 는 255 임 * / TotalSteps = 255; / * 인덱스 는 0 으로 설정 함 * / Índice = 0; / * 방향 은 void RainbowCycle () 안에 입력 되는 dir = ADELANTE 과 같음 * / Dirección = dir; }

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

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

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

vacío TheaterChase (uint32_t color1, uint32_t color2, uint8_t intervalo, dirección dir = ADELANTE) {/ * 실행 되는 패턴 은 RTHEATER_CHASE * / ActivePattern = THEATER_CHASE; / * 시간 은 void TheaterChase () 안에 입력 되는 intervalo 과 같음 * / Intervalo = intervalo; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); / * 컬러 1, 2 를 설정 * / Color1 = color1; Color2 = color2; / * 인덱스 는 0 으로 설정 함 * / Índice = 0; / * 방향 은 void TheaterChase () 안에 입력 되는 dir = ADELANTE 과 같음 * / Dirección = dir; }

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

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 (); Incremento(); }

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

void ColorWipe (uint32_t color, uint8_t intervalo, dirección dir = FORWARD) {/ * 실행 되는 패턴 은 COLOR_WIPE * / ActivePattern = COLOR_WIPE; / * 시간 은 vacío ColorWipe () 안에 입력 되는 intervalo 과 같음 * / Intervalo = intervalo; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); / * 컬러 1 을 설정 * / Color1 = color; / * 인덱스 는 0 으로 설정 함 * / Índice = 0; / * 방향 은 void ColorWipe () 안에 입력 되는 dir = ADELANTE 과 같음 * / Dirección = dir; }

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

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

/ * Escáner 의 컬러 와 시간 을 입력 * /

Escáner vacío (uint32_t color1, intervalo uint8_t) {/ * 실행 되는 패턴 은 ESCÁNER * / ActivePattern = ESCÁNER; / * 시간 은 escáner vacío () 안에 입력 되는 intervalo 과 같음 * / Intervalo = intervalo; / * 구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Color1 = color1; / * 인덱스 는 0 으로 설정 함 * / Índice = 0; }

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

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

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

Desvanecimiento vacío (uint32_t color1, uint32_t color2, uint16_t pasos, uint8_t intervalo, dirección dir = ADELANTE) {/ * 실행 되는 패턴 은 FADE * / ActivePattern = FADE; / * 시간 은 Desvanecimiento vacío () 안에 입력 되는 intervalo 과 같음 * / Intervalo = intervalo; / * 구동 갯수 는 스텝 값임 * / TotalSteps = pasos; / * 컬러 1, 2 를 설정 * / Color1 = color1; Color2 = color2; / * 인덱스 는 0 으로 설정 함 * / Índice = 0; / * 방향 은 void Fade () 안에 입력 되는 dir = ADELANTE 과 같음 * / Dirección = dir; } / * FadeUpdate 를 업데이트 했을 경우 * / void FadeUpdate () {/ * 변수 red 값 은 다음 과 같음 * / uint8_t red = ((Red (Color1) * (TotalSteps - Index)) + (Red (Color2) * Index)) / TotalSteps; / * 변수 verde 값 은 다음 과 같음 * / uint8_t verde = ((Verde (Color1) * (Pasos totales - Índice)) + (Verde (Color2) * Índice)) / Pasos totales; / * 변수 azul 값 은 다음 과 같음 * / uint8_t azul = ((Azul (Color1) * (Pasos totales - Índice)) + (Azul (Color2) * Índice)) / Pasos totales; / * 위 의 rojo, verde, azul 값 으로 컬러 를 셋팅 함 * / ColorSet (Color (rojo, verde, azul)); / * 애니메이션 을 보여주는 함수 * / show (); Incremento(); }

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

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

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

Destello vacío (uint32_t color1, intervalo uint8_t) {/ * 실행 되는 패턴 은 TWINKLE * / ActivePattern = TWINKLE; / * 시간 은 vacío Twinkle () 안에 입력 되는 intervalo 과 같음 * / Intervalo = intervalo; / * 컬러 1 를 설정 * / Color1 = color1; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); Índice = 0; }

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

void TwinkleUpdate () {/ * 모든 네오 픽셀 의 컬러 를 0 으로 셋팅 * / setAll (0, 0, 0); / * 변수 Pixel 은 aleatorio 74 * / int Pixel = aleatorio (74); / * aleatorio 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 (); Incremento(); }

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

Estrella vacía (uint32_t color1) {/ * 실행 되는 패턴 은 STAR * / ActivePattern = STAR; / * 시간 은 vacío Estrella () 안에 입력 되는 intervalo 과 같음 * / Intervalo = Intervalo; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); / * 컬러 1 을 설정 * / Color1 = color1; Índice = 0; }

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

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

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

void Rainbowsparkle (intervalo uint8_t, dirección dir = ADELANTE) {/ * 실행 되는 패턴 은 RAINBOWSPARKLE * / ActivePattern = RAINBOWSPARKLE; / * 시간 은 void Rainbowsparkle () 안에 입력 되는 intervalo 과 같음 * / Intervalo = intervalo; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); Índice = 0; / * 방향 은 void Rainbowsparkle () 안에 입력 되는 dirección 과 같음 * / Dirección = dir; }

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

void RainbowsparkleUpdate () {/ * 변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데 * / for (int i = 0; i <numPixels (); i ++) {/ * 변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데 * / if ((i + Índice)% 2 == 0) {uint32_t c = aleatorio (255); setPixelColor (i, c); } else {setPixelColor (i, random (255)); }} / * 애니메이션 을 보여주는 함수 * / show (); Incremento(); } / * Meteorito 의 시간 과 방향 을 입력 * / void Meteor (uint32_t color1) {/ * 실행 되는 패턴 은 METEOR * / ActivePattern = METEOR; / * 시간 설정 * / Intervalo = Intervalo; / * 총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Color1 = color1; Índice = 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 (); Incremento(); }

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

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

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

Flor vacía (uint32_t color1) {/ * 실행 되는 패턴 은 FLOR * / Patrón activo = FLOR; / * 시간 설정 * / Intervalo = Intervalo; / * 총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Color1 = color1; Índice = 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 (); Incremento(); }

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

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

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

uint32_t DimColor (uint32_t color) {// Desplaza los componentes R, G y B un bit a la derecha 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); } show(); }

/ * 레드 값 을 불러 옴 * /

uint8_t Rojo (uint32_t color) {return (color >> 16) & 0xFF; } / * 그린 값 을 불러 옴 * / uint8_t Verde (uint32_t color) {return (color >> 8) & 0xFF; } / * 블루 값 을 불러 옴 * / uint8_t Azul (uint32_t color) {color de retorno & 0xFF; }

/ * Arcoíris 컬러 를 불러 옴 * /

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); }}};

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

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 y strip1Complete); NeoPatterns strip2 (74, 9, NEO_GRB + NEO_KHZ800 y strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800 y strip3Complete); NeoPatterns strip4 (74, 11, NEO_GRB + NEO_KHZ800 y strip4Complete); NeoPatterns strip5 (74, 12, NEO_GRB + NEO_KHZ800 y 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 lectura [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; / * 모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음 * / unsigned long debounceDelay = 50;

configuración vacía () {

/ * 복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 방식 의 버튼 설정: GND - 5V (Conectar al número de pin) * / 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, ADELANTE);

}

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

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

///// INTERRUPTOR_2 ////////////////////////////////////////////// //////////////////////////////////////////////////// ///////////////////////////////////////////

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

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

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

///// INTERRUPTOR_3 ////////////////////////////////////////////// //////////////////////////////////////////////////// ///////////////////////////////////////////

switch (buttonCounter [1]) {caso 0: strip2. ActivePattern = STAR; strip2. Interval = 50; strip2. TotalSteps = strip2.numPixels (); rotura; caso 1: strip2. ActivePattern = RAINBOWSPARKLE; strip2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); rotura; caso 2: strip2. ActivePattern = ESCÁNER; strip2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; rotura; caso 3: strip2. ActivePattern = TWINKLE; strip2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); rotura; caso 4: strip2. ActivePattern = METEOR; strip2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); rotura; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// INTERRUPTOR_4 ////////////////////////////////////////////// //////////////////////////////////////////////////// ///////////////////////////////////////////

switch (buttonCounter [2]) {caso 0: strip3. ActivePattern = STAR; strip3. Interval = 50; strip3. TotalSteps = strip3.numPixels (); rotura; caso 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); rotura; caso 2: strip3. ActivePattern = ESCÁNER; strip3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; rotura; caso 3: strip3. ActivePattern = TWINKLE; strip3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); rotura; caso 4: strip3. ActivePattern = METEOR; strip3. Interval = 25; strip3. TotalSteps = strip3.numPixels (); rotura; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// INTERRUPTOR_5 ////////////////////////////////////////////// //////////////////////////////////////////////////// ///////////////////////////////////////////

switch (buttonCounter [3]) {caso 0: strip4. ActivePattern = STAR; strip4. Interval = 50; strip4. TotalSteps = strip4.numPixels (); rotura; caso 1: strip4. ActivePattern = RAINBOWSPARKLE; strip4. Interval = 100; strip4. TotalSteps = strip4.numPixels (); rotura; caso 2: strip4. ActivePattern = ESCÁNER; strip4. Interval = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; rotura; caso 3: strip4. ActivePattern = TWINKLE; strip4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); rotura; caso 4: strip4. ActivePattern = METEOR; strip4. Interval = 25; strip4. TotalSteps = strip4.numPixels (); rotura; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// INTERRUPTOR_6 ////////////////////////////////////////////// //////////////////////////////////////////////////// ///////////////////////////////////////////

switch (buttonCounter [4]) {caso 0: strip5. ActivePattern = STAR; strip5. Interval = 50; strip5. TotalSteps = strip5.numPixels (); rotura; caso 1: strip5. ActivePattern = RAINBOWSPARKLE; strip5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); rotura; caso 2: strip5. ActivePattern = ESCÁNER; strip5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; rotura; caso 3: strip5. ActivePattern = TWINKLE; strip5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); rotura; caso 4: strip5. ActivePattern = METEOR; strip5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); rotura; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// devolución de llamada de finalización de strip1

void strip1Complete () {strip1. Color1 = strip1. Wheel (aleatorio (255)); strip1. Color2 = strip1. Wheel (aleatorio (255)); strip1. Index = 0; }

// devolución de llamada de finalización de strip2

vacío strip2Complete () {strip2. Color1 = strip2. Wheel (aleatorio (255)); strip2. Color2 = strip2. Wheel (aleatorio (255)); strip2. Index = 0; }

// devolución de llamada de finalización de strip3

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

// devolución de llamada de finalización de strip4

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

// devolución de llamada de finalización de strip5

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

Paso 6: Resultado y realización de la película

Gracias por su interés en nuestro proyecto aunque no es suficiente.