Padrão de luz de pontos: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Comecei com a ideia de "Posso controlar a luz com minhas próprias mãos e expressar minha própria vontade?"

É um 'padrão de luz de pontos' que permite que você crie suas próprias cores, projete seus próprios padrões com essas cores e experimente vários efeitos de animação.

Etapa 1: Materiais

1. Arduino UNO x 13
2. Faixa de LED de pixel WS2901 ou WS2811 (130 LEDS)
3. Botão interruptor x 1
4. Interruptor de pressão x 65
5. Potentionmeter x 65
6. Cabo arco-íris
7. Suficientemente SMPS
8. Cabo condutor
9. Barra redonda de acrílico transparente (30 mm de diâmetro)
10. Placa acrílica de cor preta (5T) (500 mm * 790 mm) x 2, (500 mm * 35 mm) x 2, (790 mm * 35 mm) x 2

Etapa 2: Plano de construção

Etapa 3: Hardware: Projeto do circuito

1. Corte a placa de acrílico como a estrutura acima. (veja a etapa 2)

2. Um pedaço de LED de neo-pixel é colocado na parte superior e inferior do orifício do potentionmeter, e um total de 65 pares de LEDs de neo-pixel são anexados.
3. Um par de LEDs neo-pixel é conectado para formar um único pino Arduino.
4. Encaixe 65 medidores de potência nos orifícios do medidor de potência. (Coloque-o no lado oposto de uma superfície neo-pixelizada.)
5. Conecte 65 interruptores de pressão para coincidir com os orifícios dos interruptores.
6. Um total de treze Arduino UNOs são anexados a cada uma das treze zonas para ligar cinco peças de 65 peças de hardware em um Arduino UNO.
7. Conforme mostrado na foto em anexo, conecte os medidores de potência, interruptores de pressão e LEDs de neo-pixel aos pinos do Arduino UNO por fio. (veja a etapa 2)
8. Os pinos GND e 5V de vários UNOs do Arduino são coletados nos fios do cabo e, em seguida, conectados à alimentação externa. (veja a etapa 2)
9. Remova a poeira por pressão de ar.

Etapa 4: Hardware: Corte de acrílico

1. Corte a haste de acrílico com um comprimento de 50 mm.
2. Um lado da haste de acrílico é perfurado no tamanho e profundidade para coincidir com a parte do controlador do potentionmeter.
3. A haste de acrílico é cortada ligeiramente mais larga do que o orifício para uma folga que pode se encaixar bem no potentionmeter.

4. O outro lado dá uma pequena lixa para que a luz seja transmitida de maneira precisa.

Etapa 5: Código de programação do Arduino

www.kasperkamperman.com/blog/arduino/ardui…

código 'hsb para rgb' 를 참고 한 사이트

#incluir

// 'adafruit_neopixel' 헤더 파일 라는 외부 라이브러리 를 포함

// 네오 픽셀 연결 핀 번호 선언

#define PIN1 2 #define PIN2 3 #define PIN3 4 #define PIN4 5 #define PIN5 6

#define NUMPIXELS 2 // 네오 픽셀 LED 갯수

#define NUM_LIGHTS 5 // 작동 모듈 갯수 (네오 픽셀 오브젝트 갯수)

// 네오 픽셀 오브젝트 Array 선언

Adafruit_NeoPixel pixels = {Adafruit_NeoPixel (NUMPIXELS, Pin1, NEO_GRB + NEO_KHZ800), Adafruit_NeoPixel (NUMPIXELS, PIN2, NEO_GRB + NEO_KHZ800), Adafruit_NeoPixel (NUMPIXELS, PIN3, NEO_GRB + NEO_KHZ800), Adafruit_NeoPixel (NUMPIXELS, pin4, NEO_GRB + NEO_KHZ800), Adafruit_NeoPixel (NUMPIXELS, PIN5, NEO_GRB + NEO_KHZ800)}; //// 네오 픽셀 을 사용 하기 위해 객체 하나 를 생성 한다. // 첫번째 인자 값 은 네오 픽셀 의 LED 의 개수 // 두번째 인자 값 은 네오 픽셀 이 연결된 아두 이노 의 의 핀 번호 // 세번째 인자 값 은 네오 픽셀 의 타입 에 따라 바뀌는 flag

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

////// HSV 를 RGB 로 변환 하는 함수 getRGB () 를 위한 변수 와 함수 선언

const byte dim_curve = {

0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 20, 20, 20, 21, 21, 22, 22, 22, 23, 23, 24, 24, 25, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 32, 32, 33, 33, 34, 35, 35, 36, 36, 37, 38, 38, 39, 40, 40, 41, 42, 43, 43, 44, 45, 46, 47, 48, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71, 73, 74, 75, 76, 78, 79, 81, 82, 83, 85, 86, 88, 90, 91, 93, 94, 96, 98, 99, 101, 103, 105, 107, 109, 110, 112, 114, 116, 118, 121, 123, 125, 127, 129, 132, 134, 136, 139, 141, 144, 146, 149, 151, 154, 157, 159, 162, 165, 168, 171, 174, 177, 180, 183, 186, 190, 193, 196, 200, 203, 207, 211, 214, 218, 222, 226, 230, 234, 238, 242, 248, 255, }; //

void getRGB (int hue, int sat, int val, int colors [5] [3], int index) {

val = dim_curve [val]; sat = 255 - dim_curve [255 - sat];

// 색조, 채도 및 밝기 (HSB / HSV) 를 RGB 로 변환

// dim_curve 는 밝기 값 및 채도 (반전) 에서만 사용 됩니다. // 이것은 가장 자연스럽게 보입니다.

int r;

int g; int b; base interna;

if (sat == 0) {

cores [índice] [0] = val; cores [índice] [1] = val; cores [índice] [2] = val; } outro {

base = ((255 - sat) * val) >> 8;

switch (matiz / 60) {

caso 0: r = val; g = (((val - base) * matiz) / 60) + base; b = base; pausa;

caso 1:

r = (((val - base) * (60 - (matiz% 60))) / 60) + base; g = val; b = base; pausa;

caso 2:

r = base; g = val; b = (((val - base) * (matiz% 60)) / 60) + base; pausa;

caso 3:

r = base; g = (((val - base) * (60 - (matiz% 60))) / 60) + base; b = val; pausa;

caso 4:

r = (((val - base) * (matiz% 60)) / 60) + base; g = base; b = val; pausa;

caso 5:

r = val; g = base; b = (((val - base) * (60 - (matiz% 60)))) / 60) + base; pausa; }

cores [índice] [0] = r;

cores [índice] [1] = g; cores [índice] [2] = b; }

}

int rgb_colors [NUM_LIGHTS] [3]; // 네오 픽셀 오브젝트 갯수 마다 cor rgb 선언

matiz int [NUM_LIGHTS]; // 네오 픽셀 오브젝트 갯수 마다 matiz 선언 int sat [NUM_LIGHTS]; // 네오 픽셀 오브젝트 갯수 마다 명도 선언 int brignt [NUM_LIGHTS]; // 네오 픽셀 오브젝트 갯수 마다 밝기 서언

// 일반 변수 선언

int startSwitch = {8, 9, 10, 11, 12}; // liga / desliga 버튼 핀 번호 boolean startState = {false, false, false, false, false}; // liga / desliga 상태 변수

const int colorPin = {A0, A1, A2, A3, A4}; // 가변 저항 핀 번호

int colorVal = {0, 0, 0, 0, 0}; // 가변 저항 초기 값

int animationButton = 7; // 애니메이션 모드 변환 버튼 핀 번호

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

// 애니메이션 모든 변환 을 위한 버튼 디 바운싱 변수 선언 // 디 바운싱? 짧은 시간 내 많은 이벤트 이벤트 가 발생 하는것 에 대한 문제 에 대해서 지정된 시간 간격 으로 함수 함수 를 호출 하여 해결 int buttonState; // 입력 핀 으로부터 의 현재 판독 값 int lastButtonState = HIGH; // 이전 의 판독 값 은 켜진 상태 로 unsigned long lastDebounceTime = 0; // 출력 핀 이 마지막 으로 전환 된 시간 은 0 으로 unsigned long debounceDelay = 50; // 디 바운싱 타임 설정; 출력 이 깜빡 이면 증가 한다 int MODE = 0; // 애니메이션 모드 변수

int B_Interval [5]; // 블 링킹 을 위한 각 모듈 의 랜덤 속도 변수

int B_Min = 100; // 블 링킹 최단 속도; int B_Max = 500; // 블 링킹 최장 속도; int R_Interval = 50; // 레인보우 애니메이션 속도 변수 int D_Interval = 10; // 디밍 속도 변수

boolean B_state [5]; // 블 링킹 을 위한 각 모듈 의 상태 변수

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

// 멀티 테스 킹 애니메이션 을 위한 시간 변수 선언

unsigned long currentMillis; // 현재 시간 변수

longo sem sinal B_previousMillis [5]; // 각 모듈 의 블 링킹 타이머 unsigned long DR_Millis [5]; // 각 모듈 의 디밍 랜덤 타이머 (예비) unsigned long R_previousMillis; // 레인보우 타이머 unsigned long D_previousMillis; // 디밍 타이머

booleano firstRainbow = true; // 레인보우 색상 초기화 상태 변수

int RainbowSpeed; // 레인보우 변환 변수

Int Bright = 100; // 디밍 초기 값 int BrightnessFactor = 1; // 디밍 증감 값 /////////////////////////////////////////////// //////////////////////////////////////////

void setup () {

para (int i = 0; i <NUM_LIGHTS; i ++) {pixels .begin (); // 네오 픽셀 오브젝트 초기화}

// 버튼 인풋 설정

para (int i = 0; i <NUM_LIGHTS; i ++) {pinMode (startSwitch , INPUT_PULLUP); // liga / desliga 버튼 인풋 설정} pinMode (animationButton, INPUT_PULLUP); // 애니메이션 버튼 인풋 설정

para (int i = 0; i <NUM_LIGHTS; i ++) {B_Interval = int (aleatório (B_Min, B_Max)); // 모듈 별 블 링킹 랜덤 속도 (인터발) 변수 생성}

Serial.begin (9600); // 통신 설정

}

void loop () {

MODE = CheckAnimMode (); // 모드 에 애니메이션 체크 모드 함수 를 넣는다

// 버튼 과 가변 저항 을 값 을 각각 읽어 변수 에 지정 한다.

para (int i = 0; i <NUM_LIGHTS; i ++) {startState =! digitalRead (startsSwitch ); // liga / desliga 버튼 에서 읽은 값 의 반대 값 을 startState 에 넣어 준다 // startState = digitalRead (startsSwitch ); colorVal = analogRead (colorPin ); // 가변 저항 에서 읽은 값 을 가변 저항 초기 값 에 넣는다}

switch (MODE) {// 애니메이션 함수 스위치 문

caso 0: em (); // no 함수 실행 break; // 조건문 에서 빠져 나가라

caso 1:

arco-íris(); // arco-íris 함수 실행 break;

caso 2:

escurecimento (); // escurecimento 함수 실행 break;

caso 3:

piscando (); // piscando 함수 실행 break; }

para (int i = 0; i <NUM_LIGHTS; i ++) {pixels .show (); // 네오 픽셀 오브젝트 배열 켜라}

}

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

int CheckAnimMode () {

// 애니메이션 선택 버튼 을 읽어 모드 를 결정 한다.

//////////////////////////////////////////////////////// /// currentMillis = millis (); // 시간 측정 int reading = digitalRead (animationButton); if (reading! = lastButtonState) {// 입력 핀 으로부터 이전 의 버튼 의 상태 와 판독 값 비교 lastDebounceTime = millis (); // 현재 시간 을 출력 핀 이 마지막 으로 전환 된 시간 에 넣음}

if ((currentMillis - lastDebounceTime)> debounceDelay) {

if (reading! = buttonState) {// 입력 핀 으로부터 받은 현재 값 과 판독 값 과 비교

buttonState = leitura; // 판독 값 을 buttonState 에 대입

if (buttonState == LOW) {// 버튼 상태 가 꺼져 있다면

MODE ++; // 버튼 모드 1 씩 증가 if (MODE> 3) {MODE = 0; primeiro Arco-Íris = verdadeiro; // 레인보우 색상 초기화 상태 켜짐 BrightnessFactor = 1; // 디밍 증감 값 Bright = 15; // 밝기 는 15}}}}

lastButtonState = leitura; // 판독 값 을 이전 의 버튼 상태 에 대입

return MODE; Modo 함수 를 종료 하고 함수 로 값 을 리턴 하라}

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

// função do modo de animação

//sobre

void on () {Serial.println ("on"); // 시리얼 모니터 에 on 을 써라 for (int i = 0; i <NUM_LIGHTS; i ++) {color_set (i, colorVal ); // 가변 저항 값 에 따라 컬러 셋팅}}

//Arco-íris

void rainbow () {Serial.println ("chuva"); // 시리얼 모니터 에 chuva 을 써라 if (firstRainbow) {RainbowSpeed = 0; // 레인보우 속도 초기화 firstRainbow = false; // 레인보우 색상 초기화 상태 꺼짐} if (millis () - R_previousMillis> R_Interval) {// 흐른 시간 값 이 레인보우 레인보우 인터벌 값 보다 크면 R_previousMillis = currentMillis; // 현재 시간 을 이전 의 레인보우 시간 에 넣어 라 RainbowSpeed + = 10; // 레인보우 변환 변수 에 10 을 더해라}

para (int i = 0; i <NUM_LIGHTS; i ++) {color_set (i, (colorVal + RainbowSpeed)% 1023); // 레인보우 컬러 셋팅}

}

// Dimming

void dimmer () {Serial.println ("dimm"); // 시리얼 모니터 에 dimm 을 써라 Serial.println (Bright); // 시리얼 모니터 에 Brilhante 를 써라 if (currentMillis - D_previousMillis> D_Interval) {// 흐른 시간 값 이 디밍 디밍 인터벌 값 보다 크면 D_previousMillis = currentMillis; // 현재 시간 을 이전 의 디밍 시간 에 넣어 라 Bright + = BrightnessFactor; // 밝기 에 디밍 증감 값 1 씩 올려라} if (Bright 254) {BrightnessFactor = -1 * BrightnessFactor; } Bright = restrição (Bright, 99, 254); // 변수 밝기 값 을 최소값 99 ~ 최대 값 254 사이 의 값 으로 한정 한다

para (int i = 0; i <NUM_LIGHTS; i ++) {dim_color_set (i, Bright); // 디밍 컬러 셋팅}}

// Piscando

void piscando () {Serial.println ("piscando"); // 시리얼 모니터 에 piscar 를 써라

for (int i = 0; i B_Interval ) {// 흐른 시간 값 이 블링크 인터벌 값 보다 크면

B_previousMillis = currentMillis; // 현재 시간 을 이전 의 블링크 시간 에 넣어 라 B_state =! B_state ; // 각 모듈 의 블 블 링킹 상태 변수 의 값 의 반대 값 을 대입 하라}} for (int i = 0; i <NUM_LIGHTS; i ++) {if (B_state ) {// 모듈 의 블 링킹 상태 가 읽 히면 color_set (i, colorVal ); // 가변 저항 값 에 따라 컬러 셋팅} else {noColor_set (i); // 읽히지 않으면 컬러 셋팅 하지 않음}}

}

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

// função central

// conjunto de cores

void color_set (int index, int colorSenser) {

if (startState [index]) {hue [index] = map (colorSenser, 0, 1023, 0, 359); // 0 ~ 1023 값 을 0 ~ 359 값 으로 매핑 한 값 을 가지고 색상 값 으로 지정 (colorSenser 에) getRGB (hue [índice], 255, 255, rgb_colors, índice); for (int i = 0; i <NUMPIXELS; i ++) {pixels [índice].setPixelColor (i, pixels [índice]. Color (rgb_colors [índice] [0], rgb_colors [índice] [1], rgb_colors [índice] [2])); } // 픽셀 컬러 셋팅 을 rgb_colors 의 r, g, b 으로 설정} else noColor_set (índice); // 컬러 셋팅 하지 않음}

////// noColor set

void noColor_set (int index) {// 컬러 셋팅 하지 않는 함수 설정

para (int i = 0; i <NUMPIXELS; i ++) {pixels [índice].setPixelColor (i, pixels [índice]. Color (0, 0, 0)); } // 픽셀 컬러 세팅 을 0, 0, 0 으로 설정}

//// dimColor set

void dim_color_set (int index, int BC) {// 디밍 컬러 셋팅 함수 설정

if (startState [index]) {hue [index] = map (colorVal [index], 0, 1023, 0, 359); // 0 ~ 1023 값 을 0 ~ 359 값 으로 매핑 한 값 을 가지고 색상 값 으로 지정 (colorVal 에) getRGB (hue [índice], 255, BC, rgb_colors, índice); for (int i = 0; i <NUMPIXELS; i ++) {pixels [índice].setPixelColor (i, pixels [índice]. Color (rgb_colors [índice] [0], rgb_colors [índice] [1], rgb_colors [índice] [2])); } /// 픽셀 컬러 셋팅 을 rgb_colors 의 r, g, b 으로 설정} else noColor_set (índice); // 컬러 셋팅 하지 않음}

Etapa 6: um visual acabado