Model de lumină de puncte: 6 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Am început cu ideea „Pot să controlez lumina cu propriile mâini și să-mi exprim propria voință?”

Este un „Dot Light Pattern” care vă permite să vă creați propriile culori, să vă proiectați propriile modele cu acele culori și să experimentați diverse efecte de animație.

Pasul 1: Materiale

1. Arduino UNO x 13
2. Benzi LED WS2901 sau WS2811 pixeli (130 LED)
3. Buton x 1
4. Comutator cu apăsare x 65
5. Potentimetru x 65
6. Cablu curcubeu
7. Putere suficientă SMPS
8. Cablu conductor
9. Bara rotunda transparenta acrilica (diametru 30mm)
10. Placă acrilică de culoare neagră (5T) (500mm * 790mm) x 2, (500mm * 35mm) x 2, (790mm * 35mm) x 2

Pasul 2: Planul de construcție

Pasul 3: Hardware: proiectarea circuitului

1. Tăiați placa acrilică ca structura de mai sus. (vezi pasul 2)

2. O bucată de LED neo-pixel este pusă în partea superioară și inferioară a orificiului potentmetrului și sunt atașate un total de 65 de perechi de LED-uri neo-pixel.
3. O pereche de LED-uri neo-pixel sunt conectate împreună pentru a forma un singur pin Arduino.
4. Montați 65 de potențimetre în orificiile potențometrului. (Puneți-l pe partea opusă a unei suprafețe neo-pixelate.)
5. Atașați 65 de comutatoare de prindere pentru a se potrivi cu găurile comutatorului.
6. Un total de treisprezece Arduino UNO sunt atașate la fiecare dintre cele treisprezece zone pentru a lega cinci bucăți de 65 de bucăți de hardware într-un singur Arduino UNO.
7. Așa cum se arată în fotografia atașată, conectați potenzimetrele, comutatoarele snap și LED-urile neo-pixel la pinii Arduino UNO prin cablu. (vezi pasul 2)

8. Pinii GND și 5V ai mai multor Arduino UNO sunt colectați pe cablurile cablurilor, apoi conectați la sursa de alimentare externă. (vezi pasul 2)

9. Îndepărtați praful prin presiunea aerului.

Pasul 4: Hardware: tăiere acrilică

1. Tăiați tija acrilică la o lungime de 50 mm.
2. O parte a tijei acrilice este găurită la dimensiune și adâncime pentru a se potrivi cu partea de control a potențometrului.
3. Tija acrilică este tunsă puțin mai lată decât orificiul pentru un spațiu care se potrivește bine în potențometru.
4. Cealaltă parte oferă puțin șmirghel, astfel încât lumina să poată fi transmisă cu grijă.

Pasul 5: Cod de programare Arduino

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

codul „hsb la rgb” 를 참고 한 사이트

#include

// '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 선언

pixeli Adafruit_NeoPixel = {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 () 를 위한 변수 와 함수 선언

octet const 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; int baza;

if (sat == 0) {

culori [index] [0] = val; culori [index] [1] = val; culori [index] [2] = val; } altceva {

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

comutator (nuanță / 60) {

cazul 0: r = val; g = (((val - bază) * nuanță) / 60) + bază; b = bază; pauză;

cazul 1:

r = (((val - bază) * (60 - (nuanță% 60))) / 60) + bază; g = val; b = bază; pauză;

cazul 2:

r = bază; g = val; b = (((val - bază) * (nuanță% 60)) / 60) + bază; pauză;

cazul 3:

r = bază; g = (((val - bază) * (60 - (nuanță% 60))) / 60) + bază; b = val; pauză;

cazul 4:

r = (((val - bază) * (nuanță% 60)) / 60) + bază; g = bază; b = val; pauză;

cazul 5:

r = val; g = bază; b = (((val - bază) * (60 - (nuanță% 60))) / 60) + bază; pauză; }

culori [index] [0] = r;

culori [index] [1] = g; culori [index] [2] = b; }

}

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

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

// 일반 변수 선언

int startsSwitch = {8, 9, 10, 11, 12}; // on / off 버튼 핀 번호 boolean startState = {false, false, false, false, false}; // pornit / oprit 상태 변수

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

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

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

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

// 애니메이션 모든 변환 을 위한 버튼 디 바운싱 변수 선언 // 디 바운싱? Button 시간 내 많은 이벤트 가 발생 하는것 에 대한 문제 에 대해서 지정된 시간 간격 으로 함수 를 호출 하여 button int buttonState; // 입력 핀 으로부터 의 현재 판독 값 int lastButtonState = HIGH; // 이전 의 판독 값 은 켜진 상태 로 unsigned long lastDebounceTime = 0; // 출력 핀 이 마지막 으로 전환 된 시간 은 0 으로 nesemnat lung 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; // 디밍 속도 변수

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

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

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

curent lung semnat Millis; // 현재 시간 변수

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

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

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

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

configurare nulă () {

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

// 버튼 인풋 설정

for (int i = 0; i <NUM_LIGHTS; i ++) {pinMode (startsSwitch , INPUT_PULLUP); // on / off 버튼 인풋 설정} pinMode (animationButton, INPUT_PULLUP); // 애니메이션 버튼 인풋 설정

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

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

}

bucla nulă () {

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

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

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

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

caz 0: on (); // pe 함수 실행 pauză; // 조건문 에서 빠져 나가라

cazul 1:

curcubeu(); // curcubeu 함수 실행 pauză;

cazul 2:

estompare (); // estomparea 함수 실행 pauză;

cazul 3:

clipire (); // clipind 함수 실행 pauză; }

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

}

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

int CheckAnimMode () {

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

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

if ((currentMillis - lastDebounceTime)> debounceDelay) {

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

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

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

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

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

returnare MOD; 함수 를 종료 하고 mode 함수 로 값 을 리턴 하라}

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

// funcție mod animație

//pe

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

//Curcubeu

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

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

}

// Dimming

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

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

// Clipește

void clipește () {Serial.println ("clipire"); // 시리얼 모니터 에 clipesc 를 써라

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

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

}

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

// funcție de bază

// set de culori

void color_set (int index, int colorSenser) {

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

////// noColor set

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

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

//// set dimColor

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

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

Pasul 6: O privire terminată