Arduino LED տրամադրության խորանարդի բարելավում (պարզ) (ներառյալ տեսանյութը). 4 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:46

Էրլի ստեղծած LED տրամադրության փոքր խորանարդի նախագիծը տեսնելուց հետո որոշեցի անել LED Mood Cube- ի կատարելագործված տարբերակը: Իմ տարբերակը կլինի ավելի բարդ, քան բնօրինակը, քանի որ այն կլինի մի փոքր ավելի մեծ, քան բնօրինակը, կունենա երկու ավելի գույն ՝ համեմատած սկզբնական խորանարդի հետ (ավելացված դեղին և սպիտակ), կունենա գույների անվերջ պտույտ և այլն: պետք է լինի լավ նախագիծ ՝ LED լուսարձակների հետագա օգտագործման վերաբերյալ, ովքեր հասկացել են LED լույսերը լարերով միացնելու հայեցակարգը:

Քայլ 1: Նյութեր

Ահա մի քանի նյութեր, որոնք ձեզ հարկավոր են այս տրամադրության խորանարդը պատրաստելու համար.

• Breadboard
• Արդուինո - (Ես այստեղ Լեոնարդոյին ունեմ)
• Arduino սնուցման աղբյուր / USB մալուխ
• Breadboard
• Jumper Wires (շատերը, ես օգտագործել եմ 29 լար)
• Կարմիր LED x 2
• Կապույտ LED x 2
• Կանաչ LED x 2
• Դեղին LED x 2
• Սպիտակ LED x 1
• 9 դիմադրություն
• Այնքան մեծ տուփ, որ տեղավորի հացաթխիկը (ես օգտագործել եմ կոշիկի տուփ)
• Կոմունալ դանակ
• Թուղթ

Քայլ 2: Կոդ

Այստեղ տրված ծածկագրի որոշ բացատրություններ.

Կոդերի վարկը պատկանում է իմ նախագծի սկզբնական աղբյուրին, քանի որ նախագծի խմբագիրը ստեղծել է այս ծածկագրերը: Ես պարզապես կատարելագործեցի դրանցից մի քանիսը ՝ դրանք ավելի բարդ դարձնելով: Որոշ կոդերում, վերջում, կարող եք տեսնել //: Սա նշանակում է, որ այս կոդը խմբագրված է իմ կողմից, ուստի այն տարբերվում է իմ սկզբնական աղբյուրից:

Ես ունեմ նաև Arduino Creator- ի կոդի տարբերակ:

/* 3 LED, կարմիր, կանաչ և կապույտ (RGB) խաչաձև մարման համար (RGB) Մարումներն ստեղծելու համար անհրաժեշտ է անել երկու բան.

ԳՈLՅՆ ՆՇԱՆԱԿՈՄ.

Գույնը ընդամենը երեք տոկոսանոց զանգված է ՝ 0-100, որը վերահսկում է կարմիր, կանաչ և կապույտ LED- ները

Կարմիրը կարմիր LED- ն է ամբողջությամբ, կապույտը և կանաչը ՝ անջատված

int կարմիր = {100, 0, 0} Մուգ սպիտակ բոլոր երեք LED- ներն են 30% int dimWhite = {30, 30, 30} և այլն:

Որոշ սովորական գույներ ներկայացված են ստորև, կամ պատրաստեք ձեր սեփականը

LԱՆԿԱՄԱՆ ՊԱՏՎԵՐԸ.

Theրագրի հիմնական մասում դուք պետք է նշեք այն կարգը, որով ցանկանում եք, որ գույները հայտնվեն, օրինակ. crossFade (կարմիր); crossFade (կանաչ); crossFade (կապույտ);

Այդ գույները կհայտնվեն այդ հերթականությամբ ՝ մարելով

մեկ գույնի և հաջորդի մեջ

Բացի այդ, կան 5 լրացուցիչ պարամետրեր, որոնք կարող եք հարմարեցնել.

1. Սկզբնական գույնը սահմանվում է սևի (այնպես որ առաջին գույնը մարում է), բայց կարող եք նախնական գույնը դնել ցանկացած այլ գույնի: «սպասել» փոփոխականը սահմանում է մեկ խաչմերուկի մոտավոր տևողությունը: Տեսականորեն, 10 ms- ի «սպասումը» պետք է խաչաձև լինի ~ 10 վայրկյանից: Գործնականում, մյուս գործառույթները, որոնք կատարում է կոդը, դանդաղեցնում են մինչև 11 վայրկյան իմ տախտակի վրա: YMMV. 3. Եթե «կրկնել» -ը սահմանվում է 0, ծրագիրը անորոշ ժամանակով կշրջվի: եթե այն սահմանվում է թվի վրա, ապա այդ թիվը կշրջվի մի քանի անգամ, այնուհետև կանգ կառնի հաջորդականության վերջին գույնի վրա: (Սահմանեք «վերադարձը» 1 -ի վրա և վերջին գույնը դարձրեք սև, եթե ցանկանում եք, որ այն վերջում մարվի): ամբողջական, բայց մինչ հաջորդ գույնի սկսվելը: 5. DEBUG- ի դրոշը դրեք 1 -ի վրա, եթե ցանկանում եք, որ վրիպազերծման ելքը ուղարկվի սերիական մոնիտոր:

Theրագրի ներքին մասերը բարդ չեն, բայց դրանք

մի փոքր անհանգիստ են. ներքին աշխատանքը բացատրվում է հիմնական հանգույցից ներքև:

2007 թ. Ապրիլ, Քլեյ Շիրկի

*

/ Արդյունք

int ylwPin = 5; // Դեղին LED, միացված թվային կապին 5 // 改 int redPin = 6; // Կարմիր LED, միացված թվային կապին 6 // 改 int grnPin = 7; // Կանաչ LED, միացված թվային կապին 7 // 改 int bluPin = 8; // Կապույտ LED, միացված թվային կապին 8 // 改 int whiPin = 9; // Սպիտակ LED, միացված թվային կապին 9 // 改 int ylwPin2 = 10; // Դեղին LED, միացված թվային կապին 10 // 改 int redPin2 = 11; // Կարմիր LED, միացված թվային կապին 11 // 改 int grnPin2 = 12; // Կանաչ LED, միացված թվային կապին 12 // 改 int bluPin2 = 13; // Կապույտ LED, միացված թվային կապին 13 // 改

// Գունավոր զանգվածներ

int սեւ [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int սպիտակ [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int կարմիր [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int կանաչ [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int կապույտ [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int դեղին [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int մանուշակագույն [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int նարնջագույն [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int pink [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // և այլն

// Սահմանել սկզբնական գույնը

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

int սպասել = 15; // 10ms ներքին crossFade հետաձգում; ավելանալ ավելի դանդաղ մարման համար //

int պահում = 1; // Լրացուցիչ պահում, երբ գույնն ավարտված է, մինչև հաջորդ խաչմերուկը // 改 int DEBUG = 1; // DEBUG հաշվիչ; եթե սահմանված է 1 -ի վրա, արժեքները կգրեն սերիական int loopCount = 60 միջոցով; // Որքա՞ն հաճախ պետք է զեկուցի DEBUG- ը: int կրկնել = 0; // Քանի՞ անգամ պետք է օղակ անենք կանգ առնելուց առաջ: (0 առանց կանգառի) // 改 int j = 0; // Օղակի հաշվիչ կրկնելու համար

// Գունավոր փոփոխականների սկզբնականացում

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

// Տեղադրեք LED ելքերը

void setup () {pinMode (redPin, 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) {// Եթե ցանկանում ենք տեսնել արժեքներ վրիպազերծման համար …

Serial.begin (9600); //… կարգավորել սերիայի ելքը}}

// Հիմնական ծրագիր. Թվարկեք խաչմերուկների հերթականությունը

void loop () {crossFade (կարմիր); crossFade (կանաչ); crossFade (կապույտ); crossFade (դեղին); crossFade (սպիտակ); crossFade (վարդագույն); crossFade (մանուշակագույն); crossFade (նարնջագույն);

if (կրկնել) {// Արդյո՞ք մենք մի շարք անգամ ենք օղակում:

j += 1; եթե (j> = կրկնել) {// մենք դեռ այնտեղ ենք? ելք (ժ); // Եթե այո, ապա կանգ առեք: }}}

/* ՍՏՈՅՆ ՍՏՈՅՆ Է ՄԱԹԵՄԱՅԻՆ. ՊԵՏՔ ՉԷ ՊԵՏՔ ՓՈՓՈԽԵԼ ԱՅՍ ՀԻՄՈՆԵՐԻ ՀԱՄԱՐ

Րագիրը գործում է այսպես.

Պատկերացրեք խաչմերուկ, որը կարմիր LED- ը 0-10-ից տեղափոխում է կանաչը, 0-5-ից, իսկ կապույտը ՝ 10-ից 7, տասը քայլով: Մենք կցանկանայինք հաշվել 10 քայլը և ավելացնել կամ նվազեցնել գույնի արժեքները հավասարաչափ աստիճանաբար: Պատկերացրեք, a + նշանը բարձրացնում է արժեքը 1 -ով, իսկ a- ն հավասար է այն իջեցնելուն: Մեր 10 քայլերի մարումը նման կլինի.

1 2 3 4 5 6 7 8 9 10

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

Կարմիրը տասը քայլով 0 -ից հասնում է 10 -ի, կանաչը `10

0-5 ՝ 5 քայլով, իսկ կապույտը երեք քայլով ընկնում է 10-ից 7-ի:

Իրական ծրագրում գույնի տոկոսները վերածվում են

0-255 արժեքներ, և կան 1020 քայլ (255*4):

Պարզելու համար, թե որքան մեծ քայլ պետք է լինի մեկ վեր- կամ

LED- ի արժեքներից մեկի իջեցումը մենք կոչում ենք calcStep (), որը հաշվարկում է սկզբի և վերջի արժեքների միջև բացարձակ բացը, այնուհետև այդ բացը բաժանում է 1020-ով `որոշելու համար արժեքի ճշգրտումների միջև քայլի չափը: */

int calcStep (int prevValue, int endValue) {

int քայլ = endValue - prevValue; // Ո՞րն է ընդհանուր բացը: եթե (քայլ) {// Եթե դա ոչ զրո է, քայլ = 1020 / քայլ; // բաժանել 1020} վերադարձի քայլի; }

/* Հաջորդ գործառույթը calcVal է: Երբ օղակի արժեքը, ես, հասնում է գույներից մեկի համար համապատասխան քայլի չափին, այն մեծացնում կամ նվազեցնում է այդ գույնի արժեքը 1. -ով (R, G և B- ն յուրաքանչյուրը հաշվարկվում է առանձին) */

int calcVal (int քայլ, int val, int i) {

եթե ((քայլ) && i % քայլ == 0) {// Եթե քայլը զրոյական չէ և արժեքը փոխելու ժամանակը, եթե (քայլ> 0) {// ավելացրեք արժեքը, եթե քայլը դրական է … val += 1; } else if (քայլ 255) {val = 255; } else if (val <0) {val = 0; } վերադարձ val; }

/* crossFade () փոխակերպում է գույների տոկոսը a- ի

0-255 միջակայք, այնուհետև օղակվում է 1020 անգամ ՝ ստուգելով, թե արդյոք արժեքը պետք է թարմացվի ամեն անգամ, այնուհետև գույնի արժեքները գրեք ճիշտ կապում: */

void crossFade (int գույն ) {//

// Փոխակերպել 0-255 int R = (գույնը [0] * 255) / 100; int G = (գույնը [1] * 255) / 100; int B = (գույնը [2] * 255) / 100; int Y = (գույնը [3] * 255) / 100; // 改 int W = (գույնը [4] * 255) /100; //

int stepR = calcStep (prevR, R);

int stepG = calcStep (prevG, G); int քայլ Բ = հաշվարկելՔայլը (prevB, B); int stepY = calcStep (prevY, Y); // 改 int stepW = calcStep (prevW, W); //

համար (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = calcVal (stepG, grnVal, i); bluVal = calcVal (stepB, bluVal, i); ylwVal = հաշվարկել Val (քայլ Y, ylwVal, i); // 改 whiVal = calcVal (քայլW, whiVal, i); //

analogWrite (redPin, redVal); // Գրեք ընթացիկ արժեքները 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); //

ուշացում (սպասել); // Դադարեցրեք «սպասել» միլիվայրկյաններ, նախքան շրջանը վերսկսելը

if (DEBUG) {// Եթե մենք ցանկանում ենք սերիական ելք, տպեք այն հետևյալում

եթե (i == 0 կամ i % loopCount == 0) {// սկիզբ, և յուրաքանչյուր loopCount անգամ 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; }} // Թարմացրեք ընթացիկ արժեքները հաջորդ հանգույցի համար prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 հետաձգում (պահում); // Դադարեցնել կամընտիր «սպասել» միլիվայրկյաններ, նախքան օղակը վերսկսելը}

Քայլ 3: Կարգավորեք

1. Ստացեք հացաթուղթը:

2. Լարերի միացման ցուցադրում, որպեսզի LED լույսը կարողանա փայլել.

   1. Տեղադրեք LED- ը սեղանի վրա: Տեղադրեք ավելի երկար ծայրը ձախ կողմում, իսկ կարճ ծայրը ՝ աջ կողմում:
   2. Տեղադրեք ցատկող մետաղալարերի մի ծայրը մի տեղում, որը գտնվում է LED- ի ավելի երկար ծայրով նույն շարքում: Մյուս ծայրը տեղադրեք Թվային PWM բաժնի վրա: Կոդում նշվում էր, որ դեղին LED- ները պետք է միացվեն 10 -ին և 5 -ին, կարմիրները `6 -ին և 11 -ին, կապույտները` 8 -ին և 13 -ին, կանաչները `7 -ին և 12 -ին, և, վերջապես, սպիտակ LED- ին` 9 -ին:
   3. Տեղադրեք ռեզիստորի մի ծայրը նույն շարքում `LED- ի ավելի կարճ ծայրով: Մյուս ծայրը տեղադրեք մոտակայքում:
   4. Տեղադրեք մեկ այլ ցատկող մետաղալարերի ծայրը նույն շարքով `դիմադրության ծայրով, որը նույն շարքում չէ LED- ի ավելի կարճ ծայրով: Լարի մյուս ծայրը տեղադրեք բացասական լիցքի տողի վրա:
   5. Բացասական լիցքի շարանի վրա դրեք ևս մեկ ցատկող մետաղալարի ծայր և տեղադրեք դրա մյուս ծայրը GND- ի վրա:
3. Կրկնեք 2 -րդ քայլը 8 անգամ, քանի որ ցանկանում եք, որ 9 LED լուսավորվեն

4. Տեղադրեք տախտակի տուփի ներսում: Մի քանի հիշեցում այստեղ.

   1. Ես օգտագործել եմ սնուցման աղբյուր: Ստեղծեք մի փոքր անցք ձեր լարերի համար `օգտագործելով դանակը` տուփի միջով անցնելու և միացվող տախտակին միանալու համար:
   2. Համոզվեք, որ տուփը բաց է որպես մի կողմ: Կոշիկի տուփն արդեն ունի մի կողմ, որը բաց է: Եթե տուփը լիովին փակ է, կտրեք տուփի մի կողմը `բաց տարածք ստեղծելու համար:
   3. Կողքը թղթի վրա ոչ մի բանով չծածկեք: Սա այն է, որ LED լույսերը փայլեն թղթի միջով: