LED სპირალური ხე: 4 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

მე მიყვარს ყველა სახის LED ზოლები. მათთან ერთად ცისარტყელას კარგი შუქი გავაკეთე. მაშინაც კი, არასასურველი მისამართები სასარგებლოა. მე გავაკეთე გარე ბაზის ქოლგის ნათელი შუქი, ვამაგრებ მათ unbrella ნეკნებზე, ასე რომ, როდესაც ჩემი სპირალური ხე ამოიფრქვა, გადავწყვიტე შემოვხვიო მასზე led სიგრძის ზოლი.

ნაბიჯი 1: კონტროლერი

მე გადავწყვიტე გამომეყენებინა RGB მისამართები. ეს ნიშნავს, რომ მე შემიძლია დაპროგრამებული ეფექტი, მაგრამ ყველა led იცვლის ფერს ერთდროულად. ეს ასევე ნიშნავს, რომ საჭირო იქნება კონტროლერი. მე შემეძლო გამომეყენებინა arduino uno და გავაკეთე პირველადი ტესტები RGB ფარის გამოყენებით, მაგრამ დამთავრდა საბაჟო ერთი დაფის გამოყენებით შიშველი Atmega328 ჩიპით. უბრალოდ უნდა შეცვალო სამიზნე პროგრამისტი და პირდაპირ დაპროგრამო ჩიპი.

მე ბევრი ასეთი დაფა მქონდა დარჩენილი სხვა ნათურების პროექტებიდან. მოგერიდებათ გამოიყენოთ იაფი, წინასწარ დაპროგრამებული კონტროლერი, როგორც ამის ნაცვლად ჩემს ქოლგაზე.

მე დავასრულე ნელი ჯვარედინი დემო, როგორც ხის საფუძველი.

/** კოდი 3 LED- ის გადაკვეთაზე, წითელი, მწვანე და ლურჯი (RGB) * გაფუჭების შესაქმნელად თქვენ უნდა გააკეთოთ ორი რამ: * 1. აღწერეთ ფერები, რომელთა ჩვენება გსურთ * 2. ჩამოთვალეთ თქვენთვის სასურველი თანმიმდევრობა ისინი ქრებოდა * * აღწერენ ფერს: * ფერი არის მხოლოდ სამი პროცენტის მასივი, 0-100, * აკონტროლებს წითელ, მწვანე და ლურჯ LED- ებს * * წითელი არის წითელი LED მთლიანად, ლურჯი და მწვანე გამორთული * int წითელი = {100, 0, 0} * მუქი თეთრი არის სამივე LED- ები 30% * int dimWhite = {30, 30, 30} * და სხვ. * * ზოგიერთი ჩვეულებრივი ფერი მოცემულია ქვემოთ, ან შექმენით თქვენი * * LISTING შეკვეთა: * პროგრამის ძირითად ნაწილში თქვენ უნდა მიუთითოთ ბრძანება * რომელშიც გსურთ რომ გამოჩნდეს ფერები, მაგ. * crossFade (წითელი); * crossFade (მწვანე); * crossFade (ლურჯი); * * ეს ფერები გამოჩნდება იმ თანმიმდევრობით, ქრებოდა * ერთი ფერიდან და გადადის შემდეგში * * გარდა ამისა, არის 5 დამატებითი პარამეტრი, რომელთა მორგებაც შეგიძლიათ: * 1. საწყისი ფერი დაყენებულია შავზე (ასე რომ პირველი ფერი ქრება in), მაგრამ * თქვენ შეგიძლიათ დააყენოთ საწყისი ფერი ნებისმიერი სხვა ფერი * 2. შიდა მარყუჟი მუშაობს 1020 ინტერაციაზე; "ლოდინის" ცვლადი * ადგენს ერთი ჯვრისწერის სავარაუდო ხანგრძლივობას. თეორიულად, * 10 ms- ის 'ლოდინი' უნდა იყოს crossFade ~ 10 წამის განმავლობაში. * პრაქტიკაში, სხვა ფუნქციები, რომლებიც კოდი ასრულებს ნელა ამ * ქვემოთ seconds 11 წამამდე ჩემს დაფაზე. YMMV. * 3. თუ "გამეორება" დაყენებულია 0 -ზე, პროგრამა მარყუჟდება უსასრულოდ. * თუ ის დაყენებულია რიცხვზე, ის მარყუჟდება ამდენჯერ, * შემდეგ შეწყვეტს თანმიმდევრობით ბოლო ფერს. (დააყენეთ "დაბრუნება" 1 -ზე * და გახადეთ ბოლო ფერი შავი, თუ გსურთ რომ ის ბოლომდე ქრებოდეს.) * 4. არის სურვილისამებრ "გამართვის" ცვლადი, რომელიც გადის * პროგრამას "გამართვის" მილიწამებში, როდესაც ფერი დასრულებულია, * მაგრამ შემდეგი ფერის დაწყებამდე. * 5. დააყენეთ DEBUG დროშა 1 -ზე, თუ გსურთ გამოსწორების გამომავალი * გაიგზავნოს სერიულ მონიტორზე. * * პროგრამის შიდა ნაწილები არ არის რთული, მაგრამ ისინი * ცოტა აურზაურია - შიდა სამუშაოები განმარტებულია * მთავარი მარყუჟის ქვემოთ. * * 2007 წლის აპრილი, კლეი შირკი *

/ გამოყვანის

int grnPin = 9; // მწვანე LED, ციფრულ პინთან დაკავშირებული 10 int redPin = 10; // წითელი LED, ციფრულ პინთან დაკავშირებული 9 int bluPin = 11; // ლურჯი LED, ციფრულ პინთან დაკავშირებული 11

// ფერადი მასივები

შავი შავი [3] = {0, 0, 0}; int თეთრი [3] = {100, 100, 100}; int წითელი [3] = {100, 0, 0}; მწვანე მწვანე [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) {// თუ გვინდა ვნახოთ ღირებულებების გამართვისთვის…

სერიული.დაწყება (9600); //… სერიული გამოსვლის დაყენება}}

// მთავარი პროგრამა: ჩამოთვალეთ ჯვარედინების რიგი

void loop () {crossFade (წითელი); crossFade (მწვანე); crossFade (ლურჯი); crossFade (ყვითელი);

if (ვიმეორებ) {// ჩვენ მარყუჟს ვატარებთ სასრულჯერ რამდენჯერმე?

j += 1; თუ (j> = განმეორება) {// ჩვენ ჯერ კიდევ იქ ვართ? გასასვლელი (კ); // თუ ასეა, გაჩერდი. }}}

/* ქვემოთ მოცემული ხაზი არის მათემატიკა - თქვენ არ უნდა შეცვალოთ ეს საფუძვლებისთვის

* * პროგრამა მუშაობს ასე: * წარმოიდგინეთ crossfade, რომელიც წითელ 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 step = 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; } დაბრუნების ვალ; }

/* 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 = გამოთვლა ნაბიჯი (prevR, R);

int stepG = გამოთვლა ნაბიჯი (prevG, G); int ნაბიჯი B = გამოთვლა ნაბიჯი (წინა B, B);

for (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = გამოთვალოთ Val (stepG, grnVal, i); bluVal = გამოთვლა Val (ნაბიჯი B, bluVal, i);

analogWrite (redPin, redVal); // ჩაწერეთ მიმდინარე მნიშვნელობები LED ქინძისთავებზე

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

დაგვიანება (ლოდინი); // პაუზა "დაელოდეთ" მილიწამში სანამ დაიწყებთ მარყუჟს

if (DEBUG) {// თუ გვსურს სერიული გამომავალი, დაბეჭდეთ ის

if (i == 0 ან i % loopCount == 0) {// დასაწყისი, და ყველა loopCount ჯერ Serial.print ("Loop/RGB: #"); სერიული. ბეჭდვა (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: ხის შეფუთვა

მე გამოვიყენე წყალგაუმტარი ზოლები, რადგან ეს იქნება გარეთ. ისინი გამყარდნენ საკუთარ თავზე, მაგრამ მე სწრაფად გავყევი მავთულხლართებს, რათა დავრწმუნებულიყავი, რომ ისინი დარჩნენ. მარტივი და მარტივი გატეხვა. ზოლის ენერგიის გამტარუნარიანობამ გაადვილა ელექტროენერგიის მიწოდება ძირში და ენერგიის მოპოვება ვარსკვლავზე ზემოდან.

ნაბიჯი 3: არ დაივიწყო ვარსკვლავი თავზე

ვარსკვლავისთვის მე გამოვიყენე წყვილი 10W ჩიპი, რომ მიმექცია ყურადღება. მე გავაფორმე ისინი სპილენძის ფურცელს, როგორც გამაცხელებელი. მე შემეძლო მეტი ზოლის გამოყენება, რადგან ცოტაოდენი იყო.

ნაბიჯი 4: სცადეთ

პირველი ცდა სიჩქარე იყო ძალიან სწრაფი….

ერთხელ რომ დავამშვიდე საკმაოდ კარგად გამოიყურებოდა.