Përmirësimi i një kubi të Arduino LED të humorit (i thjeshtë) (i përfshirë në video): 4 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:15

Pasi pashë një projekt të vogël të kubit të humorit të krijuar nga 'Earl, vendosa të bëj një version të përmirësuar të Kubit të Mood LED. Versioni im do të jetë më kompleks se ai origjinal, pasi do të jetë pak më i madh se ai origjinal, do të ketë dy ngjyra më shumë në krahasim me kubin origjinal (të verdhë dhe të bardhë të shtuar), do të ketë një sasi të pafund rrotullimi të ngjyrave, etj. duhet të jetë një projekt i mirë për të praktikuar përdorimin e mëtejshëm të dritave LED për ata që e kuptuan konceptin e lidhjes së dritave LED me tela.

Hapi 1: Materialet

Këtu janë disa materiale që do t'ju nevojiten për të bërë këtë Kub Mood:

• Breadboard
• Arduino - (Unë kam Leonardon këtu)
• Furnizimi me energji Arduino / kabllo USB
• Breadboard
• Telat Jumper (Shumë prej tyre, kam përdorur 29 tela)
• LED i kuq x 2
• LED blu x 2
• LED i gjelbër x 2
• LED i verdhë x 2
• LED i bardhë x 1
• 9 rezistente
• Kuti mjaft e madhe për të përshtatur tryezën e bukës (kam përdorur një kuti këpucësh)
• Thikë e shërbimeve
• Letër

Hapi 2: Kodi

Disa shpjegime për kodin e dhënë këtu:

Merita e kodeve i shkon burimit origjinal të projektit tim pasi redaktuesi i projektit krijoi këto kode. Unë thjesht përmirësova disa prej tyre duke i bërë ato më komplekse. Në disa kode, mund të shihni // 改 në fund. Kjo do të thotë që ky kod është redaktuar nga unë, kështu që është i ndryshëm nga burimi im origjinal.

Unë gjithashtu kam një version të kodit në Arduino Creator.

/* Kodi për zbehjen e 3 LED-ve, të kuqe, jeshile dhe blu (RGB) Për të krijuar zbehje, duhet të bëni dy gjëra: 1. Përshkruani ngjyrat që dëshironi të shfaqen 2. Shënoni rendin në të cilin dëshironi të zbehen

P DRSHKRIMI I NGJYRS:

Një ngjyrë është vetëm një grup prej tre përqindësh, 0-100, që kontrollon LED-të e kuqe, jeshile dhe blu

E kuqja është LED e kuqe plotësisht, blu dhe jeshile fikur

int e kuqe = {100, 0, 0} E bardha e zbehtë është të tre LED me 30% int dimWhite = {30, 30, 30} etj.

Disa ngjyra të zakonshme jepen më poshtë, ose bëni tuajat

LISTA E POROSIS:

Në pjesën kryesore të programit, duhet të rendisni rendin në të cilin dëshironi të shfaqen ngjyrat, p.sh. crossFade (e kuqe); crossFade (jeshile); crossFade (blu);

Ato ngjyra do të shfaqen në atë renditje, duke u zbehur

një ngjyrë dhe në tjetrën

Përveç kësaj, ka 5 cilësime opsionale që mund t'i rregulloni:

1. Ngjyra fillestare është vendosur në të zezë (kështu që ngjyra e parë zbehet), por ju mund të vendosni që ngjyra fillestare të jetë çdo ngjyrë tjetër 2. Lakja e brendshme funksionon për 1020 integrime; variabla 'prit' përcakton kohëzgjatjen e përafërt të një kryqëzimi të vetëm. Në teori, një 'pritje' prej 10 ms duhet të bëjë një zbehje të kryqëzuar prej ~ 10 sekonda. Në praktikë, funksionet e tjera që kodi po kryen ngadalë deri në seconds 11 sekonda në tabelën time. YMMV. 3. Nëse 'përsërit' është vendosur në 0, programi do të lakohet pafundësisht. nëse është vendosur në një numër, ai do të lakojë atë numër herë, pastaj do të ndalet në ngjyrën e fundit në sekuencë. (Vendosni 'kthimin' në 1 dhe bëni ngjyrën e fundit të zezë nëse dëshironi që ajo të zbehet në fund.) 4. Ekziston një ndryshore opsionale 'mbaj', e cila e kalon programin për 'mbaj' milisekonda kur një ngjyrë është e plotë, por para se të fillojë ngjyra tjetër. 5. Vendosni flamurin DEBUG në 1 nëse dëshironi që dalja e korrigjimit të dërgohet në monitorin serik.

Pjesët e brendshme të programit nuk janë të komplikuara, por ato

janë pak shqetësuese - punimet e brendshme shpjegohen poshtë lakut kryesor.

Prill 2007, Clay Shirky

*

/ Dalja

int ylwPin = 5; // LED i verdhë, i lidhur me pinin digjital 5 // 改 int redPin = 6; // LED i kuq, i lidhur me pinin dixhital 6 // 改 int grnPin = 7; // LED i gjelbër, i lidhur me pinin dixhital 7 // 改 int bluPin = 8; // LED blu, i lidhur me pinin dixhital 8 // 改 int whiPin = 9; // LED i bardhë, i lidhur me pinin dixhital 9 // 改 int ylwPin2 = 10; // LED i verdhë, i lidhur me pinin dixhital 10 // 改 int redPin2 = 11; // LED i kuq, i lidhur me pinin dixhital 11 // 改 int grnPin2 = 12; // LED i gjelbër, i lidhur me pinin digjital 12 // 改 int bluPin2 = 13; // LED blu, i lidhur me pinin digjital 13 // 改

// Vargjet e ngjyrave

int e zezë [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int e bardhë [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int e kuqe [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int jeshile [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blu [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int verdhë [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int vjollce [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int portokalli [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int rozë [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // etj

// Vendosni ngjyrën fillestare

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

int prisni = 15; // 10ms vonesë e brendshme crossFade; rritet për zbehje më të ngadalta //

int mbaj = 1; // Mbaj opsionale kur një ngjyrë është e plotë, para kryqëzimit tjetër // 改 int DEBUG = 1; // sportel DEBUG; nëse vendoset në 1, do të shkruajë vlerat përsëri përmes serisë int loopCount = 60; // Sa shpesh duhet të raportojë DEBUG? int përsëris = 0; // Sa herë duhet të bëjmë lak para se të ndalojmë? (0 pa ndalesë) // 改 int j = 0; // Numëruesi i lakut për përsëritje

// Filloni variablat e ngjyrave

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

// Vendosni daljet LED

void setup () {pinMode (redPin, OUTPUT); // vendos kunjat si pinMode dalëse (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, OUTPUT); // 改

nëse (DEBUG) {// Nëse duam të shohim vlera për korrigjim…

Serial.filloj (9600); //… konfiguroni daljen serike}}

// Programi kryesor: rendit rendin e kryqëzimeve

void loop () {crossFade (e kuqe); crossFade (jeshile); crossFade (blu); crossFade (e verdhë); crossFade (e bardhë); crossFade (rozë); crossFade (vjollce); crossFade (portokalli);

nëse (përsëris) {// A lakojmë një numër të kufizuar herë?

j += 1; nëse (j> = përsëris) {// A jemi akoma atje? dalja (j); // Nëse po, ndalo. }}}

/* Poshtë KJO RREGULLI ISSHT MATA - NUK DUHET TT NDRYSHME T TO NDRYSHOJM TH KT P FORR BAZAT

Programi funksionon kështu:

Imagjinoni një kryqëzim që lëviz LED të kuq nga 0-10, të gjelbër nga 0-5 dhe blu nga 10 në 7, në dhjetë hapa. Ne do të donim të numëronim 10 hapat dhe të rrisnim ose ulnim vlerat e ngjyrave në rritje të barabarta. Imagjinoni a + tregon ngritjen e një vlere me 1, dhe a - e barabartë me uljen e saj. Zbehja jonë me 10 hapa do të duket si kjo:

1 2 3 4 5 6 7 8 9 10

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

E kuqja ngrihet nga 0 në 10 në dhjetë hapa, e gjelbra nga

0-5 në 5 hapa, dhe bluja bie nga 10 në 7 në tre hapa.

Në programin real, përqindjet e ngjyrave konvertohen në

0-255 vlera, dhe ka 1020 hapa (255*4).

Për të kuptuar se sa i madh duhet të jetë një hap midis një lart- ose

zbritja e njërës prej vlerave të LED, ne e quajmë calcStep (), e cila llogarit hendekun absolut midis vlerave fillestare dhe përfundimtare, dhe më pas e ndan atë hendek me 1020 për të përcaktuar madhësinë e hapit midis rregullimeve në vlerë. */

int calcStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Cili është hendeku i përgjithshëm? nëse (hapi) {// Nëse është jo-zero, hapi = 1020 / hap; // ndaj me 1020} hapin e kthimit; }

/* Funksioni tjetër është CalcVal. Kur vlera e lakut, unë, arrin madhësinë e hapit të përshtatshëm për njërën nga ngjyrat, rrit ose zvogëlon vlerën e asaj ngjyre me 1. (R, G dhe B llogariten secila veç e veç.) */

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

nëse ((hapi) && i % hap == 0) {// Nëse hapi është jo-zero dhe koha e tij për të ndryshuar një vlerë, nëse (hapi> 0) {// shtoni vlerën nëse hapi është pozitiv… val += 1; } tjetër nëse (hapi 255) {val = 255; } tjetër nëse (val <0) {val = 0; } valvula e kthimit; }

/* crossFade () konverton përqindjen e ngjyrave në a

Gama 0-255, pastaj sythe 1020 herë, duke kontrolluar nëse vlera duhet të përditësohet çdo herë, pastaj shkruani vlerat e ngjyrave në kunjat e sakta. */

void crossFade (ngjyra int ) {// 改

// Shndërrohuni në 0-255 int R = (ngjyra [0] * 255) / 100; int G = (ngjyra [1] * 255) / 100; int B = (ngjyra [2] * 255) / 100; int Y = (ngjyra [3] * 255) / 100; // 改 int W = (ngjyra [4] * 255) /100; // 改

int stepR = llogaris hapin (prevR, R);

int stepG = llogaris hapin (prevG, G); int hapB = llogaris hapin (prevB, B); int stepY = llogaris hapin (para, Y); // step int stepW = calcStep (prevW, W); // 改

për (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = llogaris Val (stepG, grnVal, i); bluVal = llogaritVal (stepB, bluVal, i); ylwVal = llogaris Val (hapiY, ylwVal, i); // 改 whiVal = llogaris Val (hapW, whiVal, i); // 改

analogWrite (redPin, redVal); // Shkruani vlerat aktuale në kunjat LED

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

vonesë (pritje); // Ndalo për 'prit' milisekonda para se të rifillosh ciklin

if (DEBUG) {// Nëse duam dalje serike, shtypeni atë në

nëse (i == 0 ose i % loopCount == 0) {// fillim, dhe çdo loopCount herë 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; }} // Përditësoni vlerat aktuale për lakun tjetër prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 vonesë (mbaj); // Pusho për 'pritjen' opsionale milisekonda para se të rifillosh ciklin}

Hapi 3: Konfiguro

1. Merrni tabelën e bukës.

2. Demo e telave lidhës në mënyrë që një dritë LED të shkëlqejë:

   1. Vendoseni LED -in në dërrasën e bukës. Vendoseni skajin më të gjatë në të majtë dhe skajin më të shkurtër në të djathtë.
   2. Vendosni një fund të një teli kërcyes në një vend që është në të njëjtën rresht me skajin më të gjatë të LED. Vendoseni skajin tjetër në seksionin Digital PWM. Kodi specifikonte LED -të e verdhë që do të lidheshin me 10 dhe 5, ato të kuqe në 6 dhe 11, ato blu në 8 dhe 13, ato jeshile në 7 dhe 12, dhe në fund LED të bardhë në 9.
   3. Vendosni një fund të një rezistence në të njëjtën rresht me skajin më të shkurtër të LED. Vendoseni skajin tjetër diku afër.
   4. Vendosni një fund të një teli tjetër kërcyes me të njëjtin rresht me fundin e rezistencës që nuk është në të njëjtën rresht me skajin më të shkurtër të LED. Vendoseni skajin tjetër të telit në rreshtin e ngarkesës negative.
   5. Vendosni një fund të një teli tjetër kërcyes në rreshtin e ngarkesës negative dhe vendoseni skajin tjetër të tij në GND.
3. Përsëriteni hapin 2 për 8 herë pasi dëshironi që 9 LED të shkëlqejnë

4. Vendoseni tabelën e bukës brenda kutisë. Disa kujtesa këtu:

   1. Kam përdorur një furnizim me energji elektrike. Krijoni një vrimë të vogël për telat tuaj duke përdorur një thikë të shërbimit për të kaluar nëpër kuti dhe për t'u lidhur me tabelën e bukës.
   2. Sigurohuni që kutia të jetë e hapur si njëra anë. Një kuti këpucësh tashmë ka njërën anë që është e hapur. Nëse kutia është e mbyllur plotësisht, prerë njërën anë të kutisë për të bërë një hapësirë të hapur.
   3. Mbuloni anën me asgjë me letër. Kjo është që dritat LED të shkëlqejnë përmes letrës.