Forbedring af en Arduino LED Mood Cube (enkel) (video inkluderet): 4 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

Efter at have set et LED -lille humørterningsprojekt skabt af 'earl, besluttede jeg at lave en forbedret version af LED Mood Cube. Min version vil være mere kompleks end den originale, da den vil være lidt større end den originale, have to flere farver i forhold til den originale terning (tilføjet gul og hvid), have en uendelig mængde rotation af farver osv. Dette burde være et godt projekt at øve på videre brug af LED -lys for dem, der forstod konceptet om at forbinde LED -lys med ledninger.

Trin 1: Materialer

Her er nogle materialer, du skal bruge til at lave denne Mood Cube:

• Brødbræt
• Arduino - (jeg har Leonardo her)
• Arduino strømforsyning / USB -kabel
• Brødbræt
• Jumper Wires (Mange af dem, jeg brugte 29 ledninger)
• Rød LED x 2
• Blå LED x 2
• Grøn LED x 2
• Gul LED x 2
• Hvid LED x 1
• 9 modstande
• Kasse stor nok til at passe til brødbrættet (jeg brugte en skokasse)
• Schweizer kniv
• Papir

Trin 2: Kode

Nogle forklaringer på koden givet her:

Krediteringen går til den originale kilde til mit projekt, da projektredaktøren oprettede disse koder. Jeg forbedrede blot nogle af dem ved at gøre dem mere komplekse. I nogle koder kan du se // 改 i sidste ende. Det betyder, at denne kode er redigeret af mig, så den er forskellig fra min originale kilde.

Jeg har også en version af koden på Arduino Creator.

/* Kode til krydsfading 3 lysdioder, rød, grøn og blå (RGB) For at oprette fades skal du gøre to ting: 1. Beskriv de farver, du vil have vist 2. Angiv den rækkefølge, du vil have dem til at falme i

BESKRIVELSE AF EN FARVE:

En farve er blot en matrix med tre procentdele, 0-100, der styrer de røde, grønne og blå lysdioder

Rød er den røde LED ved fuld, blå og grøn slukket

int rød = {100, 0, 0} Dim hvid er alle tre lysdioder ved 30% int dimWhite = {30, 30, 30} osv.

Nogle almindelige farver findes herunder, eller lav dine egne

LISTE BESTILLINGEN:

I hoveddelen af programmet skal du angive den rækkefølge, du vil have farverne til at vises i, f.eks. crossFade (rød); crossFade (grøn); crossFade (blå);

Disse farver vises i den rækkefølge og falmer ud

en farve og ind i den næste

Derudover er der 5 valgfri indstillinger, du kan justere:

1. Den oprindelige farve er indstillet til sort (så den første farve falmer ind), men du kan indstille den oprindelige farve til en hvilken som helst anden farve 2. Den interne sløjfe kører i 1020 interationer; variablen 'vent' angiver den omtrentlige varighed af en enkelt krydsfade. I teorien bør en 'ventetid' på 10 ms foretage en crossFade på ~ 10 sekunder. I praksis udfører koden de andre funktioner langsomt, dette ned til ~ 11 sekunder på mit bord. YMMV. 3. Hvis 'repeat' er indstillet til 0, vil programmet loopes på ubestemt tid. hvis det er indstillet til et tal, vil det sløjfe det antal gange og derefter stoppe med den sidste farve i sekvensen. (Indstil 'return' til 1, og gør den sidste farve sort, hvis du vil have den til at falme ud i slutningen.) 4. Der er en valgfri 'hold' -variabel, som skifter programmet til 'hold' millisekunder, når en farve er færdig, men inden den næste farve starter. 5. Indstil DEBUG -flag til 1, hvis du vil have fejlfindingsoutput sendt til den serielle skærm.

Det interne i programmet er ikke kompliceret, men de

er lidt nøjeregnende - de indre funktioner forklares under hovedsløjfen.

April 2007, Clay Shirky

*

/ Output

int ylwPin = 5; // Gul LED, tilsluttet digital pin 5 // 改 int redPin = 6; // Rød LED, tilsluttet digital pin 6 // 改 int grnPin = 7; // Grøn LED, tilsluttet digital pin 7 // 改 int bluPin = 8; // Blå LED, tilsluttet digital pin 8 // 改 int whiPin = 9; // Hvid LED, tilsluttet digital pin 9 // 改 int ylwPin2 = 10; // Gul LED, tilsluttet digital pin 10 // 改 int redPin2 = 11; // Rød LED, tilsluttet digital pin 11 // 改 int grnPin2 = 12; // Grøn LED, tilsluttet digital pin 12 // 改 int bluPin2 = 13; // Blå LED, tilsluttet digital pin 13 // 改

// Farve arrays

int black [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int white [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int rød [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int grøn [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blå [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int gul [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int lilla [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int orange [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int pink [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // osv.

// Indstil startfarve

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

int vent = 15; // 10 ms intern crossFade forsinkelse; stigning for langsommere fades // 改

int hold = 1; // Valgfri hold, når en farve er færdig, før den næste crossFade // 改 int DEBUG = 1; // DEBUG tæller; hvis indstillet til 1, vil værdierne blive sendt tilbage via seriel int loopCount = 60; // Hvor ofte skal DEBUG rapportere? int repeat = 0; // Hvor mange gange skal vi sløjfe inden vi stopper? (0 uden stop) // 改 int j = 0; // Sløjfe tæller til gentagelse

// Initialiser farvevariabler

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

// Indstil LED -udgange

void setup () {pinMode (redPin, OUTPUT); // indstiller benene som output pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, OUTPUT); // 改

if (DEBUG) {// Hvis vi vil se værdier til fejlfinding …

Serial.begin (9600); // … konfigurer den serielle udgang}}

// Hovedprogram: anfør rækkefølgen af krydsfader

void loop () {crossFade (rød); crossFade (grøn); crossFade (blå); crossFade (gul); crossFade (hvid); crossFade (pink); crossFade (lilla); crossFade (orange);

hvis (gentag) {// Sløjfer vi et begrænset antal gange?

j += 1; hvis (j> = gentag) {// Er vi der endnu? exit (j); // Stop i så fald. }}}

/* NEDENFOR DENNE LINE ER MATEN - DU BØR IKKE BEHANDLE AT ÆNDRE DETTE FOR DET GRUNDLÆGGENDE

Programmet fungerer således:

Forestil dig en krydsfade, der flytter den røde LED fra 0-10, den grønne fra 0-5 og den blå fra 10 til 7 i ti trin. Vi vil gerne tælle de 10 trin og øge eller reducere farveværdier i trinvist jævne trin. Forestil dig, at a + angiver, at en værdi hæves med 1, og a - svarer til at sænke den. Vores 10 -trins fade ville se sådan ud:

1 2 3 4 5 6 7 8 9 10

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

Den røde stiger fra 0 til 10 i ti trin, den grønne fra

0-5 i 5 trin, og den blå falder fra 10 til 7 i tre trin.

I det rigtige program konverteres farveprocenterne til

0-255 værdier, og der er 1020 trin (255*4).

For at finde ud af hvor stort et trin der skal være mellem en op- eller

ned-afkrydsning af en af LED-værdierne, kalder vi calcateStep (), som beregner det absolutte mellemrum mellem start- og slutværdierne og derefter deler dette hul med 1020 for at bestemme størrelsen af trinnet mellem justeringer i værdien. */

int calcStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Hvad er det overordnede hul? hvis (trin) {// Hvis det ikke er nul, trin = 1020 / trin; // divider med 1020} returtrin; }

/* Den næste funktion er calculateVal. Når loop -værdien, i, når den trinstørrelse, der er passende for en af farverne, øger eller reducerer den værdien af denne farve med 1. (R, G og B beregnes hver for sig.) */

int calcVal (int trin, int val, int i) {

hvis ((trin) && i % step == 0) {// Hvis trin er ikke-nul, og det er tid til at ændre en værdi, hvis (trin> 0) {// øges værdien, hvis trin er positivt … val += 1; } ellers hvis (trin 255) {val = 255; } ellers hvis (val <0) {val = 0; } returværdi; }

/* crossFade () konverterer farveprocenten til a

0-255 område, sløjfer derefter 1020 gange, kontrollerer om værdien skal opdateres hver gang og skriver derefter farveværdierne til de korrekte ben. */

void crossFade (int color ) {// 改

// Konverter til 0-255 int R = (farve [0] * 255) / 100; int G = (farve [1] * 255) / 100; int B = (farve [2] * 255) / 100; int Y = (farve [3] * 255) / 100; // 改 int W = (farve [4] * 255) /100; // 改

int stepR = calculStep (prevR, R);

int stepG = calculStep (prevG, G); int stepB = calculStep (prevB, B); int stepY = calculStep (prevY, Y); // 改 int stepW = calculateStep (prevW, W); // 改

for (int i = 0; i <= 1020; i ++) {redVal = calculateVal (stepR, redVal, i); grnVal = calculateVal (stepG, grnVal, i); bluVal = calculateVal (trinB, bluVal, i); ylwVal = calculateVal (stepY, ylwVal, i); // 改 whiVal = calculateVal (stepW, whiVal, i); // 改

analogWrite (redPin, redVal); // Skriv aktuelle værdier til LED -ben

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

forsinkelse (vent); // Sæt pause på 'vent' millisekunder, før sløjfen genoptages

if (DEBUG) {// Hvis vi vil have seriel output, skal du udskrive det på

hvis (i == 0 eller i % loopCount == 0) {// begyndelse, og hver loopCount gange Serial.print ("Loop/RGBYW: #"); Serial.print (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 (" /"); // 改} DEBUG += 1; }}} // Opdater aktuelle værdier for næste loop prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 forsinkelse (hold); // Pause for valgfrie 'vent' millisekunder, før sløjfen genoptages}

Trin 3: Opsætning

1. Få brødbrættet.

2. Demo af tilslutning af ledninger, så et LED -lys kan lyse:

   1. Sæt LED'en på brødbrættet. Placer den længere ende til venstre og den kortere ende til højre.
   2. Placer den ene ende af en jumper wire på et sted, der er på samme række med LED'ens længere ende. Placer den anden ende på Digital PWM -sektionen. Koden angav de gule lysdioder, der skulle tilsluttes til 10 og 5, røde til 6 og 11, blå til 8 og 13, grønne til 7 og 12 og til sidst hvide til 9.
   3. Placer den ene ende af en modstand på samme række med den kortere ende af LED'en. Placer den anden ende et sted i nærheden.
   4. Placer enden af en anden jumper wire med samme række med enden af modstanden, der ikke er på samme række med den kortere ende af LED'en. Placer den anden ende af ledningen på rækken med negativ ladning.
   5. Placer enden af endnu en jumper wire på den negative ladning række og placere den anden ende på GND.
3. Gentag trin 2 8 gange, da du vil have 9 lysdioder til at lyse

4. Læg brødbrættet inde i æsken. Et par påmindelser her:

   1. Jeg brugte en strømforsyning. Opret et lille hul til dine ledninger ved hjælp af en kniv til at passere gennem kassen og forbinde til brødbrættet.
   2. Sørg for, at boksen er den ene side, der er åben. En skokasse har allerede den ene side, der er åben. Hvis kassen er helt lukket, skal du skære den ene side af kassen for at skabe et åbent rum.
   3. Dæk ikke siden med noget med papir. Dette er for at LED -lys skal lyse gennem papir.