გაუმართაობა 

Arduino ღილაკების სწორი შეერთება. ღილაკის დაკავშირება Arduino-სთან

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

ღილაკის მიკროკონტროლერთან დაკავშირების უმარტივესი დიაგრამა ასე გამოიყურება:

თუ გასაღები S 1ღიაა (ღილაკი გამოშვებულია), შემდეგ ციფრულ შეყვანაზე დ ინმიკროკონტროლერი გვექნება 5 ვ ძაბვა, რომელიც შეესაბამება ლოგიკურს. როდესაც დააჭირეთ ღილაკს, შედით დ ინუერთდება მიწას, რომელიც შეესაბამება ლოგიკურ ნულოვან დონეს და მთელი ძაბვა დაეცემა რეზისტორზე R 1, რომლის ღირებულება შეირჩევა იმის საფუძველზე, რომ ღილაკზე დაჭერისას მასში არც ისე ბევრი მიედინება. მაღალი დენი(ჩვეულებრივ, დაახლოებით 10÷100 kOhm).

თუ უბრალოდ დააკავშირებთ ღილაკს ციფრულ შეყვანასა და მიწას შორის (რეზისტორის გარეშე R 1, დაკავშირებულია +5V) ან შემავალსა და +5V-ს შორის, შემდეგ იმ მდგომარეობაში, როდესაც ღილაკი არ არის დაჭერილი, მიკროკონტროლერის ციფრულ შეყვანაზე იქნება განუსაზღვრელი ძაბვა (შეიძლება შეესაბამებოდეს დონეს 0, ან შესაძლოა 1) და ჩვენ ვკითხულობთ შემთხვევით მდგომარეობებს. ამიტომ გამოიყენება რეზისტორი R 1, რომელიც, როგორც ამბობენ, ღილაკის გათავისუფლებისას შემავალს +5V-მდე „აწევს“.

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

ღილაკის დაკავშირება არდუინო

მიკროკონტროლერები ატმელი AVR ATmega (რომლის საფუძველზეც აგებულია არდუინო) აქვს ჩაშენებული პროგრამული უზრუნველყოფასთან დაკავშირებული დატვირთვის რეზისტორები R n 20 kOhm და ჩვენ შეგვიძლია გამოვიყენოთ ისინი კავშირის დიაგრამის გამარტივებით.


შიდა დატვირთვის რეზისტორს უკავშირდება ლოგიკური ერთის ჩაწერა პორტის საჭირო ბიტზე.

ესკიზის მაგალითი არდუინო, რომელიც ჩართავს და გამორთავს პინ 13-ზე ჩაშენებულ LED-ს, იმისდა მიხედვით, დაჭერით თუ გამოუშვით მეორე პინთან დაკავშირებული ღილაკი შიდა დატვირთვის რეზისტორების გამოყენებით:

void setup() ( pinMode(13, OUTPUT); //LED პინ 13 pinMode(2, INPUT); //2 პინი შეყვანის რეჟიმშია. ღილაკი დაკავშირებულია მიწასთან. digitalWrite(2, HIGH); // შეაერთეთ ამოსაწევი რეზისტორი ) void loop() ( digitalWrite(13, !digitalRead(2)); // წაიკითხეთ ღილაკის მდგომარეობა და გადართეთ LED )

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

საკონტაქტო bounce

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

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

ეს ბიბლიოთეკა მოიცავს შემდეგ მეთოდებს:

  • bounce ()- Bounce ობიექტის ინიციალიზაცია
  • ბათილი ინტერვალი (ხელმოუწერელი გრძელი ინტერვალი)— აწესებს ანტი-ამობრუნების დროს მილიწამებში
  • void მიმაგრება (int pin)— აყენებს პინს, რომელზეც არის დაკავშირებული ღილაკი და აკავშირებს ჩაშენებულ ასაწევ რეზისტორს ამ პინთან
  • int განახლება()- იმიტომ რომ Bounceარ იყენებს, თქვენ „ახლებთ“ ობიექტს, სანამ წაიკითხავთ მის მდგომარეობას და ეს უნდა გაკეთდეს მუდმივად (მაგალითად, შიგნით მარყუჟი). მეთოდი განახლება განაახლებს ობიექტს და ბრუნდება მართალი(1), თუ პინის მდგომარეობა შეიცვალა (ღილაკი დააჭირეს ან, პირიქით, გაათავისუფლეს) და ცრუ(0) წინააღმდეგ შემთხვევაში. მეთოდის გამოძახება განახლება შიგნით მარყუჟიმხოლოდ ერთხელ უნდა გაკეთდეს.
  • წაკითხული არ არის ()— აბრუნებს პინის განახლებულ მდგომარეობას

ნაგულისხმევად, Bounce ბიბლიოთეკა იყენებს სტაბილიზაციის ინტერვალს ( სტაბილური ინტერვალი) ანტი-ბოუნსის განხორციელება. ეს უფრო ადვილად გასაგებია და გამორიცხავს საუბრების ხანგრძლივობის ცოდნას.


Პარამეტრი სტაბილური ინტერვალი Bounce ბიბლიოთეკები

რომელმაც დაადგინა

#define BOUNCE_LOCK-OUT

#define BOUNCE_LOCK-OUT

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


აი ამ ბიბლიოთეკის გამოყენების მაგალითი:

#შეიცავს Bounce bouncer = Bounce(); // შექმენით Bounce კლასის void setup() ინსტანცია ( pinMode(2 ,INPUT); // ღილაკი პინ 2-ზე digitalWrite(2,HIGH); // დააკავშირეთ ჩაშენებული ასაწევი რეზისტორის bouncer .attach(2 // დააინსტალირეთ ღილაკი bouncer(5) // დააყენეთ პარამეტრის სტაბილური ინტერვალი = 5 ms Serial.begin(9600 bps) void loop()); განახლება()) ( // თუ მოვლენა მოხდება, თუ (bouncer.read()==0) ( //თუ ღილაკზე დაჭერილია Serial.println("დაჭერილი"); //აჩვენეთ შეტყობინება დაჭერის შესახებ ) else Serial. println("გამოშვებული");

#შეიცავს

Bounce bouncer = Bounce () ; //შექმენით Bounce კლასის ინსტანცია

void setup()

pinMode (2, INPUT); // ღილაკი პინ 2-ზე

digitalWrite(2, HIGH); // დააკავშირეთ ჩაშენებული ასაწევი რეზისტორი

მატყუარა. მიმაგრება (2); // დააყენეთ ღილაკი

მცოცავი. ინტერვალი (5); // დააყენეთ პარამეტრის სტაბილური ინტერვალი = 5 ms

სერიალი. დაწყება (9600); //დააყენეთ სერიული პორტი 9600 bps

void loop ()

თუ (bouncer . განახლება () )

{ //თუ მოხდა მოვლენა

თუ (ბოუნკერი . წაკითხვა () == 0 )

დაგჭირდებათ

  • არდუინო;
  • ტაქტის ღილაკი;
  • რეზისტორი 10 kOhm;
  • პურის დაფა;
  • დამაკავშირებელი მავთულები.

1 სახეებიღილაკები

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

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

ღილაკები ასევე იყოფა:

  • ჩვეულებრივ ღია,
  • ჩვეულებრივ დახურულია.
პირველები დაჭერისას ხურავს წრეს, მეორეები ხსნიან წრეს.

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

2 რეკავსკონტაქტები

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



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

3 არასწორი კავშირიღილაკები

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



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

4 ღილაკის დაკავშირებამიკროსქემის მიხედვით ასაწევი რეზისტორით

ჯერ დავუკავშირდეთ Arduino ღილაკიმიკროსქემის მიხედვით ასაწევი რეზისტორით. ამისათვის დააკავშირეთ ღილაკის ერთი კონტაქტი მიწასთან, მეორე კი ციფრულ გამომავალზე "2". ციფრული გამომავალი "2" ასევე დაუკავშირდება 10 kOhm რეზისტორის საშუალებით +5 V მიწოდებას.



მოდით დავწეროთ ასეთი ჩანახატი ღილაკზე დაწკაპუნების დასამუშავებლად და ატვირთოთ Arduino-ზე.

// დააყენეთ პინის ნომრები: const int buttonPin = 2; const int ledPin = 13; void setup() ( pinMode (ledPin, OUTPUT); pinMode (ღილაკიPin, INPUT); } void loop() ( int buttonState = digitalRead(buttonPin); // წაიკითხეთ ღილაკის მდგომარეობა, თუ (buttonState == HIGH) ( digitalWrite (ledPin, HIGH); // ჩართეთ LED ღილაკის დაჭერისას) სხვა ( digitalWrite (ledPin, LOW); // გამორთეთ LED როდესაც ღილაკი გათავისუფლდება) }

ჩაშენებული LED პინ "13"-ზე მუდმივად ჩართულია ღილაკზე დაჭერამდე. იმათ. Arduino-ს "2" პორტზე ყოველთვის არის მაღალი ლოგიკური დონე HIGH. როდესაც ღილაკს ვაჭერთ, პორტ "2"-ზე ძაბვა ხდება დაბალი და LED ითიშება.

5 ღილაკის დაკავშირებასქემის მიხედვით ჩამოსაშლელი რეზისტორით

ახლა მოდით შევკრიბოთ წრე ჩამოსაშლელი რეზისტორით. ჩვენ ვუკავშირდებით ღილაკის ერთ კონტაქტს +5 ვ დენის წყაროს, მეორე ციფრულ გამომავალს "2". ჩვენ ვაკავშირებთ ციფრულ გამომავალს "2" 10 kOhm რეზისტორის საშუალებით მიწასთან. ჩვენ არ შევცვლით ესკიზს.



Arduino-ს ციფრულ პორტზე "2" მიკროსქემის ჩართვისას დაბალი დონე LOW და LED არ ანათებს. ღილაკზე დაჭერისას პორტი "2" იღებს მაღალი დონე HIGH და LED ანათებს.

ამ მაგალითში ჩვენ შევხედავთ ღილაკის დაკავშირებას Arduino კონტროლერთან. ღილაკზე დაჭერისას ჩვენ ავანთებთ ჩაშენებულ LED-ს. უმრავლესობა არდუინოს დაფებიაქვს ჩაშენებული SMT LED გამომავალი 13 (პინი 13).

საჭირო კომპონენტები

  • Arduino კონტროლერი
  • ტაქტის ღილაკი
  • 10 kOhm რეზისტორი
  • პროტოტიპის დაფა
  • დამაკავშირებელი მავთულები

კავშირი

ჩვენ ვაკავშირებთ დენის გამომავალს (5V) და მიწას (Gnd), წითელი და შავი სადენებით, შესაბამისად, პურის დაფაზე. როგორც წესი, პურის დაფები იყენებენ ქინძისთავების ყველაზე გარე მწკრივებს სიმძლავრისა და დასაბუთებისთვის, როგორც ეს ნაჩვენებია ფიგურაში. მესამე ცისფერი მავთულით ჩვენ ვუკავშირებთ Arduino კონტროლერის ციფრულ პინს 2 საათის ღილაკის პინს. იმავე კონტაქტს, ან მასთან მუდმივად დაკავშირებულ კონტაქტს 4-პინიანი დიზაინით, ჩვენ ვუერთებთ 10 kOhm-ის ასაწევ რეზისტორს, რომელიც თავის მხრივ უკავშირდება მიწას. ღილაკის სხვა გამომავალს ვუერთებთ 5 ვ დენის წყაროს.

როდესაც საათის ღილაკზე არ არის დაჭერილი, გამომავალი 2 დაკავშირებულია მხოლოდ მიწასთან ასაწევი რეზისტორის საშუალებით და ეს შეყვანა იკითხება LOW. ღილაკზე დაჭერისას ჩნდება კონტაქტი 2-სა და 5 ვ დენის წყაროს შორის და ის იკითხება.

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

პირველმა პროგრამამ უნდა აკონტროლოს LED ღილაკის გამოყენებით:

  • ღილაკზე დაჭერისას LED ანათებს;
  • ღილაკზე დაჭერისას LED არ ანათებს.

ღილაკის და LED დაკავშირება Arduino დაფაზე.

Დაკავშირება გარე ელემენტებივ Arduino კონტროლერი UNO-ს აქვს 14 ციფრული პინი. თითოეული პინი შეიძლება განისაზღვროს პროგრამის მიერ, როგორც შემავალი ან გამომავალი.

ციფრულ გამომავალს აქვს მხოლოდ ორი მდგომარეობა, მაღალი და დაბალი. მაღალი მდგომარეობა შეესაბამება გამომავალ ძაბვას დაახლოებით 5 V, დაბალი მდგომარეობა - 0 V. გამომავალი საშუალებას იძლევა დააკავშიროთ დატვირთვა 40 mA-მდე დენით.

მას შემდეგ, რაც pin განისაზღვრება, როგორც შემავალი, მისი მდგომარეობის წაკითხვით, ძაბვის დონე შეიძლება განისაზღვროს შესასვლელში. 5 ვ-სთან ახლოს ძაბვისას (ფაქტობრივად 3 ვ-ზე მეტი) წაიკითხება მაღალი მდგომარეობა, რომელიც შეესაბამება HIGH მუდმივას. როდესაც ძაბვა ახლოს არის 0-თან (1,5 ვ-ზე ნაკლები), დაბალი მდგომარეობა ან დაბალი მუდმივი იკითხება.

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

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

რეზისტორი გამოითვლება ფორმულით I = Uoutput - Udrop LED / R-ზე.

Uoutput = 5 V, Udrop on LED შეიძლება იქნას მიღებული ტოლი 1.5 V (უფრო ზუსტად მითითებულია საცნობარო წიგნში). გამოდის, რომ ჩვენს წრეში LED-ის მეშვეობით დენი დაყენებულია 10 mA-ზე.

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

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



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

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



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


I/O კონტროლის ფუნქციები.

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

pinMode (პინი, რეჟიმი)

ადგენს გამომავალი რეჟიმს (შეყვანა ან გამომავალი).

არგუმენტები: პინი და რეჟიმი.

  • pin – pin ნომერი;
  • რეჟიმი - გამომავალი რეჟიმი.

ფუნქცია არაფერს აბრუნებს.

ციფრული ჩაწერა (პინი, მნიშვნელობა)

ადგენს გამომავალი სტატუსს (მაღალი ან დაბალი).

არგუმენტების პინი და მნიშვნელობა:

  • pin – pin ნომერი;
  • მნიშვნელობა - გამომავალი სტატუსი.

ფუნქცია არაფერს აბრუნებს.

ციფრული წაკითხვა (პინი)

კითხულობს შეყვანის სტატუსს.

არგუმენტები: pin - pin ნომერი.

აბრუნებს შესვლის სტატუსს:

digitalRead(pin) = LOW შეყვანის დაბალი დონე
digitalRead(pin) = HIGH შეყვანის მაღალი დონე

LED კონტროლის პროგრამა.

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

/* პროგრამა scetch_5_1 გაკვეთილი 5
*/

ლოგიკური ღილაკი სახელმწიფო; // შექმენით გლობალური ცვლადი ღილაკიState

void setup() (
pinMode (13, OUTPUT); //

}

// გაუთავებელი ციკლი
void loop() (



}

შესანახად შუალედური ღირებულებაღილაკის მდგომარეობა, შექმენით ცვლადი ღილაკიState ტიპის ლოგიკური. ეს ლოგიკური ტიპიმონაცემები. ცვლადს შეუძლია მიიღოს ორი მნიშვნელობიდან ერთი: true ან false. ჩვენს შემთხვევაში, LED ანათებს და არ ანათებს.

დააკოპირეთ ან გადაწერეთ პროგრამის კოდი ფანჯარაში Arduino IDE. ჩამოტვირთეთ კონტროლერში და შეამოწმეთ.

Arduino პროექტების შესანახად შევქმენი საქაღალდე d:\Arduino Projects\Lessons\Lesson5. პროგრამის თითოეულ გაკვეთილზე მე ვეძახი scetch_5_1, scetch_5_2, ... თქვენ შეგიძლიათ იგივე გააკეთოთ ან შეიყვანოთ თქვენი ფაილების შენახვის სისტემა.

პროგრამის ბლოკი:

buttonState = digitalRead(12); // წაიკითხეთ შეყვანის მდგომარეობა 12 (ღილაკი) და ჩაწერეთ ღილაკსState
ღილაკისახელმწიფო = ! ღილაკისახელმწიფო; // buttonState ცვლადის ინვერსია
digitalWrite(13, buttonState); // ჩაწერეთ მდგომარეობა ღილაკიდანState გამომავალ 13-მდე (LED)

შეიძლება დაიწეროს შუალედური ღილაკისState ცვლადის გამოყენების გარეშე.

digitalWrite(13, ! digitalRead(12));

digitalWrite() ფუნქციის არგუმენტი არის digitalRead() ფუნქცია. სასიამოვნო სტილიეს არის ზუსტად ვარიანტი. დამატებითი ცვლადები არ არის საჭირო, ნაკლები ტექსტი.

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

ამავე პროგრამის სხვა ვერსია, გამოყენებით პირობითი ოპერატორითუ.

/* პროგრამა scetch_5_2 გაკვეთილი 5
ანათებს LED-ს (პინი 13) ღილაკზე (პინი 12) დაჭერისას */

void setup() (
pinMode (13, OUTPUT); // განსაზღვრეთ პინი 13 (LED), როგორც გამოსავალი
pinMode(12, INPUT_PULLUP); // განსაზღვრეთ pin 12 (ღილაკი) როგორც შეყვანა
}

// გაუთავებელი ციკლი
void loop() (
if (digitalRead(12) == LOW) digitalWrite(13, HIGH);
else digitalWrite(13, LOW);
}

IN გაუთავებელი მარყუჟიმოწმდება პინი 12 (ღილაკი) მდგომარეობა და თუ ის დაბალია (LOW), მაშინ 13-ზე (LED) იქმნება მაღალი მდგომარეობა (HIGH). წინააღმდეგ შემთხვევაში, LED სტატუსი დაბალია.

#განსაზღვრე დირექტივა.

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

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

IN ზოგადი ხედიეს ასე გამოიყურება:

#define name character_sequence

თუ ჩვენს პროგრამებში ვწერთ:

#define LED_PIN 13 //

ყოველ ჯერზე, როდესაც პროგრამაში გამოჩნდება სახელი LED_PIN, თარგმანის დროს მას ჩაანაცვლებს სიმბოლოები 13. LED-ის ჩართვის ფუნქცია ასე გამოიყურება:

digitalWrite(LED_PIN, HIGH);

საბოლოო პროგრამა #define-ის გამოყენებით.

/* მე-5 გაკვეთილის პროგრამა
ანათებს LED-ს (პინი 13) ღილაკზე (პინი 12) დაჭერისას */

#define LED_PIN 13 // LED პინის ნომერია 13
#define BUTTON_PIN 12 // ღილაკის პინის ნომერია 12

void setup() (
pinMode(LED_PIN, OUTPUT); // განსაზღვრეთ პინი 13 (LED), როგორც გამოსავალი
pinMode(BUTTON_PIN, INPUT_PULLUP); // განსაზღვრეთ pin 12 (ღილაკი) როგორც შეყვანა
}

// გაუთავებელი ციკლი
void loop() (
digitalWrite(LED_PIN, ! digitalRead(BUTTON_PIN));
}

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

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



გაქვთ შეკითხვები?

შეატყობინეთ შეცდომას

ტექსტი, რომელიც გაეგზავნება ჩვენს რედაქტორებს:

გაგზავნა