Attiny85 პარალელური პროგრამირება ან გოგრა მრავალფერიანი თვალებით: 7 ნაბიჯი

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

ავტორი ავტორი: jumbleviewJumbleview.info

შესახებ: მე ვმუშაობ პროგრამული უზრუნველყოფის ინჟინრად ერთ -ერთ Bay Area (California) კომპანიაში. როდესაც დრო მაქვს, მომწონს მიკრო კონტროლერების დაპროგრამება, მექანიკური სათამაშოების შექმნა და სახლის გაუმჯობესების პროექტების გაკეთება. მეტი jumbleview შესახებ »

ეს პროექტი გვიჩვენებს, თუ როგორ უნდა გავაკონტროლოთ ორი 10 მმ-იანი სამი ფერის სამი ფერის ანოდი LED (გოგრის ჰელოუინის ბრჭყვიალა ფერადი თვალები) Attiny85 ჩიპით. პროექტის მიზანია მკითხველის გაცნობა პარალელური პროგრამირების ხელოვნებაში და ადამ დანკელსის პროთრედის ბიბლიოთეკის გამოყენებაში. ეს პროექტი ვარაუდობს, რომ მკითხველმა იცის AVR 8-ბიტიანი კონტროლერების შესახებ, შეუძლია დაწეროს C- პროგრამა და აქვს გარკვეული გამოცდილება Atmel studio– სთან.

პროექტის კოდი გამოქვეყნებულია GitHub– ზე:

მარაგები

პროგრამირების დაწყებამდე ჯერ კიდევ გჭირდებათ სქემის შექმნა. აქ არის კომპონენტები:

• კონტროლი Attiny85 (ნებისმიერი ელექტრონული მიმწოდებელი).
• ორი სამი ფერის 10 მმ -იანი LED ნათურა საერთო ანოდით. ადაფრუტის LED- ები
• რეზისტორები 100 Ohm, 120 Ohm, 150 Ohm 0.125 ან 0.250 Wt (ნებისმიერი ელექტრონული მიმწოდებელი).
• ექვსი Pin სათაური AVR ISP ინტერფეისისთვის. შეიძლება გაკეთდეს ამ ადაფრუტის სათაურიდან
• ზოგიერთი პურის დაფა ან დაბეჭდილი შაბლონის დაფა. მე გამოვიყენე ეს
• AVR ISP MKII ინტერფეისი და Atmel Studio 6.1 (ასევე უნდა მუშაობდეს გვიანდელი ვერსია).

ნაბიჯი 1: წრე

დიზაინი იყენებს ხუთ ჩიპს:

• ორი ქინძისთავები გამოიყენება ანოდების გასაკონტროლებლად: თითოეული LED ანოდი მიმაგრებულია გამოყოფილ პინზე.
• სამი ქინძისთავი მიმაგრებულია (რეზისტორების საშუალებით) LED- ების კათოდებზე (ერთი და იგივე პინზე მიმაგრებული თითოეული led- ის ერთი ფერის კათოდი)

ერთი იკითხავს: რატომ არ გამოვიყენოთ ჩიპის ექვსივე შესასვლელი/გარეთ ქინძისთავები, ასე რომ LED ანოდები პირდაპირ იქნება დაკავშირებული +5 ვ -თან და თითოეულ კათოდს ექნება თავისი მიძღვნილი პინი? ეს გახდის პროგრამირებას პირდაპირ. სამწუხაროდ, პრობლემაა: pin PB5 (RESET) არის სუსტი პინი, რომელსაც შეუძლია უზრუნველყოს დენის მხოლოდ m 2 mA, ხოლო საჭიროა ~ 20 mA.

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

ნაბიჯი 2: დროის დიაგრამა

დროის დიაგრამა გვეხმარება გავიგოთ რა გვჭირდება პროგრამირებისთვის.

დიაგრამაზე ზედა ორი რიგი გვიჩვენებს ძაბვის ცვლილებას LED ანოდებზე. LED ანოდებთან დაკავშირებულ ქინძისთავებზე ძაბვა იცვლება სიხშირით ~ 250 ჰც. ეს ძაბვის რხევა მარცხენა LED- ისთვის არის საპირისპირო მარჯვენა LED- ის რხევისა. როდესაც ძაბვა ანოდზე მაღალია შესაბამისი LED შეიძლება იყოს ნათელი. როდესაც ის დაბალია შესაბამისი LED ბნელია. ეს ნიშნავს, რომ თითოეული LED შეიძლება იყოს ნათელი 2 მილიწამიანი ინტერვალით და მუქი კიდევ 2 მილიწამში. იმის გამო, რომ ადამიანის თვალს აქვს გარკვეული ინერცია, 250 Hz მოციმციმე არ არის შესამჩნევი დამკვირვებლის მიერ. დიაგრამაზე ქვედა სამი სტრიქონი გვიჩვენებს ძაბვის ცვლილებას LED- ების კათოდებთან დაკავშირებულ ქინძისთავებზე. მოდით შევხედოთ დიაგრამის პირველ სვეტს. ის გვიჩვენებს შემთხვევას, როდესაც მარცხენა LED არის წითელი და მარჯვენა LED მწვანე. აქ წითელი კათოდები დაბალი რჩება, ხოლო მარცხენა ანოდი მაღალია, მწვანე კათოდი დაბალია, ხოლო მარჯვენა ანოდი მაღალია, ხოლო ცისფერი კათოდი ყოველთვის დაბალია. დიაგრამაზე სხვა სვეტები გვიჩვენებს კათოდისა და ანოდის ძაბვის კომბინაციებს სხვადასხვა ფერისთვის.

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

ნაბიჯი 3: პროგრამირება. მაკროები და განმარტებები

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

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

ნაბიჯი 4: პროგრამირება. მთავარი მარყუჟი

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

ძირითადი ფუნქცია ინიციალიზაციის შემდეგ რჩება სამუდამოდ მარყუჟში. ამ მარყუჟში ის აკეთებს შემდეგ ნაბიჯებს:

• იწვევს მარცხენა LED- ს პროთოდრედის რუტინას. ის ცვლის ქინძისთავების ძაბვას.
• დააყოვნეთ ორი მილიწამი. პინ ძაბვაში ცვლილებები არ ხდება.
• იძახებს პროთოდედს მარჯვენა LED- ისთვის. ის ცვლის რაღაც ძაბვას.
• დააყოვნეთ 2 MS. პინ ძაბვაში ცვლილებები არ ხდება.

ნაბიჯი 5: პროგრამირება. დამხმარე ფუნქციები

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

და არის კიდევ ერთი ფუნქცია, რომელსაც უშუალოდ მიმართავს პროთოდედის რუტინა. მისი სახელია DoAndCountdown ().

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

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

ფუნქცია DoAndCountdown () აბრუნებს საპირისპირო მრიცხველის მნიშვნელობას.

ნაბიჯი 6: პროგრამირება. Protothread რუტინები

და აქ არის ჩარჩო ბირთვი: protothread რუტინა. სიმარტივისთვის მაგალითი შემოიფარგლება მხოლოდ სამი საფეხურით: ფერის შეცვლისთვის წითელი, მწვანე და ლურჯი.

ფუნქცია გამოიყენება ორი არგუმენტით:

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

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

• ფუნქციის გამოძახება DoAndCountdown. ეს ადგენს ძაბვას LED კათოდებზე, რათა გამოსცეს კონკრეტული ფერი.
• დაბრუნებული შედეგი 0. -სთან შედარებით. თუ მდგომარეობა არის "ყალბი" პროთოდის ფუნქცია მაშინვე ბრუნდება და კონტროლს აძლევს მთავარ მარყუჟს.
• როდესაც პროტოდის მოხსნა მოხდება შემდეგ ჯერზე ის კვლავ აღასრულებს კოდს PT_BEGIN- მდე, შემდეგ ხტება პირდაპირ PT_WAIT_UNTIL მაკროებში, საიდანაც იგი დაბრუნდა ბოლო დროს.
• ასეთი ქმედებები განმეორდება მანამ, სანამ DoAndCountdown არ არის 0. ამ შემთხვევაში დაბრუნება არ არსებობს, პროგრამა რჩება პროტექსტში და ასრულებს კოდის შემდეგ სტრიქონს. ჩვენს შემთხვევაში, ეს არის შემდეგი PT_WAIT_UNTIL, მაგრამ ზოგადად ის შეიძლება იყოს თითქმის ნებისმიერი C კოდი.
• მეორე PT_WAIT_UNTIL საპირისპირო მრიცხველის პირველადი შესრულებისას არის 0, ასე რომ DoAndCountdown () პროცედურამ დაადგინა ის საწყის მნიშვნელობაზე. მეორე მაკრო კვლავ შესრულდება 250 -ჯერ, სანამ შემობრუნების მრიცხველი არ მიაღწევს 0 -ს.
• სტრუქტურული მდგომარეობის მდგომარეობა გადატვირთულია როგორც კი კონტროლი აღწევს PT_END მაკროებს. როდესაც protothread ფუნქცია გამოიძახება შემდეგ ჯერზე protothread სეგმენტი იწყებს კოდის ხაზის შესრულებას PT_BEGIN- ის შემდეგ.

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

ნაბიჯი 7: შიდა

მთელი პროგრამა 200 კოდზე ნაკლებია (კომენტარებითა და ცარიელი ხაზებით) და იღებს Attiny85 კოდის მეხსიერების 20% -ზე ნაკლებს. საჭიროების შემთხვევაში, შესაძლებელია გამოვიყენოთ კიდევ რამდენიმე პროტექსტური რუტინა და მივანიჭოთ მათ ბევრად უფრო რთული ლოგიკა.

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

მოწინავე სისტემებისთვის, ასეთი ამოცანების კონტროლი ხორციელდება ოპერაციული სისტემის ბირთვის საშუალებით ან შემსრულებლის მიერ შემსრულებელ ენაზე ჩართული ენის გაშვების დროს. მაგრამ protothreads პროგრამისტი პროგრამისტი აკონტროლებს მას ხელით გამოყენებით protothreads macros ბიბლიოთეკა ამოცანების routines და მოწოდების ასეთი routines (როგორც წესი, ძირითადი მარყუჟის გარეთ).

თქვენ ალბათ გსურთ იცოდეთ როგორ მუშაობს პროთოდემი სინამდვილეში? სად იმალება მაგია? Protothreads ეყრდნობა სპეციალურ C ენის მახასიათებელს: ის ფაქტი, რომ C შეცვლის შემთხვევის განცხადება შეიძლება ჩაშენებული იყოს if ან სხვა ბლოკში (მაგალითად while ან for). დეტალები შეგიძლიათ ნახოთ ადამ დანკელსის საიტზე

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