„Arduino“LED nuotaikos kubo tobulinimas (paprastas) (įtrauktas vaizdo įrašas): 4 žingsniai

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:45

Pamačiusi „Earl“sukurtą mažos šviesos nuotaikos kubo projektą, nusprendžiau padaryti patobulintą „LED Mood Cube“versiją. Mano versija bus sudėtingesnė nei originali, nes ji bus šiek tiek didesnė už pradinę, turės dar dvi spalvas, lyginant su originaliu kubu (pridėta geltona ir balta), begalinis spalvų sukimasis ir pan. turėtų būti geras projektas praktikuoti tolesnį LED žibintų naudojimą tiems, kurie suprato LED žibintų prijungimo prie laidų koncepciją.

1 žingsnis: medžiagos

Štai keletas medžiagų, kurių jums reikės norint sukurti šį nuotaikos kubą:

• Bandomoji Lenta
• Arduino - (čia turiu Leonardo)
• „Arduino“maitinimo šaltinis / USB kabelis
• Bandomoji Lenta
• Trumpieji laidai (daug jų, naudojau 29 laidus)
• Raudonas šviesos diodas x 2
• Mėlynas šviesos diodas x 2
• Žalia šviesos diodas x 2
• Geltonas šviesos diodas x 2
• Baltas šviesos diodas x 1
• 9 rezistoriai
• Dėžutė pakankamai didelė, kad tilptų duonos lentą (naudojau batų dėžutę)
• Naudingas peilis
• Popierius

2 žingsnis: kodas

Keletas čia pateikto kodo paaiškinimų:

Kodų kreditas atitenka pirminiam mano projekto šaltiniui, nes projekto redaktorius sukūrė šiuos kodus. Aš tik patobulinau kai kuriuos iš jų, padarydamas juos sudėtingesnius. Kai kurių kodų pabaigoje galite pamatyti // 改. Tai reiškia, kad šį kodą redaguoju aš, todėl jis skiriasi nuo mano pirminio šaltinio.

Taip pat turiu „Arduino Creator“kodo versiją.

/* Kryžminimo išblukimo 3 šviesos diodų, raudonų, žalių ir mėlynų (RGB) kodas Norėdami sukurti išblukimus, turite atlikti du veiksmus: 1. Apibūdinkite norimas rodyti spalvas 2. Išvardykite, kokia tvarka norite išblukti.

SPALVOS APRAŠYMAS:

Spalva yra tik trijų procentų masyvas, 0–100, valdantis raudonus, žalius ir mėlynus šviesos diodus

Raudona yra raudonas šviesos diodas, visiškai išjungtas, mėlynas ir žalias

int red = {100, 0, 0} Blyškiai balta yra visi trys šviesos diodai, esant 30% int dimWhite = {30, 30, 30} ir tt

Žemiau pateikiamos kai kurios įprastos spalvos arba pasigaminkite patys

UŽSAKYTI UŽSAKYMĄ:

Pagrindinėje programos dalyje turite išvardyti, kokia tvarka norite spalvoti, pvz. crossFade (raudona); crossFade (žalia); crossFade (mėlyna);

Tos spalvos bus rodomos tokia tvarka, išnyks

viena spalva ir kita

Be to, yra 5 pasirenkami nustatymai, kuriuos galite koreguoti:

1. Pradinė spalva nustatyta į juodą (taigi pirmoji spalva išblėsta), tačiau galite nustatyti, kad pradinė spalva būtų bet kokia kita. 2. Vidinė kilpa veikia 1020 kartų; „Wait“kintamasis nustato apytikslę vieno kryžminimo trukmę. Teoriškai 10 ms „laukimas“turėtų padaryti ~ 10 sekundžių kryžiaus išnykimą. Praktiškai kitos funkcijos, kurias atlieka kodas, mano lentoje sulėtėja iki ~ 11 sekundžių. YMMV. 3. Jei „pakartojimas“yra nustatytas į 0, programa veiks ciklas neribotą laiką. jei jis nustatytas kaip skaičius, jis tą skaičių kartų pakartos, tada sustos ties paskutine spalvos seka. (Nustatykite „return“į 1 ir paskutinę spalvą padarykite juodą, jei norite, kad ji išnyktų pabaigoje.) 4. Yra pasirenkamas „hold“kintamasis, kuris įterpia „palaikymo“programą milisekundėms, kai spalva baigtas, bet prieš prasidedant kitai spalvai. 5. Jei norite, kad derinimo išvestis būtų siunčiama į nuoseklųjį monitorių, nustatykite DEBUG vėliavą į 1.

Programos vidiniai elementai nėra sudėtingi, bet jie

yra šiek tiek nerimtas - vidinė veikla paaiškinta žemiau pagrindinės kilpos.

2007 m. Balandžio mėn., Clay Shirky

*

/ Išvestis

int ylwPin = 5; // Geltonas šviesos diodas, prijungtas prie skaitmeninio kaiščio 5 // 改 int redPin = 6; // Raudonas šviesos diodas, prijungtas prie skaitmeninio kaiščio 6 // 改 int grnPin = 7; // Žalias šviesos diodas, prijungtas prie skaitmeninio kaiščio 7 // 改 int bluPin = 8; // Mėlynas šviesos diodas, prijungtas prie skaitmeninio kaiščio 8 // 改 int whiPin = 9; // Baltas šviesos diodas, prijungtas prie skaitmeninio kaiščio 9 // 改 int ylwPin2 = 10; // Geltonas šviesos diodas, prijungtas prie skaitmeninio kaiščio 10 // 改 int redPin2 = 11; // Raudonas šviesos diodas, prijungtas prie skaitmeninio kaiščio 11 // 改 int grnPin2 = 12; // Žalia šviesos diodas, prijungtas prie skaitmeninio kaiščio 12 // 改 int bluPin2 = 13; // Mėlynas šviesos diodas, prijungtas prie skaitmeninio kaiščio 13 // 改

// Spalvų masyvai

int juoda [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int balta [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int raudona [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int žalia [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blue [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int geltona [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int purpurinė [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int oranžinė [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int rožinė [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // ir tt

// Nustatykite pradinę spalvą

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

int laukti = 15; // 10ms vidinis crossFade delay; padidėjimas lėtesniam išblukimui // 改

int palaikymas = 1; // Pasirenkamas palaikymas, kai spalva baigta, prieš kitą crossFade // 改 int DEBUG = 1; // DEBUG skaitiklis; jei nustatyta į 1, įrašys reikšmes atgal per serijinį int loopCount = 60; // Kaip dažnai turėtų pranešti DEBUG? int pakartojimas = 0; // Kiek kartų turėtume kilpoti prieš sustodami? (0 be sustojimo) // 改 int j = 0; // Kartojimo ciklo skaitiklis

// Inicijuoti spalvų kintamuosius

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

// Nustatykite LED išėjimus

void setup () {pinMode (redPin, OUTPUT); // nustato kaiščius kaip išvesties 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) {// Jei norime matyti derinimo vertes …

Serial.begin (9600); //… nustatyti serijos išvestį}}

// Pagrindinė programa: išvardykite kryžminimo tvarką

void loop () {crossFade (raudona); crossFade (žalia); crossFade (mėlyna); crossFade (geltona); crossFade (balta); crossFade (rožinė); crossFade (violetinė); crossFade (oranžinė);

jei (kartoti) {// Ar mes cikluojame ribotą skaičių kartų?

j += 1; if (j> = pakartoti) {// Ar mes jau ten? išėjimas (j); // Jei taip, sustok. }}}

/* Žemiau ši eilutė yra matematika - NETURĖTŲ TAI PAKEISTI PAGRINDŲ

Programa veikia taip:

Įsivaizduokite kryžminį užtemimą, kuris perkelia raudoną šviesos diodą nuo 0 iki 10, žalią nuo 0 iki 5 ir mėlyną nuo 10 iki 7, atlikdamas dešimt žingsnių. Norėtume suskaičiuoti 10 žingsnių ir padidinti ar sumažinti spalvų vertes tolygiai. Įsivaizduokite, kad + rodo vertės padidinimą 1, o a - lygi jos sumažinimui. Mūsų 10 žingsnių išblukimas atrodytų taip:

1 2 3 4 5 6 7 8 9 10

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

Raudona pakyla nuo 0 iki 10 per dešimt žingsnių, žalia - nuo

0–5 per 5 žingsnius, o mėlyna spalva nukrenta nuo 10 iki 7 per tris žingsnius.

Tikroje programoje spalvų procentas konvertuojamas į

0-255 reikšmės ir yra 1020 žingsnių (255*4).

Norėdami išsiaiškinti, koks didelis žingsnis turėtų būti tarp vieno aukštyn arba aukštyn

pažymėdami vieną iš šviesos diodų reikšmių žemyn, vadiname calcStep (), kuris apskaičiuoja absoliutų atotrūkį tarp pradžios ir pabaigos reikšmių, o tada padalija tą skirtumą iš 1020, kad nustatytų žingsnio tarp vertės koregavimo dydį. */

int calcStep (int prevValue, int endValue) {

int žingsnis = endValue - prevValue; // Koks bendras atotrūkis? if (step) {// Jei jo nulis, žingsnis = 1020 / step; // padalinti iš 1020} return step; }

/* Kita funkcija yra calcVal. Kai kilpos vertė, i, pasiekia vienai iš spalvų tinkamą žingsnio dydį, padidina arba sumažina tos spalvos vertę 1 (R, G ir B apskaičiuojami atskirai.) */

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

if ((žingsnis) && i % step == 0) {// Jei žingsnis yra ne nulis ir laikas keisti vertę, if (žingsnis> 0) {// padidinkite vertę, jei žingsnis teigiamas… val += 1; } else if (255 žingsnis) {val = 255; } else if (val <0) {val = 0; } return val; }

/* crossFade () konvertuoja procentines spalvas į a

0–255 diapazoną, tada ciklus 1020 kartų, tikrindami, ar kiekvieną kartą reikia atnaujinti vertę, tada rašydami spalvų reikšmes į tinkamus kaiščius. */

void crossFade (int spalva ) {// 改

// Konvertuoti į 0-255 int R = (spalva [0] * 255) / 100; int G = (spalva [1] * 255) / 100; int B = (spalva [2] * 255) / 100; int Y = (spalva [3] * 255) / 100; // 改 int W = (spalva [4] * 255) /100; // 改

int stepR = apskaičiuoti žingsnį (prevR, R);

int stepG = calcStep (prevG, G); int stepB = apskaičiuotiStep (prevB, B); int stepY = apskaičiuotiStep (prevY, Y); // 改 int stepW = apskaičiuotiStep (prevW, W); // 改

už (int i = 0; i <= 1020; i ++) {redVal = apskaičiuotiVal (žingsnisR, redVal, i); grnVal = apskaičiuotiVal (stepG, grnVal, i); bluVal = apskaičiuotiVal (žingsnis B, bluVal, i); ylwVal = apskaičiuotiVal (Y žingsnis, ylwVal, i); // 改 whiVal = apskaičiuotiVal (žingsnisW, whiVal, i); // 改

analogWrite (redPin, redVal); // Įrašykite esamas reikšmes į LED kaiščius

analogWrite (grnPin, grnVal); analogWrite („bluPin“, „bluVal“); analogWrite (ylwPin, ylwVal); // 改 analoginis rašymas (whiPin, whiVal); // 改 analoginis rašymas (grnPin2, grnVal); // 改 analoginis rašymas („bluPin2“, „bluVal“); // 改 analoginis rašymas (ylwPin2, ylwVal); // 改 analoginis rašymas (redPin2, redVal); // 改

atidėti (laukti); // Sustabdykite „palaukite“milisekundes prieš atnaujindami ciklą

if (DEBUG) {// Jei norime serijinės išvesties, atspausdinkite ją adresu

if (i == 0 arba i % loopCount == 0) {// pradžia ir kiekviena kilpaCount kartus Serial.print ("Loop/RGBYW: #"); Serijinis atspaudas (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; }} // Atnaujinti dabartines kitos ciklo reikšmes prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 delay (hold); // Pristabdykite pasirinktinai „palaukite“milisekundes prieš atnaujindami ciklą}

3 žingsnis: Nustatykite

1. Gaukite duonos lentą.

2. Jungiamųjų laidų demonstracija, kad LED lemputė galėtų šviesti:

   1. Padėkite šviesos diodą ant duonos lentos. Ilgesnį galą padėkite kairėje, o trumpesnį - dešinėje.
   2. Vieną trumpiklio laido galą uždėkite toje vietoje, kuri yra toje pačioje eilutėje su ilgesniu šviesos diodo galu. Kitą galą uždėkite ant skaitmeninio PWM skyriaus. Kodas nurodė, kad geltoni šviesos diodai turi būti prijungti prie 10 ir 5, raudoni - prie 6 ir 11, mėlyni - prie 8 ir 13, žali - prie 7 ir 12 ir galiausiai balti šviesos diodai prie 9.
   3. Vieną rezistoriaus galą uždėkite toje pačioje eilutėje su trumpesniu šviesos diodo galu. Kitą galą padėkite kažkur šalia.
   4. Įdėkite kito jungiamojo laido galą su ta pačia eilute su rezistoriaus galu, kuris nėra toje pačioje eilutėje su trumpesniu šviesos diodo galu. Kitą laido galą uždėkite ant neigiamo krūvio eilutės.
   5. Ant neigiamo krūvio eilutės uždėkite dar vieno jungiamojo laido galą, o kitą - ant GND.
3. Pakartokite 2 veiksmą 8 kartus, kol norite, kad šviestų 9 šviesos diodai

4. Įdėkite duonos lentą į dėžę. Keletas priminimų čia:

   1. Naudojau maitinimo šaltinį. Naudodami peilį sukurkite mažą skylę laidams, kad praeitumėte per dėžę ir prijunkite prie duonos lentos.
   2. Įsitikinkite, kad dėžutė yra viena pusė, kuri yra atidaryta. Batų dėžutė jau turi vieną atvirą pusę. Jei dėžutė visiškai uždaryta, supjaustykite vieną dėžutės pusę, kad atsirastų atvira erdvė.
   3. Šoną niekuo neuždenkite popieriumi. Tai skirta šviesos diodams šviesti per popierių.