Arduino LED garastāvokļa kuba uzlabošana (vienkāršs) (iekļauts video): 4 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:53

Ieraudzījis 'mazā LED garastāvokļa kuba projektu, ko radījis' grāfs, es nolēmu izveidot uzlabotu LED garastāvokļa kuba versiju. Mana versija būs sarežģītāka nekā sākotnējā, jo tā būs nedaudz lielāka par sākotnējo, tai būs vēl divas krāsas salīdzinājumā ar sākotnējo kubu (pievienots dzeltens un balts), tai būs bezgalīga krāsu rotācija utt. vajadzētu būt labam projektam, lai praktizētu LED lampu turpmāku izmantošanu tiem, kas saprata LED gaismu savienošanas ar vadiem jēdzienu.

1. solis: materiāli

Šeit ir daži materiāli, kas jums būs nepieciešami, lai izveidotu šo garastāvokļa kubu:

• Maizes dēlis
• Arduino - (man šeit ir Leonardo)
• Arduino barošanas avots / USB kabelis
• Maizes dēlis
• Jumper vadi (daudz no tiem, es izmantoju 29 vadus)
• Sarkana gaismas diode x 2
• Zils LED x 2
• Zaļā gaismas diode x 2
• Dzeltena gaismas diode x 2
• Balta LED x 1
• 9 rezistori
• Kastīte ir pietiekami liela, lai ietilptu maizes dēļā (es izmantoju apavu kasti)
• Komunālais nazis
• Papīrs

2. darbība: kods

Daži šeit sniegtā koda skaidrojumi:

Kodu kredīts ir mana projekta sākotnējais avots, jo projekta redaktors izveidoja šos kodus. Es tikai dažus no tiem uzlaboju, padarot tos sarežģītākus. Dažos kodos beigās var redzēt // 改. Tas nozīmē, ka šo kodu esmu rediģējis es, tāpēc tas atšķiras no mana sākotnējā avota.

Man ir arī Arduino Creator koda versija.

/* Kods krustošanās izbalēšanai 3 gaismas diodes, sarkana, zaļa un zila (RGB) Lai izveidotu izbalēšanu, jums ir jādara divas lietas: 1. Aprakstiet krāsas, kuras vēlaties parādīt. 2. Norādiet secību, kādā vēlaties tās izbalināt.

KRĀSAS APRAKSTS:

Krāsa ir tikai trīs procentu masīvs, 0-100, kas kontrolē sarkanās, zaļās un zilās gaismas diodes

Sarkans ir sarkans gaismas diodes pilns, zils un zaļš

int red = {100, 0, 0} Gaiši balts ir visas trīs gaismas diodes ar 30% int dimWhite = {30, 30, 30} utt.

Dažas izplatītas krāsas ir norādītas zemāk, vai arī izveidojiet tās pats

KĀRTĪBAS SARAKSTS:

Programmas galvenajā daļā ir jāuzskaita secība, kādā vēlaties parādīt krāsas, piem. crossFade (sarkans); crossFade (zaļš); crossFade (zils);

Šīs krāsas parādīsies šādā secībā, izbalējot

vienā krāsā un nākamajā

Turklāt ir pieejami 5 papildu iestatījumi:

1. Sākotnējā krāsa ir iestatīta uz melnu (tātad pirmā krāsa izgaist), bet jūs varat iestatīt sākotnējo krāsu uz jebkuru citu krāsu. 2. Iekšējā cilpa darbojas 1020 mijiedarbībās; mainīgais “gaidīt” nosaka aptuvenu vienas krustošanās ilgumu. Teorētiski 10 ms “gaidīšanai” vajadzētu veikt ~ 10 sekunžu krustu. Praksē citas funkcijas, ko kods veic, palēnina to līdz ~ 11 sekundēm uz mana dēļa. YMMV. 3. Ja “atkārtot” ir iestatīts uz 0, programma darbosies bezgalīgi. ja tas ir iestatīts uz skaitli, tas atkārtos šo ciklu ciklu, pēc tam apstāsies pie pēdējās krāsas secībā. (Iestatiet “atgriešanās” uz 1 un pēdējo krāsu padariet melnu, ja vēlaties, lai tā izbalētu beigās.) 4. Pastāv neobligāts “aizturēšanas” mainīgais, kas pases programmu “aizturēt” milisekundēs, ja krāsa ir pabeigta, bet pirms nākamās krāsas sākuma. 5. Iestatiet DEBUG karodziņu uz 1, ja vēlaties, lai atkļūdošanas izvade tiktu nosūtīta uz seriālo monitoru.

Programmas iekšpuse nav sarežģīta, bet tā ir

ir nedaudz satraucoši - iekšējā darbība ir izskaidrota zem galvenās cilpas.

2007. gada aprīlis, Clay Shirky

*

/ Izeja

int ylwPin = 5; // Dzeltena gaismas diode, savienota ar digitālo tapu 5 // 改 int redPin = 6; // Sarkana gaismas diode, savienota ar digitālo tapu 6 // 改 int grnPin = 7; // Zaļā gaismas diode, savienota ar digitālo tapu 7 // 改 int bluPin = 8; // Zila gaismas diode, savienota ar ciparu tapu 8 // 改 int whiPin = 9; // Baltā gaismas diode, savienota ar ciparu tapu 9 // 改 int ylwPin2 = 10; // Dzeltena gaismas diode, savienota ar ciparu tapu 10 // 改 int redPin2 = 11; // Sarkana gaismas diode, savienota ar ciparu tapu 11 // 改 int grnPin2 = 12; // Zaļā gaismas diode, savienota ar digitālo tapu 12 // 改 int bluPin2 = 13; // Zila gaismas diode, savienota ar digitālo tapu 13 // 改

// Krāsu masīvi

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 red [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int green [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int blue [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 dzeltens [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int violeta [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int oranžs [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int rozā [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // utt.

// Iestatiet sākotnējo krāsu

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

int gaidīt = 15; // 10 ms iekšējā crossFade aizture; palielinājums lēnākam izbalējumam // 改

int aizturēt = 1; // Neobligāti turiet, kad krāsa ir pabeigta, pirms nākamās crossFade // 改 int DEBUG = 1; // DEBUG skaitītājs; ja iestatīts uz 1, rakstīs vērtības atpakaļ, izmantojot seriālo int loopCount = 60; // Cik bieži vajadzētu ziņot par DEBUG? int atkārtojums = 0; // Cik reizes mums vajadzētu pārtraukt pirms apstāšanās? (0 bez apstāšanās) // 改 int j = 0; // Cilpas skaitītājs atkārtojumam

// Inicializēt krāsu mainīgos

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

// Iestatiet LED izejas

void setup () {pinMode (redPin, OUTPUT); // uzstāda tapas kā izejas 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) {// Ja mēs vēlamies redzēt atkļūdošanas vērtības…

Sērijas sākums (9600); //… iestatīt sērijas izvadi}}

// Galvenā programma: uzskaitiet krustošanās secību

void loop () {crossFade (sarkans); crossFade (zaļš); crossFade (zils); crossFade (dzeltens); crossFade (balts); crossFade (rozā); crossFade (violets); crossFade (oranža);

ja (atkārtot) {// Vai mēs cilpojam ierobežotu skaitu reižu?

j += 1; ja (j> = atkārtot) {// Vai mēs jau esam tur? izeja (j); // Ja tā, tad apstājies. }}}

/* Zemāk šī līnija ir matemātika - jums tas nebūtu jāmaina uz pamatiem

Programma darbojas šādi:

Iedomājieties krustošanos, kas desmit soļos pārvieto sarkano gaismas diodi no 0-10, zaļo no 0-5 un zilo no 10 līdz 7. Mēs vēlamies saskaitīt 10 soļus un palielināt vai samazināt krāsu vērtības vienmērīgi. Iedomājieties, ka + norāda vērtības paaugstināšanu par 1, bet a - ir vienāda ar tās pazemināšanu. Mūsu 10 soļu izbalēšana izskatītos šādi:

1 2 3 4 5 6 7 8 9 10

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

Sarkanais palielinās no 0 līdz 10 desmit soļos, zaļš no

0-5 5 soļos, un zils nokrīt no 10 līdz 7 trīs soļos.

Reālajā programmā krāsu procenti tiek pārvērsti

0-255 vērtības, un ir 1020 soļi (255*4).

Lai noskaidrotu, cik lielam solim vajadzētu būt starp vienu augšup vai augšu

atzīmējot vienu no LED vērtībām uz leju, mēs to saucam par calcStep (), kas aprēķina absolūto atstarpi starp sākuma un beigu vērtībām un pēc tam sadala šo atstarpi ar 1020, lai noteiktu soli starp vērtības korekcijām. */

int calcStep (int prevValue, int endValue) {

int solis = endValue - prevValue; // Kāda vispār ir plaisa? if (solis) {// Ja tā nav nulle, solis = 1020 / solis; // dalīt ar 1020} atgriešanās solis; }

/* Nākamā funkcija ir calcVal. Kad cilpas vērtība, i, sasniedz soli, kas piemērots kādai no krāsām, tas palielina vai samazina šīs krāsas vērtību par 1. (R, G un B tiek aprēķināti atsevišķi.) */

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

if ((solis) && i % solis == 0) {// Ja solis nav nulle un ir pienācis laiks mainīt vērtību, if (solis> 0) {// vērtības palielināšana, ja solis ir pozitīvs… val += 1; } cits if (255. solis) {val = 255; } cits, ja (val <0) {val = 0; } atgriešanās val; }

/* crossFade () pārvērš procentuālās krāsas uz a

Diapazonu 0-255, pēc tam cilpas 1020 reizes, pārbaudot, vai vērtība ir jāatjaunina katru reizi, pēc tam ierakstot krāsu vērtības pareizajās tapās. */

void crossFade (int krāsa ) {// 改

// Pārvērst par 0-255 int R = (krāsa [0] * 255) / 100; int G = (krāsa [1] * 255) / 100; int B = (krāsa [2] * 255) / 100; int Y = (krāsa [3] * 255) / 100; // 改 int W = (krāsa [4] * 255) /100; // 改

int stepR = aprēķinātStep (prevR, R);

int stepG = aprēķinātStep (prevG, G); int solisB = aprēķinātStep (prevB, B); int solisY = aprēķinātStep (iepriekšējais, Y); // 改 int stepW = calcStep (prevW, W); // 改

par (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = aprēķinātVal (solisG, grnVal, i); bluVal = aprēķinātVal (solisB, bluVal, i); ylwVal = aprēķinātVal (solis Y, ylwVal, i); // 改 whiVal = aprēķinātVal (solisW, whiVal, i); // 改

analogWrite (redPin, redVal); // Ierakstiet pašreizējās vērtības LED tapās

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

aizkavēties (gaidīt); // Pirms cilpas atsākšanas pauzējiet uz “gaidīšanas” milisekundēm

if (DEBUG) {// Ja mēs vēlamies sērijveida izvadi, izdrukājiet to

if (i == 0 vai i % loopCount == 0) {// sākums, un katrs loopCount reizes Serial.print ("Loop/RGBYW: #"); Sērijas nospiedums (i); Serial.print ("|"); Serial.print (redVal); Serial.print (" /"); Serial.print (grnVal); Serial.print (" /"); Serial.println (bluVal); Serial.print (" /"); Sērijas.println (ylwVal); // 改 Serial.print (" /"); // 改 Serial.println (whiVal); // 改 Serial.print (" /"); // 改} DEBUG += 1; }} // Atjaunināt pašreizējās vērtības nākamajai cilpai prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 kavēšanās (aizturēšana); // Pauze, lai pēc izvēles atjaunotu cikla gaidīšanas milisekundes}

3. darbība: iestatīšana

1. Iegūstiet maizes dēli.

2. Savienojošo vadu demonstrācija, lai spīdētu LED gaisma:

   1. Uzlieciet LED uz maizes dēļa. Novietojiet garāko galu kreisajā pusē un īsāko galu labajā pusē.
   2. Novietojiet vienu džempera stieples galu vietā, kas atrodas vienā rindā ar gaismas diodes garāko galu. Novietojiet otru galu uz sadaļu Digital PWM. Kods noteica dzeltenās gaismas diodes, kas jāpievieno 10 un 5, sarkanās - 6 un 11, zilās - 8 un 13, zaļās - 7 un 12 un visbeidzot baltās gaismas diodes - 9.
   3. Novietojiet vienu rezistora galu vienā rindā ar gaismas diodes īsāko galu. Novietojiet otru galu kaut kur tuvu.
   4. Novietojiet cita džempera stieples galu ar tādu pašu rindu ar rezistora galu, kas nav vienā rindā ar gaismas diodes īsāko galu. Novietojiet stieples otru galu uz negatīvās uzlādes rindas.
   5. Novietojiet vēl viena džempera stieples galu uz negatīvās uzlādes rindas un novietojiet tā otru galu uz GND.
3. Atkārtojiet 2. darbību 8 reizes, kamēr vēlaties, lai spīd 9 gaismas diodes

4. Ievietojiet maizes dēli kastes iekšpusē. Daži atgādinājumi šeit:

   1. Es izmantoju barošanas avotu. Izveidojiet nelielu caurumu vadiem, izmantojot komunālo nazi, lai izietu cauri kastē un izveidotu savienojumu ar maizes dēli.
   2. Pārliecinieties, vai kaste ir atvērta kā viena puse. Apavu kastē jau ir atvērta viena puse. Ja kaste ir pilnībā aizvērta, nogrieziet vienu kastes pusi, lai izveidotu brīvu vietu.
   3. Pārklājiet sānu ar neko ar papīru. Tas ir paredzēts, lai gaismas diodes spīdētu caur papīru.