Forbedring av en Arduino LED Mood Cube (enkel) (video inkludert): 4 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:22

Etter å ha sett et lite LED -humørterningprosjekt laget av 'earl, bestemte jeg meg for å gjøre en forbedret versjon av LED Mood Cube. Min versjon vil være mer kompleks enn den originale, da den vil være litt større enn den originale, ha to flere farger sammenlignet med den originale kuben (lagt til gul og hvit), ha en uendelig mengde rotasjon av farger, etc. Dette burde være et godt prosjekt å øve på videre bruk av LED -lys for de som forsto konseptet om å koble LED -lys med ledninger.

Trinn 1: Materialer

Her er noen materialer du trenger for å lage denne Mood Cube:

• Brødbrett
• Arduino - (jeg har Leonardo her)
• Arduino strømforsyning / USB -kabel
• Brødbrett
• Jumper Wires (Mange av dem, jeg brukte 29 ledninger)
• Rød LED x 2
• Blå LED x 2
• Grønn LED x 2
• Gul LED x 2
• Hvit LED x 1
• 9 motstander
• Eske som er stor nok til å passe til brødbrettet (jeg brukte en skokasse)
• Verktøykniv
• Papir

Trinn 2: Kode

Noen forklaringer på koden gitt her:

Kredittens æren går til den opprinnelige kilden til prosjektet mitt da redaktøren for prosjektet opprettet disse kodene. Jeg forbedret bare noen av dem ved å gjøre dem mer komplekse. I noen koder ser du kanskje // 改 til slutt. Dette betyr at denne koden er redigert av meg, så den er forskjellig fra min opprinnelige kilde.

Jeg har også en versjon av koden på Arduino Creator.

/* Kode for kryssfading 3 lysdioder, rød, grønn og blå (RGB) For å lage fades, må du gjøre to ting: 1. Beskriv fargene du vil vise 2. Liste opp rekkefølgen du vil at de skal falme i

BESKRIVELSE AV EN FARGE:

En farge er bare en matrise på tre prosent, 0-100, som styrer de røde, grønne og blå lysdiodene

Rød er den røde LED -lampen full, blå og grønn av

int rød = {100, 0, 0} Dim hvit er alle tre lysdiodene på 30% int dimWhite = {30, 30, 30} etc.

Noen vanlige farger er gitt nedenfor, eller lag din egen

LISTE BESTILLINGEN:

I hoveddelen av programmet må du liste opp rekkefølgen du vil at fargene skal vises i, f.eks. crossFade (rød); crossFade (grønn); crossFade (blå);

Disse fargene vil vises i den rekkefølgen og falme ut

en farge og inn i den neste

I tillegg er det fem valgfrie innstillinger du kan justere:

1. Den opprinnelige fargen er satt til svart (så den første fargen blekner), men du kan sette den opprinnelige fargen til å være hvilken som helst annen farge 2. Den interne sløyfen kjører for 1020 interaksjoner; variabelen "vent" angir omtrentlig varighet for en enkelt kryssfade. I teorien bør en "ventetid" på 10 ms gjøre en crossFade på ~ 10 sekunder. I praksis utfører de andre funksjonene koden sakte dette ned til ~ 11 sekunder på brettet mitt. YMMV. 3. Hvis "gjenta" er satt til 0, vil programmet sløyfe på ubestemt tid. hvis det er satt til et tall, vil det sløyfe det antallet ganger, og deretter stoppe på den siste fargen i sekvensen. (Sett "retur" til 1, og gjør den siste fargen svart hvis du vil at den skal falme ut på slutten.) 4. Det er en valgfri "hold" -variabel, som går ut på programmet for "hold" millisekunder når en farge er fullført, men før neste farge starter. 5. Sett DEBUG -flagget til 1 hvis du vil at feilsøkingsutdata skal sendes til den serielle skjermen.

Internt i programmet er ikke komplisert, men de

er litt masete - de indre virkningene forklares under hovedsløyfen.

April 2007, Clay Shirky

*

/ Utgang

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

// Fargefiler

int svart [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int hvit [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ønn [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blue [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int yellow [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int lilla [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int oransje [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int rosa [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // etc.

// Angi innledende farge

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

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

int hold = 1; // Valgfritt hold når en farge er fullført, før neste crossFade // 改 int DEBUG = 1; // DEBUG teller; hvis den er satt til 1, vil den skrive verdiene tilbake via seriell int loopCount = 60; // Hvor ofte skal DEBUG rapportere? int repeat = 0; // Hvor mange ganger skal vi sløyfe før vi stopper? (0 uten stopp) // 改 int j = 0; // Sløyfeteller for gjentagelse

// Initialiser fargevariabler

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

// Sett opp LED -utgangene

ugyldig oppsett () {pinMode (redPin, OUTPUT); // angir pinnene 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 verdier for feilsøking …

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

// Hovedprogram: oppgi rekkefølgen på kryssfades

void loop () {crossFade (red); crossFade (grønn); crossFade (blå); crossFade (gul); crossFade (hvit); crossFade (rosa); crossFade (lilla); crossFade (oransje);

hvis (gjenta) {// Sløyfer vi et begrenset antall ganger?

j += 1; if (j> = gjenta) {// Er vi der ennå? utgang (j); // Stopp i så fall. }}}

/* UNDER DENNE LINJEN ER MATEN - DU BØR IKKE TRENGE Å ENDRE DETTE FOR DET GRUNNLEGGENDE

Programmet fungerer slik:

Tenk deg en kryssfade som flytter den røde lysdioden fra 0-10, den grønne fra 0-5, og den blå fra 10 til 7, i ti trinn. Vi vil telle de 10 trinnene og øke eller redusere fargeverdier i trinnvis trinn. Tenk deg at a + indikerer å øke verdien med 1, og a - tilsvarer å senke den. Vår 10 -trinns fade vil se slik ut:

1 2 3 4 5 6 7 8 9 10

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

Den røde stiger fra 0 til 10 på ti trinn, den grønne fra

0-5 i 5 trinn, og det blå faller fra 10 til 7 i tre trinn.

I det virkelige programmet konverteres fargeprosentene til

0-255 verdier, og det er 1020 trinn (255*4).

For å finne ut hvor stort et trinn det bør være mellom en opp- eller

ned-kryss av en av LED-verdiene, kaller vi calcateStep (), som beregner det absolutte gapet mellom start- og sluttverdiene, og deretter deler det gapet med 1020 for å bestemme størrelsen på trinnet mellom justeringer i verdien. */

int calcateStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Hva er det totale gapet? if (trinn) {// Hvis det ikke er null, trinn = 1020 / trinn; // divider med 1020} retur trinn; }

/* Den neste funksjonen er calculateVal. Når sløyfeverdien, i, når trinnstørrelsen som er passende for en av fargene, øker eller reduserer den verdien til den fargen med 1. (R, G og B beregnes hver for seg.) */

int calculateVal (int trinn, int val, int i) {

if ((trinn) && i % step == 0) {// Hvis trinnet er ikke-null og det er på tide å endre en verdi, hvis (trinn> 0) {// øk verdien hvis trinnet er positivt … val += 1; } annet hvis (trinn 255) {val = 255; } annet hvis (val <0) {val = 0; } returval; }

/* crossFade () konverterer prosentandelen farger til a

0-255-området, deretter sløyfe 1020 ganger, for å se om verdien må oppdateres hver gang, og deretter skrive fargeverdiene til de riktige pinnene. */

void crossFade (int color ) {// 改

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

int stepR = calculateStep (prevR, R);

int stepG = calculateStep (prevG, G); int stepB = calculateStep (prevB, B); int stepY = calculateStep (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 (trinn B, bluVal, i); ylwVal = calculateVal (stepY, ylwVal, i); // 改 whiVal = calculateVal (stepW, whiVal, i); // 改

analogWrite (redPin, redVal); // Skriv gjeldende verdier til LED -pinner

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); // Pause i "vent" millisekunder før du fortsetter sløyfen

if (DEBUG) {// Hvis vi vil ha seriell utskrift, skriver du den ut på

if (i == 0 eller i % loopCount == 0) {// begynnelse, og hver loopCount ganger 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; }}} // Oppdater nåværende verdier for neste sløyfe prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 forsinkelse (hold); // Pause for valgfrie 'vent' millisekunder før du fortsetter sløyfen}

Trinn 3: Sett opp

1. Få brødbrettet.

2. Demo for tilkobling av ledninger slik at et LED -lys kan skinne:

   1. Sett lysdioden på brødbrettet. Plasser den lengre enden til venstre og den kortere enden til høyre.
   2. Plasser den ene enden av en jumper wire på et sted som er på samme rad med den lengre enden av LED. Plasser den andre enden på Digital PWM -delen. Koden spesifiserte de gule lysdiodene som skulle kobles til 10 og 5, de røde til 6 og 11, de blå til 8 og 13, de grønne til 7 og 12 og til slutt hvite til 9.
   3. Plasser den ene enden av en motstand på samme rad med den kortere enden av lysdioden. Plasser den andre enden et sted i nærheten.
   4. Plasser enden av en annen jumper wire med samme rad med enden av motstanden som ikke er på samme rad med den kortere enden av LED. Plasser den andre enden av ledningen på den negative ladningsraden.
   5. Plasser enden av enda en startkabel på den negative ladningsraden og plasser den andre enden på GND.
3. Gjenta trinn 2 8 ganger da du vil at 9 lysdioder skal lyse

4. Plasser brødbrettet inne i esken. Noen påminnelser her:

   1. Jeg brukte strømforsyning. Lag et lite hull for ledningene dine ved hjelp av en verktøykniv for å passere gjennom esken og koble til brødbrettet.
   2. Sørg for at boksen er den ene siden som er åpen. En skokasse har allerede den ene siden som er åpen. Hvis esken er helt lukket, kutter du av den ene siden av esken for å lage et åpent mellomrom.
   3. Dekk siden med ingenting med papir. Dette er for at LED -lys skal lyse gjennom papir.