Verbetering van 'n Arduino LED Mood Cube (eenvoudig) (video ingesluit): 4 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:24

Nadat ek 'n LED -bui met 'n klein bui gesien het, gemaak deur 'earl, het ek besluit om 'n verbeterde weergawe van die LED Mood Cube te doen. My weergawe sal meer ingewikkeld wees as die oorspronklike, aangesien dit effens groter is as die oorspronklike, nog twee kleure in vergelyking met die oorspronklike kubus het (geel en wit bygevoeg), oneindig veel rotasie van kleure, ens. behoort 'n goeie projek te wees om die gebruik van LED -ligte verder te gebruik vir diegene wat die konsep verstaan het om LED -ligte met drade te verbind.

Stap 1: materiaal

Hier is 'n paar materiaal wat u nodig het om hierdie bui te maak:

• Broodbord
• Arduino - (ek het Leonardo hier)
• Arduino -kragbron / USB -kabel
• Broodbord
• Jumper Wires (baie daarvan, ek het 29 drade gebruik)
• Rooi LED x 2
• Blou LED x 2
• Groen LED x 2
• Geel LED x 2
• Wit LED x 1
• 9 weerstande
• Boks groot genoeg om op die broodbord te pas (ek het 'n skoenboks gebruik)
• Knipmes
• Papier

Stap 2: Kode

'N Verduideliking vir die kode wat hier gegee word:

Die krediet van die kodes gaan na die oorspronklike bron van my projek, aangesien die redakteur van die projek hierdie kodes geskep het. Ek het sommige daarvan bloot verbeter deur dit meer kompleks te maak. In sommige kodes kan u uiteindelik // 改 sien. Dit beteken dat hierdie kode deur my geredigeer is, dus dit verskil van my oorspronklike bron.

Ek het ook 'n weergawe van die kode op Arduino Creator.

/* Kode vir kruisverbleking van 3 LED's, rooi, groen en blou (RGB) Om vervaagings te skep, moet u twee dinge doen: 1. Beskryf die kleure waarin u wil vertoon 2. Maak 'n lys van die volgorde waarin u wil vervaag.

'N KLEUR BESKRYF:

'N Kleur is slegs 'n skikking van drie persentasies, 0-100, wat die rooi, groen en blou LED's beheer

Rooi is die rooi LED vol, blou en groen af

int rooi = {100, 0, 0} Dim wit is al drie LED's teen 30% int dimWhite = {30, 30, 30} ens.

'N Paar algemene kleure word hieronder verskaf, of maak u eie

Die lys van die bestelling:

In die hoofgedeelte van die program moet u die volgorde waarin u wil kleur, lys, bv. crossFade (rooi); crossFade (groen); crossFade (blou);

Die kleure sal in die volgorde verskyn en vervaag

een kleur en in die volgende

Boonop is daar 5 opsionele instellings wat u kan aanpas:

1. Die aanvanklike kleur is op swart gestel (dus vervaag die eerste kleur), maar u kan die aanvanklike kleur in enige ander kleur stel. 2. Die interne lus loop vir 1020 interaksies; die 'wag' -veranderlike stel die geskatte duur van 'n enkele kruisverf in. In teorie moet 'n 'wag' van 10 ms 'n crossFade van ~ 10 sekondes maak. In die praktyk, die ander funksies wat die kode verrig, vertraag dit tot ~ 11 sekondes op my bord. YMMV. 3. As 'herhaal' op 0 is, loop die program vir onbepaalde tyd. as dit op 'n getal gestel is, loop dit die aantal kere in 'n lus en stop dan met die laaste kleur in die ry. (Stel 'terugkeer' op 1, en maak die laaste kleur swart as u aan die einde wil vervaag.) 4. Daar is 'n opsionele 'hou' -veranderlike, wat die program vir' hou 'millisekondes pas as 'n kleur voltooi, maar voordat die volgende kleur begin. 5. Stel die DEBUG -vlag op 1 as u wil hê dat ontfoutingsuitsette na die seriële monitor gestuur moet word.

Die interne aspekte van die program is nie ingewikkeld nie, maar wel

is 'n bietjie kieskeurig - die innerlike werking word onder die hooflus verduidelik.

April 2007, Clay Shirky

*

/ Uitset

int ylwPin = 5; // Geel LED, gekoppel aan digitale pen 5 // 改 int redPin = 6; // Rooi LED, gekoppel aan digitale pen 6 // 改 int grnPin = 7; // Groen LED, gekoppel aan digitale pen 7 // 改 int bluPin = 8; // Blou LED, gekoppel aan digitale pen 8 // 改 int whiPin = 9; // Wit LED, gekoppel aan digitale pen 9 // 改 int ylwPin2 = 10; // Geel LED, gekoppel aan digitale pen 10 // 改 int redPin2 = 11; // Rooi LED, gekoppel aan digitale pen 11 // 改 int grnPin2 = 12; // Groen LED, gekoppel aan digitale pen 12 // 改 int bluPin2 = 13; // Blou LED, gekoppel aan digitale pen 13 // 改

// Kleurskikkings

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 rooi [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int groen [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blou [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int geel [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int pers [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int oranje [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int pink [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // ens.

// Stel die aanvanklike kleur in

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

int wag = 15; // 10ms interne crossFade vertraging; toename vir stadiger vervaag // 改

int hou = 1; // Opsioneel hou wanneer 'n kleur voltooi is, voor die volgende crossFade // 改 int DEBUG = 1; // DEBUG -toonbank; as dit op 1 gestel is, sal dit waardes terugskryf via seriële int loopCount = 60; // Hoe gereeld moet DEBUG rapporteer? int herhaal = 0; // Hoeveel keer moet ons loop voordat ons stop? (0 sonder stop) // 改 int j = 0; // Lusteller vir herhaling

// Initialiseer kleurveranderlikes

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

// Stel die LED -uitsette op

ongeldige opstelling () {pinMode (redPin, OUTPUT); // stel die penne in as 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) {// As ons waardes vir ontfouting wil sien …

Serial.begin (9600); // … stel die reeksopstelling op}}

// Hoofprogram: lys die volgorde van kruisverf

leemte -lus () {crossFade (rooi); crossFade (groen); crossFade (blou); crossFade (geel); crossFade (wit); crossFade (pienk); crossFade (pers); crossFade (oranje);

as (herhaal) {// Loop ons 'n eindige aantal kere?

j += 1; if (j> = herhaal) {// Is ons al daar? uitgang (j); // As dit so is, stop. }}}

/* HIERONDER IS HIERDIE REËL DIE WISKUNDE - U hoef dit nie te verander vir die basiese beginsels nie

Die program werk so:

Stel jou 'n kruisverf voor wat die rooi LED van 0-10, die groen van 0-5 en die blou van 10 na 7 in tien stappe beweeg. Ons wil die 10 stappe tel en kleurwaardes in eweredige trappe verhoog of verlaag. Stel jou voor a + dui op die verhoging van 'n waarde met 1, en a - is gelyk aan die verlaging daarvan. Ons 10 -stappe vervaag sou lyk soos:

1 2 3 4 5 6 7 8 9 10

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

Die rooi styg van 0 tot 10 in tien stappe, die groen van

0-5 in 5 stappe, en die blou val van 10 tot 7 in drie stappe.

In die regte program word die kleurpersentasies omgeskakel na

0-255 waardes, en daar is 1020 stappe (255*4).

Om uit te vind hoe groot 'n stap moet wees tussen een op- of

As u een van die LED-waardes afmerk, noem ons calculeStep (), wat die absolute gaping tussen die begin- en eindwaardes bereken en die gaping dan met 1020 verdeel om die grootte van die stap tussen die aanpassings in die waarde te bepaal. */

int calculeerStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Wat is die algehele gaping? as (stap) {// As dit nie-nul is nie, stap = 1020 / stap; // deel met 1020} terugstap; }

/* Die volgende funksie is calculateVal. Wanneer die luswaarde, i, bereik die trapprootte wat geskik is vir een van die kleure, dit verhoog of verminder die waarde van die kleur met 1. (R, G en B word elkeen afsonderlik bereken.) */

int berekenVal (int stap, int val, int i) {

if ((stap) && i % step == 0) {// As stap nie-nul is en dit tyd is om 'n waarde te verander, as (stap> 0) {// die waarde verhoog as stap positief is … val += 1; } anders as (stap 255) {val = 255; } anders as (val <0) {val = 0; } terugkeer val; }

/* crossFade () skakel die persentasie kleure om na a

0-255 reeks, loop dan 1020 keer, kyk of die waarde elke keer bygewerk moet word, en skryf dan die kleurwaardes na die regte penne. */

void crossFade (int color ) {// 改

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

int stepR = bereken Step (prevR, R);

int stepG = bereken Step (prevG, G); int stapB = bereken stap (prevB, B); int stepY = calculeerStep (prevY, Y); // 改 int stepW = bereken Step (prevW, W); // 改

vir (int i = 0; i <= 1020; i ++) {redVal = calcuVal (stepR, redVal, i); grnVal = calculeerVal (stapG, grnVal, i); bluVal = berekenVal (stapB, bluVal, i); ylwVal = calculeerVal (stepY, ylwVal, i); // 改 whiVal = calculeerVal (stapW, whiVal, i); // 改

analogWrite (redPin, redVal); // Skryf huidige waardes na LED -penne

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

vertraag (wag); // Wag vir 'wag' millisekondes voordat die lus hervat word

if (DEBUG) {// As ons seriële uitvoer wil hê, druk dit by die

if (i == 0 of i % loopCount == 0) {// begin, en elke loopCount keer 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; }}} // Werk huidige waardes op vir volgende lus prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 vertraging (hou); // Wag vir opsionele 'wag' millisekondes voordat die lus hervat word}

Stap 3: Stel op

1. Kry die broodbord.

2. Demo van verbindingsdrade sodat 'n LED -lig kan skyn:

   1. Sit die LED op die broodbord. Plaas die langer punt aan die linkerkant en die korter kant aan die regterkant.
   2. Plaas die een kant van 'n jumperdraad op 'n plek wat op dieselfde ry is met die langer kant van die LED. Plaas die ander kant op die Digital PWM -afdeling. Die kode spesifiseer die geel LED's wat gekoppel moet word aan 10 en 5, die rooi na 6 en 11, die blou na 8 en 13, die groen na 7 en 12, en uiteindelik die wit LED na 9.
   3. Plaas die een kant van 'n weerstand op dieselfde ry met die korter kant van die LED. Plaas die ander kant iewers naby.
   4. Plaas 'n einde van 'n ander springdraad met dieselfde ry met die einde van die weerstand wat nie op dieselfde ry is met die korter kant van die LED nie. Plaas die ander kant van die draad op die negatiewe ladingry.
   5. Plaas die einde van nog 'n jumperdraad op die negatiewe ladingry en plaas die ander kant daarvan op GND.
3. Herhaal stap 2 vir 8 keer, aangesien u 9 LED's wil laat skyn

4. Plaas die broodbord in die boks. 'N Paar herinnerings hier:

   1. Ek het 'n kragtoevoer gebruik. Maak 'n klein gaatjie vir u drade met 'n mes om deur die boks te gaan en aan die broodbord te koppel.
   2. Maak seker dat die boks oop is aan die een kant. 'N Skoenboks het reeds een kant wat oop is. As die boks heeltemal toe is, sny aan die een kant van die boks om 'n oop ruimte te maak.
   3. Bedek die kant met niks met papier nie. Dit is vir LED -ligte wat deur papier skyn.