Ulepszanie kostki nastroju Arduino LED (proste) (załączone wideo): 4 kroki

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:29

Po obejrzeniu projektu LED small mood cube stworzonego przez Earla, postanowiłem zrobić ulepszoną wersję LED Mood Cube. Moja wersja będzie bardziej złożona niż oryginalna, ponieważ będzie nieco większa od oryginalnej, będzie miała o dwa kolory więcej w stosunku do oryginalnej kostki (dodano żółty i biały), będzie miała nieskończoną ilość rotacji kolorów itp. powinien być dobrym projektem do przećwiczenia dalszego użytkowania świateł LED dla tych, którzy rozumieją koncepcję łączenia świateł LED z przewodami.

Krok 1: Materiały

Oto kilka materiałów, których będziesz potrzebować, aby wykonać tę kostkę nastroju:

• Deska do krojenia chleba
• Arduino - (mam tu Leonardo)
• Zasilacz Arduino / kabel USB
• Deska do krojenia chleba
• Przewody połączeniowe (dużo ich, użyłem 29 przewodów)
• Czerwona dioda x 2
• Niebieska dioda LED x 2
• Zielona dioda x 2
• Żółta dioda x 2
• Biała dioda LED x 1
• 9 rezystorów
• Pudełko na tyle duże, by zmieściło się w płytce do krojenia chleba (użyłem pudełka po butach)
• Nóż uniwersalny
• Papier

Krok 2: Kod

Wyjaśnienie kodu podanego tutaj:

Kredyty kodów trafiają do oryginalnego źródła mojego projektu, ponieważ redaktor projektu stworzył te kody. Po prostu poprawiłem niektóre z nich, czyniąc je bardziej złożonymi. W niektórych kodach możesz zobaczyć na końcu //改. Oznacza to, że ten kod jest przeze mnie edytowany, więc różni się od mojego oryginalnego źródła.

Mam też wersję kodu na Arduino Creator.

/* Kod cross-fadingu 3 diody LED, czerwona, zielona i niebieska (RGB) Aby stworzyć zanikanie, musisz zrobić dwie rzeczy: 1. Opisz kolory, które chcesz wyświetlać 2. Wymień kolejność, w jakiej mają one zanikać

OPISUJĄCY KOLOR:

Kolor to tylko tablica trzech procentów, 0-100, kontrolujących czerwone, zielone i niebieskie diody LED

Czerwony to czerwona dioda LED w pełni, niebieska i zielona wyłączona

int red = { 100, 0, 0 } Dim white to wszystkie trzy diody LED przy 30% int dimWhite = {30, 30, 30} itd.

Niektóre popularne kolory są podane poniżej lub stwórz własne

LISTA ZAMÓWIENIA:

W głównej części programu należy podać kolejność, w jakiej mają się pojawiać kolory, m.in. crossFade (czerwony); crossFade(zielony); crossFade (niebieski);

Te kolory pojawią się w tej kolejności, zanikając

jeden kolor i w następny

Ponadto istnieje 5 opcjonalnych ustawień, które możesz dostosować:

1. Początkowy kolor jest ustawiony na czarny (więc pierwszy kolor zanika), ale możesz ustawić początkowy kolor na dowolny inny. 2. Wewnętrzna pętla działa na 1020 interakcjach; zmienna 'wait' określa przybliżony czas trwania pojedynczego przejścia. Teoretycznie „czekanie” 10 ms powinno spowodować crossFade trwające ~10 sekund. W praktyce inne funkcje, które wykonuje kod, spowalniają to do ~11 sekund na mojej tablicy. YMMV. 3. Jeśli 'repeat' jest ustawione na 0, program będzie zapętlał się w nieskończoność. jeśli jest ustawiony na liczbę, zapętli tę liczbę razy, a następnie zatrzyma się na ostatnim kolorze w sekwencji. (Ustaw 'return' na 1 i ustaw ostatni kolor na czarny, jeśli chcesz, aby wyblakł na końcu.) 4. Istnieje opcjonalna zmienna 'hold', która zatrzymuje program na 'hold' na milisekundy, gdy kolor jest zakończyć, ale przed rozpoczęciem następnego koloru. 5. Ustaw flagę DEBUG na 1, jeśli chcesz, aby dane wyjściowe debugowania były wysyłane do monitora szeregowego.

Wnętrze programu nie jest skomplikowane, ale…

są trochę wybredne - wewnętrzne działanie wyjaśniono poniżej głównej pętli.

Kwiecień 2007, Clay Shirky

*

/ Wyjście

int ylwPin = 5; // Żółta dioda LED, podłączona do cyfrowego pinu 5 //改 int redPin = 6; // Czerwona dioda LED, podłączona do cyfrowego pinu 6 //改 int grnPin = 7; // Zielona dioda LED, podłączona do cyfrowego pinu 7 //改 int bluPin = 8; // Niebieska dioda LED, podłączona do cyfrowego pinu 8 //改 int whiPin = 9; // Biała dioda LED, podłączona do cyfrowego pinu 9 //改 int ylwPin2 = 10; // Żółta dioda LED, podłączona do cyfrowego pinu 10 //改 int redPin2 = 11; // Czerwona dioda LED podłączona do cyfrowego pinu 11 //改 int grnPin2 = 12; // Zielona dioda LED, podłączona do cyfrowego pinu 12 //改 int bluPin2 = 13; // Niebieska dioda LED, podłączona do cyfrowego pinu 13 //改

// Tablice kolorów

int czarny[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };//改 int biały[9] = { 100, 100, 100, 100, 100, 100, 100, 100, 100 };//改 int czerwony[9] = { 0, 0, 100, 0, 0, 0, 100, 0, 0 };//改 int zielony[9] = { 0, 100, 0, 0, 0, 0, 0, 100, 0 };//改 int niebieski[9] = { 0, 0, 0, 100, 0, 0, 0, 0, 100 };//改 int żółty[9] = { 100, 0, 0, 0, 0, 100, 0, 0, 0}; //改 int fioletowy[9] = { 0, 50, 0, 50, 0, 0, 50, 0, 50 }; //改 int pomarańczowy[9] = { 50, 50, 0, 0, 0, 50, 50, 0, 0 }; //改 int różowy[9] = { 0, 50, 0, 0, 50, 0, 0, 50, 0, }; //改 // itd.

// Ustaw początkowy kolor

int redVal = czarny[0]; int grnVal = czarny[1]; int bluVal = czarny[2]; int ylwVal = czarny[3]; //改 int whiVal = czarny[4]; //改

int czekaj = 15; // 10ms wewnętrzne opóźnienie crossFade; wzrost dla wolniejszych zaników //改

int przytrzymaj = 1; // Opcjonalne wstrzymanie po zakończeniu koloru, przed następnym crossFade //改 int DEBUG = 1; // licznik DEBUGÓW; jeśli ustawione na 1, zapisze wartości z powrotem przez port szeregowy int loopCount = 60; // Jak często należy zgłaszać DEBUG? int powtórz = 0; // Ile razy powinniśmy wykonać pętlę przed zatrzymaniem? (0 oznacza brak zatrzymania) //改 int j = 0; // Licznik pętli do powtórzenia

// Zainicjuj zmienne kolorów

int prevR = redVal; int prevG = grnVal; int prevB = bluVal; int prevY = ylwVal; int prevW = whiVal; //改

// Skonfiguruj wyjścia LED

void setup() { pinMode(redPin, OUTPUT); // ustawia piny jako wyjście pinMode(grnPin, OUTPUT); pinMode(bluPin, WYJŚCIE); pinMode(ylwPin, WYJŚCIE); //改 pinMode(whiPin, OUTPUT); //改 pinMode(grnPin2, WYJŚCIE); //改 pinMode(bluPin2, WYJŚCIE); //改 pinMode(ylwPin2, WYJŚCIE); //改 pinMode(redPin2, WYJŚCIE); //改

if (DEBUG) { // Jeśli chcemy zobaczyć wartości do debugowania…

Serial.początek(9600); // …skonfiguruj wyjście szeregowe } }

// Program główny: podaj kolejność przenikania

void loop() { crossFade(czerwony); crossFade(zielony); crossFade (niebieski); crossFade(żółty); crossFade (biały); crossFade(różowy); crossFade(fioletowy); crossFade(pomarańczowy);

if (repeat) { // Czy wykonujemy pętlę skończoną liczbę razy?

j += 1; if (j >= powtórz) { // Czy już tam jesteśmy? wyjście(j); // Jeśli tak, przestań. } } }

/* PONIŻEJ TEJ LINII ZNAJDUJE SIĘ MATEMATYKA - NIE POWINIEN BYĆ TEGO ZMIENIAĆ ZE WZGLĘDU NA PODSTAWY

Program działa tak:

Wyobraź sobie crossfade, który przesuwa czerwoną diodę LED z 0-10, zieloną z 0-5 i niebieską z 10 do 7 w dziesięciu krokach. Chcielibyśmy policzyć 10 kroków i zwiększyć lub zmniejszyć wartości kolorów w równych krokach. Wyobraź sobie, że + oznacza podniesienie wartości o 1, a - oznacza jej obniżenie. Nasze 10 stopniowe zanikanie wyglądałoby tak:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + + G + + + + + B - - -

Czerwony rośnie od 0 do 10 w dziesięciu krokach, zielony od

0-5 w 5 krokach, a niebieski spada z 10 do 7 w trzech krokach.

W rzeczywistym programie procenty kolorów są przeliczane na

0-255 wartości i jest 1020 kroków (255*4).

Aby dowiedzieć się, jak duży powinien być krok między jednym w górę lub

zaznaczając jedną z wartości diod LED, wywołujemy metodę kalkulacjiStep(), która oblicza bezwzględną przerwę między wartościami początkową i końcową, a następnie dzieli tę przerwę przez 1020, aby określić wielkość kroku między korektami wartości. */

int obliczKrok(int prevValue, int endValue) {

int step = endValue - prevValue; // Jaka jest ogólna luka? if (step) { // Jeśli jest niezerowe, step = 1020 / step; // podziel przez 1020 } return step; }

/* Następna funkcja to obliczWartość. Gdy wartość pętli, i, osiąga wielkość kroku odpowiednią dla jednego z kolorów, zwiększa lub zmniejsza wartość tego koloru o 1. (R, G i B są obliczane osobno.) */

int obliczVal(int step, int val, int i) {

if ((step) && i % step == 0) { // Jeżeli step jest niezerowy i czas na zmianę wartości, if (step > 0) { // zwiększ wartość, jeśli step jest dodatni… val += 1; } else if (etap 255) {val = 255; } else if (val < 0) { val = 0; } return val; }

/* crossFade() konwertuje kolory procentowe na a

Zakres 0-255, następnie pętla 1020 razy, sprawdzając, czy wartość musi być aktualizowana za każdym razem, a następnie zapisując wartości kolorów do właściwych pinów. */

void crossFade(int kolor) { //改

// Konwertuj na 0-255 int R = (color[0] * 255) / 100; int G = (kolor[1] * 255) / 100; int B = (kolor[2] * 255) / 100; int Y = (kolor[3] * 255) / 100; //改 int W = (kolor[4] * 255) / 100; //改

int stepR = obliczKrok(prevR, R);

int stepG = obliczKrok(prevG, G); int stepB = obliczKrok(prevB, B); int stepY = obliczKrok(poprzedni Y, Y); //改 int stepW = obliczKrok(poprzedni W, W); //改

for (int i = 0; i <= 1020; i++) { redVal = obliczVal(krokR, redVal, i); grnVal = obliczVal(krokG, grnVal, i); bluVal = oblicz Val(krok B, bluVal, i); ylwVal = obliczVal(krokY, ylwVal, i); //改 whiVal = obliczVal(krokW, whiVal, i); //改

zapis analogowy(redPin, redVal); // Zapisz aktualne wartości do pinów LED

analogWrite(grnPin, grnVal); zapis analogowy(bluPin, bluVal); analogWrite(ylwPin, ylwVal); //改 analogWrite(whiPin, whiVal); //改 zapis analogowy(grnPin2, grnVal); //改 zapis analogowy(bluPin2, bluVal); //改 zapis analogowy(ylwPin2, ylwVal); //改 zapis analogowy(redPin2, redVal); //改

opóźnienie (czekaj); // Pauza na „czekaj” milisekundy przed wznowieniem pętli

if (DEBUG) { // Jeśli chcemy uzyskać wyjście szeregowe, wypisz je na

if (i == 0 lub i % loopCount == 0) { // początek i co loopCount razy Serial.print("Loop/RGBYW: #"); druk.seryjny(i); Serial.print(" | "); Serial.print(redVal); Serial.print(" / "); Serial.print(grnVal); Serial.print(" / "); Serial.println(bluVal); Serial.print(" / "); Serial.println(ylwVal); //改 Serial.print(" / "); //改 Serial.println(whiVal); //改 Serial.print(" / "); //改 } DEBUGUJ += 1; } } // Aktualizacja bieżących wartości dla następnej pętli prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; //改 prevW = whiVal; //改 opóźnienie(przytrzymaj); // Pauza na opcjonalne „czekaj” milisekundy przed wznowieniem pętli }

Krok 3: Konfiguracja

1. Zdobądź deskę do krojenia chleba.

2. Demonstracja przewodów połączeniowych, dzięki którym światło LED może świecić:

   1. Umieść diodę LED na płytce stykowej. Umieść dłuższy koniec po lewej, a krótszy po prawej.
   2. Umieść jeden koniec przewodu połączeniowego w miejscu, które znajduje się w tym samym rzędzie co dłuższy koniec diody LED. Umieść drugi koniec na sekcji Digital PWM. Kod określał, że żółte diody mają być podłączone do 10 i 5, czerwone do 6 i 11, niebieskie do 8 i 13, zielone do 7 i 12, a białe diody do 9.
   3. Umieść jeden koniec rezystora w tym samym rzędzie z krótszym końcem diody LED. Umieść drugi koniec gdzieś blisko.
   4. Umieść końcówkę innego przewodu połączeniowego z tym samym rzędem co końcówka rezystora, która nie znajduje się w tym samym rzędzie co krótszy koniec diody LED. Umieść drugi koniec przewodu w rzędzie z ładunkiem ujemnym.
   5. Umieść koniec kolejnego przewodu połączeniowego w rzędzie z ładunkiem ujemnym, a drugi koniec na GND.
3. Powtórz krok 2 8 razy, aż 9 diod LED ma świecić

4. Umieść płytkę stykową w pudełku. Oto kilka przypomnień:

   1. Użyłem zasilacza. Utwórz mały otwór na przewody za pomocą noża uniwersalnego, aby przejść przez pudełko i połączyć się z płytą stykową.
   2. Upewnij się, że pudełko jest otwarte z jednej strony. Pudełko na buty ma już jedną otwartą stronę. Jeśli pudełko jest całkowicie zamknięte, odetnij jeden bok pudełka, aby zrobić otwartą przestrzeń.
   3. Przykryj stronę niczym papierem. Dzięki temu światła LED przeświecają przez papier.