Arduino LED -meeleolu kuubi täiustamine (lihtne) (videoga kaasas): 4 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:47

Olles näinud 'Earli loodud LED -meeleolukuubiku projekti, otsustasin teha LED Mood Cube'i täiustatud versiooni. Minu versioon on originaalist keerukam, kuna see on pisut suurem kui originaal, sellel on võrreldes algkuubikuga veel kaks värvi (lisatud kollane ja valge), värvide pöörlemine on lõpmatu jne. peaks olema hea projekt LED -tulede edasise kasutamise harjutamiseks neile, kes said aru LED -tulede juhtmetega ühendamise kontseptsioonist.

Samm: materjalid

Siin on mõned materjalid, mida vajate selle meeleolu kuubi valmistamiseks:

• Leivalaud
• Arduino - (mul on siin Leonardo)
• Arduino toiteallikas / USB -kaabel
• Leivalaud
• Jumper juhtmed (palju neid, ma kasutasin 29 juhtmest)
• Punane LED x 2
• Sinine LED x 2
• Roheline LED x 2
• Kollane LED x 2
• Valge LED x 1
• 9 takistit
• Karp piisavalt suur, et mahutada leivalaud (kasutasin kingakarpi)
• Kasulik nuga
• Paber

2. samm: kood

Mõned selgitused siin toodud koodile:

Koodide krediit läheb minu projekti algallikale, kuna projekti toimetaja lõi need koodid. Ma lihtsalt parandasin mõnda neist, muutes need keerukamaks. Mõne koodi puhul võite lõpuks näha // 改. See tähendab, et seda koodi olen mina redigeerinud, seega erineb see minu algallikast.

Mul on ka Arduino Creatori koodi versioon.

/* Kolme LED-i, punase, rohelise ja sinise (RGB) tuhmumise kood Pimenduse loomiseks peate tegema kahte asja: 1. kirjeldage värve, mida soovite kuvada;

VÄRVI KIRJELDUS:

Värv on vaid kolme protsendi massiiv, 0–100, mis juhib punaseid, rohelisi ja siniseid LED-e

Punane on punane LED täis, sinine ja roheline ei põle

int red = {100, 0, 0} Hämarduv valge on kõik kolm LED -i 30% int dimWhite = {30, 30, 30} jne.

Mõned levinumad värvid on toodud allpool või tehke ise

TELLIMUSE LOETELU:

Programmi põhiosas peate loetlema järjekorra, milles soovite värve kuvada, nt. crossFade (punane); crossFade (roheline); crossFade (sinine);

Need värvid kuvatakse selles järjekorras, kustudes

ühte värvi ja järgmisse

Lisaks saate reguleerida 5 valikulist seadet:

1. Esialgne värv on seatud mustaks (nii et esimene värv tuhmub), kuid saate määrata algvärviks mis tahes muu värvi. 2. Sisemine silmus kestab 1020 interaktsiooni; muutuja "oota" määrab ühe ristumise ligikaudse kestuse. Teoreetiliselt peaks 10 ms "ootamine" muutma ~ 10 sekundit. Praktikas muud funktsioonid, mida kood täidab, aeglustavad seda minu plaadil ~ 11 sekundini. YMMV. 3. Kui „kordus” on seatud väärtusele 0, kordab programm lõputult. kui see on seatud numbrile, lülitab see selle arvu kordi ringi, seejärel peatub jada viimasel värvil. (Seadistage 'return' väärtuseks 1 ja tehke viimane värv mustaks, kui soovite, et see lõpuks kustuks.) valmis, kuid enne järgmise värvi algust. 5. Kui soovite, et silumisväljund saadetaks jadamonitorile, määrake DEBUG lipuks 1.

Programmi sisemus pole keeruline, kuid see on nii

on pisut närvilised - sisemist tööd selgitatakse põhiahela all.

Aprill 2007, Clay Shirky

*

/ Väljund

int ylwPin = 5; // Kollane LED, ühendatud digitaalse tihvtiga 5 // 改 int redPin = 6; // Punane LED, ühendatud digitaalse tihvtiga 6 // 改 int grnPin = 7; // Roheline LED, ühendatud digitaalse tihvtiga 7 // 改 int bluPin = 8; // Sinine LED, ühendatud digitaalse tihvtiga 8 // 改 int whiPin = 9; // Valge LED, ühendatud digitaalse tihvtiga 9 // 改 int ylwPin2 = 10; // Kollane LED, ühendatud digitaalse tihvtiga 10 // 改 int redPin2 = 11; // Punane LED, ühendatud digitaalse tihvtiga 11 // 改 int grnPin2 = 12; // Roheline LED, ühendatud digitaalse tihvtiga 12 // 改 int bluPin2 = 13; // Sinine LED, ühendatud digitaalse tihvtiga 13 // 改

// Värvimassiivid

int must [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int valge [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 punane [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int roheline [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 sinine [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 kollane [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int lilla [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int oranž [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int roosa [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // jne.

// Määra esialgne värv

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

int ootama = 15; // 10 ms sisemine crossFade viivitus; suurendamine aeglasemate tuhmumiste korral // 改

int hoidmine = 1; // Valikuline hoidmine, kui värv on valmis, enne järgmist crossFade // 改 int DEBUG = 1; // DEBUG counter; kui see on seatud väärtusele 1, kirjutab väärtused järjestikuse int loopCount = 60 kaudu tagasi; // Kui tihti peaks DEBUG teatama? int kordus = 0; // Mitu korda peaksime enne peatumist loopima? (0 peatumata) // 改 int j = 0; // Silmusloendur kordamiseks

// Värvimuutujate lähtestamine

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

// LED -väljundite seadistamine

void setup () {pinMode (redPin, OUTPUT); // määrab tihvtid väljundiks 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) {// Kui tahame silumisväärtusi näha …

Seriaalne algus (9600); //… seadistage seeriaväljund}}

// Põhiprogramm: loetlege ristsuhete järjekord

void loop () {crossFade (punane); crossFade (roheline); crossFade (sinine); crossFade (kollane); crossFade (valge); crossFade (roosa); crossFade (lilla); crossFade (oranž);

if (kordus) {// Kas me loopime lõplikku arvu kordi?

j += 1; kui (j> = korda) {// Kas me oleme juba kohal? väljapääs (j); // Kui jah, siis lõpeta. }}}

/* ALLA SELLELE JÄRGI ON MATEMAATIKA - SINA EI PEAKS PÕHITEGA seda muutma

Programm töötab järgmiselt:

Kujutage ette ristpimestust, mis liigutab kümne sammuga punase LED-i 0-10, rohelise 0-5 ja sinise 10 kuni 7. Tahaksime lugeda 10 sammu ja suurendada või vähendada värviväärtusi ühtlaselt sammuga. Kujutage ette, et + näitab väärtuse tõstmist 1 võrra ja a - võrdub selle alandamisega. Meie 10 -astmeline hägustumine näeks välja selline:

1 2 3 4 5 6 7 8 9 10

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

Punane tõuseb kümne sammuga 0 -lt 10 -ni, roheline alates

0-5 viie sammuga ja sinine langeb 10-lt 7-le kolme sammuga.

Reaalses programmis teisendatakse värviprotsendid

0–255 väärtust ja 1020 sammu (255*4).

Et aru saada, kui suur samm peaks olema ühe üles- või

ühe LED-väärtuse alla-linnukese, nimetame calcStep (), mis arvutab algus- ja lõppväärtuste vahelise absoluutse vahe ning jagab seejärel selle vahe 1020-ga, et määrata väärtuse korrigeerimise vahelise sammu suurus. */

int calcStep (int prevValue, int endValue) {

int samm = endValue - prevValue; // Mis on üldine vahe? if (samm) {// Kui see ei ole null, siis samm = 1020 / samm; // jaga 1020 -ga} tagasi samm; }

/* Järgmine funktsioon on calcVal. Kui silmuse väärtus, i, saavutab ühele värvile sobiva sammu suuruse, suurendab või vähendab selle värvi väärtust 1 võrra. (R, G ja B arvutatakse eraldi.) */

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

if ((samm) && i % step == 0) {// Kui samm ei ole null ja on aeg väärtust muuta, if (samm> 0) {// väärtuse suurendamine, kui samm on positiivne… val += 1; } else if (samm 255) {val = 255; } muu kui (val <0) {val = 0; } tagasivoolu val; }

/* crossFade () teisendab värvide protsendi a -ks

Vahemikus 0–255, seejärel silmuseid 1020 korda, kontrollides, kas väärtust tuleb iga kord värskendada, ja kirjutades seejärel värviväärtused õigetele tihvtidele. */

void crossFade (int värv ) {// 改

// Teisenda 0-255 int R = (värv [0] * 255) / 100; int G = (värv [1] * 255) / 100; int B = (värv [2] * 255) / 100; int Y = (värv [3] * 255) / 100; // 改 int W = (värv [4] * 255) /100; // 改

int sammR = arvuta samm (prevR, R);

int stepG = calcStep (prevG, G); int sammB = arvuta samm (prevB, B); int sammY = arvuta samm (eelmine, Y); // 改 int sammW = calcStep (prevW, W); // 改

jaoks (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = arvutaVal (stepG, grnVal, i); bluVal = arvutaVal (sammB, bluVal, i); ylwVal = arvutaVal (sammY, ylwVal, i); // 改 whiVal = arvutaVal (sammW, whiVal, i); // 改

analogWrite (redPin, redVal); // Kirjutage praegused väärtused LED -tihvtidele

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

viivitus (oota); // Paus ootamiseks millisekundiks enne silmuse jätkamist

if (DEBUG) {// Kui soovime seeriaväljundit, printige see aadressilt

if (i == 0 või i % loopCount == 0) {// algus ja iga loopCount korda Serial.print ("Loop/RGBYW: #"); Seeriatrükk (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; }} // Järgmise tsükli praeguste väärtuste värskendamine prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 viivitus (hoidmine); // Paus valikulise ootamise millisekundiks enne silmuse jätkamist}

3. samm: seadistage

1. Hankige leivalaud.

2. Ühendusjuhtmete demo, et LED -tuli saaks särada:

   1. Asetage LED leivaplaadile. Asetage pikem ots vasakule ja lühem ots paremale.
   2. Asetage hüppaja juhtme üks ots kohale, mis asub LED -i pikema otsaga samal real. Asetage teine ots digitaalse PWM -i sektsiooni. Kood määras kollased LED -id, mis tuleb ühendada 10 ja 5, punased 6 ja 11, sinised 8 ja 13, rohelised 7 ja 12 ning lõpuks valged LED -id 9 -ga.
   3. Asetage takisti üks ots LED -i lühema otsaga samale reale. Asetage teine ots kuhugi lähedale.
   4. Asetage teise sama reaga hüppajajuhtme ots takisti otsaga, mis ei ole LED -i lühema otsaga samal real. Asetage juhtme teine ots negatiivse laengu reale.
   5. Asetage veel ühe hüppaja traadi ots negatiivse laengu reale ja asetage selle teine ots GND -le.
3. Korrake sammu 2 8 korda, kui soovite 9 LED -i särada

4. Asetage leivalaud karbi sisse. Paar meeldetuletust siit:

   1. Kasutasin toiteallikat. Looge oma juhtmetele väike auk, kasutades kasti nuga, et see kastist läbi minna ja leivaplaadiga ühendada.
   2. Veenduge, et kasti üks pool on avatud. Kingakarpi üks külg on juba avatud. Kui kast on täielikult suletud, lõigake karbi üks külg lahti, et tekiks vaba ruum.
   3. Kata pool paberiga mitte millegagi. See on mõeldud selleks, et LED -tuled paistaksid läbi paberi.