Arduino LED განწყობის კუბის გაუმჯობესება (მარტივი) (ვიდეო შედის): 4 ნაბიჯი

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

მას შემდეგ, რაც ვნახე LED– ის მცირე განწყობის კუბის პროექტი, რომელიც შეიქმნა’Earl– ის მიერ, მე გადავწყვიტე გამეკეთებინა LED Mood Cube– ის გაუმჯობესებული ვერსია. ჩემი ვერსია უფრო რთული იქნება ვიდრე ორიგინალი, რადგან ის იქნება ოდნავ უფრო დიდი ვიდრე ორიგინალი, აქვს კიდევ ორი ფერი ორიგინალ კუბიკთან შედარებით (დაემატა ყვითელი და თეთრი), აქვს უსასრულო რაოდენობის ბრუნვა და ა.შ. უნდა იყოს კარგი პროექტი პრაქტიკაში LED განათების შემდგომი გამოყენებისათვის მათთვის, ვინც ესმის კონცეფცია LED ნათურების მავთულხლართებთან დაკავშირების შესახებ.

ნაბიჯი 1: მასალები

აქ არის რამოდენიმე მასალა, რაც დაგჭირდებათ განწყობის კუბიკის გასაკეთებლად:

• პურის დაფა
• არდუინო - (მე აქ ლეონარდო მყავს)
• Arduino კვების წყარო / USB კაბელი
• პურის დაფა
• 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) გაცვეთილების შესაქმნელად, თქვენ უნდა გააკეთოთ ორი რამ: 1. აღწერეთ ფერები, რომელთა ჩვენებაც გსურთ.

აღწერს ფერს:

ფერი არის მხოლოდ სამი პროცენტის მასივი, 0-100, რომელიც აკონტროლებს წითელ, მწვანე და ლურჯ LED- ებს

წითელი არის წითელი LED სრულად, ლურჯი და მწვანე გამორთული

int წითელი = {100, 0, 0} მუქი თეთრი არის სამივე LED- ები 30% int dimWhite = {30, 30, 30} და ა.

ზოგიერთი ჩვეულებრივი ფერი მოცემულია ქვემოთ, ან შექმენით საკუთარი

შეკვეთის გაგზავნა:

პროგრამის ძირითად ნაწილში თქვენ უნდა მიუთითოთ ის თანმიმდევრობა, რომელშიც გსურთ რომ გამოჩნდეს ფერები, მაგ. crossFade (წითელი); crossFade (მწვანე); crossFade (ლურჯი);

ეს ფერები გამოჩნდება ამ თანმიმდევრობით, ქრება

ერთი ფერი და მეორეში

გარდა ამისა, არის 5 დამატებითი პარამეტრი, რომლის მორგებაც შეგიძლიათ:

1. საწყისი ფერი დაყენებულია შავზე (ასე რომ პირველი ფერი ქრება), მაგრამ თქვენ შეგიძლიათ დააყენოთ საწყისი ფერი ნებისმიერი სხვა ფერით. შიდა მარყუჟი მუშაობს 1020 ინტერაციაზე; "ლოდინის" ცვლადი ადგენს ერთი ჯვრისწერის სავარაუდო ხანგრძლივობას. თეორიულად, 10 ms- ის "ლოდინმა" უნდა გააკეთოს crossFade ~ 10 წამი. პრაქტიკაში, სხვა ფუნქციები, რომელსაც კოდი ასრულებს, ნელნელა მცირდება seconds 11 წამამდე ჩემს დაფაზე. YMMV. 3. თუ "გამეორება" დაყენებულია 0 -ზე, პროგრამა მარყუჟდება უსასრულოდ. თუ ის დაყენებულია რიცხვზე, ის მარყუჟდება ამდენჯერ, შემდეგ შეწყვეტს თანმიმდევრობით ბოლო ფერს. (დააყენეთ "დაბრუნება" 1 -ზე და გახადეთ ბოლო ფერი შავი, თუ გინდათ რომ ის ბოლომდე ქრებოდეს.) 4. არის სურვილისამებრ "გამართვის" ცვლადი, რომელიც გადის პროგრამას მილიწამებში "გამართვის" დროს სრული, მაგრამ სანამ მომდევნო ფერი დაიწყება. 5. დააყენეთ DEBUG დროშა 1 -ზე თუ გინდათ რომ გამართვის გამომუშავება გაიგზავნოს სერიულ მონიტორზე.

პროგრამის შიდა ნაწილი არ არის რთული, მაგრამ ასეა

ცოტა აურზაურია - შიდა სამუშაოები განმარტებულია ძირითადი მარყუჟის ქვემოთ.

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 //

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

შავი შავი [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 purple [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int ნარინჯისფერი [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 ვარდისფერი [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; // სურვილისამებრ გამართვა, როდესაც ფერი დასრულებულია, მომდევნო crossFade– მდე // 改 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) {// თუ გვინდა ვნახოთ ღირებულებების გამართვისთვის…

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

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

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

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

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

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

პროგრამა მუშაობს ასე:

წარმოიდგინეთ ჯვარედინი საფარი, რომელიც წითელ LED- ს გადააქვს 0-10-დან, მწვანე 0-5-დან და ლურჯს 10-დან 7-მდე, ათი ნაბიჯით. ჩვენ გვსურს 10 საფეხურის დათვლა და ფერის მნიშვნელობების გაზრდა ან შემცირება თანაბარი ნაბიჯებით. წარმოიდგინეთ + მიუთითებს მნიშვნელობის ამაღლებაზე 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 ფერი ) {// 改

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

int stepG = გამოთვლა ნაბიჯი (prevG, G); int ნაბიჯი B = გამოთვლა ნაბიჯი (წინა B, B); int stepY = გამოთვლა ნაბიჯი (წინა, Y); // step int stepW = calcStep (prevW, W); //

for (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = გამოთვალოთ Val (stepG, grnVal, i); bluVal = გამოთვლა Val (ნაბიჯი B, bluVal, i); ylwVal = გამოთვლა Val (ნაბიჯი Y, ylwVal, i); // 改 whiVal = გამოთვლა Val (ნაბიჯი 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) {// თუ გვსურს სერიული გამომავალი, დაბეჭდეთ ის

if (i == 0 ან i % loopCount == 0) {// დასაწყისი, და ყველა loopCount ჯერ Serial.print ("მარყუჟი/RGBYW: #"); სერიული. ბეჭდვა (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 შუქები ბრწყინავდეს ქაღალდზე.