Arduino-ში შეფერხებები ძალიან დიდ როლს თამაშობს. მათ გარეშე Blink-ის უმარტივესი მაგალითიც კი, რომელიც ციმციმებს LED-ს განსაზღვრული დროის შემდეგ, ვერ იმუშავებს. მაგრამ ახალბედა პროგრამისტების უმეტესობამ ცოტა იცის დროის დაყოვნების შესახებ და იყენებს მხოლოდ Arduino-ს დაყოვნებას ამ ბრძანების გვერდითი ეფექტების ცოდნის გარეშე. ამ სტატიაში დეტალურად ვისაუბრებ დროის ფუნქციებზე და როგორ გამოვიყენოთ ისინი Arduino IDE-ში.
Arduino-ში არის რამდენიმე განსხვავებული ბრძანება, რომლებიც პასუხისმგებელნი არიან დროზე მუშაობაზე და პაუზებზე:
- დაგვიანებით ()
- delayMicroseconds()
- millis ()
- მიკროს ()
ისინი განსხვავდებიან სიზუსტით და აქვთ საკუთარი მახასიათებლები, რომლებიც გასათვალისწინებელია კოდის დაწერისას.
arduino-ს დაყოვნების ფუნქციის გამოყენება
Სინტაქსი
Arduino delay არის უმარტივესი ბრძანება და ყველაზე ხშირად გამოიყენება დამწყებთათვის. არსებითად, ეს არის შეფერხება, რომელიც აჩერებს პროგრამას ფრჩხილებში მითითებული მილიწამების რაოდენობით. (ერთ წამში არის 1000 მილიწამი.) მაქსიმალური მნიშვნელობა შეიძლება იყოს 4294967295 ms, რაც დაახლოებით უდრის 50 დღეს. მოდით შევხედოთ მარტივ მაგალითს, რომელიც ნათლად აჩვენებს, თუ როგორ მუშაობს ეს ბრძანება.
Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // გაგზავნეთ მაღალი სიგნალი pin 13 delay (10000); // პაუზა 10000ms ან 10 წამი digitalWrite13, LOW) ; // გაგზავნეთ დაბალი სიგნალი pin 13 delay(10000); // პაუზა 10000 ms ან 10 წამი)
მეთოდში აწყობაჩვენ ვაზუსტებთ, რომ პინი 13 გამოყენებული იქნება გამოსავალად. პროგრამის ძირითად ნაწილში მაღალი სიგნალი ჯერ პინზე იგზავნება, შემდეგ ვაჭიანებთ 10 წამით. ამ დროის განმავლობაში, პროგრამა, როგორც ჩანს, შეჩერებულია. მერე დაბალი სიგნალი ეძლევა და ისევ შეფერხება ხდება და ყველაფერი თავიდან იწყება. შედეგად, მივიღებთ, რომ პინი მონაცვლეობით მიეწოდება 5 ვ, შემდეგ 0.
თქვენ ნათლად უნდა გესმოდეთ, რომ შეფერხების გამოყენებით პაუზის დროს, პროგრამის მუშაობა შეჩერებულია, აპლიკაცია არ მიიღებს მონაცემებს სენსორებისგან. ეს არის Arduino-ს დაყოვნების ფუნქციის გამოყენების ყველაზე დიდი მინუსი. ამ შეზღუდვის თავიდან აცილება შეგიძლიათ შეფერხებების გამოყენებით, მაგრამ ამაზე ცალკე სტატიაში ვისაუბრებთ.
შეფერხების მაგალითი მოციმციმე LED-ით
მაგალითი სქემა იმის საილუსტრაციოდ, თუ როგორ მუშაობს დაყოვნების ფუნქცია.
თქვენ შეგიძლიათ ააწყოთ წრე LED-ით და რეზისტორით. შემდეგ გვექნება სტანდარტული მაგალითი - LED-ის მოციმციმე. ამისათვის თქვენ უნდა დააკავშიროთ LED დადებითი კონტაქტით ქინძისთავთან, რომელიც ჩვენ დავნიშნეთ, როგორც გამომავალი. ჩვენ ვუკავშირდებით LED-ის თავისუფალ ფეხს მიწასთან დაახლოებით 220 Ohms-ის რეზისტორის მეშვეობით (შესაძლებელია ცოტა მეტი). თქვენ შეგიძლიათ განსაზღვროთ პოლარობა მისი შიგნიდან დათვალიერებით. შიგნით დიდი ჭიქა უკავშირდება მინუსს, პატარა ფეხი კი პლუსს. თუ თქვენი LED არის ახალი, მაშინ შეგიძლიათ განსაზღვროთ პოლარობა მილების სიგრძით: გრძელი ფეხი არის პლუსი, მოკლე ფეხი არის მინუსი.
delayMicroseconds ფუნქცია
ეს ფუნქცია დაყოვნების სრული ანალოგია, გარდა იმისა, რომ მისი საზომი ერთეულები არის არა მილიწამები, არამედ მიკროწამები (1 წამში არის 1 000 000 მიკროწამი). მაქსიმალური მნიშვნელობა იქნება 16383, რაც უდრის 16 მილიწამს. გარჩევადობა არის 4, ანუ რიცხვი ყოველთვის იქნება ოთხის ნამრავლი. მაგალითის ნაწყვეტი ასე გამოიყურება:
DigitalWrite (2, HIGH); // გაგზავნეთ მაღალი სიგნალი პინზე 2 delayMicroseconds(16383); // პაუზა 16383 μs digitalWrite(2, LOW); // გაგზავნეთ დაბალი სიგნალი პინზე 2 delayMicroseconds(16383); // პაუზა 16383 μs
DelayMicroseconds-ის პრობლემა ზუსტად იგივეა, რაც დაგვიანებით - ეს ფუნქციები მთლიანად „აკიდებს“ პროგრამას და ის ფაქტიურად იყინება გარკვეული ხნით. ამ დროს შეუძლებელია პორტებთან მუშაობა, სენსორებიდან ინფორმაციის წაკითხვა და მათემატიკური ოპერაციების შესრულება. ეს ვარიანტი შესაფერისია მოციმციმე განათებისთვის, მაგრამ გამოცდილი მომხმარებლები არ იყენებენ მას დიდი პროექტებისთვის, რადგან ასეთი წარუმატებლობები იქ არ არის საჭირო. ამიტომ, ბევრად უკეთესია ქვემოთ აღწერილი ფუნქციების გამოყენება.
Millis ფუნქცია დაგვიანების ნაცვლად
millis() ფუნქცია საშუალებას მოგცემთ შეასრულოთ დაყოვნება Arduino-ზე, რითაც თავიდან აიცილებთ წინა მეთოდების ნაკლოვანებებს. მილის პარამეტრის მაქსიმალური მნიშვნელობა იგივეა რაც დაყოვნების ფუნქციის (4294967295ms ან 50 დღე).
millis-ის გამოყენებით, ჩვენ არ ვწყვეტთ მთელი ესკიზის შესრულებას, არამედ უბრალოდ ვაჩვენებთ, თუ რამდენ ხანს უნდა Arduino-მ უბრალოდ „გვერდის ავლით“ კოდის ზუსტი ბლოკი, რომლის შეჩერებაც გვინდა. delay millis-ისგან განსხვავებით, ის თავისთავად არაფერს აჩერებს. ეს ბრძანება უბრალოდ გვაბრუნებს მიკროკონტროლერის ჩაშენებული ტაიმერიდან იმ მილიწამების რაოდენობას, რომელიც გავიდა დაწყებიდან. ციკლის ყოველი გამოძახებით ჩვენ თვითონ ვზომავთ დროს, რომელიც გავიდა ჩვენი კოდის ბოლო გამოძახებიდან და თუ დროის სხვაობა სასურველ პაუზაზე ნაკლებია, მაშინ ჩვენ უგულებელყოფთ კოდს. როგორც კი სხვაობა საჭირო პაუზაზე მეტი გახდება, ჩვენ ვასრულებთ კოდს, ვიღებთ მიმდინარე დროს იმავე მილის გამოყენებით და ვიხსენებთ მას - ეს დრო იქნება ახალი საწყისი წერტილი. შემდეგ ციკლში, უკუნთვლა უკვე იქნება ახალი წერტილიდან და ჩვენ კვლავ უგულებელყოფთ კოდს, სანამ ახალი სხვაობა millis-სა და ჩვენს ადრე შენახულ მნიშვნელობას შორის კვლავ არ მიაღწევს სასურველ პაუზას.
დაყოვნების გარეშე millis-ის გამოყენება მოითხოვს მეტ კოდს, მაგრამ მისი დახმარებით შეგიძლიათ აახამოთ LED და შეაჩეროთ ესკიზი სისტემის გაჩერების გარეშე.
აქ არის მაგალითი, რომელიც ნათლად ასახავს გუნდის მუშაობას:
ხელმოუწერელი ხანგრძლივი დრო; // ცვლადი საცნობარო წერტილის შესანახად void setup() ( Serial.begin(9600); ) void loop() ( /* ამ დროს იწყება delay() ანალოგის შესრულება. გამოთვალეთ სხვაობა მიმდინარე მომენტსა და მომენტს შორის ადრე შენახული საცნობარო წერტილი თუ სხვაობა სასურველ მნიშვნელობაზე მეტია, მაშინ შეასრულეთ კოდი, თუ არა, არ გააკეთოთ არაფერი */ if (millis() - დრო > 10000)( // ნაცვლად 10000, შეცვალეთ პაუზის მნიშვნელობა. = millis(Serial.println)
პირველ რიგში ვაცნობთ დროის ცვლადს, რომელიც ინახავს მილიწამების რაოდენობას. ნაგულისხმევად, ცვლადის მნიშვნელობა არის 0. პროგრამის ძირითად ნაწილში ჩვენ ვამოწმებთ პირობას: თუ მიკროკონტროლერის დაწყებიდან მილიწამების რაოდენობა მინუს დროის ცვლადში ჩაწერილი რიცხვი არის 10000-ზე მეტი, მაშინ შესრულებულია პორტის მონიტორზე შეტყობინების გაგზავნის მოქმედება და მიმდინარე დროის მნიშვნელობა ჩაიწერება ცვლადზე. პროგრამის მუშაობის შედეგად პორტის მონიტორზე ყოველ 10 წამში გამოჩნდება შეტყობინება 10 წამი. ეს მეთოდი საშუალებას გაძლევთ დაუყოვნებლად დაახამხამოთ LED.
დაყოვნების ნაცვლად მიკრო ფუნქცია
ამ ფუნქციას ასევე შეუძლია შეასრულოს დაყოვნება დაყოვნების ბრძანების გამოყენების გარეშე. ის მუშაობს ზუსტად ისევე, როგორც მილისი, მაგრამ ითვლის მიკროწამებს და არა მილიწამებს 4 μs გარჩევადობით. მისი მაქსიმალური მნიშვნელობაა 4294967295 მიკროწამი ან 70 წუთი. თუ ის ჭარბობს, მნიშვნელობა უბრალოდ გადაკეთდება 0-ზე, არ დაგავიწყდეთ ამის შესახებ.
Შემაჯამებელი
Arduino პლატფორმა გვაწვდის რამდენიმე გზას ჩვენი პროექტის შეფერხების განსახორციელებლად. დაგვიანების გამოყენებით, შეგიძლიათ სწრაფად შეაჩეროთ ესკიზის შესრულება, მაგრამ ამავე დროს დაბლოკოთ მიკროკონტროლერის მუშაობა. millis ბრძანების გამოყენება საშუალებას გაძლევთ გააკეთოთ შეფერხების გარეშე Arduino-ში, მაგრამ ამას დასჭირდება ცოტა მეტი პროგრამირება. აირჩიეთ საუკეთესო მეთოდი თქვენი პროექტის სირთულიდან გამომდინარე. როგორც წესი, მარტივ ჩანახატებში და 10 წამზე ნაკლები დაგვიანებით გამოიყენება დაყოვნება. თუ ოპერაციული ლოგიკა უფრო რთულია და საჭიროა დიდი დაყოვნება, მაშინ ჯობია დაყოვნების ნაცვლად გამოიყენოთ მილისი.
" წარმოგიდგენთ სასწავლო კურსს "Arduino დამწყებთათვის". სერია შედგება 10 გაკვეთილისგან, ასევე დამატებითი მასალისგან. გაკვეთილები მოიცავს ტექსტურ ინსტრუქციებს, ფოტოებს და სასწავლო ვიდეოებს. თითოეულ გაკვეთილზე ნახავთ საჭირო კომპონენტების ჩამონათვალს, პროგრამის ჩამონათვალს და კავშირის დიაგრამას. ამ 10 ძირითადი გაკვეთილის დასრულების შემდეგ, თქვენ შეძლებთ გადახვიდეთ უფრო საინტერესო მოდელებზე და Arduino-ზე დაფუძნებული რობოტების მშენებლობაზე. კურსი განკუთვნილია დამწყებთათვის, არ არის საჭირო დამატებითი ინფორმაცია ელექტროტექნიკის ან რობოტიკის შესახებ.
მოკლე ინფორმაცია Arduino-ს შესახებ
რა არის Arduino?
Arduino (Arduino) არის აპარატურის გამოთვლითი პლატფორმა, რომლის ძირითადი კომპონენტებია შეყვანა-გამომავალი დაფა და განვითარების გარემო. Arduino შეიძლება გამოყენებულ იქნას დამოუკიდებელი ინტერაქტიული ობიექტების შესაქმნელად, ან კომპიუტერზე გაშვებულ პროგრამულ უზრუნველყოფასთან დასაკავშირებლად. Arduino არის ერთი დაფის კომპიუტერი.
როგორ არის დაკავშირებული Arduino და რობოტები?
პასუხი ძალიან მარტივია - Arduino ხშირად გამოიყენება როგორც რობოტის ტვინი.
Arduino-ს დაფების უპირატესობა მსგავს პლატფორმებთან შედარებით არის მათი შედარებით დაბალი ფასი და თითქმის ფართო განაწილება მოყვარულებსა და პროფესიონალებს შორის რობოტიკისა და ელექტროტექნიკის სფეროში. როგორც კი დაიწყებთ Arduino-ს, თქვენ იპოვით მხარდაჭერას ნებისმიერ ენაზე და თანამოაზრე ადამიანებს, რომლებიც უპასუხებენ თქვენს შეკითხვებს და განიხილავენ თქვენს განვითარებას.
გაკვეთილი 1. ციმციმ LED არდუინოზე
პირველ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ LED-ი Arduino-ს და აკონტროლოთ ის მოციმციმე. ეს არის ყველაზე მარტივი და ძირითადი მოდელი.
სინათლის დიოდი- ნახევარგამტარული მოწყობილობა, რომელიც ქმნის ოპტიკურ გამოსხივებას, როდესაც მასში ელექტრული დენი გადის წინა მიმართულებით.
გაკვეთილი 2. ღილაკის დაკავშირება Arduino-ზე
ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ ღილაკი და LED Arduino-ს.
ღილაკზე დაჭერისას LED აინთება, ხოლო ღილაკის დაჭერისას ის არ ანათებს. ეს ასევე საბაზისო მოდელია.
გაკვეთილი 3. პოტენციომეტრის დაკავშირება Arduino-ზე
ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ პოტენციომეტრი Arduino-სთან.
პოტენციომეტრი- ეს რეზისტორი რეგულირებადი წინააღმდეგობით.პოტენციომეტრები გამოიყენება როგორც სხვადასხვა პარამეტრის რეგულატორები - ხმის მოცულობა, სიმძლავრე, ძაბვა და ა.შ.ეს ასევე ერთ-ერთი ძირითადი სქემაა. ჩვენს მოდელში პოტენციომეტრის ღილაკის შემობრუნებისგანLED-ის სიკაშკაშე დამოკიდებული იქნება.
გაკვეთილი 4. სერვო კონტროლი Arduino-ზე
ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ სერვო Arduino-ს.
სერვოარის ძრავა, რომლის ლილვის პოზიციის კონტროლი შესაძლებელია ბრუნვის კუთხის დაყენებით.
სერვოები გამოიყენება რობოტების სხვადასხვა მექანიკური მოძრაობის სიმულაციისთვის.
გაკვეთილი 5. სამი ფერის LED Arduino-ზე
ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ სამი ფერის LED Arduino-ს.
სამფერი LED(rgb led) - ეს არის სამი LED სხვადასხვა ფერის ერთ კორპუსში. მათ მოყვება ან პატარა ბეჭდური მიკროსქემის დაფა, რომელზედაც განთავსებულია რეზისტორები, ან ჩაშენებული რეზისტორების გარეშე. გაკვეთილი მოიცავს ორივე ვარიანტს.
გაკვეთილი 6. პიეზოელექტრული ელემენტი არდუინოზე
ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ პიეზო ელემენტი Arduino-სთან.
პიეზო ელემენტი- ელექტრომექანიკური გადამყვანი, რომელიც ითარგმნებაელექტრული ძაბვა მემბრანის ვიბრაციაში. ეს ვიბრაციები ქმნის ხმას.
ჩვენს მოდელში ხმის სიხშირის კორექტირება შესაძლებელია პროგრამაში შესაბამისი პარამეტრების დაყენებით.
გაკვეთილი 7. ფოტორეზისტორი Arduino-ზე
ჩვენი კურსის ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ ფოტორეზისტორი Arduino-სთან.
ფოტორეზისტორი- რეზისტორი, რომლის წინააღმდეგობა დამოკიდებულია მასზე დაცემული სინათლის სიკაშკაშეზე.
ჩვენს მოდელში LED ანათებს მხოლოდ იმ შემთხვევაში, თუ ფოტორეზისტორის ზემოთ შუქის სიკაშკაშე გარკვეულზე ნაკლებია, ეს სიკაშკაშე შეიძლება დარეგულირდეს პროგრამაში.
გაკვეთილი 8. მოძრაობის სენსორი (PIR) Arduino-ზე. ელექტრონული ფოსტის ავტომატური გაგზავნა
ჩვენი კურსის ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ მოძრაობის სენსორი (PIR) Arduino-სთან, ასევე მოაწყოთ ელექტრონული ფოსტის ავტომატური გაგზავნა. 
მოძრაობის სენსორი (PIR)- ინფრაწითელი სენსორი ადამიანების ან ცხოველების მოძრაობის ან ყოფნის დასადგენად.
ჩვენს მოდელში, PIR სენსორიდან ადამიანის მოძრაობის შესახებ სიგნალის მიღებისას, Arduino აგზავნის ბრძანებას კომპიუტერში ელექტრონული ფოსტის გასაგზავნად და წერილი ავტომატურად იგზავნება.
გაკვეთილი 9. ტემპერატურისა და ტენიანობის სენსორის DHT11 ან DHT22 დაკავშირება
ჩვენს ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ DHT11 ან DHT22 ტემპერატურისა და ტენიანობის სენსორი Arduino-ს და ასევე გაეცნობით მათ მახასიათებლებს შორის განსხვავებებს. 
ტემპერატურის და ტენიანობის სენსორიარის კომპოზიციური ციფრული სენსორი, რომელიც შედგება ტენიანობის ტევადი სენსორისგან და ტემპერატურის გასაზომი თერმისტორისგან.
ჩვენს მოდელში, Arduino კითხულობს სენსორის კითხვას და აჩვენებს კითხვებს კომპიუტერის ეკრანზე.
გაკვეთილი 10. მატრიცული კლავიატურის დაკავშირება
ჩვენი კურსის ამ გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ მატრიცული კლავიატურა Arduino დაფაზე და ასევე გაეცნობით სხვადასხვა საინტერესო სქემებს.
მატრიქსის კლავიატურაგამოიგონეს დიდი რაოდენობით ღილაკების კავშირის გასამარტივებლად. ასეთი მოწყობილობები ყველგან გვხვდება - კომპიუტერის კლავიატურებში, კალკულატორებში და ა.შ.
გაკვეთილი 11. DS3231 რეალურ დროში საათის მოდულის დაკავშირება
ჩვენი კურსის ბოლო გაკვეთილზე თქვენ შეისწავლით თუ როგორ დააკავშიროთ რეალური დროის საათის მოდული ოჯახიდან 
DS Arduino-ს დაფაზე და ასევე გაეცანით სხვადასხვა საინტერესო სქემებს.
რეალური დროის საათის მოდული- ეს არის ელექტრონული წრე, რომელიც შექმნილია ქრონომეტრიული მონაცემების ჩასაწერად (მიმდინარე დრო, თარიღი, კვირის დღე და ა.შ.) და არის სისტემა, რომელიც შედგება ენერგიის ავტონომიური წყაროსა და ჩამწერი მოწყობილობისგან.
განაცხადი. მზა ჩარჩოები და არდუინოს რობოტები
თქვენ შეგიძლიათ დაიწყოთ არდუინოს სწავლა არა მხოლოდ თავად დაფიდან, არამედ ამ დაფაზე დაფუძნებული მზა, სრულფასოვანი რობოტის შეძენით - ობობის რობოტი, რობოტი მანქანა, კუს რობოტი და ა.შ. ასეთიგზა ის ასევე შესაფერისია მათთვის, ვისაც განსაკუთრებით არ იზიდავს ელექტრული სქემები.
სამუშაო რობოტის მოდელის შეძენით, ე.ი. სინამდვილეში, მზა მაღალტექნოლოგიური სათამაშოს შეუძლია გააღვიძოს ინტერესი დამოუკიდებელი დიზაინისა და რობოტიკის მიმართ. Arduino პლატფორმის გახსნილობა საშუალებას გაძლევთ შექმნათ ახალი სათამაშოები იგივე კომპონენტებისგან.
კიდევ ერთი ვარიანტია რობოტის ჩარჩოს ან სხეულის შეძენა: პლატფორმა ბორბლებზე ან ტრასაზე, ჰუმანოიდი, ობობა და ა.შ. ამ შემთხვევაში რობოტის შევსება თავად მოგიწევთ.
განაცხადი. მობილური დირექტორია
– ასისტენტი ალგორითმების შემქმნელებისთვის Arduino პლატფორმისთვის, რომლის მიზანია მისცეს საბოლოო მომხმარებელს შესაძლებლობა ჰქონდეს ბრძანებების მობილური ნაკრები (საცნობარო წიგნი).
აპლიკაცია შედგება 3 ძირითადი განყოფილებისგან:
- ოპერატორები;
- მონაცემები;
- ფუნქციები.
სად ვიყიდო Arduino
არდუინოს კომპლექტები
კურსი განახლდება დამატებითი გაკვეთილებით. Მოგვყევი
დღეს ვისაუბრებთ SD და micro SD ბარათების გამოყენებაზე Arduino-ში. ჩვენ გავარკვევთ, როგორ დავაკავშიროთ SD ბარათები Arduino-სთან, როგორ დავწეროთ და წაიკითხოთ ინფორმაცია. დამატებითი მეხსიერების გამოყენება შეიძლება ძალიან სასარგებლო იყოს ბევრ პროექტში. თუ არ იცით რა არის SPI, I2C და ანალოგური პინები, მაშინ გირჩევთ უყუროთ წარსულ გაკვეთილებს და გაიგოთ ეს Arduino საკომუნიკაციო ინტერფეისები.
ამ გაკვეთილში ვისაუბრებთ უსადენო კომუნიკაციაზე Arduino-ს ორ დაფას შორის. ეს შეიძლება იყოს ძალიან გამოსადეგი ბრძანებების გადასაცემად ერთი Arduino-დან მეორეზე, ან ინფორმაციის გაცვლისთვის თქვენს წვრილმანებს შორის. უკაბელო მონაცემთა გადაცემის შესაძლებლობა ხსნის ახალ შესაძლებლობებს თქვენი პროექტების შექმნისას.
ამ გაკვეთილზე ჩვენ გავეცნობით I2C ავტობუსს. I2C არის საკომუნიკაციო ავტობუსი, რომელიც იყენებს მხოლოდ ორ ხაზს. ამ ინტერფეისის გამოყენებით, Arduino-ს შეუძლია დაუკავშირდეს ბევრ მოწყობილობას ორი მავთულის საშუალებით. დღეს ჩვენ გავარკვევთ, თუ როგორ დავაკავშიროთ სენსორები Arduino-ს I2C ავტობუსის მეშვეობით, როგორ მივიღოთ წვდომა კონკრეტულ მოწყობილობაზე და როგორ მივიღოთ მონაცემები ამ მოწყობილობებიდან.
ამ გაკვეთილში ვისაუბრებთ Arduino Serial საკომუნიკაციო ინტერფეისზე. ჩვენ უკვე გამოვიყენეთ ეს ინტერფეისი წინა გაკვეთილებში, როდესაც კომპიუტერის ეკრანზე ვაჩვენეთ სენსორების მნიშვნელობები. დღეს ჩვენ უფრო დეტალურად განვიხილავთ, თუ როგორ მუშაობს ეს კავშირი და ასევე ვისწავლით როგორ გამოვიყენოთ კომპიუტერის პორტის მონიტორზე გადაცემული მონაცემები დამუშავების გამოყენებით.
დღეს ჩვენ ვისაუბრებთ ტრანზისტორებზე და არდუინოსთან დატვირთვების შეერთებაზე. თავად Arduino-ს არ შეუძლია გამოიმუშაოს 5 ვოლტზე მაღალი ძაბვა და 40 mA-ზე მაღალი დენი ერთი პინიდან. ეს საკმარისია სენსორებისა და LED-ებისთვის, მაგრამ თუ ჩვენ გვსურს უფრო მომთხოვნი მოწყობილობების დაკავშირება, ტრანზისტორების ან რელეების გამოყენება მოგვიწევს.
ამ გაკვეთილზე ვისაუბრებთ მიკროსქემის დიზაინის საფუძვლებზე, რომელიც გამოიყენება Arduino-ზე. და დავიწყოთ, რა თქმა უნდა, ოჰმის კანონით, რადგან ეს არის ყველა მიკროსქემის საფუძველი. ასევე ამ გაკვეთილზე ვისაუბრებთ წინაღობაზე, აწევის და აწევის რეზისტორებზე, დენის და ძაბვის გამოთვლაზე.
ამ სტატიაში გადავწყვიტე შემექმნა სრული ნაბიჯ-ნაბიჯ სახელმძღვანელო Arduino-ს დამწყებთათვის. ჩვენ გადავხედავთ რა არის Arduino, რა გჭირდებათ სწავლის დასაწყებად, სად უნდა ჩამოტვირთოთ და როგორ დააინსტალიროთ და დააკონფიგურიროთ პროგრამირების გარემო, როგორ მუშაობს და როგორ გამოვიყენოთ პროგრამირების ენა და ბევრი სხვა რამ, რაც აუცილებელია სრულფასოვანი შესაქმნელად კომპლექსური მოწყობილობები, რომლებიც დაფუძნებულია ამ მიკროკონტროლერების ოჯახზე.
აქ მე შევეცდები მოგცეთ შეკუმშული მინიმუმი, რათა გაიგოთ Arduino-სთან მუშაობის პრინციპები. პროგრამირებადი მიკროკონტროლერების სამყაროში უფრო სრულყოფილი ჩაძირვისთვის ყურადღება მიაქციეთ ამ საიტის სხვა განყოფილებებსა და სტატიებს. ზოგიერთი ასპექტის უფრო დეტალური შესწავლისთვის ამ საიტზე დავტოვებ ბმულებს სხვა მასალებზე.
რა არის Arduino და რისთვის არის ის?
Arduino არის ელექტრონული კონსტრუქციის ნაკრები, რომელიც ნებისმიერს საშუალებას აძლევს შექმნას სხვადასხვა ელექტრომექანიკური მოწყობილობა. Arduino შედგება პროგრამული უზრუნველყოფისა და ტექნიკისგან. პროგრამული უზრუნველყოფის ნაწილი მოიცავს დეველოპერულ გარემოს (პროგრამა firmware-ის ჩაწერისა და გამართვისთვის), ბევრ მზა და მოსახერხებელ ბიბლიოთეკას და გამარტივებულ პროგრამირების ენას. აპარატურა მოიცავს მიკროკონტროლერების დიდ ხაზს და მათთვის მზა მოდულებს. ამის წყალობით, Arduino-სთან მუშაობა ძალიან მარტივია!
Arduino-ს დახმარებით შეგიძლიათ ისწავლოთ პროგრამირება, ელექტროინჟინერია და მექანიკა. მაგრამ ეს არ არის მხოლოდ საგანმანათლებლო კონსტრუქტორი. მის საფუძველზე შეგიძლიათ შექმნათ მართლაც სასარგებლო მოწყობილობები.
დაწყებული მარტივი მოციმციმე განათებიდან, ამინდის სადგურებიდან, ავტომატიზაციის სისტემებით და დამთავრებული ჭკვიანი სახლის სისტემებით, CNC მანქანებით და უპილოტო საფრენი აპარატებით. შესაძლებლობები არც კი შემოიფარგლება თქვენი ფანტაზიით, რადგან არსებობს უამრავი ინსტრუქცია და იდეა განსახორციელებლად.
Arduino დამწყებ ნაკრები
იმისათვის, რომ დაიწყოთ Arduino-ს სწავლა, თქვენ უნდა შეიძინოთ თავად მიკროკონტროლერის დაფა და დამატებითი ნაწილები. უმჯობესია შეიძინოთ Arduino-ს დამწყებ ნაკრები, მაგრამ თქვენ შეგიძლიათ აირჩიოთ ყველაფერი, რაც გჭირდებათ. გირჩევ კომპლექტის არჩევას, რადგან ის უფრო მარტივი და ხშირად იაფია. აქ არის ბმულები საუკეთესო კომპლექტებისა და ცალკეული ნაწილების შესახებ, რომელთა შესწავლა აუცილებლად დაგჭირდებათ:
| ძირითადი Arduino ნაკრები დამწყებთათვის: | იყიდე |
| დიდი ნაკრები ტრენინგისა და პირველი პროექტებისთვის: | იყიდე |
| დამატებითი სენსორების და მოდულების ნაკრები: | იყიდე |
| Arduino Uno არის ყველაზე ძირითადი და მოსახერხებელი მოდელი ხაზიდან: | იყიდე |
| უსადუღო დაფა მარტივი სწავლისა და პროტოტიპისთვის: | იყიდე |
| სადენების ნაკრები მოსახერხებელი კონექტორებით: | იყიდე |
| LED კომპლექტი: | იყიდე |
| რეზისტორების ნაკრები: | იყიდე |
| ღილაკები: | იყიდე |
| პოტენციომეტრები: | იყიდე |
Arduino IDE განვითარების გარემო
იმისათვის, რომ ჩაწეროთ, გამართოთ და ჩამოტვირთოთ firmware, თქვენ უნდა ჩამოტვირთოთ და დააინსტალიროთ Arduino IDE. ეს არის ძალიან მარტივი და მოსახერხებელი პროგრამა. ჩემს ვებგვერდზე მე უკვე აღვწერე განვითარების გარემოს ჩამოტვირთვის, ინსტალაციისა და კონფიგურაციის პროცესი. ამიტომ, აქ მე უბრალოდ დავტოვებ ბმულებს პროგრამის უახლესი ვერსიისა და
| ვერსია | ფანჯრები | Mac OS X | Linux |
| 1.8.2 |
Arduino პროგრამირების ენა
როდესაც ხელში გაქვთ მიკროკონტროლერის დაფა და თქვენს კომპიუტერში დაინსტალირებული განვითარების გარემო, შეგიძლიათ დაიწყოთ თქვენი პირველი ესკიზების (firmware) წერა. ამისათვის თქვენ უნდა გაეცნოთ პროგრამირების ენას.
Arduino პროგრამირება იყენებს C++ ენის გამარტივებულ ვერსიას წინასწარ განსაზღვრული ფუნქციებით. როგორც C-ის მსგავს პროგრამირების ენებში, არსებობს კოდის დაწერის მთელი რიგი წესები. აქ არის ყველაზე ძირითადი:
- თითოეულ ინსტრუქციას უნდა მოჰყვეს მძიმით (;)
- ფუნქციის გამოცხადებამდე, თქვენ უნდა მიუთითოთ ფუნქციის მიერ დაბრუნებული მონაცემთა ტიპი, ან გაუქმდეს, თუ ფუნქცია არ დააბრუნებს მნიშვნელობას.
- ცვლადის გამოცხადებამდე ასევე აუცილებელია მონაცემთა ტიპის მითითება.
- კომენტარები მითითებულია: // Inline და /* ბლოკი */
თქვენ შეგიძლიათ მეტი შეიტყოთ მონაცემთა ტიპების, ფუნქციების, ცვლადების, ოპერატორების და ენის კონსტრუქციების შესახებ გვერდზე: თქვენ არ გჭირდებათ ამ ინფორმაციის დამახსოვრება და დამახსოვრება. თქვენ ყოველთვის შეგიძლიათ გადახვიდეთ საცნობარო წიგნში და დაათვალიეროთ კონკრეტული ფუნქციის სინტაქსი.
Arduino-ს ყველა firmware უნდა შეიცავდეს მინიმუმ 2 ფუნქციას. ეს არის setup() და loop().
დაყენების ფუნქცია
იმისათვის, რომ ყველაფერი იმუშაოს, ჩვენ უნდა დავწეროთ ესკიზი. მოდით გავანათოთ LED ღილაკის დაჭერის შემდეგ და გამოვიდეს შემდეგი დაჭერის შემდეგ. აქ არის ჩვენი პირველი ესკიზი:
// ცვლადები დაკავშირებული მოწყობილობების ქინძისთავებით int switchPin = 8; int ledPin = 11; // ცვლადები ღილაკის მდგომარეობის შესანახად და LED ლოგიკური ბოლოButton = LOW; ლოგიკური მიმდინარე ღილაკი = LOW; ლოგიკური ledOn = ყალბი; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); ) // ფუნქცია ლოგიკური debounse (ბოლური ბოლო) (ლოგიკური დენი = digitalRead(switchPin); if(last != მიმდინარე) ( დაგვიანებით ( 5 მიმდინარე = digitalRead(switchPin) დაბრუნების დენი ) void loop() (currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) (ledOn = !ledOn; ) lastButton = currentButton ; (ledPin, ledOn);
// ცვლადები დაკავშირებული მოწყობილობების ქინძისთავებით int switchPin = 8; int ledPin = 11; // ცვლადები ღილაკის და LED მდგომარეობის შესანახად ლოგიკური lastButton = LOW ; ლოგიკური მიმდინარე ღილაკი = LOW ; ლოგიკური ledOn = ყალბი; void setup() ( pinMode (switchPin, INPUT); pinMode (ledPin, OUTPUT); // ფუნქცია debouncing ლოგიკური დებოუნსი (ლოგიკური ბოლო) ( ლოგიკური დენი = digitalRead(switchPin); თუ (ბოლო != მიმდინარე) ( დაგვიანებით(5); მიმდინარე = ციფრული წაკითხვა (switchPin); დაბრუნების დენი ; void loop() ( currentButton = debounse(lastButton); თუ (ბოლო ღილაკი == დაბალი && მიმდინარე ღილაკი == მაღალი) ( ledOn = ! ledOn; lastButton = currentButton ; digitalWrite (ledPin, ledOn); |
ამ ჩანახატში მე შევქმენი დამატებითი დებოუნსის ფუნქცია კონტაქტის აბრუნის ჩასახშობად. ჩემს ვებსაიტზე არის ინფორმაცია კონტაქტის დაბრუნების შესახებ. დარწმუნდით, რომ შეამოწმეთ ეს მასალა.
PWM Arduino
პულსის სიგანის მოდულაცია (PWM) არის ძაბვის კონტროლის პროცესი სიგნალის სამუშაო ციკლის გამოყენებით. ანუ PWM-ის გამოყენებით ჩვენ შეგვიძლია შეუფერხებლად გავაკონტროლოთ დატვირთვა. მაგალითად, შეგიძლიათ შეუფერხებლად შეცვალოთ LED- ის სიკაშკაშე, მაგრამ სიკაშკაშის ეს ცვლილება მიიღება არა ძაბვის შემცირებით, არამედ დაბალი სიგნალის ინტერვალების გაზრდით. PWM-ის მუშაობის პრინციპი ნაჩვენებია ამ დიაგრამაში:
როდესაც LED-ზე ვსვამთ PWM-ს, ის იწყებს სწრაფად ანთებას და ჩაქრობას. ადამიანის თვალი ამას ვერ ხედავს, რადგან სიხშირე ძალიან მაღალია. მაგრამ ვიდეოს გადაღებისას, დიდი ალბათობით, ნახავთ მომენტებს, როდესაც LED არ არის ანთებული. ეს მოხდება იმ პირობით, რომ კამერის კადრების სიხშირე არ არის PWM სიხშირის ჯერადი.
Arduino-ს აქვს ჩაშენებული პულსის სიგანის მოდულატორი. თქვენ შეგიძლიათ გამოიყენოთ PWM მხოლოდ იმ ქინძისთავებზე, რომლებსაც აქვთ მიკროკონტროლერი. მაგალითად, Arduino Uno-ს და Nano-ს აქვს 6 PWM პინი: ეს არის ქინძისთავები D3, D5, D6, D9, D10 და D11. ქინძისთავები შეიძლება განსხვავდებოდეს სხვა დაფებზე. თქვენ შეგიძლიათ იპოვოთ თქვენთვის საინტერესო დაფის აღწერა
PWM-ის გამოსაყენებლად Arduino-ში არის ფუნქცია, რომელიც არგუმენტად იღებს პინის ნომერს და PWM მნიშვნელობას 0-დან 255-მდე. 0 არის 0% შევსება მაღალი სიგნალით, ხოლო 255 არის 100%. მაგალითის სახით დავწეროთ მარტივი ესკიზი. მოდით, LED განათდეს შეუფერხებლად, დაველოდოთ ერთი წამი და გაქრება ისევე შეუფერხებლად და ასე უსასრულოდ. აქ მოცემულია ამ ფუნქციის გამოყენების მაგალითი:
// LED უკავშირდება pin 11 int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( for (int i = 0; i< 255; i++) { analogWrite(ledPin, i); delay(5); } delay(1000); for (int i = 255; i >0; i--) (ანალოგური ჩაწერა (ledPin, i); დაყოვნება (5); ) )
// LED დაკავშირებულია პინ 11-თან int ledPin = 11; void setup() ( pinMode (ledPin, OUTPUT); void loop() ( for (int i = 0; i< 255 ; i ++ ) { analogWrite(ledPin, i); დაგვიანებით(5); დაგვიანებით (1000); for (int i = 255; i > 0; i -- ) ( |
ეს სიმულატორი საუკეთესოდ მუშაობს Chrome ბრაუზერზე
მოდით უფრო ახლოს მივხედოთ Arduino-ს.
Arduino არ არის დიდი კომპიუტერი, რომელიც შეიძლება დაკავშირებული იყოს გარე სქემებთან. Arduino Uno იყენებს Atmega 328P
ეს არის ყველაზე დიდი ჩიპი დაფაზე. ეს ჩიპი ახორციელებს პროგრამებს, რომლებიც ინახება მის მეხსიერებაში. შეგიძლიათ ჩამოტვირთოთ პროგრამა usb-ის საშუალებით Arduino IDE-ის გამოყენებით. USB პორტი ასევე უზრუნველყოფს არდუინოს ენერგიას.
არის ცალკე დენის კონექტორი. დაფას აქვს ორი ქინძისთავები 5v და 3.3v, რომლებიც საჭიროა სხვადასხვა მოწყობილობების კვებისათვის. თქვენ ასევე იპოვით ქინძისთავებს, რომლებიც აღინიშნება GND, ეს არის გრუნტის ქინძისთავები (დამიწება არის 0V). Arduino პლატფორმას ასევე აქვს 14 ციფრული პინი, ეტიკეტირებული 0-დან 13-მდე, რომლებიც უკავშირდებიან გარე კვანძებს და აქვთ ორი მდგომარეობა, მაღალი ან დაბალი (ჩართული ან გამორთული). ამ კონტაქტებს შეუძლიათ იმუშაონ როგორც გამომავალი ან შეყვანის სახით, ე.ი. მათ შეუძლიათ ან გადასცენ გარკვეული მონაცემები და გააკონტროლონ გარე მოწყობილობები, ან მიიღონ მონაცემები მოწყობილობებიდან. დაფაზე შემდეგი ქინძისთავები ეტიკეტირებულია A0-A5. ეს არის ანალოგური შეყვანები, რომლებსაც შეუძლიათ მიიღონ მონაცემები სხვადასხვა სენსორებისგან. ეს განსაკუთრებით მოსახერხებელია, როდესაც საჭიროა გარკვეული დიაპაზონის გაზომვა, როგორიცაა ტემპერატურა. ანალოგურ შეყვანას აქვს დამატებითი ფუნქციები, რომლებიც შეიძლება ცალკე ჩართოთ.
როგორ გამოვიყენოთ განვითარების დაფა.
პურის დაფა საჭიროა ნაწილების დროებით დასაკავშირებლად, შეამოწმეთ როგორ მუშაობს მოწყობილობა, სანამ ყველაფერს შეაერთებთ.
ყველა შემდეგი მაგალითი აწყობილია პურის დაფაზე, რათა სწრაფად შეიტანოთ ცვლილებები წრედში და ხელახლა გამოიყენოთ ნაწილები შედუღების შეწუხების გარეშე.
პურის დაფას აქვს ხვრელების რიგები, რომლებშიც შეგიძლიათ ჩადოთ ნაწილები და მავთულები. ამ ხვრელების ზოგიერთი ნაწილი ერთმანეთთან ელექტრონულად არის დაკავშირებული.
ორი ზედა და ქვედა რიგები დაკავშირებულია რიგებში მთელი დაფის გასწვრივ. ეს რიგები გამოიყენება მიკროსქემის ელექტრომომარაგებისთვის. ეს შეიძლება იყოს 5V ან 3.3V, მაგრამ ნებისმიერ შემთხვევაში, პირველი რაც უნდა გააკეთოთ არის 5V და GND დაფაზე, როგორც ნაჩვენებია სურათზე. ზოგჯერ ეს მწკრივი კავშირები შეიძლება დაირღვეს დაფის შუაში, შემდეგ თუ დაგჭირდებათ, შეგიძლიათ დააკავშიროთ ისინი, როგორც ნაჩვენებია სურათზე.
დარჩენილი ხვრელები, რომლებიც მდებარეობს დაფის შუაში, დაჯგუფებულია ხუთ ხვრელების ჯგუფებად. ისინი გამოიყენება მიკროსქემის ნაწილების დასაკავშირებლად.
პირველი, რასაც ჩვენ დავუკავშირებთ ჩვენს მიკროკონტროლერს, არის LED. ელექტრო კავშირის დიაგრამა ნაჩვენებია სურათზე.
რატომ არის საჭირო რეზისტორი წრეში? ამ შემთხვევაში, ის ზღუდავს დენს, რომელიც გადის LED- ში. თითოეული LED განკუთვნილია გარკვეული დენისთვის და თუ ეს დენი უფრო მაღალია, LED მარცხდება. თქვენ შეგიძლიათ გაიგოთ რა მნიშვნელობა უნდა ჰქონდეს რეზისტორის ოჰმის კანონის გამოყენებით. მათთვის, ვინც არ იცის ან დაავიწყდა, ოჰმის კანონი ამბობს, რომ არსებობს ხაზოვანი კავშირი დენსა და ძაბვას შორის. ანუ რაც მეტ ძაბვას მივმართავთ რეზისტორს მით მეტი დენი გაივლის მასში.
V=I*R
სად ვ- ძაბვა რეზისტორზე
მე- დენი რეზისტორის მეშვეობით
რ- წინააღმდეგობა, რომელიც უნდა მოიძებნოს.
პირველ რიგში, ჩვენ უნდა გავარკვიოთ ძაბვა რეზისტორზე. 3 მმ ან 5 მმ LED-ების უმეტესობას, რომელსაც თქვენ გამოიყენებთ, აქვთ 3 ვოლტიანი სამუშაო ძაბვა. ეს ნიშნავს, რომ რეზისტორზე უნდა ჩავაქროთ 5-3 = 2 ვ.
შემდეგ ჩვენ გამოვთვლით რეზისტორში გამავალ დენს.
3 მმ და 5 მმ LED-ების უმეტესობა ანათებს სრული სიკაშკაშით 20 mA-ზე. ამაზე დიდ დენს შეუძლია გამორთოს ისინი, ხოლო ნაკლები ინტენსივობის დენი შეამცირებს მათ სიკაშკაშეს ზიანის მიყენების გარეშე.
ასე რომ, ჩვენ გვინდა დავაკავშიროთ LED 5V წრედს ისე, რომ იგი ატარებს დენს 20 mA. ვინაიდან ყველა ნაწილი შედის ერთ წრეში, რეზისტორს ასევე ექნება დენი 20 mA.
ვიღებთ
2V = 20 mA * R
2V = 0.02A * R
R = 100 Ohm
100 Ohms არის მინიმალური წინააღმდეგობა, უმჯობესია გამოიყენოთ ცოტა მეტი, რადგან LED- ებს აქვთ მახასიათებლების გარკვეული ცვალებადობა.
ამ მაგალითში გამოყენებულია 220 Ohm რეზისტორი. მხოლოდ იმიტომ, რომ ავტორს ბევრი აქვს: wink: .
ჩადეთ LED დაფის შუა ხვრელებში ისე, რომ მისი გრძელი კაბელი იყოს დაკავშირებული რეზისტორის ერთ-ერთ მილს. შეაერთეთ რეზისტორის მეორე ბოლო 5 ვ-ზე და შეაერთეთ LED-ის მეორე კაბელი GND-ზე. LED უნდა აანთოს.
გთხოვთ, გაითვალისწინოთ, რომ LED-ის დაკავშირებისას განსხვავებაა. დენი მიედინება გრძელი ტერმინალიდან მოკლეზე. დიაგრამაში შეგიძლიათ წარმოიდგინოთ, რომ დენი მიედინება იმ მიმართულებით, სადაც მიმართულია სამკუთხედი. სცადეთ შუქდიოდური ნათურა თავდაყირა დაატრიალოთ და დაინახავთ რომ არ აინთება.
მაგრამ როგორ დააკავშირებთ რეზისტორს, არავითარი განსხვავება არ არის. შეგიძლიათ გადააბრუნოთ ან სცადოთ მისი დაკავშირება LED-ის სხვა პინთან, ეს არ იმოქმედებს მიკროსქემის მუშაობაზე. ის მაინც შეზღუდავს დენს LED-ის მეშვეობით.
არდუინოს ესკიზის ანატომია.
პროგრამებს Arduino-სთვის ეწოდება ესკიზი. ისინი შედგება ორი ძირითადი ფუნქციისგან. ფუნქცია აწყობადა ფუნქცია მარყუჟი
ამ ფუნქციის შიგნით თქვენ დააყენებთ ყველა ძირითად პარამეტრს. რომელი ქინძისთავები იმუშავებს როგორც შემავალი ან გამომავალი, რომელ ბიბლიოთეკებს დააკავშირებს, ცვლადების ინიციალიზაციას. ფუნქცია Აწყობა()მუშაობს მხოლოდ ერთხელ ესკიზის დროს, როდესაც იწყება პროგრამის შესრულება.
ეს არის მთავარი ფუნქცია, რომელიც შესრულებულია შემდეგ აწყობა(). სინამდვილეში, ეს არის თავად პროგრამა. ეს ფუნქცია იმუშავებს განუსაზღვრელი ვადით, სანამ არ გამორთავთ დენს.
Arduino მოციმციმე LED
ამ მაგალითში ჩვენ დავაკავშირებთ LED წრეს Arduino-ს ერთ-ერთ ციფრულ პინს და ჩავრთავთ და გამორთავთ მას პროგრამის გამოყენებით და თქვენ ასევე შეისწავლით რამდენიმე სასარგებლო ფუნქციას.
ეს ფუნქცია გამოიყენება აწყობა()პროგრამის ნაწილია და ემსახურება ქინძისთავების ინიციალიზაციას, რომლებსაც გამოიყენებთ შეყვანად (INPUT)ან გასასვლელი (გამომავალი). თქვენ ვერ შეძლებთ მონაცემების წაკითხვას ან ჩაწერას პინიდან, სანამ არ დააყენებთ მას შესაბამისად pinMode. ამ ფუნქციას აქვს ორი არგუმენტი: პინ კოდიარის პინის ნომერი, რომელსაც გამოიყენებთ.
რეჟიმი- ადგენს, თუ როგორ იმუშავებს პინი. Შესასვლელთან (INPUT)ან გასასვლელი (გამომავალი). LED-ის გასანათებლად უნდა მივცეთ სიგნალი FROMარდუინო. ამისათვის ჩვენ ვაკონფიგურირებთ გამომავალი პინი.
- ეს ფუნქცია გამოიყენება მდგომარეობის დასაყენებლად (სახელმწიფო)პინა (პინ კოდი). არსებობს ორი ძირითადი სახელმწიფო (რეალურად 3 მათგანი), ერთი არის მაღალი, პინზე იქნება 5V, ეს სხვა რამეა დაბალიდა პინი იქნება 0 ვ. ეს ნიშნავს, რომ LED-ის გასანათებლად საჭიროა LED-თან დაკავშირებული პინი დავაყენოთ მაღალ დონეზე მაღალი.
დაგვიანება. ემსახურება პროგრამის მოქმედების შეფერხებას msec-ში მითითებული პერიოდით.
ქვემოთ მოცემულია კოდი, რომელიც აქცევს LED-ს ციმციმს.
//LED Blink int ledPin = 7;//Arduino პინი, რომელზეც LED არის დაკავშირებული void setup() ( pinMode(ledPin, OUTPUT);// pin-ის დაყენება როგორც OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// ჩართეთ LED დაყოვნება (1000);// დაყოვნება 1000 ms (1 წმ) ციფრული ჩაწერა (ledPin, LOW);// გამორთეთ LED დაყოვნება (1000);// დაელოდეთ 1 წმ)
მცირე განმარტებები კოდზე.
ხაზები, რომლებიც იწყება "//"-ით არის კომენტარები და არდუინო იგნორირებულია.
ყველა ბრძანება მთავრდება მძიმით, თუ ისინი დაივიწყებთ, თქვენ მიიღებთ შეცდომის შეტყობინებას.
ledPinარის ცვლადი. ცვლადები გამოიყენება პროგრამებში მნიშვნელობების შესანახად. ამ მაგალითში ცვლადი ledPinმნიშვნელობა ენიჭება 7-ს, ეს არის Arduino პინის ნომერი. როდესაც Arduino პროგრამა ხვდება ცვლადის მქონე ხაზს ledPin, ის გამოიყენებს ჩვენ მიერ ადრე მითითებულ მნიშვნელობას.
ასე რომ ჩაწერეთ pinMode (ledPin, OUTPUT)ჩაწერის მსგავსი pinMode (7, OUTPUT).
მაგრამ პირველ შემთხვევაში, თქვენ უბრალოდ უნდა შეცვალოთ ცვლადი და ის შეიცვლება თითოეულ სტრიქონში, სადაც ის გამოიყენება, ხოლო მეორე შემთხვევაში, ცვლადის შესაცვლელად, თქვენ უნდა გააკეთოთ ცვლილებები ხელით თითოეულ ბრძანებაში.
პირველი ხაზი მიუთითებს ცვლადის ტიპზე. Arduino-ს პროგრამირებისას მნიშვნელოვანია ყოველთვის გამოაცხადოთ ცვლადების ტიპი. ჯერ-ჯერობით საკმარისია ამის ცოდნა INTაცხადებს უარყოფით და დადებით რიცხვებს.
ქვემოთ მოცემულია ესკიზის სიმულაცია. დააწკაპუნეთ დაწყებაზე, რომ ნახოთ წრე მოქმედებაში.
როგორც მოსალოდნელი იყო, LED გამოდის და ერთი წამის შემდეგ ისევ ჩართულია. სცადეთ შეცვალოთ დაყოვნება, რომ ნახოთ როგორ მუშაობს.
მრავალი LED-ის კონტროლი.
ამ მაგალითში თქვენ შეისწავლით თუ როგორ მართოთ მრავალი LED-ები. ამისათვის დააინსტალირეთ კიდევ 3 LED დაფაზე და დააკავშირეთ ისინი რეზისტორებსა და Arduino ქინძისთავებს, როგორც ეს ნაჩვენებია ქვემოთ.
იმისათვის, რომ LED-ები სათითაოდ ჩართოთ და გამორთოთ, თქვენ უნდა დაწეროთ მსგავსი პროგრამა:
//Multi LED Blink int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() ( //დააყენეთ ქინძისთავები როგორც OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH );// LED-ის დაყოვნების ჩართვა (1000);//დაყოვნება 1 წმ ციფრული ჩაწერა (led1Pin, LOW);//გამორთეთ LED დაყოვნება(1000);//დაყოვნება 1 წმ //იგივე გააკეთეთ დანარჩენი 3-ისთვის LED-ები ციფრული ჩაწერა (led2Pin , HIGH);// LED-ის დაყოვნება (1000);//დაყოვნება 1 წმ ციფრული ჩაწერა (led2Pin, LOW);//ჩაქრება LED დაყოვნება(1000);//დაყოვნება 1 წმ DigitalWrite(led3Pin, HIGH );// LED დაყოვნების აანთება (1000);// დაყოვნება 1 წმ ციფრული ჩაწერა (led3Pin, LOW);// ჩაქრება LED დაყოვნება (1000);//დაყოვნება 1 წმ ციფრული ჩაწერა (led4Pin, HIGH);//ჩართეთ LED დაყოვნება (1000);// დაყოვნება 1 წმ ციფრული ჩაწერა (led4Pin, LOW);//ჩაქრობა LED დაყოვნება (1000);//დაყოვნება 1 წმ)
ეს პროგრამა მშვენივრად იმუშავებს, მაგრამ ეს არ არის ყველაზე რაციონალური გამოსავალი. კოდი უნდა შეიცვალოს. იმისათვის, რომ პროგრამამ განმეორებით იმუშაოს, ჩვენ გამოვიყენებთ კონსტრუქციას სახელწოდებით.
მარყუჟები სასარგებლოა, როდესაც ერთი და იგივე მოქმედების რამდენჯერმე გამეორება გჭირდებათ. ზემოთ მოცემულ კოდში ჩვენ ვიმეორებთ ხაზებს
DigitalWrite (led4Pin, HIGH); დაგვიანებით (1000); digitalWrite (led4Pin, LOW); დაგვიანებით (1000);
სრული ესკიზის კოდი დანართში (ჩამოტვირთვები: 1260)
LED სიკაშკაშის რეგულირება
ზოგჯერ დაგჭირდებათ პროგრამაში LED-ების სიკაშკაშის შეცვლა. ეს შეიძლება გაკეთდეს ბრძანების გამოყენებით analogWrite()
. ეს ბრძანება რთავს და გამორთავს LED-ს ისე სწრაფად, რომ თვალი ვერ ხედავს ციმციმს. თუ LED ჩართულია ნახევარ დროს და გამორთულია ნახევარ დროს, ვიზუალურად გამოჩნდება, რომ ის ანათებს თავისი სიკაშკაშის ნახევარზე. ამას ეწოდება პულსის სიგანის მოდულაცია (ინგლისურად PWM ან PWM). Shim საკმაოდ ხშირად გამოიყენება, რადგან ის შეიძლება გამოყენებულ იქნას "ანალოგური" კომპონენტის გასაკონტროლებლად ციფრული კოდის გამოყენებით. Arduino-ს ყველა პინი არ არის შესაფერისი ამ მიზნებისათვის. მხოლოდ ის დასკვნები, რომლებთანაც არის ასეთი აღნიშვნა " ~
თქვენ დაინახავთ მას 3,5,6,9,10,11 ქინძისთავის გვერდით.
შეაერთეთ თქვენი LED-ები ერთ-ერთ PWM ქინძისთავთან (ავტორისთვის ეს არის პინი 9). ახლა გაუშვით LED მოციმციმე ესკიზი, მაგრამ ჯერ შეცვალეთ ბრძანება ციფრული ჩაწერა () on analogWrite(). analogWrite()აქვს ორი არგუმენტი: პირველი არის პინის ნომერი, ხოლო მეორე არის PWM მნიშვნელობა (0-255), LED-ებთან მიმართებაში ეს იქნება მათი სიკაშკაშე, ხოლო ელექტროძრავებისთვის ბრუნვის სიჩქარე. ქვემოთ მოცემულია კოდის მაგალითი სხვადასხვა LED სიკაშკაშისთვის.
//შეცვალეთ LED-ის სიკაშკაშე int ledPin = 9;// LED არის დაკავშირებული ამ pin void setup() ( pinMode(ledPin, OUTPUT);// pin-ის ინიციალიზაცია გამოსავალზე ) void loop() ( analogWrite( ledPin, 255);// სრული სიკაშკაშე (255/255 = 1) დაყოვნება (1000);//პაუზა 1 წმ ციფრული ჩაწერა (ledPin, LOW);// გამორთეთ LED დაყოვნება (1000);//პაუზა 1 წმ analogWrite( ledPin, 191);//სიკაშკაშე 3/4 (191/255 ~= 0.75) დაგვიანებით (1000);//პაუზა 1 წმ ციფრული ჩაწერა (ledPin, LOW);// გამორთეთ LED დაყოვნება (1000);// პაუზა 1 წმ. ანალოგური ჩაწერა (ledPin, 127 //ნახევარი სიკაშკაშე (127/255 ~= 0.5) დაყოვნება (1000);//პაუზა 1 წამი ციფრული ჩაწერა (ledPin, LOW);//გამორთეთ LED დაყოვნება (1000);/ /პაუზა 1 წმ analogWrite(ledPin, 63 //Quarter სიკაშკაშე (63/255 ~= 0.25) delay(1000);//pause 1 sec digitalWrite(ledPin, LOW);//გამორთეთ LED დაყოვნება(1000) ;//პაუზა 1 წმ)
სცადეთ შეცვალოთ PWM მნიშვნელობა ბრძანებაში analogWrite()რომ ნახოთ, როგორ მოქმედებს ეს სიკაშკაშეზე.
შემდეგი, თქვენ შეისწავლით თუ როგორ შეუფერხებლად დაარეგულიროთ სიკაშკაშე სრულიდან ნულამდე. თქვენ, რა თქმა უნდა, შეგიძლიათ დააკოპიროთ კოდის ნაწილი 255-ჯერ
analogWrite (ledPin, სიკაშკაშე); დაგვიანებით(5);//მოკლე დაყოვნების სიკაშკაშე = სიკაშკაშე + 1;
მაგრამ, გესმით, ეს არ იქნება პრაქტიკული. ამის საუკეთესო გზა არის FOR მარყუჟის გამოყენება, რომელიც ადრე ვიყენებდით.
შემდეგი მაგალითი იყენებს ორ მარყუჟს, ერთი სიკაშკაშის შესამცირებლად 255-დან 0-მდე
for (int სიკაშკაშე = 0; სიკაშკაშე = 0; სიკაშკაშე--) (ანალოგური ჩაწერა (ledPin, სიკაშკაშე); დაყოვნება (5); )
დაგვიანებით (5)გამოიყენება სიკაშკაშის გაქრობის სიჩქარის შესანელებლად 5*256=1280ms=1.28s)
პირველი ხაზი იყენებს " სიკაშკაშე -იმისათვის, რომ სიკაშკაშის მნიშვნელობა შემცირდეს 1-ით ყოველ ჯერზე, როდესაც ციკლი განმეორდება. გაითვალისწინეთ, რომ ციკლი იმუშავებს მანამ, სანამ სიკაშკაშე >=0.ნიშნის გამოცვლა >
ნიშანზე >=
ჩვენ შევიტანეთ 0 სიკაშკაშის დიაპაზონში. ეს ესკიზი მოდელირებულია ქვემოთ. // შეუფერხებლად შეცვალეთ სიკაშკაშე int ledPin = 9;// LED არის დაკავშირებული ამ pin void setup() ( pinMode(ledPin, OUTPUT);// გამომავალი პინის ინიციალიზაცია) void loop() ( // შეუფერხებლად გაზარდეთ სიკაშკაშე (0-დან 255-მდე) (int სიკაშკაშე = 0; სიკაშკაშე = 0; სიკაშკაშე--) (ანალოგური ჩაწერა (ledPin, სიკაშკაშე); დაყოვნება (5); ) დაყოვნება (1000);//მოიცადეთ 1 წმ // შეუფერხებლად შეამცირეთ სიკაშკაშე (255-დან 0-მდე) (int სიკაშკაშე = 255; სიკაშკაშე>=0; სიკაშკაშე--) (ანალოგური ჩაწერა (ledPin, სიკაშკაშე); დაყოვნება (5); ) დაყოვნება (1000);//დაელოდეთ 1 წმ) )
ეს არ არის ძალიან თვალსაჩინო, მაგრამ იდეა ნათელია.
RGB LED და Arduino
RGB LED არის სინამდვილეში სამი სხვადასხვა ფერის LED ერთ პაკეტში.
სხვადასხვა სიკაშკაშის მქონე LED-ების ჩათვლით, შეგიძლიათ დააკავშიროთ ისინი სხვადასხვა ფერის შესაქმნელად. Arduino-სთვის, სადაც სიკაშკაშის დონეების რაოდენობაა 256, მიიღებთ 256^3=16581375 შესაძლო ფერს. სინამდვილეში, რა თქმა უნდა, ისინი ნაკლები იქნება.
LED, რომელსაც ჩვენ გამოვიყენებთ, არის საერთო კათოდი. იმათ. სამივე LED სტრუქტურულად დაკავშირებულია კათოდებით ერთ ტერმინალთან. ჩვენ დავაკავშირებთ ამ პინს GND პინს. დარჩენილი ქინძისთავები, შემზღუდველი რეზისტორების მეშვეობით, უნდა იყოს დაკავშირებული PWM ქინძისთავებთან. ავტორმა გამოიყენა ქინძისთავები 9-11 ამ გზით შესაძლებელი იქნება თითოეული LED-ის ცალ-ცალკე კონტროლი. პირველი ესკიზი გვიჩვენებს, თუ როგორ უნდა ჩართოთ თითოეული LED ინდივიდუალურად.
//RGB LED - ტესტი //პინი კავშირები int red = 9; int green = 10; int blue = 11; void setup())( pinMode(წითელი, OUTPUT); pinMode(ლურჯი, OUTPUT); pinMode(მწვანე, OUTPUT); ) void loop())( //ჩართეთ/გამორთეთ წითელი LED digitalWrite(წითელი, HIGH); დაყოვნება(500) ციფრული ჩაწერა(წითელი, LOW) HIGH DigitalWrite (ლურჯი, დაბალი);
შემდეგი მაგალითი იყენებს ბრძანებებს analogWrite()და მიიღოთ სხვადასხვა შემთხვევითი სიკაშკაშის მნიშვნელობები LED-ებისთვის. თქვენ ნახავთ, რომ სხვადასხვა ფერები იცვლება შემთხვევით.
//RGB LED - შემთხვევითი ფერები //pin კავშირები int red = 9; int green = 10; int blue = 11; void setup())( pinMode(წითელი, OUTPUT); pinMode(ლურჯი, OUTPUT); pinMode(მწვანე, OUTPUT); ) void loop())( //აირჩიე შემთხვევითი ფერის ანალოგიWrite(წითელი, შემთხვევითი(256)); analogWrite(ლურჯი, შემთხვევითი(256));
შემთხვევითი (256)-აბრუნებს შემთხვევით რიცხვს 0-დან 255-მდე დიაპაზონში.
თანდართულ ფაილში არის ესკიზი, რომელიც აჩვენებს გლუვი ფერის გადასვლებს წითელიდან მწვანეზე, შემდეგ ლურჯზე, წითელზე, მწვანეზე და ა.შ. (ჩამოტვირთვები: 348)
ესკიზის მაგალითი მუშაობს, მაგრამ ბევრი დუბლიკატი კოდია. თქვენ შეგიძლიათ გაამარტივოთ კოდი საკუთარი დამხმარე ფუნქციის დაწერით, რომელიც შეუფერხებლად შეიცვლება ერთი ფერიდან მეორეზე.
აი, როგორ გამოიყურება: (ჩამოტვირთვები: 385)
მოდით შევხედოთ ფუნქციის განსაზღვრას ნაწილ-ნაწილ. ფუნქციას ეძახიან ფადერიდა აქვს ორი არგუმენტი. თითოეული არგუმენტი გამოყოფილია მძიმით და აქვს ფუნქციის განსაზღვრის პირველ სტრიქონზე გამოცხადებული ტიპი: void fader (int color1, int color2). თქვენ ხედავთ, რომ ორივე არგუმენტი გამოცხადებულია როგორც ინტდა მათ სახელებს აძლევენ ფერი 1და ფერი 2როგორც პირობის ცვლადები ფუნქციის განსაზღვრისთვის. ბათილადნიშნავს, რომ ფუნქცია არ აბრუნებს რაიმე მნიშვნელობას, ის უბრალოდ ახორციელებს ბრძანებებს. თუ თქვენ უნდა დაწეროთ ფუნქცია, რომელიც დააბრუნებს გამრავლების შედეგს, ის ასე გამოიყურება:
int მულტიპლიკატორი (int ნომერი1, int ნომერი2) (int პროდუქტი = ნომერი1*number2; დაბრუნების პროდუქტი; )
დააკვირდით, როგორ გამოვაცხადეთ ტიპი ინტროგორც დაბრუნების ტიპი
ბათილად.
ფუნქციის შიგნით არის ბრძანებები, რომლებიც უკვე გამოიყენეთ წინა ესკიზში, მხოლოდ პინის ნომრები შეიცვალა ფერი 1და ფერი 2. ფუნქციას ეძახიან ფადერი, მისი არგუმენტები გამოითვლება როგორც ფერი 1 = წითელიდა ფერი 2 = მწვანე. არქივი შეიცავს სრულ ჩანახატს ფუნქციების გამოყენებით (ჩამოტვირთვები: 288)
ღილაკი
შემდეგი ესკიზი გამოიყენებს ღილაკს ჩვეულებრივ ღია კონტაქტებით, ჩაკეტვის გარეშე.
ეს ნიშნავს, რომ სანამ ღილაკი არ არის დაჭერილი, მასში დენი არ გადის და გათავისუფლების შემდეგ ღილაკი უბრუნდება თავდაპირველ პოზიციას.
ღილაკის გარდა, წრე იყენებს რეზისტორს. ამ შემთხვევაში, ის არ ზღუდავს დენს, მაგრამ "იყვანს" ღილაკს 0V-მდე (GND). იმათ. სანამ ღილაკს არ დააჭერთ, არდუინოს პინი, რომელზედაც ის არის დაკავშირებული, იკლებს. წრედში გამოყენებული რეზისტორი არის 10 kOhm.
//დაადგენს როდის დაჭერით ღილაკს int buttonPin = 7; void setup())( pinMode(buttonPin, INPUT);//პინის დაწყების დაწყება Serial.begin(9600);//სერიული პორტის დაწყება) void loop())( if (digitalRead(buttonPin)==HIGH )(//თუ ღილაკზეა დაჭერილი Serial.println("დაჭერილი"); // წარწერის ჩვენება "დაჭერილია") სხვას ( Serial.println("დაჭერილი");// წინააღმდეგ შემთხვევაში "დააჭირეს") )
ამ ესკიზში არის რამდენიმე ახალი ბრძანება.
-ეს ბრძანება იღებს მაღალი და დაბალი მნიშვნელობების გამომავალს, რომელსაც ჩვენ ვამოწმებთ. ეს გამომავალი ჯერ უნდა იყოს კონფიგურირებული, როგორც შეყვანა setup().
; //where buttonPin არის პინის ნომერი, სადაც ღილაკი არის დაკავშირებული.
სერიული პორტი საშუალებას აძლევს Arduino-ს გაუგზავნოს შეტყობინებები კომპიუტერში, სანამ თავად კონტროლერი ახორციელებს პროგრამას. ეს სასარგებლოა პროგრამის გამართვისთვის, შეტყობინებების გაგზავნისთვის სხვა მოწყობილობებზე ან აპლიკაციებზე. სერიული პორტით (ასევე უწოდებენ UART ან USART) მონაცემთა გადაცემის ჩასართავად, საჭიროა მისი ინიციალიზაცია setup()-ში.
Serial.begin()აქვს მხოლოდ ერთი არგუმენტი - ეს არის მონაცემთა გადაცემის სიჩქარე Arduino-სა და კომპიუტერს შორის.
ესკიზი იყენებს ბრძანებას, რათა გამოსახოს შეტყობინება ეკრანზე Arduino IDE-ში (ინსტრუმენტები >> სერიული მონიტორი).
- დიზაინი საშუალებას გაძლევთ აკონტროლოთ პროგრამის შესრულების პროგრესი რამდენიმე შემოწმების ერთ ადგილას გაერთიანებით.
თუ digitalRead დააბრუნებს HIGH, მაშინ სიტყვა "დაჭერილი" გამოჩნდება მონიტორზე. სხვა შემთხვევაში (წინააღმდეგ შემთხვევაში) სიტყვა "გამოშვებული" გამოჩნდება მონიტორზე. ახლა შეგიძლიათ სცადოთ LED-ის ჩართვა და გამორთვა ღილაკის დაჭერით.
//ღილაკის დაჭერის ამოცნობა LED გამომავალი int ღილაკითPin = 7; int ledPin = 8; void setup())( pinMode(buttonPin, INPUT);//ამჯერად ჩვენ დავაყენებთ ღილაკის პინს, როგორც INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin )= =HIGH)( digitalWrite(ledPin,HIGH); Serial.println("დაჭერილი"); ) else (digitWrite(ledPin,LOW); Serial.println("დაუპრესილი"); ) )
ანალოგური შეყვანა.
ანალოგური წაკითხვასაშუალებას გაძლევთ წაიკითხოთ მონაცემები Arduino-ს ერთ-ერთი ანალოგური პინიდან და აჩვენებს მნიშვნელობას 0 (0V)-დან 1023 (5V-მდე) დიაპაზონში. თუ ანალოგური შეყვანის ძაბვა არის 2.5 ვ, მაშინ დაიბეჭდება 2.5 / 5 * 1023 = 512
ანალოგური წაკითხვააქვს მხოლოდ ერთი არგუმენტი - ეს არის ანალოგური შეყვანის ნომერი (A0-A5). შემდეგი ესკიზი აჩვენებს კოდს პოტენციომეტრიდან ძაბვის წაკითხვისთვის. ამისათვის შეაერთეთ ცვლადი რეზისტორი, გარე ტერმინალები 5V და GND ქინძისთავებს, ხოლო შუა ტერმინალი A0 შესასვლელთან.
გაუშვით შემდეგი კოდი და ნახეთ სერიულ მონიტორზე, თუ როგორ იცვლება მნიშვნელობები რეზისტორის ღილაკის ბრუნვის მიხედვით.
//ანალოგური შეყვანა int potPin = A0;//პოტენციომეტრის ცენტრალური პინი დაკავშირებულია ამ პინთან void setup())( //ანალოგური პინი ჩართულია როგორც შემავალი ნაგულისხმევად, ამიტომ ინიციალიზაცია არ არის საჭირო Serial.begin(9600 ) void loop())( int potVal = analogRead(potPin);//potVal არის რიცხვი 0-დან 1023-მდე Serial.println(potVal)
შემდეგი ესკიზი აერთიანებს ღილაკზე დაჭერის ესკიზს და LED სიკაშკაშის კონტროლის ჩანახატს. LED ღილაკიდან ჩაირთვება და სიკაშკაშე გაკონტროლდება პოტენციომეტრით.
//ღილაკზე დაჭერის ამოცნობა LED გამომავალი და ცვლადი ინტენსივობის int ღილაკიPin = 7; int ledPin = 9; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//თუ დააჭირეთ ღილაკს int analogVal = analogRead(potPin) int scaledVal = map(analogVal, 0, 1023, 0, 255); ( digitalWrite(ledPin, LOW);//გამორთეთ თუ ღილაკი არ არის დაჭერილი Serial.println("დაჭერილი"); ) )
ახალი ხელნაკეთი პროდუქტების მიწოდება ფოსტაში
მიიღეთ ახალი ხელნაკეთი პროდუქტების არჩევანი ელექტრონული ფოსტით. არა სპამი, მხოლოდ სასარგებლო იდეები!