Სარჩევი:

მოციმციმე სანთლის ხიდი: 6 ნაბიჯი (სურათებით)
მოციმციმე სანთლის ხიდი: 6 ნაბიჯი (სურათებით)

ვიდეო: მოციმციმე სანთლის ხიდი: 6 ნაბიჯი (სურათებით)

ვიდეო: მოციმციმე სანთლის ხიდი: 6 ნაბიჯი (სურათებით)
ვიდეო: 4 კგ დაკლება 7 დღეში ყოველდღიური ვარჯიში სახლში/Lose 4 Kg In 7 Days Daily Home Workout 2024, ნოემბერი
Anonim
Image
Image

ეს ინსტრუქცია გვიჩვენებს, თუ როგორ გადავაქციოთ უბრალო სანთლის ხიდი სტატიკური შუქით ლამაზ მბზინავ განწყობის შუქად, მბჟუტავი შუქების უსასრულო ცვალებადობით, მოციმციმე, ტალღის ნიმუშებით და სხვა. საშობაო გაყიდვების შემდგომ ვიყიდე სანთლის ხიდი 8 ევროდ. მას აქვს 7 LED ნათურა და 33 ვ 3 ვტ კედლის ადაპტერი. იგი ბრწყინავს ნათელ და თბილ თეთრ ფერს და იდეალური იქნება ამ პროექტისთვის, სადაც მე დავდებ არდუინოს, რომ სანთლები აციმციმდეს. ყველაზე პოპულარული Arduino არის Arduino Uno. ამ პროექტში მე ვიყენებ Arduino Mega 2560- ს.

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

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

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

  • 4 განსხვავებული მბჟუტავი შუქი, რომელიც ასახავს ნამდვილ სანთლებს
  • 2 განსხვავებული მოციმციმე (სხვაგვარად სტატიკური ნათურების შემთხვევითი მოციმციმე)
  • 2 განსხვავებული ტალღის ნიმუში
  • მარტივი სტატიკური შუქი

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

მარაგები

  • 1 LED სანთლის ხიდი 7 ნათურებით. დარწმუნდით, რომ ეს არის დაბალი ძაბვის DC მოდელი, ბატარეებით ან კედელზე დამონტაჟებული დენის წყაროსთან, რომელიც სასიკვდილო 110 - 240 V AC- ს გარდაქმნის ზოგიერთ 6 - 30 V DC- მდე. ასე რომ, სრულიად უსაფრთხოა სანთლის ხიდის გატეხვა.
  • 1 Arduino Mega (ნებისმიერი სხვა მიკროკონტროლერი გააკეთებს, უბრალოდ დარწმუნდით, რომ შეგიძლიათ მისი დაპროგრამება)
  • 1 დაფის პროტოტიპი
  • ჯუმბერის მავთულები და სხვა მავთულები
  • soldering ინსტრუმენტი
  • მულტიმეტრი
  • 7 რეზისტორი, 120 Ω
  • 1 ღილაკი (მე ვაჩვენებ, თუ როგორ შეგიძლიათ გამოიყენოთ ჩაშენებული ღილაკი არდუინოზე)
  • Darlington ტრანზისტორი IC 7 ტრანზისტორი, ULN2803AP გააკეთებს (თუ თქვენ იყენებთ Arduino Uno ან Meaga, თქვენ ნამდვილად არ გჭირდებათ ეს)
  • 5 ვ ელექტროენერგიის ბანკი განკუთვნილია მობილური ტელეფონებისთვის

ნაბიჯი 1: შეამოწმეთ რა გაქვთ

შეამოწმეთ რა გაქვთ
შეამოწმეთ რა გაქვთ
შეამოწმეთ რა გაქვთ
შეამოწმეთ რა გაქვთ

გაარკვიეთ რა ძაბვაზე მუშაობს თითოეული LED და რამდენი დენი გადის.

  1. გახსენით სანთლის ხიდის ქვედა ნაწილი. იპოვეთ ორი მავთული, რომელიც მიდის ერთ სანთელზე.
  2. მოაცილეთ კაბელებიდან იზოლაცია, რომელიც გამოავლენს სპილენძის მავთულხლართებს სპილენძის მავთულის გაჭრის გარეშე.
  3. ჩართეთ განათება (დაისვენეთ, ეს მხოლოდ რამდენიმე ვოლტია) და გაზომეთ ძაბვა გამოვლენილი სპილენძის მავთულხლართებზე.
  4. გათიშეთ კაბელი ერთ – ერთ საზომი წერტილში (ამ დროს ნათურები ჩაქრება, რა თქმა უნდა), მოაშორეთ იზოლაცია (3 - 4 მმ) ორივე ბოლოში. გაზომეთ მიმდინარე მიმდინარეობა. რასაც აკეთებთ არის ის, რომ თქვენ ხელახლა აკავშირებთ გაჭრილ კაბელს თქვენს მულტიმეტრთან და უშვებთ მთელ მიმდინარეობას თქვენს მულტიმეტრში, რაც ახლა გეუბნებათ დენის რაოდენობას.

ჩემი კითხვები

ძაბვა ერთ სანთელზე (ნაბიჯი 3): 3.1 ვ

გაითვალისწინეთ, რომ სანთლის ხიდის დენის წყარო იყო 33 ვ. ასე რომ, შვიდჯერ 3.1 ვ არის მხოლოდ 21.7 ვ. ზოგიერთ სანთელზე უნდა იყოს დამატებითი რეზისტორი. სანთლის ძაბვა რომ გავზომე, ის უნდა ყოფილიყო 11 ვ.

სანთლის ანთების დროს (დენი 4) დენი მიედინება: 19 mA

მე ვაპირებ ყველაფრის ენერგიას 5 V 2 A ბატარეის პაკეტით. სანთლებისთვის, მე უნდა დავწიო ძაბვა 5 ვ -დან 3 ვ -მდე. მე მჭირდება რეზისტორი, რომელიც ძაბვას 2 ვ -ს ჩამოაგდებს 19 mA დენზე.

2 V / 0.019 A = 105 Ω

ენერგიის გაფანტვა არის:

2 V * 19 mA = 38 მგვტ

ეს უმნიშვნელოა. გაცილებით მეტს შეეძლო თავად გამეყენებინა რეზისტორი. მიუხედავად ამისა, 105 Ω რეზისტორის გარეშე შეიძლება LED ააფეთქო. მე მაქვს 100 Ω და 120 Ω რეზისტორები. მე მივდივარ 120 Ω– ით. ის მეტ დაცვას იძლევა.

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

ასე რომ, ახლა მე ვიცი, რომ რა ენერგიის წყაროს ვიყენებ, როგორიც არ უნდა იყოს ძაბვა, მე უნდა დავწიო ძაბვა 3 ვ -მდე, რაც საშუალებას მისცემს 19 mA- ს გაიაროს.

მე რომ უფრო კარგად ვიცნობდე LED ტექნოლოგიას, მე ვიცნობდი გამოყენებული LED- ის ტიპს და ვიცოდი, რომ მას სჭირდებოდა 3 ვ.

ნაბიჯი 2: ზოგიერთი Soldering

ზოგიერთი Soldering
ზოგიერთი Soldering
ზოგიერთი Soldering
ზოგიერთი Soldering

ამ ნაბიჯში მე ვაკავშირებ ყველა პოზიტიურ (+) მავთულს 5 სანთელიდან ერთ მავთულზე. შემდეგ თითოეულ სანთელზე ვამატებ ცალკეულ უარყოფით (-) მავთულს. LED ნათურა ანათებს მხოლოდ მაშინ, როდესაც '+' და '-' მარჯვნივ მიდის. ვინაიდან თქვენ გაქვთ მხოლოდ ორი იდენტური კაბელის ბოლო თითოეული სანთლიდან, თქვენ უნდა შეამოწმოთ რომელია "+" და რომელი არის "-". ამისათვის თქვენ გჭირდებათ 3 ვ ენერგიის წყარო. მე მქონდა პატარა ბატარეის პაკეტი, ორი AAA ბატარეის ჩათვლით. 3 ვ მონეტის ბატარეა შესანიშნავად მუშაობს ტესტირებისთვისაც.

სანთლის ხიდს სჭირდება 8 კაბელი არდუინოსა და ხიდს შორის გასაშვებად. თუ იპოვით კაბელს 8 იზოლირებული მავთულით, ეს შესანიშნავი იქნება. ერთი მავთული უნდა შეიცავდეს 120 mA- ს, დანარჩენებს მხოლოდ 20 mA აქვთ. მე ავირჩიე 4 ორმაგი მავთულის კაბელის გამოყენება, რაც მე შემთხვევით მქონდა.

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

მეორე სურათი გვიჩვენებს '-' მავთულს, რომელიც საჭიროა თითოეულ სანთელს. საერთო "+" მავთული მიდის პირდაპირ არდუინოს 5 V პინზე (ან შესაძლოა პურის დაფაზე). თითოეული '-' მავთული მიდის ტრანზისტორი IC- ის საკუთარ პინზე (ისევ, ალბათ, პურის დაფაზე).

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

ნაბიჯი 3: კავშირები

კავშირები
კავშირები
კავშირები
კავშირები
კავშირები
კავშირები
კავშირები
კავშირები

არდუინოს შესახებ, აღებულია ამ გვერდიდან:

  • სულ მაქსიმალური დენი თითო შესასვლელ/გამომავალ პინზე: 40mA
  • ყველა შეყვანის/გამომავალი ქინძისთავების დენებისაგან გაერთიანებული: 200mA

ჩემი სანთლები ამოიღებენ 19 mA- ს თითოეული, როდესაც იკვებება 3 V. მათგან შვიდია, რაც 133 mA- ს შეადგენს. ასე რომ, მე შემიძლია მათი ჩართვა პირდაპირ გამომავალი ქინძისთავებიდან. თუმცა, მე მაქვს სათადარიგო darlington ტრანზისტორი IC. ასე ვფიქრობდი, რატომაც არა. ჩემი წრე აკეთებს საქმეს სათანადოდ: მონაცემთა ქინძისთავები მხოლოდ სიგნალებისთვისაა და არა ენერგიისთვის. სამაგიეროდ მე ვიყენებ 5 V პინს Arduino– ზე LED განათების ჩართვისთვის. ტესტის გაშვებისას მე მაქვს ლეპტოპი არდუინოსთან დაკავშირებული. ყველაფერი იკვებება ლეპტოპის USB– ით, რომელიც იძლევა 5 ვ. Arduino Mega– ს აქვს საკუთარი დაუკრავენ, რომელიც 500 mA– ზე აფეთქებს კომპიუტერის დასაცავად. ჩემი სანთლები მაქსიმუმ 133 mA- ს მიაპყრობენ. არდუინო ალბათ გაცილებით ნაკლებია. ყველაფერი კარგად მუშაობს, როდესაც ლეპტოპი იკვებება, ამიტომ Arduino– ს USB პორტთან დაკავშირებული 5 ვ ბატარეის პაკეტის გამოყენება კარგია.

მონაცემთა ქინძისთავები D3 - D9 მიდის IC ULN2803APGCN– ზე. LED- ები მუშაობენ 3 ვ -ზე. თითოეული ნათურა უკავშირდება 5 ვ წყაროს და შემდგომ 120 Ω რეზისტორს. IC– ის ერთი არხის გვერდით, რომელიც საბოლოოდ აკავშირებს მიკროსქემს მიწასთან, IC– ში დარლინგტონის ტრანზისტორის საშუალებით.

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

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

ფოტოებზე ნაჩვენებია, თუ როგორ გამოდის ახალი კაბელები ხიდიდან, როგორ დავაყენე ტრანზისტორი IC და რეზისტორები პურის დაფაზე და როგორ უკავშირდება ჯუმბერის მავთულები არდუინო მეგას. მე დავჭრა 4 კაცი-მამაკაცი მხტუნავის მავთული 8 ნახევარ მავთულად, რომელიც შევაერთე სანთლის ხიდიდან გამოსულ 8 კაბელს. ამ გზით შემიძლია უბრალოდ ჩავაგდო კაბელები პურის დაფაზე.

ალტერნატივა ტრანზისტორების გარეშე

წინა საფეხურზე, მე მოვამზადე საერთო '+' მავთული სანთლებისთვის და ცალკე '-' მავთულები, რომლებიც ტრანზისტორი IC- ით მიდიან მიწაზე. როდესაც ერთი მონაცემთა ბარათი მაღლა იწევს, შესაბამისი '-' მავთული დამიწებდება მისი ტრანზისტორით და LED განათებით.

"-" მავთულის პირდაპირ დაკავშირება არდუინოს მონაცემთა ქინძისთავებთანაც იმუშავებდა, მაგრამ ყოველთვის გაითვალისწინეთ რამდენად დგას მონაცემთა ქინძისთავები! ამ მიდგომას ჩემი პროგრამის შეცვლა დასჭირდება. სანთლების ჩასართავად დასჭირდება მონაცემთა ქინძისთავები დაბლა. იმისათვის, რომ გამოიყენოთ ჩემი პროგრამა, თქვენ უნდა შეცვალოთ '+' და '-' სანთლებში. გქონდეთ საერთო მავთული სანთლებისთვის, რომელიც მიდის GND– ზე Arduino– ზე. ცალკე მავთულები გადის სანთლის '+' მავთულსა და არდუინოს მონაცემთა პინს შორის.

ნაბიჯი 4: მსუბუქი პროგრამები

ჩემი პროგრამა, რომელსაც წარმოგიდგენთ შემდეგ ეტაპზე, გადის 9 მსუბუქი პროგრამით. ღილაკის დაჭერით წამში შუქდება შუქი, შემდეგ იწყება შემდეგი განათების პროგრამა. პროგრამები შემდეგია:

  1. ძლიერი მოციმციმე. სანთლები შემთხვევით ციმციმებენ. ეს ძალიან შემაშფოთებელია, როდესაც მათ ახლო მანძილიდან უყურებთ, მაგრამ შეიძლება კარგად გამოიყურებოდეს შორიდან და შესაძლოა ყინვის სხვენის ფანჯრის მიღმა. თუმცა, თქვენმა მეზობელმა შეიძლება გამოიძახოს სახანძრო ბრიგადა.
  2. რბილი მოციმციმე. ძალიან კარგად გამოიყურება. როგორც ნამდვილი სანთლები ოთახში ნახაზის გარეშე.
  3. ცვალებადი ციმციმა. სანთლები შეუფერხებლად იცვლება ძლიერ და რბილ ციმციმებს შორის 30 წმ ინტერვალით.
  4. ცვალებადი ციმციმა. მე –3 ნომრის მსგავსად, მაგრამ თითოეული სანთელი განსხვავდება თავისი ტემპით 30 – დან 60 – მდე.
  5. სწრაფი მოციმციმე. სანთლები ანათებენ სტატიკურად ჩამქრალ დონეზე და შემთხვევით ციმციმებენ. საშუალოდ ერთი ციმციმა ყოველ წამს ხდება.
  6. ნელი ციმციმა. მომწონს #5, მაგრამ გაცილებით ნელი ტემპით.
  7. სწრაფი ტალღა შუა სანთლიდან ქვედა სანთლებზე.
  8. ნელი ტალღა შუა სანთლიდან ქვედა სანთლებზე.
  9. სტატიკური ნათელი შუქი. მე უნდა ჩავრთო ეს, არ მინდოდა ორიგინალური ფუნქციის მოშორება.

ნაბიჯი 5: კოდი

/*

FLICKERING CANDLE BRIDGE */ // გამოაცხადეთ რეჟიმის ცვლადი მდგომარეობის შესანარჩუნებლად // გადატვირთვის ოპერაციის საშუალებით _attribute _ ((განყოფილება (". Noinit"))) ხელმოუწერელი int რეჟიმი; // როდესაც პროგრამა იწყებს გადატვირთვის შემდეგ, მეხსიერების ეს ნაწილი // არ ინიციალიზდება, მაგრამ ინახავს მნიშვნელობას // რაც მას ჰქონდა გადატვირთვის წინ. პირველად როდესაც // პროგრამა გაშვებულია, მას აქვს შემთხვევითი მნიშვნელობა. / * * სანთლის კლასი ინახავს ყველაფერს რაც საჭიროა * მბჟუტავი სანთლისთვის სინათლის დონის გამოსათვლელად. */ class candle {private: long maxtime; გრძელი პერიოდი; გრძელი მაქსილიტი; გრძელი მინლიტი; გრძელი შუალედი; ხანგრძლივი ორიგინალი დრო; ხანგრძლივი წარმოშობის დრო; გრძელი ორიგმაქსლიტი; ხანგრძლივი origminlite; გრძელი ორიგინალიტი; ხანგრძლივი deltamaxtime; ხანგრძლივი deltamintime; გრძელი დელტამაქსლიტი; გრძელი დელტამინლიტი; გრძელი დელტამეანლიტი; ხანგრძლივი lforate; ხანგრძლივი საღამო; ხანგრძლივი დასაწყისი; გრძელი სამიზნე; float phactor; ხანგრძლივი სამიზნე; ხანგრძლივი დაწყების დრო; ხანგრძლივი დელტატიმი; void newtarget (ბათილია); ხანგრძლივი onetarget (ბათილია); საჯარო: სანთელი (long mat, long mit, long mal, long mil, long mel, long eo); გრძელი დონე (ბათილია); void initlfo (long deltamat, long deltamit, long deltamal, long deltamil, long deltamean, long rate); void setlfo (ბათილია); }; candle:: candle (long mat, long mit, long mal, long mil, long mel, long eo): maxtime (mat), mintime (mit), maxlite (mal), minlite (mil), meanlite (mel), საღამო (eo), origmaxtime (mat), origmintime (mit), origmaxlite (mal), origminlite (mil), origmeanlite (mel) {target = meanlite; newtarget (); } / * * levelnow () აბრუნებს სანთლის სინათლის დონეს ახლავე. * ფუნქცია ზრუნავს ახალი შემთხვევითი სინათლის დონის განსაზღვრაზე და * დრო, რომელიც უნდა დაჭირდეს ამ დონის მიღწევას. ცვლილება არ არის ხაზოვანი, * მაგრამ მიჰყვება სიგმოიდურ მრუდს. როდესაც დრო არ არის ახალი * დონის განსაზღვრის დრო, ფუნქცია უბრალოდ აბრუნებს სინათლის დონეს. */ long candle:: levelnow (void) {long help, now; float t1, t2; ახლა = მილი (); if (ახლა> = targettime) {დახმარება = სამიზნე; newtarget (); დახმარების დაბრუნება; } else {// help = target * (millis () - starttime) / deltatime + start * (targettime - millis ()) / deltatime; t1 = float (სამიზნე დრო - ახლა) / deltatime; t2 = 1. - t1; // ეს არის სიგმოიდური გაანგარიშების დახმარება = t1*t1*t1*დაწყება + t1*t1*t2*დაწყება*3 + t1*t2*t2*სამიზნე*3 + t2*t2*t2*სამიზნე; დახმარების დაბრუნება; }} void candle:: newtarget (void) {long sum; ჯამი = 0; for (long i = 0; i <evenout; i ++) sum+= onetarget (); დაწყება = სამიზნე; სამიზნე = თანხა / საღამო; დაწყების დრო = მილი (); targettime = დაწყების დრო + შემთხვევითი (დრო, დრო); deltatime = targettime - დაწყების დრო; } long candle:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = now; / * * ალგორი მოციმციმე "წილი მილიწამების შემდეგ": * დაიწყეთ შემოწმება განაკვეთის შემდეგ / 2 მილიწამი * კურსის პერიოდში / 2 მილიწამი, გახადეთ * მოციმციმე შანსი იყოს 50 %. * თუ მაჩვენებელი 10000 ms, 5000 ms დროს მონეტა * გადატრიალდა 50 -ჯერ. * 1/50 = 0.02 * თუ შემთხვევითი (10000) დაწყების დრო + განაკვეთი / 2) {თუ (შემთხვევითი (განაკვეთი) სამიზნე დრო) დაბრუნდა დაბალი ლაით; დაბრუნება (დაწყება - lowlite) * (targettime - ახლა) / (targettime - დაწყების დრო) + lowlite; } void twinkler:: twink (void) {starttime = millis (); targettime = შემთხვევითი (mintime, maxtime) + დაწყების დრო; დაწყება = შემთხვევითი (minlite, maxlite); } void setup () {int led; // წაიკითხეთ ჯადოსნური რეჟიმის ცვლადი, რომელიც უნდა გითხრათ // რა სინათლის პროგრამა იყო გაშვებული ბოლო დროს, გაზარდეთ იგი // და გადატვირთეთ ნულამდე. რეჟიმი ++; რეჟიმი %= 9; // ეს ზრუნავს ნებისმიერ მნიშვნელობაზე // იყო პირველად Arduino // გაშვებული ეს პროგრამა. / * * მნიშვნელოვანი შენიშვნა * ============= * * * მთავარი რაც ამ პროგრამას აკეთებს არის PWM * სიგნალების გამოშვება LED განათებებზე. აქ დავაყენე 3 - დან 9 - მდე * გამომავალი რეჟიმი. Arduino Mega2560– ზე, ეს ქინძისთავები გამოდიან * ლამაზად PWM სიგნალებს. თუ თქვენ გაქვთ სხვა Arduino, შეამოწმეთ * რომელი ქინძისთავები (და რამდენი) შეგიძლიათ გამოიყენოთ. თქვენ ყოველთვის შეგიძლიათ * გადაწეროთ კოდი PWM პროგრამული უზრუნველყოფის გამოსაყენებლად, თუ თქვენი Arduino * ვერ უზრუნველყოფს საკმარის აპარატურულ PWM ქინძისთავებს. * */ pinMode (3, OUTPUT); pinMode (4, OUTPUT); pinMode (5, OUTPUT); pinMode (6, OUTPUT); pinMode (7, OUTPUT); pinMode (8, OUTPUT); pinMode (9, OUTPUT); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // უბრალოდ გამორთეთ არდუინოს სანთელზე გამაღიზიანებელი წითელი ლიდერი *ქილა [7]; // მოემზადეთ მოციმციმე სანთლების გამოსაყენებლად, იყენებთ თუ არა მათ მოციმციმე *twink [7]; // მოემზადეთ მოციმციმე სანთლების გამოსაყენებლად … თუ (რეჟიმი == 8) {for (int i = 3; i <10; i ++) analogWrite (i, 255); ხოლო (ჭეშმარიტი); // ყოველ ჯერზე, როდესაც ეს პროგრამა მუშაობს, ის გადადის // ამ სახის გაუთავებელ მარყუჟში, სანამ გადატვირთვა // ღილაკს არ დააჭერთ. } if (რეჟიმი <2) // მოციმციმე {long maxtime_; გრძელი პერიოდი_; გრძელი მაქსლიტი_; გრძელი მინლიტი_; გრძელი საშუალო_; გრძელი კი _; if (რეჟიმი == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; მინლიტი_ = 0; meanlite_ = 128; თუნდაც_ = 1; } if (რეჟიმი == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; მინლიტი_ = 100; meanlite_ = 200; კი_ = 1; } for (int i = 0; i <7; i ++) {can = ახალი სანთელი (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // დაუსრულებელი მარყუჟი სანთლების მოციმციმე {for (int i = 0; i levelnow ()); }} თუ (რეჟიმი <4) // lfo დაემატა მოციმციმე {if (mode == 2) // იგივე lfo (30 წ) ყველა სანთლისთვის {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} თუ (რეჟიმი == 3) // ცვლადი lfo: s სანთლებისთვის {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); შეუძლია [1]-> initlfo (75, 50, 0, 50, 36, 25000); შეუძლია [2]-> initlfo (75, 50, 0, 50, 36, 30000); შეუძლია [3]-> initlfo (75, 50, 0, 50, 36, 35000); შეუძლია [4]-> initlfo (75, 40, 0, 50, 36, 40000); შეუძლია [5]-> initlfo (75, 30, 0, 50, 26, 45000); შეუძლია [6]-> initlfo (75, 20, 0, 50, 16, 50000); შეუძლია [7]-> initlfo (75, 10, 0, 50, 6, 55000);} ხოლო (ჭეშმარიტი) // დაუსრულებელი მარყუჟი სანთლების მოციმციმე lfo- ით {long lastclock = 0; for (int i = 0; i levelnow ()); if (millis ()> lastclock + 4000) {lastclock = millis (); for (int i = 0; i setlfo ();}}} თუ (რეჟიმი <6) // მოციმციმე სანთლები {int speedo; თუ (რეჟიმი == 4) speedo = 6000; სხვაგვარად speedo = 22000; for (int i = 0; i <7; i ++) twink = ახალი ციმციმა (300, 295, 255, 250, speedo); ხოლო (ჭეშმარიტი) {for (int i = 0; i levelnow ()); }} // ტალღები. // ეს სექცია იწყება ხვეული ფრჩხილებით მხოლოდ // იმის უზრუნველსაყოფად, რომ არ არსებობს კონფლიქტური ცვლადების სახელები. // არ არის საჭირო ფრჩხილებში, არ არის საჭირო შემოწმება // რეჟიმის მნიშვნელობა.{int ლოლიტი = 2; int hilite = 255; int ნიშნავს; int ampl; float fasedelta = 2.5; float fase; int elong; float phactor; ხანგრძლივი პერიოდი; საშუალო = (ლოლიტი + ჰილიტი) / 2; ampl = hilite - საშუალო; თუ (რეჟიმი == 6) პერიოდი = 1500; სხვა პერიოდი = 3500; ფაქტორი = 6.28318530718 / პერიოდი; ხოლო (ჭეშმარიტი) {fase = phactor * (millis () % პერიოდი); წაგრძელებული = საშუალო + გამაძლიერებელი * ცოდვა (ფაზა); analogWrite (7, წაგრძელებული); analogWrite (9, წაგრძელებული); fase = phactor * ((millis () + პერიოდი / 4) % პერიოდი); წაგრძელებული = საშუალო + გამაძლიერებელი * ცოდვა (ფაზა); analogWrite (3, წაგრძელებული); analogWrite (8, წაგრძელებული); fase = phactor * ((millis () + პერიოდი / 2) % პერიოდი); წაგრძელებული = საშუალო + გამაძლიერებელი * ცოდვა (ფაზა); analogWrite (4, წაგრძელებული); analogWrite (5, წაგრძელებული); fase = phactor * ((millis () + 3 * პერიოდი / 4) % პერიოდი); წაგრძელებული = საშუალო + გამაძლიერებელი * ცოდვა (ფაზა); analogWrite (6, წაგრძელებული); } // სანთლის მავთულის არდუინოსთან შეერთების დროს, // მე ისინი ავურიე და არასოდეს დამილაგებია. // წესრიგი მნიშვნელოვანია ტალღის ნიმუშების შესაქმნელად, // ასე რომ, მე უბრალოდ დავწერე ეს პატარა მაგიდა ჩემთვის: // // სანთელი# ხიდში: 2 3 5 4 7 6 1 // მონაცემთა პინი არდუინოზე: 3 4 5 6 7 8 9}} void loop () {// რადგან ყველა სინათლის პროგრამა არის საკუთარი უსასრულო მარყუჟი, // მე დავწერე ყველა მარყუჟი დასაწყისში () განყოფილებაში // და არაფერი დავტოვე ამ მარყუჟის () განყოფილებისთვის. }

ნაბიჯი 6: PWM– ის შესახებ

LED- ები ბრწყინავს, როდესაც იკვებება 3 ვ -ით, მხოლოდ 1.5 ვ -ის გამოყენებით ისინი საერთოდ არ ანათებენ. LED ნათურები არ ქრებოდა ლამაზად ქრებოდა ძაბვით, ისევე როგორც ინკანდესენტური ნათურები. ამის ნაცვლად, ისინი უნდა იყოს ჩართული სრული ძაბვით, შემდეგ კი გამორთული. როდესაც ეს ხდება 50 -ჯერ წამში, ისინი მშვენივრად ანათებენ 50 % -იანი სიკაშკატით, მეტნაკლებად. თუ მათ უფლება ექნებათ იყოს მხოლოდ 5 ms და გამორთული 15 ms, ისინი შეიძლება ბრწყინავდნენ 25 % სიკაშკაშეზე. ეს ტექნიკა არის ის, რაც ხდის LED შუქის დაბნელებას. ამ ტექნიკას ეწოდება პულსის სიგანის მოდულაცია ან PWM. მიკროკონტროლერს, როგორიცაა Arduino, ჩვეულებრივ აქვს მონაცემთა ქინძისთავები, რომლებსაც შეუძლიათ სიგნალების ჩართვა/გამორთვა. მონაცემთა ზოგიერთ ქინძისთავს აქვს შესაძლებლობები PWM– სთვის. მაგრამ თუ არ არის საკმარისი PWM ჩამონტაჟებული ქინძისთავები, ჩვეულებრივ შესაძლებელია გამოვიყენოთ პროგრამირებული ბიბლიოთეკები "პროგრამული PWM ქინძისთავების" შესაქმნელად.

ჩემს პროექტში მე გამოვიყენე Arduino Mega2560, რომელსაც აქვს ტექნიკური PWM ქინძისთავები 3 - 9. თუ თქვენ იყენებთ Arduino UNO– ს, თქვენ გაქვთ მხოლოდ ექვსი PWM ქინძი. ამ შემთხვევაში, თუ თქვენ გჭირდებათ მე -7 (ან თუნდაც მეტი) სანთელი, შემიძლია გირჩიოთ ბრეტ ჰაგმანის პროგრამული უზრუნველყოფის PWM ბიბლიოთეკა, რომელიც შეგიძლიათ იხილოთ აქ.

გირჩევთ: