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

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

ჩემს Arduino 101 გაკვეთილში თქვენ გასწავლით თუ როგორ უნდა შექმნათ თქვენი გარემო Tinkercad– ში. მე ვიყენებ Tinkercad– ს, რადგან ეს არის საკმაოდ მძლავრი ონლაინ პლატფორმა, რომელიც მაძლევს საშუალებას გამოვავლინო რიგი უნარ -ჩვევები სტუდენტებისთვის სქემების შესაქმნელად. მოგერიდებათ ააშენოთ ყველა ჩემი გაკვეთილი Arduino IDE და ნამდვილი Arduino გამოყენებით!

ამ გაკვეთილში ჩვენ ვისწავლით ღილაკებს! ჩვენ უნდა ვიცოდეთ:

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

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

მზადაა? Დავიწყოთ!

ნაბიჯი 1: დაფის დაყენება

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

Breadboard Mini- ს აქვს ორი დენის რელსები ზემოდან და ქვემოდან. ჩვენ ვამაგრებთ მათ Arduino– ს, ასე რომ ჩვენ შეგვიძლია მივაწოდოთ ძალა უფრო მეტ კომპონენტს. მოგვიანებით ამ გაკვეთილში ჩვენ გამოვიყენებთ 3 ღილაკს, ასე რომ დაგვჭირდება მეტი ენერგია. გასათვალისწინებელია ის, რომ პატარა დაფაზე, დენის რელსები გადის მთელს ბორტზე, ჰორიზონტალურად. ეს განსხვავდება სვეტებისგან მთავარი პროტოტიპების არეში შუაში; ეს ვერტიკალურად მუშაობს. თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი დენის ქინძისთავები, რათა უზრუნველყოთ ნებისმიერი სვეტის ენერგია მთავარ უბანში შუაში.

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

ნაბიჯი 2: დაამატეთ ღილაკი და რეზისტორი

დაამატეთ პატარა ღილაკი კომპონენტების უჯრიდან. ის უნდა გამოიყურებოდეს როგორც სურათზე. დარწმუნდით, რომ ეს არ არის გადართვა! დაამატეთ რეზისტორიც. დააწკაპუნეთ მასზე და დააყენეთ მისი მნიშვნელობა 10kΩ. ეს საკმარისია იმისათვის, რომ დაიჭიროთ პინი დაბლა, როდესაც ის არ არის დაკავშირებული, რაც ძალიან მნიშვნელოვანია მოგვიანებით კოდში.

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

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

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

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

მოათავსეთ რეზისტორი ქვედა მარჯვენა პინიდან სვეტების გასწვრივ, ასე რომ ის ჰორიზონტალურად ზის.

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

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

ახლა მოდით დავამატოთ მავთულები.

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

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

ნაბიჯი 4: კოდი…

მოდით შევხედოთ კოდს ძირითადი ღილაკისთვის.

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

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

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

// განსაზღვრეთ მუდმივები

#განსაზღვრეთ ღილაკი 2 void setup () {pinMode (ღილაკი, INPUT); სერიული.დაწყება (9600); } void loop () {// წაიკითხეთ ციფრული პინი ღილაკის სტატუსის შესამოწმებლად int pressed = digitalRead (ღილაკი); // ღილაკი ბრუნდება HIGH დაჭერის შემთხვევაში, LOW თუ არა (დაჭერილი == HIGH) {Serial.println ("დაჭერილი!"); }}

კარგი, კარგად მუშაობს!

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

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

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

ახლა… ჩვენი კოდი შეიძლება დასრულებულად გამოიყურებოდეს… მაგრამ ჩვენ გვაქვს პრობლემა.

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

მოდი გამოვასწოროთ!

ნაბიჯი 5: პატარა დებიუნი

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

მოდით შევხედოთ კოდს:

#განსაზღვრეთ ღილაკი 2#განსაზღვრეთ debounceTimeout 100

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

long int lastDebounceTime;

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

ჩვენ არ გვჭირდება არაფრის შეცვლა void setup () ფუნქციაში. მოდით დავტოვოთ ის.

void loop () {// წაიკითხეთ ციფრული პინი ღილაკის სტატუსის შესამოწმებლად int pressed = digitalRead (ღილაკი); long int currentTime = მილი (); // ღილაკის კოდი}

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

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

void loop () {// წაიკითხეთ ციფრული პინი ღილაკის სტატუსის შესამოწმებლად int pressed = digitalRead (ღილაკი); long int currentTime = მილი (); თუ (დაჭერილი == LOW) {// აღადგინეთ დათვლის დრო, სანამ ღილაკი არ არის დაჭერილი lastDebounceTime = currentTime; } // ღილაკის კოდი}

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

void loop () {// წაიკითხეთ ციფრული პინი ღილაკის სტატუსის შესამოწმებლად int pressed = digitalRead (ღილაკი); long int currentTime = მილი (); თუ (დაპრესილი == LOW) {// აღადგინეთ დათვლის დრო სანამ ღილაკი არ არის დაჭერილი lastDebounceTime = currentTime; } // ღილაკზე დაჭერილია მოცემული დრო, თუ ((((მიმდინარე დრო - lastDebounceTime)> debounceTimeout)) {// თუ დრო ამოიწურა, დააჭირეთ ღილაკს! Serial.println ("დაჭერილი!"); }}

კოდის ბოლო ბლოკი იღებს მიმდინარე დროს, გამოაქვს ბოლო დებიუანსის დრო და ადარებს მას ჩვენ მიერ დადგენილ ვადას. თუ ის უფრო დიდია, კოდი მიიჩნევს, რომ ღილაკი ამ დროს დაჭერილია და პასუხობს. სისუფთავე!

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

ახლა მოდით შევხედოთ პრაქტიკულ მაგალითს.

ნაბიჯი 6: მენიუს შექმნა

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

ამ პროექტისთვის ჩვენ გვჭირდება:

• სამი ღილაკი
• სამი რეზისტორი დაყენებულია 10kΩ– ზე

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

სამი ღილაკი არის მენიუს გახსნა/შემდეგი ვარიანტი, შეცვლის ვარიანტი (როგორც აქ, პარამეტრების შეცვლა) და მენიუს შენახვის/დახურვის ღილაკი.

გაააქტიურეთ, მოდით შევხედოთ კოდს!

ნაბიჯი 7: კოდის დაშლა - გლობალური

კარგი, ეს იქნება გრძელი ნაბიჯი, მაგრამ მე ვაპირებ გავლა კოდის თითოეულ მონაკვეთზე.

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

// განსაზღვრეთ მუდმივები #განსაზღვრეთ მენიუ ღილაკი 2 #განსაზღვრეთ მენიუ შეარჩიეთ 3 #განსაზღვრეთ მენიუ შეინახეთ 4 #განსაზღვრეთ დებუნსი დრო 50 – ის შემდეგ // ცვლადების განსაზღვრა მენიუში ButtonPreviousState = LOW; int menuSelectPreviousState = LOW; int menuSavePreviousState = LOW; long int lastDebounceTime; // მენიუს პარამეტრები char * menuOptions = {"შეამოწმეთ ტემპერატურა", "შეამოწმეთ სინათლე"}; bool featureSetting = {ყალბი, ყალბი}; bool menuMode = false; bool menuNeedsPrint = false; int ვარიანტი არჩეული = 0;

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

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

მენიუს პარამეტრების ბლოკს აქვს რამდენიმე ახალი ფუნქცია. პირველი, char * (დიახ, ეს არის მიზანმიმართული ვარსკვლავი), რომელიც არის სიმბოლო/სიმებიანი პირდაპირი ცვლადი. ეს არის მეხსიერებაში სტატიკური შენახვის მაჩვენებელი. თქვენ არ შეგიძლიათ შეცვალოთ იგი (მაგალითად, როგორც პითონში შეგიძლიათ). ეს char *menuOptions ხაზი ქმნის სიმებიანი სიტყვასიტყვით მასივს. თქვენ შეგიძლიათ დაამატოთ იმდენი მენიუ, რამდენიც გსურთ.

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

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

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

ნაბიჯი 8: კოდის დაშლა - დაყენება და პერსონალური ფუნქციები

Setup () ფუნქცია საკმაოდ მარტივია, მხოლოდ სამი შეყვანის დეკლარაცია:

void setup () {pinMode (menuSelect, INPUT); pinMode (მენიუს შენახვა, შეყვანა); pinMode (მენიუს არჩევა, შეყვანა); სერიული.დაწყება (9600); }

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

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

// ფუნქცია მიმდინარე შერჩეული პარამეტრის დაბრუნებისათვის charr *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // დაბრუნების ვარიანტი არჩეული დაბრუნების მენიუ ვარიანტი; } // მიმდინარე შერჩეული ვარიანტის სტატუსის დაბრუნების ფუნქცია char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "ყალბი"; } else {optionSettingVal = "მართალია"; } // Return optionSetting return optionSettingVal; }

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

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

// მიმდინარე პარამეტრის გადართვის ფუნქცია ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; ჭეშმარიტი დაბრუნება; }

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

ნაბიჯი 9: მარყუჟი…

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

ბათილი მარყუჟი () {

// იმუშავე აქ <-----}

კარგი, ჩვენ ადრე ვნახეთ ეს:

// ღილაკების წაკითხვა int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (მენიუს არჩევა); int menuSavePressed = digitalRead (მენიუს შენახვა); // მიიღეთ მიმდინარე დრო long int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// აღადგინეთ დათვლის დრო, სანამ ღილაკი არ არის დაჭერილი lastDebounceTime = currentTime; menuButtonPreviousState = LOW; menuSelectPreviousState = LOW; menuSavePreviousState = LOW; }

ყველაფერი რაც აქ უნდა გამეკეთებინა იყო სამი digitalRead () ზარის დამატება და დარწმუნებული ვიყავი, რომ გავითვალისწინე ის ფაქტი, რომ თუ ყველა ღილაკი დაბალი იყო, ჩვენ უნდა გადატვირთოთ ტაიმერი (lastDebounceTime = currentTime) და ყველა წინა მდგომარეობა დაბალზე დავაყენოთ. მე ასევე ვინახავ millis () - ს მიმდინარე დროში.

მომდევნო განყოფილება ბუდეს ხაზის შიგნით

if (((currentTime - lastDebounceTime)> debounceTimeout)) {

// იმუშავე აქ <----}

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

if ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // აცნობეთ მომხმარებელს Serial.println ("მენიუ აქტიურია"); } else if (menuMode == true && optionSelected = 1) {// პარამეტრების გადაყენება optionSelected = 0; } // მენიუს მენიუს დაბეჭდვაNeedsPrint = true; // ღილაკის გადართვა წინა. მიუთითეთ მხოლოდ მენიუს ჩვენება // თუ ღილაკი გათავისუფლდება და კვლავ დაჭერილია menuButtonPreviousState = menuButtonPressed; // იქნება მაღალი}

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

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

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

// menuSelect არის დაჭერილი, მიაწოდეთ logicif ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// შეცვალეთ არჩეული ვარიანტი // ამ მომენტში, ეს მხოლოდ მართალია/მცდარი // მაგრამ შეიძლება იყოს არაფერი bool გადართვა = ToggleOptionSelected (); if (გადართვა) {menuNeedsPrint = true; } else {Serial.println ("რაღაც შეცდა. გთხოვთ სცადოთ ხელახლა"); }} // გადართვა მდგომარეობის გადართვა მხოლოდ გაშვების შემთხვევაში და კვლავ დაჭერით menuSelectPreviousState = menuSelectPressed; }

ეს ცოტა კოდი ამუშავებს menuSelectPressed ღილაკს ერთნაირად, გარდა ამ დროის ჩვენ უბრალოდ გავუშვით ToggleOptionSelected () ფუნქცია. როგორც უკვე ვთქვი, თქვენ შეგიძლიათ შეცვალოთ ეს ფუნქცია, ასე რომ ის უფრო მეტს აკეთებს, მაგრამ ეს არის ის, რაც მე მჭირდება ამის გასაკეთებლად.

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

if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// მენიუდან გასვლა // აქ თქვენ შეგიძლიათ ნებისმიერი დალაგება // ან შეინახოთ EEPROM menuMode = false; Serial.println ("მენიუდან გასული"); // გადართვა ისე, რომ მენიუ გამოდის მხოლოდ ერთხელ menuSavePreviousState = menuSavePressed; }}

ეს ფუნქცია ამუშავებს menuSave ღილაკს, რომელიც მხოლოდ მენიუდან გამოდის. ეს არის ის ადგილი, სადაც შეიძლება გქონდეთ გაუქმების ან შენახვის ვარიანტი, იქნებ გაასუფთაოთ ან შეინახოთ EEPROM– ში. მე უბრალოდ ვბეჭდავ "მენიუდან გავიდა" და დავაყენე ღილაკის მდგომარეობა HIGH- ზე, რათა არ მოხდეს მარყუჟი.

if (menuMode && menuNeedsPrint) {// ჩვენ დავბეჭდეთ მენიუ, ასე რომ თუ რამე არ მოხდა // არ არის საჭირო მისი ხელახლა დაბეჭდვა menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("რჩეული:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }

ეს არის menuPrint ალგორითმი, რომელიც მუშაობს მხოლოდ მაშინ, როდესაც მენიუ აქტიურია და როდესაც menuNeedsPrint ცვლადი არის ჭეშმარიტი.

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

ისე, ეს არის ის! იხილეთ შემდეგი ნაბიჯი მთლიანი კოდის ბლოკისთვის.

ნაბიჯი 10: საბოლოო კოდის ბლოკირება

// განსაზღვრეთ მუდმივები

#განსაზღვრეთ მენიუ ღილაკი 2 #განსაზღვრეთ მენიუ შეარჩიეთ 3 #განსაზღვრეთ მენიუ შეინახეთ 4 #განსაზღვრეთ დენომენცია Timeout 50 int menuButtonPreviousState = LOW; int menuSelectPreviousState = LOW; int menuSavePreviousState = LOW; // ცვლადების განსაზღვრა long int lastDebounceTime; bool lightSensor = ჭეშმარიტი; bool tempSensor = ჭეშმარიტი; // მენიუს პარამეტრები char * menuOptions = {"შეამოწმეთ ტემპერატურა", "შეამოწმეთ სინათლე"}; bool featureSetting = {ყალბი, ყალბი}; bool menuMode = false; bool menuNeedsPrint = false; int ვარიანტი არჩეული = 0; // დაყენების ფუნქცია

void setup () {pinMode (menuSelect, INPUT); pinMode (მენიუს შენახვა, შეყვანა); pinMode (მენიუს არჩევა, შეყვანა); სერიული.დაწყება (9600); }

// ფუნქცია მიმდინარე შერჩეული ვარიანტის დაბრუნებისთვის char *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // დაბრუნების ვარიანტი არჩეული დაბრუნების მენიუ ვარიანტი; } // მიმდინარე შერჩეული ვარიანტის სტატუსის დაბრუნების ფუნქცია char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "ყალბი"; } else {optionSettingVal = "მართალია"; } // Return optionSetting return optionSettingVal; } // მიმდინარე ვარიანტის გადატვირთვის ფუნქცია boog ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; ჭეშმარიტი დაბრუნება; } // მთავარი მარყუჟი

void loop () {// ღილაკების წაკითხვა int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (მენიუს არჩევა); int menuSavePressed = digitalRead (მენიუს შენახვა); // მიიღეთ მიმდინარე დრო long int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// აღადგინეთ დათვლის დრო, სანამ ღილაკი არ არის დაჭერილი lastDebounceTime = currentTime; menuButtonPreviousState = LOW; menuSelectPreviousState = LOW; menuSavePreviousState = LOW; } if (((currentTime - lastDebounceTime)> debounceTimeout)) {// თუ დრო ამოიწურა, დააჭირეთ ღილაკს!

// menuButton არის დაჭერილი, მიუთითეთ ლოგიკა

// იხსნება მხოლოდ მაშინ, როდესაც ღილაკი ადრე იყო გათავისუფლებული, თუ ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // აცნობეთ მომხმარებელს Serial.println ("მენიუ აქტიურია"); } else if (menuMode == true && optionSelected = 1) {// პარამეტრების გადაყენება optionSelected = 0; } // მენიუს მენიუს დაბეჭდვაNeedsPrint = true; // ღილაკის გადართვა წინა. მიუთითეთ მხოლოდ მენიუს ჩვენება // თუ ღილაკი გათავისუფლდება და კვლავ დაჭერილია menuButtonPreviousState = menuButtonPressed; // იქნება HIGH} // menuSelect არის დაპრესილი, მიუთითეთ ლოგიკა, თუ ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// შეცვალეთ არჩეული ვარიანტი // ამ მომენტში, ეს არის უბრალოდ true/false // მაგრამ შეიძლება იყოს ნებისმიერი რამ bool toggle = ToggleOptionSelected (); if (გადართვა) {menuNeedsPrint = true; } else {Serial.print ("რაღაც შეცდა. გთხოვთ სცადოთ ხელახლა"); }} // გადართვა მდგომარეობის გადართვა მხოლოდ გაშვების შემთხვევაში და კვლავ დაჭერით menuSelectPreviousState = menuSelectPressed; } if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// გამოდით მენიუდან // აქ თქვენ შეგიძლიათ ნებისმიერი დალაგება // ან შეინახოთ EEPROM menuMode = false; Serial.println ("მენიუდან გასული"); // გადართვა ისე, რომ მენიუ გამოდის მხოლოდ ერთხელ menuSavePreviousState = menuSavePressed; }} // ამობეჭდვა მიმდინარე მენიუს ვარიანტი აქტიური, მაგრამ მხოლოდ ერთხელ დაბეჭდე თუ (menuMode && menuNeedsPrint) {// ჩვენ დავბეჭდეთ მენიუ, ასე რომ, თუ რამე არ მოხდება, აღარ არის საჭირო მისი დაბეჭდვა menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("რჩეული:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }}}

წრე ხელმისაწვდომია Tinkercad– ის საიტზე. მე ჩამონტაჟებული სქემა ქვემოთ თქვენც ნახოთ!

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