კრიპტიკური კედლის საათი: 27 ნაბიჯი (სურათებით)

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

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

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

იგი აღჭურვილია 96 LED- ით, რომლებიც ანათებენ 52 'ციფრულ' რეგიონს. ორიგინალისგან განსხვავებით, მას აქვს წრიული დიზაინი, რომელიც მოიცავს წამის ბეჭედს, ნაცვლად ჰორიზონტალური ზოლის განლაგებისა. გარე ზოლები მიუთითებს წამს შუა წერტილთან ერთად, მომდევნო ორი ზოლი მიუთითებს წუთებს, ხოლო შიდა შიდა ზოლები მიუთითებს საათებს.

თუ თქვენ გაქვთ ჯართის მასალა და დამატებითი დრო თქვენს ხელებზე, რატომ არ გამოვიყენოთ ეს დრო ისეთი რამის შესაქმნელად, რომელიც ამას აჩვენებს!

არის რამოდენიმე ცვლილება, რომელსაც მე შევიტან ამ პროექტში, თუ ის კვლავ განმეორდება. ჯერ ჩარჩოსა და LED დაფას შავის ნაცვლად თეთრად ვხატავდი. ეს ასახავს მეტ შუქს წინა დიდი ობიექტივიდან. მე ასევე დაველოდები ბოლომდე ჩადეთ LED- ები. მე მჭირდებოდა დაფის ადრე დასრულება, რათა დამეხმარა კოდის წერაში. ყოველივე ამის გარეშე, მოდით ვისწავლოთ მისი წაკითხვა!

ნაბიჯი 1: როგორ წავიკითხოთ საათი

საათი იკითხება შიდა წრეებიდან გარედან. ოთხი ველის შიდა რგოლი აღნიშნავს თითოეულს ხუთ სრულ საათს, მეორე რგოლთან ერთად, ასევე ოთხ ველს, რომელიც აღნიშნავს თითოეულს ერთ სრულ საათს, აჩვენებს საათის მნიშვნელობას 24-საათიან ფორმატში. მესამე რგოლი შედგება თერთმეტი ველისგან, რომლებიც აღნიშნავენ თითოეულ ხუთ სრულ წუთს, მომდევნო რგოლს აქვს კიდევ ოთხი ველი, რომლებიც აღნიშნავს თითო სრულ წუთს. დაბოლოს, 29 ველის გარე რგოლი აღნიშნავს ლუწ წამებს, ცენტრში მოციმციმე შუქი ნიშნავს კენტი (როცა განათებულია) ან ლუწი რიცხვი (როცა არ არის განათებული) წამი.

მაგალითად, ზემოაღნიშნულ სურათზე არის ხუთსაათიანი ციფრებიდან 1, ერთსაათიანი ციფრებიდან 3, ხუთწუთიანი ციფრებიდან 8, ერთწუთიანი ციფრების 4 და ორი მეორე ციფრიდან 23 და შუა მეორე ციფრი განათებულია.

1x5 + 3x1: 8x5 + 4x1: 23x2 + 1x1 = 8:44:47 = 8:44:47 დილით

ზემოთ ნაჩვენები დროა: 3x5 + 0x1: 3x5 + 2x1: 5x2 + 1x1 = 15:17:11 = 3:17:11 PM

ზემოთ ნაჩვენები დროა: 3x5 + 2x1: 3x5 + 3x1: 16x2 + 1x1 = 17:18:33 = 5:18:33 PM

ნაბიჯი 2: ინსტრუმენტები და მასალები

ელექტრონიკის მასალები:

• არდუინო ნანო
• რეალურ დროში საათი
• მისამართებიანი LED- ები
• დენის დანამატი
• დენის კაბელი
• USB კვების დანამატი
• შუქზე დამოკიდებული რეზისტორი და დაბალანსებული რეზისტორი (თუ გინდათ რომ ღამით დაბნელდეს)
• მავთული

ხის მასალები:

• 3/4 შემოსული პლაივუდი
• თხელი პლაივუდი
• ხის ჯართი (მე გამოვიყენე 2x4, მაგრამ მყარი ხე ასევე იმუშავებს)
• საღებავი
• აკრილის 30 x 36 ინჩი. ფურცელი (ნაპოვნია ადგილობრივ სახლის გაუმჯობესების მაღაზიაში)
• ფანჯრის ელფერი (სცადეთ წყარო ადგილობრივად. თუ არცერთი არ არის ხელმისაწვდომი, შეგიძლიათ იპოვოთ საკმაოდ დიდი ფურცელი აქ)
• ფანჯრის ელფერით განაცხადის სითხე (მე გამოვიყენე წყალი შერეული ბავშვის შამპუნთან სპრეის ბოთლში)
• ვინდექსი
• ყასაბი ქაღალდი
• ხრახნები
• სპრეი წებოვანი
• წებო
• Წებოს ჯოხი

ინსტრუმენტები:

• მმართველი
• Xacto დანა
• Ფირზე
• ორმხრივი ლენტი
• Კომპასი
• წრე ჭრის ჯიგ
• Jigsaw
• Bandsaw
• Spindle Sander
• პალმის სანდრი
• დისკი Sander
• როუტერის მაგიდა
• Awl
• საბურღი და საბურღი ბიტი/დრაივერები
• დამჭერები
• გასაყიდი რკინა
• Solder
• მავთულის სტრიპტიზორები

ნაბიჯი 3: შაბლონების შეკრება

დიდი შაბლონისთვის, დაბეჭდეთ იგი Adobe Reader– ის ვებ – გვერდის გამოყენებით. მოაცილეთ მინდვრები თითოეული ქაღალდისა და ფირზე ერთად. ვერტიკალური, ჰორიზონტალური და დიაგონალური ხაზები დაგეხმარებათ შაბლონის გაფორმებაში. ყველა გვერდს აქვს მცირე რიცხვი, რომელიც დაეხმარება მათ ორგანიზებაში, თუ ისინი მწყობრიდან გამოდიან.

ყველა საჭირო შაბლონი და ფაილი ნაპოვნია 26 -ე ნაბიჯში.

ნაბიჯი 4: უხეში მოჭრილი წრეები

პლაივუდის 3/4 დიუმიანი ფურცლის ორი შაბლონის განლაგება, კომპასით დახაზეთ წრეები ოდნავ უფრო დიდი ვიდრე საჭიროა. Jigsaw– ის გამოყენებით, ამოიღეთ უხეში ფორმა.

ნაბიჯი 5: ზომაში გაჭრა

წრიული საჭრელი ჯაჭვის გამოყენებით bandwaw, გაჭრა წრეების საბოლოო ზომა.

ნაბიჯი 6: გამოიყენეთ შაბლონი

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

ნაბიჯი 7: შაბლონის მოჭრა

Jigsaw– ის გამოყენებით, ამოჭერით შაბლონის თითოეული ცალკეული ფანჯარა. თუ თქვენ გაქვთ წვდომა CNC– ზე, ეს ნაბიჯი ბევრად უფრო ადვილი იქნება! თითოეულ ფანჯარაში გავაღე ხვრელი ამ პროცესის დასახმარებლად. როდესაც დაიწყებთ ჭრას, შაბლონი შეიძლება დაიწყოს ამოსვლა. თუ ეს მოხდება, შეგიძლიათ დააფიქსიროთ იგი მცირე ზომის ფირზე.

ნაბიჯი 8: დაფქვა

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

ნაბიჯი 9: საბურღი უჭირავს LED- ებს

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

ნაბიჯი 10: შეაერთეთ დაფები

შეცვალეთ წინა და უკანა დაფები და მონიშნეთ ჩარჩოს ნაწილები LED დაფის უკანა მხარეს. გადაიტანეთ ჩარჩო უკან LED დაფის წინა მხარეს და გაბურღეთ ხვრელები და დააწებეთ ნაჭრები ერთმანეთთან.

იხილეთ სურათის შენიშვნები დამატებითი ინფორმაციისთვის.

ნაბიჯი 11: ჩადეთ LED- ები

დააყენეთ LED- ები LED დაფის უკანა მხარეს. ხვრელები უნდა იყოს საკმარისად დაშორებული ისე, რომ თქვენ არ დაგჭირდეთ მავთულის გაჭრა, გარდა ერთი წრიდან მეორეზე გადასვლისა.

უკანა მხრიდან, LED- ები იწყება ცენტრში და შემდეგ მოძრაობენ საათის ისრის საწინააღმდეგოდ და შემდეგ რგოლამდე.

ნაბიჯი 12: მიამაგრეთ სეგმენტი 1

ამოიღეთ 9 სეგმენტი "სეგმენტი 1" შაბლონიდან, რომელიც ერთვის 3/4 შემოსულ პლაივუდს (ნაპოვნია 26 -ე საფეხურზე). მიამაგრეთ LED დაფაზე წებოთი და დამჭერებით. თუ მოუთმენელი ხართ, ასევე შეგიძლიათ გამოიყენოთ ფრჩხილები, რომ დააჭიროთ მას.

გაშრობისთანავე გაწურეთ დისკი გამრეცხვით.

ნაბიჯი 13: ხატვა

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

ნაბიჯი 14: ნაწილი 2

ხისგან მიმაგრებული "სეგმენტი 2" შაბლონიდან ამოიღეთ 9 სეგმენტი, რომლის სისქეა 2 3/8 ინჩი (ნაპოვნია 26 -ე საფეხურზე). მე გამოვიყენე ჯართი 2x4s მაღაზიის გარშემო. მშრალი მორგება სეგმენტების და უზრუნველყოს იგი კარგად შეესაბამება band clamp. თუ ყველაფერი ამოიწურება, გარედან გადააფარეთ მხატვრების ლენტი, რომ წებო არ დაიჭიროს და გააჩერეთ მინიმუმ ერთი საათით, სანამ შემდეგ საფეხურზე გადახვალთ.

ნაბიჯი 15: ნაწილი 3

ამოიღეთ 9 სეგმენტი "სეგმენტი 3" შაბლონიდან, მიმაგრებული 3/8 ინჩიდან სქელი ჯართი (ნაპოვნია 26 -ე საფეხურზე). მიამაგრეთ ისინი ისე, რომ სეგმენტი 2 -დან თითოეული სეგმენტის შუაშია. ეს გააძლიერებს ბეჭედს.

ნაბიჯი 16: გლუვი ბეჭედი და საღებავი

დიდი ბეჭდის ამოჭრილი ნაჭერიდან შევიმუშავე საბაჟო მოსახვეწი ბლოკი. გახეხეთ რგოლის შიგნით და გარეთ და შეავსეთ ნებისმიერი ბზარი, რომელიც შეიძლება გაჩნდეს წებოს პროცესის დროს.

მას შემდეგ რაც გლუვი გახდება, წაისვით შავი ფერის რამდენიმე ფენა და გამჭვირვალე ქურთუკი.

ნაბიჯი 17: აკრილის მოჭრა

აკრილის მოჭრა კვადრატზე 30 x 30 სმ და მონიშნეთ ცენტრი. მიამაგრეთ აკრილი ორმაგი ცალმხრივი ლენტით. გამრეცხი როუტერის ბიტის გამოყენებით ამოიღეთ ჭარბი აკრილი

ნაბიჯი 18: გამოიყენეთ ფანჯრის ელფერი

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

ნაბიჯი 19: მიამაგრეთ დეფუზერი

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

ნაბიჯი 20: გამოიყენეთ იზოლაცია

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

ნაბიჯი 21: შეკრება

ამოიღეთ სხვა დამცავი ფენა აკრილისგან. განათავსეთ აკრილის ბეჭედი შიგნით ფანჯრის ელფერით ზემოთ. საათის დარჩენილი ნაწილი გადაიტანეთ რგოლში. გამოიყენეთ დამჭერი სინათლის წნევის დასაყენებლად, სანამ ხვრელი იჭრება რგოლში და LED დაფაზე. ეს უნდა იყოს დაახლოებით 1 1/8 ინჩი უკნიდან. ფრთხილად იყავით, რომ არ გაბურღოთ LED- ში. ხრახნიანი ხრახნიანი ხრახნი ხვრელში. გაიმეორეთ სულ რვა ხრახნი საათის პერიმეტრის გარშემო.

ნაბიჯი 22: მიამაგრეთ წამყვანი წერტილები

წებოს წამყვანი მიუთითებს საათის უკანა მხარეს უკანა საფარის დასაკავშირებლად. ეს არის 3/4 ინჩი სქელი და დაახლოებით 2 ინჩი გრძელი.

ნაბიჯი 23: საბურღი სიმძლავრე და LDR სენსორული ხვრელები

გაბურღეთ დენის ხვრელი საათის ბოლოში დენის შტეფსელისთვის და ზედა ხვრელი სინათლეზე დამოკიდებული რეზისტორის (LDR) სენსორისთვის.

ნაბიჯი 24: დააინსტალირეთ ელექტრონიკის დამჭერი

დააინსტალირეთ 3D ბეჭდვის დამჭერი RTC და Arduino Nano– სთვის. შეაერთეთ ყველა ელექტრონიკა, როგორც ეს მოცემულია სქემატურ რეჟიმში.

ნაბიჯი 25: უკანა საფარი

გაჭერით უკანა საფარი თხელი პლაივუდისგან, რომელიც უფრო მცირეა ვიდრე საათის გარეთ. საბურღი ხვრელები წამყვან წერტილებში. იპოვნეთ ზურგის ცენტრი და გაზომეთ 8 ინჩი ორივე მიმართულებით საკვანძო ხვრელების მოსაჭრელად (სტანდარტული 16 აშშ – ში საყრდენების ცენტრებში). მე გავაღე მთავარი ხვრელი, უფრო დიდი ვიდრე ხრახნების თავი, რომელსაც მე გამოვიყენებ და ერთი მიმართულებით უფრო დიდი ჩავაგდე. შეღებეთ შავი და მიამაგრეთ საფარი ადგილზე.

ნაბიჯი 26: კოდი და ფაილები

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

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

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

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

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

#მოიცავს "RTClib.h"

#ჩართეთ #განსაზღვრეთ NUM_LEDS 96 #განსაზღვრეთ DATA_PIN 3 #განსაზღვრეთ LDR A0 RTC_DS1307 rtc; ლოგიკური დრო შეცვლა = ყალბი; ლოგიკური printTime = ყალბი; // დააყენეთ true, თუ გინდათ რომ გამომავალი ნახოთ კონსოლში. სასარგებლოა გამართვისთვის. ლოგიკური redDown = ჭეშმარიტი; ლოგიკური greenDown = ყალბი; ლოგიკური blueDown = ყალბი; ლოგიკური ციკლი = ყალბი; // დააყენეთ true, თუ გსურთ საათის ფერები ციკლს ლოგიკური ხაზგასმით = ჭეშმარიტი; // დააყენეთ true მონიშნეთ "ბოლო ციფრი". // დროის თითოეული ჯგუფის დაწყებისა და დასასრულის ადგილები const SECOND_1_LOCATION = 0; const int HOUR_2_START_LOCATION = 1; const int HOUR_2_END_LOCATION = 8; const int HOUR_1_START_LOCATION = 9; const int HOUR_1_END_LOCATION = 20; const int MINUTE_2_START_LOCATION = 21; const int MINUTE_2_END_LOCATION = 42; const int MINUTE_1_START_LOCATION = 43; const int MINUTE_1_END_LOCATION = 66; const int SECOND_2_START_LOCATION = 67; const int SECOND_2_END_LOCATION = 95; const int LEDS_PER_HOUR_1 = 3; const int LEDS_PER_HOUR_2 = 2; const int LEDS_PER_MINUTE_1 = 6; const int LEDS_PER_MINUTE_2 = 2; // მულტიპლიკატორები გამოიყენება დროის გასანაწილებლად კონსტანტ MULTIPLIER_FIVE = 5; const int MULTIPLIER_TWO = 2; const int START_UP_DELAY = 1; // შეცვალეთ ეს დასაჩქარებლად ან შენელებისთვის ჩატვირთვის ანიმაციის const int CYCLE_SPEED = 1; // ფერის შეცვლის ციკლის აქ შეცვლა (უნდა იყოს 1 -ზე ზემოთ) // ცვლადების გამოცხადება int lastSecond = 0; int currentHour = 0; int currentMinute = 0; int currentSecond = 0; int საათი 1 = 0; int საათი 2 = 0; int წუთი 1 = 0; int წუთი 2 = 0; int მეორე 1 = 0; int მეორე 2 = 0; int cycleCount = 1; float fadeValue = 255; float fadeCheck = 255; uint8_t ნათელი = 255; int ნომერიOnimimations = 5; int შემთხვევითობა = 0; // ფერების დაყენება uint8_t წითელი = 0; uint8_t მწვანე = 0; uint8_t ლურჯი = 255; uint8_t მონიშნეთ_წითელი = 60; uint8_t მონიშნეთ_მწვანე = 60; uint8_t მონიშნეთ_ ლურჯი = 255; // LED– ების მასივის განსაზღვრა CRGB leds [NUM_LEDS]; void setup () {Serial.begin (19200); FastLED.addLeds (leds, NUM_LEDS); LEDS.set სიკაშკაშე (ნათელი); FastLED.clear (); rtc.begin (); // კომენტარის ხაზის ქვემოთ დროის დასადგენად. // rtc.adjust (DateTime (2020, 2, 19, 23, 59, 50)); // rtc.adjust (DateTime (F (_ DATE_), F (_ TIME_))); // დამწყები ანიმაციის ანიმაცია (შემთხვევითობა); } void loop () {// მიიღეთ დრო DateTime now = rtc.now (); currentHour = ახლა. საათი (); currentMinute = ახლა. წუთი (); currentSecond = ახლა. მეორე (); timeChange = false; // გამოიყენეთ ეს ხელით დროის დასადგენად RTC– ს გარეშე. სასარგებლოა გამართვისთვის // currentHour = 5; // currentMinute = 30; // currentSecond = 30; // ყველა ბიტის ნულამდე გადაყვანა (int i = SECOND_1_LOCATION; i <= SECOND_2_END_LOCATION; i ++) {leds = CRGB:: შავი; } // საათის დაყენება // საათის დაყენება 1 საათი 1 = (მიმდინარე საათი % MULTIPLIER_FIVE) * LEDS_PER_HOUR_1; // ეს დაითვლის დროის ერთეულის სულ LED- ებს (int i = HOUR_1_START_LOCATION; i 0) // && hour1 <12) {for (int i = (HOUR_1_START_LOCATION + hour1 - 1); i> = (HOUR_1_START_LOCATION + საათი 1-LEDS_PER_HOUR_1); i--) {leds = CRGB (მონიშნეთ_წითელი, მონიშნეთ_მწვანე, მონიშნეთ_ლურჯი); }} // საათის დაყენება 2 საათი 2 = (მიმდინარე საათი / MULTIPLIER_FIVE) * LEDS_PER_HOUR_2; // ეს ითვლის დროის ერთეულის სულ LED- ებს (int i = HOUR_2_START_LOCATION; i 0) // && hour2 <8) {for (int i = (HOUR_2_START_LOCATION + hour2 - 1); i> = (HOUR_2_START_LOCATION + საათი 2-LEDS_PER_HOUR_2); i--) {leds = CRGB (მონიშნეთ_წითელი, მონიშნეთ_მწვანე, მონიშნეთ_ლურჯი); }} // წუთის დაყენება // წუთის დაყენება 1 წუთი 1 = (მიმდინარე წუთში % MULTIPLIER_FIVE) * LEDS_PER_MINUTE_1; // ეს ითვლის დროის ერთეულის მთლიანი LED- ების განათებას (int i = MINUTE_1_START_LOCATION; i 0) // && წუთი 1 <24) {for (int i = (MINUTE_1_START_LOCATION + წუთი 1 - 1); i> = (MINUTE_1_START_LOCATION + წუთი 1-LEDS_PER_MINUTE_1); i--) {leds = CRGB (მონიშნეთ_წითელი, მონიშნეთ_მწვანე, მონიშნეთ_ლურჯი); }} // დააყენეთ წუთი 2 წუთი 2 = (მიმდინარე წუთი / MULTIPLIER_FIVE) * LEDS_PER_MINUTE_2; // ეს ითვლის დროის ერთეულის სულ LED- ებს (int i = MINUTE_2_START_LOCATION; i 0) // && minute2 <22) {for (int i = (MINUTE_2_START_LOCATION + წუთი2 - 1); i> = (MINUTE_2_START_LOCATION + წუთი 2-LEDS_PER_MINUTE_2); i--) {leds = CRGB (მონიშნეთ_წითელი, მონიშნეთ_მწვანე, მონიშნეთ_ლურჯი); }} // უცნობია მეორე თუ (currentSecond! = LastSecond) {timeChange = true; } // დააყენე მეორე 1 წამი 1 = მიმდინარე მეორე მეორე MULTIPLIER_TWO; if (second1 == 1) {leds [SECOND_1_LOCATION] = CRGB (წითელი, მწვანე, ლურჯი); } // დააყენე მეორე 2 მეორე 2 = მიმდინარე მეორე / MULTIPLIER_TWO; for (int i = SECOND_2_START_LOCATION; i 0) // && second2 <29) {for (int i = (SECOND_2_START_LOCATION + second2 - 1); i> = (SECOND_2_START_LOCATION + second2 - 1); i--) {leds = CRGB (მონიშნეთ_წითელი, მონიშნეთ_მწვანე, მონიშნეთ_ლურჯი); }} lastSecond = currentSecond; // დაითვალეთ პროგრამის ციკლები და გამოიძახეთ setColor ფუნქცია, რომ შეცვალოთ LED- ების ფერი ოდესმე CYCLE_SPEED ციკლები. თუ (cycleCount ნათელი) // {// fadeValue = ნათელი; //} // else if (fadeValue <150) // {// fadeValue = 150; //} // LEDS.setBrightness (fadeValue); FastLED.show (); // ამობეჭდოთ მიმდინარე დრო კონსოლში if (timeChange == true && printTime == true) {printToConsole (); }} // ანიმაციის ფუნქცია აქ დაამატეთ მეტი ანიმაცია, როგორც გსურთ void animate (int select) {if (select == 0) {for (int i = SECOND_1_LOCATION; i <= SECOND_2_END_LOCATION; i ++) {leds = CRGB (წითელი, მწვანე, ლურჯი); FastLED.show (); დაგვიანება (START_UP_DELAY); } for (int i = SECOND_2_END_LOCATION; i> = SECOND_1_LOCATION; i--) {leds = CRGB:: შავი; FastLED.show (); დაგვიანება (START_UP_DELAY); }} else if (აირჩიეთ == 1) {for (int i = 0; i <250; i ++) {int light = შემთხვევითი (95); leds [შუქი] = CRGB (წითელი, მწვანე, ლურჯი); FastLED.show (); }} else if (აირჩიეთ == 2) {leds [0] = CRGB (წითელი, მწვანე, ლურჯი); (int i = 0; i <= SECOND_2_END_LOCATION - SECOND_2_START_LOCATION; i ++) {leds [SECOND_2_START_LOCATION+i] = CRGB (წითელი, მწვანე, ლურჯი); if (i <= (MINUTE_1_END_LOCATION - MINUTE_1_START_LOCATION)) {leds [MINUTE_1_START_LOCATION + i] = CRGB (წითელი, მწვანე, ლურჯი); } if (i <= (MINUTE_2_END_LOCATION - MINUTE_2_START_LOCATION)) {leds [MINUTE_2_START_LOCATION + i] = CRGB (წითელი, მწვანე, ლურჯი); } if (i <= (HOUR_1_END_LOCATION - HOUR_1_START_LOCATION)) {leds [HOUR_1_START_LOCATION + i] = CRGB (წითელი, მწვანე, ლურჯი); } if (i <= (HOUR_2_END_LOCATION - HOUR_2_START_LOCATION)) {leds [HOUR_2_START_LOCATION + i] = CRGB (წითელი, მწვანე, ლურჯი); } დაყოვნება (34); FastLED.show (); }} else if (აირჩიეთ == 3) {leds [0] = CRGB (წითელი, მწვანე, ლურჯი); (int i = 0; i <= SECOND_2_END_LOCATION - SECOND_2_START_LOCATION; i ++) {leds [SECOND_2_END_LOCATION - i] = CRGB (წითელი, მწვანე, ლურჯი); if (i <= (MINUTE_1_END_LOCATION - MINUTE_1_START_LOCATION)) {leds [MINUTE_1_END_LOCATION - i] = CRGB (წითელი, მწვანე, ლურჯი); } if (i <= (MINUTE_2_END_LOCATION - MINUTE_2_START_LOCATION)) {leds [MINUTE_2_END_LOCATION - i] = CRGB (წითელი, მწვანე, ლურჯი); } if (i <= (HOUR_1_END_LOCATION - HOUR_1_START_LOCATION)) {leds [HOUR_1_END_LOCATION - i] = CRGB (წითელი, მწვანე, ლურჯი); } if (i <= (HOUR_2_END_LOCATION - HOUR_2_START_LOCATION)) {leds [HOUR_2_END_LOCATION - i] = CRGB (წითელი, მწვანე,ლურჯი); } დაყოვნება (34); FastLED.show (); }} else if (აირჩიეთ == 4) {for (int i = SECOND_2_END_LOCATION; i> = SECOND_1_LOCATION; i--) {leds = CRGB:: შავი; } FastLED.show (); დაგვიანება (200); (int i = SECOND_1_LOCATION; i <= SECOND_2_END_LOCATION; i ++) {leds = CRGB (წითელი, მწვანე, ლურჯი); } FastLED.show (); დაგვიანება (200); (int i = SECOND_2_END_LOCATION; i> = SECOND_1_LOCATION; i--) {leds = CRGB:: შავი; } FastLED.show (); დაგვიანება (200); (int i = SECOND_1_LOCATION; i <= SECOND_2_END_LOCATION; i ++) {leds = CRGB (წითელი, მწვანე, ლურჯი); } FastLED.show (); დაგვიანება (200); (int i = SECOND_2_END_LOCATION; i> = SECOND_1_LOCATION; i--) {leds = CRGB:: შავი; } FastLED.show (); დაგვიანება (200); }} // ფერის ველოსიპედის ფუნქცია void setColor (boolean cycleColors) {if (cycleColors == true) {if (redDown == true && greenDown == false) {red ++; მწვანე--; თუ (მწვანე <= 0) {წითელი = 255; redDown = ყალბი; greenDown = ჭეშმარიტი; }} else if (greenDown == true && blueDown == false) {green ++; ლურჯი-; თუ (ლურჯი <= 0) {მწვანე = 255; greenDown = ყალბი; blueDown = ჭეშმარიტი; }} else if (blueDown == true && redDown == false) {blue ++; წითელი-; თუ (წითელი <= 0) {ლურჯი = 255; blueDown = ყალბი; redDown = ჭეშმარიტი; }}} სხვა {წითელი = 0; მწვანე = 0; ლურჯი = 255; }} // ბეჭდვა სერიულ მონიტორზე ფუნქცია void printToConsole () {Serial.print ("მიმდინარე დრო:"); Serial.print (მიმდინარე საათი); Serial.print (":"); Serial.print (currentMinute); Serial.print (":"); Serial.println (მიმდინარე მეორე); Serial.println (""); (int i = HOUR_2_START_LOCATION; i <= HOUR_2_END_LOCATION; i ++) {Serial.print (leds ); if (i % 2 == 0) {Serial.print (""); }} Serial.println (""); (int i = HOUR_1_START_LOCATION; i <= HOUR_1_END_LOCATION; i ++) {Serial.print (leds ); if (((i - HOUR_1_START_LOCATION + 1) % 3) == 0) {Serial.print (""); }} Serial.println (""); (int i = MINUTE_2_START_LOCATION; i <= MINUTE_2_END_LOCATION; i ++) {Serial.print (leds ); if (((i - MINUTE_2_START_LOCATION) + 1) % 2 == 0) {Serial.print (""); }} Serial.println (""); (int i = MINUTE_1_START_LOCATION; i <= MINUTE_1_END_LOCATION; i ++) {Serial.print (leds ); if (((i - MINUTE_1_START_LOCATION) + 1) % 6 == 0) {Serial.print (""); }} Serial.println (""); (int i = SECOND_2_START_LOCATION; i <= SECOND_2_END_LOCATION; i ++) {Serial.print (leds ); Serial.print (""); } Serial.println (""); Serial.println (leds [SECOND_1_LOCATION]); Serial.println (); for (int i = 0; i <NUM_LEDS; i ++) {Serial.print (leds ); } Serial.println (); Serial.println (); }

ნაბიჯი 27: ისიამოვნეთ

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