LED պարույր ծառ. 4 քայլ (նկարներով)

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

Ես սիրում եմ բոլոր տեսակի LED շերտերը: Նրանց հետ գեղեցիկ ծիածանի լույս վառեցի: Նույնիսկ ոչ հասցեականները օգտակար են: Ես շուկայական պայծառ լուսամփոփ եմ բացել ՝ դրանք ամրացնելով չամրացված կողերին, այնպես որ, երբ իմ պարույր ծառը փչեց, ես որոշեցի դրա շուրջը փաթաթել մի երկար լուսադիոդային ժապավեն:

Քայլ 1: Վերահսկիչ

Ես որոշեցի օգտագործել ոչ հասցեավորվող RGB լուսարձակներ: Սա նշանակում է, որ ես կարող եմ ծրագրավորված ազդեցություն ունենալ, բայց բոլոր լուսարձակները միաժամանակ փոխում են գույնը: Սա նաև նշանակում է, որ անհրաժեշտ կլինի վերահսկիչ: Ես կարող էի օգտագործել arduino uno- ն և նախնական թեստերը կատարել RGB վահանի միջոցով, բայց վերջում օգտագործեցի սովորական մեկ տախտակ ՝ մերկ Atmega328 չիպով: Պարզապես պետք է միացնեի նպատակային ծրագրավորողին և անմիջապես ծրագրավորեր չիպը:

Ես ունեի այս տախտակներից շատերը մնացած լամպերի նախագծերից: Ազատորեն օգտագործեք էժան ներկառուցված նախապես ծրագրավորված վերահսկիչ, ինչպես դա արեցի իմ անձրևանոցի փոխարեն:

Ես ավարտեցի դանդաղ խաչաձեւ ցուցադրման ցուցադրումը որպես ծառի հիմք:

/** 3 LED, կարմիր, կանաչ և կապույտ (RGB) խաչաձև մարման համար * Մարումն ստեղծելու համար հարկավոր է անել երկու բան. * 1. Նկարագրեք այն գույները, որոնք ցանկանում եք ցուցադրվել * 2. Նշեք ձեր ուզած կարգը դրանք գունաթափվում են * * ԳՈLՅՆԸ ՆԵՐԿԱՅԱՈՄ. * Գույնը ընդամենը երեք տոկոսանոց զանգված է ՝ 0-100, * վերահսկում է կարմիր, կանաչ և կապույտ LED- ները * * Կարմիրը կարմիր LED- ն ամբողջությամբ, կապույտ և կանաչը անջատված է * int կարմիր = {100, 0, 0} * Մուգ սպիտակ բոլոր երեք LED- ներն են 30% * int dimWhite = {30, 30, 30} * և այլն * * Ստորև բերված են որոշ սովորական գույներ կամ ինքներդ պատրաստեք * * ԼՍԵԼ Պատվեր. * Theրագրի հիմնական մասում դուք պետք է նշեք այն կարգը *, որով ցանկանում եք, որ գույները հայտնվեն, օրինակ. * crossFade (կարմիր); * crossFade (կանաչ); * crossFade (կապույտ); * * Այդ գույները կհայտնվեն այդ հերթականությամբ ՝ մարելով * մեկ գույնից և հաջորդի մեջ * * Բացի այդ, կան 5 ընտրովի պարամետրեր, որոնք կարող եք հարմարեցնել ՝ * 1. 1. Սկզբնական գույնը սահմանվել է սևի (այնպես որ առաջին գույնը մարում է մեջ), բայց * կարող եք նախնական գույնը սահմանել որևէ այլ գույնի * 2. Ներքին հանգույցն աշխատում է 1020 ինտերակացիայի համար; «սպասել» փոփոխականը * սահմանում է մեկ խաչմերուկի մոտավոր տևողությունը: Տեսականորեն, * 10 ms- ի «սպասումը» պետք է խաչաձև լինի ~ 10 վայրկյանից: * Գործնականում, մյուս գործառույթները, որոնք ծածկագիրը կատարում է դանդաղ, մինչև * 11 վայրկյան իմ տախտակի վրա: YMMV. * 3. Եթե «կրկնել» -ը սահմանվում է 0, ծրագիրը անորոշ ժամանակով կշրջվի: * եթե այն դրված է թվի վրա, այն այդքան անգամ կլորանա, * այնուհետև կանգ առեք հաջորդականության վերջին գույնի վրա: (Սահմանեք «վերադարձը» 1, * և վերջին գույնը դարձրեք սև, եթե ցանկանում եք, որ այն վերջում մարվի) գույնը ամբողջական է *, բայց մինչև հաջորդ գույնի սկսվելը: * 5. DEBUG- ի դրոշը դրեք 1 -ի վրա, եթե ցանկանում եք, որ վրիպազերծման ելքը * ուղարկվի սերիական մոնիտորին: * * Theրագրի ներքին մասերը բարդ չեն, բայց դրանք * մի փոքր անհանգիստ են. Ներքին աշխատանքը բացատրված է * հիմնական հանգույցից ներքև: * * 2007 թ. Ապրիլ, Քլեյ Շիրկի *

/ Արդյունք

int grnPin = 9; // Կանաչ LED, միացված թվային կապին 10 int redPin = 10; // Կարմիր LED, միացված թվային կապին 9 int bluPin = 11; // Կապույտ LED, միացված է թվային կապին 11

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

int սեւ [3] = {0, 0, 0}; int սպիտակ [3] = {100, 100, 100}; int կարմիր [3] = {100, 0, 0}; int կանաչ [3] = {0, 100, 0}; int կապույտ [3] = {0, 0, 100}; int դեղին [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // և այլն

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

int redVal = սև [0]; int grnVal = սև [1]; int bluVal = սև [2];

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

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

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

int prevR = redVal; int prevG = grnVal; int prevB = bluVal;

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

void setup () {pinMode (redPin, OUTPUT); // կապումներն է դնում ելքային pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

if (DEBUG) {// Եթե ցանկանում ենք տեսնել արժեքներ վրիպազերծման համար …

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

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

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

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

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

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

* * Worksրագիրն աշխատում է այսպես. * Պատկերացրեք խաչմերուկ, որը կարմիր 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-ը տասը քայլով, կանաչը * 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 գույնը [3]) {

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

int stepR = calcStep (prevR, R);

int stepG = calcStep (prevG, G); int քայլ Բ = հաշվարկելՔայլը (prevB, B);

համար (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = calcVal (stepG, grnVal, i); bluVal = calcVal (stepB, bluVal, i);

analogWrite (redPin, redVal); // Գրեք ընթացիկ արժեքները LED կապում

analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal);

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

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

եթե (i == 0 կամ i % loopCount == 0) {// սկիզբ, և յուրաքանչյուր loopCount անգամ Serial.print ("Loop/RGB: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print (" /"); Serial.print (grnVal); Serial.print (" /"); Serial.println (bluVal); } DEBUG += 1; }} // Թարմացրեք ընթացիկ արժեքները հաջորդ հանգույցի համար prevR = redVal; prevG = grnVal; prevB = bluVal; հետաձգում (պահում); // Դադարեցնել կամընտիր «սպասել» միլիվայրկյաններ, նախքան օղակը վերսկսելը}

Քայլ 2: Wառը փաթաթելը

Ես օգտագործել եմ անջրանցիկ շերտեր, քանի որ դրանք դրսում են լինելու: Նրանք իսկապես ինքնուրույն կպչում էին, բայց ես արագորեն հետևեցի մետաղալարերին `համոզվելու, որ դրանք տեղում են: Պարզ և հեշտ կոտրում: Շերտի հոսանքի հզորությունը հնարավորություն տվեց հեշտությամբ սնուցել սնուցման աղբյուրը ներքևից և հոսանք ստանալ աստղից դեպի վերև:

Քայլ 3: Մի մոռացեք աստղը վերևում

Աստղի համար ես օգտագործել եմ մի զույգ 10 Վտ չիպսեր `որոշակի ուշադրություն գրավելու համար: Ես դրանք կպցրեցի պղնձե թերթի վրա որպես ջերմատաքացուցիչ: Ես կարող էի ավելի շատ ժապավեն օգտագործել, քանի որ մի քիչ ավելորդ մնաց:

Քայլ 4: Փորձեք այն

Առաջին փորձը արագությունը չափազանց մեծ էր…

Մի անգամ հանգստացրեցի, այն բավականին լավ տեսք ուներ: