Προγραμματισμός κουμπιού στο Arduino. Σύνδεση κουμπιού στο Arduino. Σύνδεση κουμπιού χρησιμοποιώντας κύκλωμα αντίστασης έλξης

Πολύ συχνά χρησιμοποιείται στα ηλεκτρονικά. Με την πρώτη ματιά, η συνεργασία μαζί τους δεν είναι γεμάτη εκπλήξεις, αλλά υπάρχουν παγίδες και εδώ.

Αν και το κουμπί έχει τέσσερα πόδια, μπορεί στην πραγματικότητα να θεωρηθεί ως δύο τμήματα του κυκλώματος που κλείνουν στην κορυφή. Βεβαιωθείτε ότι η σύνδεση είναι σωστή, ώστε το κύκλωμα να είναι σωστό.

Ας συνδέσουμε το κουμπί χωρίς να χρησιμοποιήσουμε ελεγκτή, περνώντας ρεύμα από 5V. Όταν πατήσετε το κουμπί, το κύκλωμα θα κλείσει και το LED θα ανάψει. Τίποτα απροσδόκητο.

Στην πραγματικότητα, πρέπει να διαβάσουμε το σήμα από το κουμπί και να ανταποκριθούμε σε αυτό. Επομένως, ας προσπαθήσουμε να αλλάξουμε το σχήμα. Ας συνδέσουμε μια ακίδα του κουμπιού στην τροφοδοσία και ας συνδέσουμε την 3 στην πλακέτα. Από την ακίδα 3 θα διαβάσουμε πληροφορίες: λογικό μηδέν ή λογικό ένα. Όταν πατήσετε το κουμπί, το κύκλωμα κλείνει, η ακίδα 3 θα έχει μια λογική και θα ανάψουμε το LED.

Int buttonPin = 12; int ledPin = 3; void setup() ( pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT); ) void loop() ( bool val = digitalRead(buttonPin); digitalWrite(ledPin, val); )

Ο κωδικός λειτουργεί καλά όταν κάνετε κλικ στο κουμπί. Και όταν αφήσουμε το κουμπί και δημιουργήσουμε διακοπή στο κύκλωμα, δημιουργείται πρόβλημα. Ο ακροδέκτης 12 γίνεται ελεύθερος και κρέμεται σε απροσδιόριστη κατάσταση στη λειτουργία ΕΙΣΑΓΩΓΗ(θυμηθείτε το μάθημα για τις ψηφιακές εξόδους). Ως αποτέλεσμα, παίρνουμε τυχαίες τιμές και το LED ανάβει και σβήνει λόγω παρεμβολών.

Για να αποφύγετε αυτό το πρόβλημα, μπορείτε να προσθέσετε μια αντίσταση 10 έως 100 kOhm και να πατήσετε το κουμπί για γείωση. Σε αυτή την περίπτωση, το κύκλωμα θα κλείσει ακόμα και όταν το κουμπί απελευθερωθεί. Σε αυτή την περίπτωση, η αντίσταση ονομάζεται pull down. Αυτό είναι ένα διάγραμμα εργασίας που μπορεί να χρησιμοποιηθεί στο πρόγραμμα σπουδών.

Παρά το κύκλωμα εργασίας με μια συρόμενη αντίσταση, έχουμε πρόβλημα όταν εργαζόμαστε με ένα σύνθετο έργο. Το γεγονός είναι ότι είναι πιθανό πολλές συσκευές στο κύκλωμα να χρησιμοποιούν διαφορετικές τιμές ισχύος. Και τότε θα πρέπει να τροφοδοτήσετε κάθε κουμπί της συσκευής με τη δική του ξεχωριστή πτυσσόμενη αντίσταση. Στην πράξη, συνηθίζεται να συνδέετε όχι στο τροφοδοτικό, αλλά στη γείωση, το οποίο είναι πάντα το ίδιο και ίσο με 0. Σε αυτή την περίπτωση, η ίδια η αντίσταση θα πρέπει να συνδεθεί στο τροφοδοτικό - να τραβήξει προς τα πάνω. Η αντίσταση σε αυτή την περίπτωση είναι ένα pull up. Ωστόσο, προκύπτει ένα άλλο πρόβλημα - η συμπεριφορά του LED έχει αλλάξει με τον αντίθετο τρόπο - όταν πατηθεί, το LED σβήνει και όταν απελευθερωθεί, ανάβει. Το πρόβλημα μπορεί να λυθεί απλά αλλάζοντας μια γραμμή κώδικα.

DigitalWrite(ledPin, !val);

Απλώς αλλάζουμε την τιμή της μεταβλητής στο αντίθετο. Αυτή είναι η τυπική προσέγγιση όταν εργάζεστε με ένα κουμπί. Τώρα θα είναι πιο εύκολο για εσάς να κατανοήσετε τα παραδείγματα από το Arduino IDE.

Αξίζει να σημειωθεί ότι οι ακίδες της πλακέτας Arduino έχουν ήδη ενσωματωμένες αντιστάσεις έλξης (εκτός από την ακίδα 13) και μπορούμε να αφαιρέσουμε την εξωτερική αντίσταση. Αλλά τότε πρέπει επίσης να υποδείξετε ρητά τη χρήση αυτής της αντίστασης μέσω κώδικα με την παράμετρο INPUT_PULLUP.

Int buttonPin = 12; int ledPin = 3; void setup() ( pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT_PULLUP); ) void loop() ( bool val = digitalRead(buttonPin); digitalWrite(ledPin, !val); καθυστέρηση(100); )

01.Βασικά: DigitalReadSerial

Ας μελετήσουμε ένα παράδειγμα DigitalReadSerialαπό Αρχείο | Παραδείγματα | 01.Βασικά.

Μάθαμε πώς να συνδέουμε σωστά ένα κουμπί και μπορούμε να μελετήσουμε τα ενσωματωμένα παραδείγματα. Θα διαβάσουμε το σήμα που προέρχεται από την ψηφιακή έξοδο όταν πατηθεί το κουμπί.

Ένα χονδρικά συναρμολογημένο διάγραμμα μπορεί να μοιάζει με αυτό:

Θα περιγράψω εν συντομία αυτό το σχήμα με λόγια. Εισάγουμε ένα κουμπί στο κέντρο του breadboard έτσι ώστε το αυλάκι του breadboard να τρέχει ανάμεσα στα ζευγαρωμένα πόδια. Στη συνέχεια, συνδέστε το τροφοδοτικό με βραχυκυκλωτήρες 5Vκαι γη GNDσε ένα Arduino με ράγες σε ένα breadboard. Στη συνέχεια, συνδέουμε την ψηφιακή καρφίτσα με αριθμό 2 στο Arduino με ένα βραχυκυκλωτήρα στο ένα πόδι του κουμπιού στο breadboard. Συνδέουμε το ίδιο πόδι του κουμπιού, αλλά από την άλλη πλευρά με μια αντίσταση, η οποία παίζει το ρόλο του πτυσσόμενη αντίσταση. Μετά από αυτό συνδέουμε την ίδια την αντίσταση στη γείωση. Συνδέουμε το τρίτο πόδι του κουμπιού με τη θετική ράγα στο breadboard. Το μόνο που μένει είναι να συνδέσουμε τις πλαϊνές ράγες μαζί στο breadboard και είμαστε έτοιμοι να μελετήσουμε ένα νέο παράδειγμα.

Το κουμπί εκτελεί μια πολύ σημαντική λειτουργία - κλείνει το κύκλωμα όταν πατηθεί. Όταν δεν πατηθεί το κουμπί, το ρεύμα δεν περνά ανάμεσα στα πόδια του κουμπιού και δεν μπορούμε να πιάσουμε το σήμα από την ψηφιακή ακίδα με αριθμό 2. Επομένως, η κατάσταση της ακίδας καθορίζεται από το σύστημα ως ΧΑΜΗΛΟΣή 0. Όταν πατηθεί το κουμπί, τα δύο πόδια του συνδέονται, επιτρέποντας στο ρεύμα να ρέει από το τροφοδοτικό στον ψηφιακό ακροδέκτη 2 και το σύστημα διαβάζει το σήμα διέλευσης ως ΥΨΗΛΟΣή 1.

Ας αναλύσουμε τον κώδικα κομμάτι-κομμάτι

// Η δεύτερη ακίδα συνδέεται με το κουμπί int pushButton = 2; void setup() ( Serial.begin(9600); pinMode(pushButton, INPUT); ) void loop() ( int buttonState = digitalRead(pushButton); Serial.println(buttonState); delay(1); // καθυστέρηση για σταθερότητα )

Σε λειτουργία εγκατάσταση ()αποκαθιστούμε επικοινωνία με τη θύρα για ανάγνωση δεδομένων με ταχύτητα 9600 bps από το Arduino στον υπολογιστή σας: Serial.begin(9600).

Η δεύτερη γραμμή είναι ήδη γνωστή σε εμάς, αλλά η παράμετρος χρησιμοποιείται τώρα εδώ ΕΙΣΑΓΩΓΗ- ρυθμίσαμε τη δεύτερη ψηφιακή έξοδο να διαβάζει δεδομένα που προέρχονται από το κουμπί: pinMode(pushButton, INPUT);

Στον βρόχο διαβάζουμε τις εισερχόμενες πληροφορίες. Πρώτα χρειαζόμαστε μια νέα μεταβλητή κουμπίΚατάσταση, το οποίο θα περιέχει τις τιμές 0 ή 1 που προέρχονται από τη συνάρτηση digitalRead().

Για να μπορούμε να δούμε τις εισερχόμενες πληροφορίες, πρέπει να εμφανίσουμε τα αποτελέσματα που προέκυψαν στο παράθυρο Σειριακής παρακολούθησης χρησιμοποιώντας την εντολή println().

Για μεγαλύτερη σταθερότητα κατά την ανάγνωση δεδομένων, θα ορίσουμε την ελάχιστη καθυστέρηση.

Εάν εκτελέσετε το πρόγραμμα τώρα και ανοίξετε επίσης το παράθυρο Σειριακή οθόνη(μενού Εργαλεία | Σειριακή οθόνη), τότε θα δείτε ατελείωτα μηδενικά στην οθόνη. Το πρόγραμμα μετράει συνεχώς την κατάσταση της δομής μας και εμφανίζει το αποτέλεσμα - χωρίς ρεύμα. Αν πατήσετε το κουμπί και κρατήσετε πατημένο, θα δείτε ότι οι αριθμοί αλλάζουν από 0 σε 1. Αυτό σημαίνει ότι έχει εμφανιστεί ρεύμα στο κύκλωμά μας και οι πληροφορίες έχουν αλλάξει.

02.Ψηφιακό: Κουμπί

Η εργασία με ένα κουμπί συζητείται επίσης στο παράδειγμα Αρχείο | Παραδείγματα | 02.Ψηφιακό | Κουμπί. Το κουμπί είναι συνδεδεμένο στην ακίδα 2 και η λυχνία LED είναι συνδεδεμένη στην ακίδα 13. Το κουμπί πρέπει επίσης να συνδεθεί στην τροφοδοσία και στη γείωση μέσω μιας αντίστασης 10K. Η ίδια η αρχή λειτουργίας παραμένει αμετάβλητη. Μόνο που αυτή τη φορά δεν θα εμφανίσουμε πληροφορίες για την κατάσταση του κουμπιού στην οθόνη, αλλά θα ανάψουμε το LED. Αυτή η επιλογή είναι πιο οπτική. Όταν πατάτε και αφήνετε το κουμπί, το ενσωματωμένο LED θα πρέπει να ανάβει ή να σβήνει.

Const int buttonPin = 2; // έξοδος για το κουμπί const int ledPin = 13; // Έξοδος για LED int buttonState = 0; // κατάσταση κουμπιού - πατημένο ή απελευθερωμένο void setup() ( // λειτουργία εξόδου για το LED pinMode(ledPin, OUTPUT); // λειτουργία εισόδου για το κουμπί pinMode(buttonPin, INPUT); ) void loop() ( // ανάγνωση η κατάσταση του κουμπιού κουμπιούState = digitalRead(buttonPin); // εάν πατηθεί το κουμπί, τότε η κατάστασή του είναι ΥΨΗΛΗ: εάν (buttonState == HIGH) ( // ενεργοποιήστε το LED digitalWrite(ledPin, HIGH); ) αλλιώς ( // διαφορετικά απενεργοποιήστε το LED digitalWrite(ledPin, LOW ); ) )

Ας υποθέσουμε ότι θέλουμε να αλλάξουμε τη συμπεριφορά - εάν δεν πατηθεί το κουμπί, το LED ανάβει και όταν πατηθεί, το LED δεν ανάβει. Αρκεί να αλλάξετε μια γραμμή κώδικα.

Αν (buttonState == LOW)

Και τώρα ο γρίφος! Ανεβάσατε την πρώτη έκδοση του σκίτσου στον πίνακα και ξαφνικά ο υπολογιστής σας χάλασε. Δεν μπορείτε να επεξεργαστείτε το σκίτσο για να χρησιμοποιήσετε τη δεύτερη επιλογή. Πώς μπορείτε να βγείτε από αυτή την κατάσταση;

Πρέπει να αλλάξετε την πολικότητα του κυκλώματος! Το καλώδιο από την αντίσταση που πηγαίνει στη γείωση πρέπει να συνδεθεί σε 5 V και το καλώδιο που πήγε από 5 V στο κουμπί πρέπει να συνδεθεί στη γείωση. Όταν είναι ενεργοποιημένο, το ρεύμα θα ρέει από το τροφοδοτικό στον ακροδέκτη 2 χωρίς παρεμβολές και θα ληφθεί η τιμή ΥΨΗΛΟΣ. Όταν πατήσετε το κουμπί, θα δημιουργηθεί ένα άλλο κύκλωμα και η ακίδα 2 θα παραμείνει χωρίς ρεύμα.

02.Digital: StateChangeDetection

Στο παράδειγμα Αρχείο | Παραδείγματα | 02.Ψηφιακό | StateChange DetectionΥπάρχει πλήθος κλικ κουμπιών και η κατάσταση του κουμπιού (ενεργοποίηση ή απενεργοποίηση). Το σχήμα παραμένει το ίδιο. Το κουμπί είναι συνδεδεμένο στην ακίδα 2 και η λυχνία LED είναι συνδεδεμένη στην ακίδα 13 (μπορείτε να χρησιμοποιήσετε την ενσωματωμένη). Το κουμπί θα πρέπει επίσης να είναι συνδεδεμένο στην τροφοδοσία και μια πτυσσόμενη αντίσταση 10K στη γείωση.

Const int buttonPin = 2; Κουμπί // στον ακροδέκτη 2 const int ledPin = 13; // LED στον ακροδέκτη 13 int κουμπίPushCounter = 0; // πατήστε το κουμπί μετρητής int buttonState = 0; // τρέχουσα κατάσταση του κουμπιού int lastButtonState = 0; // προηγούμενη κατάσταση του κουμπιού void setup() ( // ορίστε τη λειτουργία εισόδου για το κουμπί pinMode(buttonPin, INPUT); // ορίστε τη λειτουργία εξόδου για το LED pinMode(ledPin, OUTPUT); // ενεργοποίηση σειριακής μετάδοσης δεδομένων Serial.begin(9600) ;) void loop() ( // διαβάστε τις μετρήσεις από το κουμπί εξόδου buttonState = digitalRead(buttonPin); // συγκρίνετε την κατάσταση με την προηγούμενη κατάσταση if (buttonState != lastButtonState) ( // εάν το η κατάσταση έχει αλλάξει, αυξήστε τον μετρητή εάν (buttonState == HIGH ) ( // εάν η τρέχουσα κατάσταση είναι ΥΨΗΛΗ, τότε το κουμπί είναι ενεργοποιημένο buttonPushCounter++; Serial.println("on"); Serial.print("αριθμός πατημάτων κουμπιού: "); Serial.println(buttonPushCounter); ) else ( // εάν η τρέχουσα κατάσταση LOW, που σημαίνει ότι το κουμπί είναι απενεργοποιημένο Serial.println("off"); ) // μια μικρή καθυστέρηση για την εξάλειψη της καθυστέρησης του εφέ αναπήδησης( 50); ) // αποθηκεύστε την τρέχουσα κατάσταση ως την τελευταία κατάσταση για την επόμενη φορά lastButtonState = buttonState; // ενεργοποιήστε το LED κάθε τέταρτο πάτημα, ελέγχοντας τη διαίρεση με το υπόλοιπο του μετρητή πίεσης εάν (buttonPushCounter % 4 == 0) ( digitalWrite(ledPin, HIGH); ) else ( digitalWrite(ledPin, LOW); ) )

02.Digital: Debounce

Τα κουμπιά έχουν ένα εφέ που ονομάζεται "αναβοσβήνει". Κατά το κλείσιμο και το άνοιγμα ανάμεσα στις πλάκες του κουμπιού, εμφανίζονται μικροσπινθήρες που προκαλούν έως και δώδεκα διακόπτες σε λίγα χιλιοστά του δευτερολέπτου. Το φαινόμενο ονομάζεται αναπήδηση. Αυτό πρέπει να λαμβάνεται υπόψη εάν είναι απαραίτητο να καταγραφούν «κλικ». Επομένως, η πρωταρχική μαρτυρία δεν μπορεί να είναι αξιόπιστη. Για το λόγο αυτό, συχνά κάνουν μια μικρή καθυστέρηση στα σκίτσα, και μόνο τότε διαβάζουν τις αναγνώσεις. Στην κανονική κατάσταση, όταν δεν πατάμε το κουμπί ή κρατάμε πατημένο το κουμπί, δεν υπάρχει αποτέλεσμα αναπήδησης. Μερικές φορές για αυτούς τους σκοπούς σε εκπαιδευτικά παραδείγματα χρησιμοποιείται η συνάρτηση καθυστέρηση(), αλλά στην πράξη θα πρέπει να χρησιμοποιήσετε τη συνάρτηση millis (), όπως στο παράδειγμα Αρχείο | Παραδείγματα | 02.Ψηφιακό | Debounce. Το διάγραμμα σύνδεσης παραμένει αμετάβλητο.

Const int buttonPin = 2; Κουμπί // στον ακροδέκτη 2 const int ledPin = 13; // LED στον ακροδέκτη 13 int ledState = HIGH; // τρέχουσα κατάσταση του κουμπιού LED intState; // τρέχουσα κατάσταση εξόδου για το κουμπί int lastButtonState = LOW; // προηγούμενη κατάσταση εξόδου για το κουμπί // χρήση ανυπόγραφου τύπου για χρήση μεγάλων αριθμών χωρίς υπογραφή long lastDebounceTime = 0; // πρόσφατα ανυπόγραφο long debounceDelay = 50; // καθυστέρηση, αύξηση αν χρειάζεται void setup() ( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); digitalWrite(ledPin, ledState); ) void loop() ( // ανάγνωση της κατάστασης του κουμπιού int reading = digitalRead( buttonPin); // εάν πατηθεί το κουμπί, // τότε περιμένουμε λίγο για να εξαλειφθεί η αναπήδηση // εάν η κατάσταση έχει αλλάξει (αναπήδηση ή πάτημα) εάν (ανάγνωση != lastButtonState) ( // επαναφορά του χρονοδιακόπτη lastDebounceTime = millis(); ) if (( millis() - lastDebounceTime) > debounceDelay) ( // όποια και αν είναι η ανάγνωση, ήταν εκεί για περισσότερο από την καθυστέρηση // καθυστέρηση, οπότε πάρτε την ως την πραγματική τρέχουσα κατάσταση: / / εάν η κατάσταση του κουμπιού έχει αλλάξει εάν (reading != buttonState) ( buttonState = ανάγνωση; // αλλάξτε το LED εάν η κατάσταση του νέου κουμπιού είναι ΥΨΗΛΗ εάν (buttonState == HIGH) ( ledState = !ledState; ) ) ) // ορίστε το LED digitalWrite(ledPin, ledState); // αποθηκεύστε την κατάσταση του κουμπιού. Την επόμενη φορά στον βρόχο θα γίνει η τιμή του lastButtonState: lastButtonState = ανάγνωση; )

02.Digital: DigitalInputPullup (Ενσωματωμένη pull-up αντίσταση)

Οι ψηφιακές ακίδες διαθέτουν ήδη αντιστάσεις 20 kOhm που μπορούν να χρησιμοποιηθούν ως έλξεις κατά την εργασία με κουμπιά. Ας δούμε ένα παράδειγμα Αρχείο | Παραδείγματα | 02.Ψηφιακό | DigitalInputPullup.

Διάγραμμα σύνδεσης - συνδέστε την πρώτη ακίδα του κουμπιού στην καρφίτσα 2 στην πλακέτα και τη δεύτερη ακίδα του κουμπιού στην καρφίτσα GND. Όσο τρέχει το σκίτσο, θα διαβάζουμε τις ενδείξεις του δεύτερου pin.

Void setup() ( Serial.begin(9600); // ρυθμίστε την ακίδα 2 σε λειτουργία εισόδου και ενεργοποιήστε την ενσωματωμένη pull-up αντίσταση pinMode(2, INPUT_PULLUP); pinMode(13, OUTPUT); // LED ) void loop() ( // πάρτε τις ενδείξεις του κουμπιού int sensorVal = digitalRead(2); // έξοδο σε Serial Monitor Serial.println(sensorVal); // Θυμηθείτε ότι όταν χρησιμοποιείτε μια αντίσταση έλξης ισχύος, η κατάσταση του κουμπιού αντιστρέφεται / / Όταν δεν πατηθεί, το κουμπί έχει την τιμή HIGH και LOW όταν πατηθεί. // Όταν πατάτε το κουμπί, ανάβετε το LED, όταν το αφήσετε, απενεργοποιήστε το εάν (sensorVal == HIGH) ( digitalWrite(13, LOW); ) other (digitalWrite(13, HIGH); ) )

Αν τρέξουμε το σκίτσο, θα δούμε ότι στην οθόνη εμφανίζονται οι αριθμοί 1 ( ΥΨΗΛΟΣ). Όταν πατήσετε το κουμπί, οι τιμές θα αλλάξουν σε 0 ( ΧΑΜΗΛΟΣ).

ΚΑΙ Arduinoεδώ δεν αποτελεί εξαίρεση, αφού η λυχνία LED αναβοσβήνει, προσπαθεί να συνδέσει το κουμπί και να το χρησιμοποιήσει για να ελέγξει το αναβοσβήσιμο αυτού του LED. Δεν υπάρχει τίποτα ιδιαίτερα περίπλοκο εδώ, αλλά υπάρχει μια απόχρωση που ονομάζεται "αναπήδηση επαφής". Πώς να συνδέσετε σωστά ένα κουμπί ArduinoΤι είναι η «αναπήδηση επαφής», πώς εκδηλώνεται αυτό το αποτέλεσμα και οι μέθοδοι καταπολέμησής του θα συζητηθούν σήμερα.

Το απλούστερο διάγραμμα για τη σύνδεση ενός κουμπιού σε έναν μικροελεγκτή μοιάζει με αυτό:

Αν το κλειδί S 1είναι ανοιχτό (το κουμπί απελευθερώνεται), μετά στην ψηφιακή είσοδο Δ σεμικροελεγκτή θα έχουμε τάση 5V, που αντιστοιχεί σε λογική. Όταν πατηθεί το κουμπί, εισάγετε Δ σεσυνδέεται με τη γείωση, η οποία αντιστοιχεί στο λογικό μηδενικό επίπεδο και όλη η τάση θα πέσει στην αντίσταση R 1, η τιμή του οποίου επιλέγεται με βάση το γεγονός ότι όταν πατηθεί το κουμπί δεν διαρρέει πολύ ρεύμα (συνήθως περίπου 10÷100 kOhm).

Αν απλώς συνδέσετε ένα κουμπί μεταξύ της ψηφιακής εισόδου και της γείωσης (χωρίς αντίσταση R 1, συνδεδεμένο σε +5V) ή μεταξύ της εισόδου και των +5V, στη συνέχεια στη θέση όταν δεν πατηθεί το κουμπί, θα υπάρχει μια απροσδιόριστη τάση στην ψηφιακή είσοδο του μικροελεγκτή (μπορεί να αντιστοιχεί στο επίπεδο 0 ή ίσως 1) και θα διαβάζαμε τυχαίες καταστάσεις. Επομένως χρησιμοποιείται αντίσταση R 1, το οποίο λέγεται ότι «ανεβάζει» την είσοδο στα +5V όταν απελευθερωθεί το κουμπί.

Διαβάζοντας την κατάσταση της ψηφιακής εισόδου του μικροελεγκτή, μπορούμε να προσδιορίσουμε εάν το κουμπί είναι πατημένο (λογική κατάσταση 0) ή όχι (θα λάβουμε μια λογική στην είσοδο).

Σύνδεση κουμπιού σε Arduino

Μικροελεγκτές Atmel AVR ATmega(με βάση την οποία κατασκευάζεται Arduino) έχουν ενσωματωμένες αντιστάσεις φορτίου συνδεδεμένες με λογισμικό R n 20 kOhm και μπορούμε να τα χρησιμοποιήσουμε απλοποιώντας το διάγραμμα σύνδεσης.

Η εσωτερική αντίσταση φορτίου συνδέεται γράφοντας μια λογική στο απαιτούμενο bit της θύρας.

Παράδειγμα σκίτσου Arduino, το οποίο ανάβει και σβήνει το ενσωματωμένο LED στον ακροδέκτη 13, ανάλογα με το αν πατηθεί ή απελευθερωθεί το κουμπί που είναι συνδεδεμένο στη δεύτερη ακίδα, χρησιμοποιώντας μια εσωτερική αντίσταση φορτίου:

void setup() ( pinMode(13, OUTPUT); //LED στον ακροδέκτη 13 pinMode(2, INPUT); //2 pin είναι σε λειτουργία εισόδου. Το κουμπί είναι συνδεδεμένο στη γείωση. digitalWrite(2, HIGH); // συνδέστε την αντίσταση έλξης ) void loop() ( digitalWrite(13, !digitalRead(2)); // διαβάστε την κατάσταση του κουμπιού και αλλάξτε το LED )

Εδώ αντιστρέφουμε την τιμή που διαβάζεται από τη θύρα εισόδου χρησιμοποιώντας ένα Boolean ΔΕΝ, που υποδηλώνεται με ένα θαυμαστικό πριν από τη συνάρτηση digitalRead, αφού όταν πατηθεί το κουμπί διαβάζουμε 0 και για να ανάψουμε το LED στη θύρα πρέπει να στείλουμε το 1.

Αναπήδηση επαφής

Όλα θα ήταν καλά αν ζούσαμε σε έναν ιδανικό κόσμο με τέλεια κουμπιά. Οι πραγματικές μηχανικές επαφές που υπάρχουν στα κουμπιά δεν κλείνουν ούτε ανοίγουν ποτέ αμέσως. Σε σύντομο χρονικό διάστημα, οι επαφές του κλειδιού (κουμπιού) κλείνουν και ανοίγουν επανειλημμένα, με αποτέλεσμα να μην λαμβάνεται ούτε μία πτώση τάσης, αλλά ένα ολόκληρο πακέτο παλμών στην είσοδο του μικροελεγκτή. Αυτό το φαινόμενο ονομάζεται «αναπήδηση επαφής».

Στο παραπάνω παράδειγμα, όταν απλά ανάβαμε και σβήναμε τη λυχνία LED χρησιμοποιώντας ένα κουμπί, δεν το παρατηρήσαμε, καθώς η ενεργοποίηση/απενεργοποίηση της λυχνίας LED τη στιγμή της «αναπήδησης» έγινε πολύ γρήγορα και απλά δεν το είδαμε με μάτια.

Αυτή η βιβλιοθήκη περιλαμβάνει τις ακόλουθες μεθόδους:

• πήδημα()— προετοιμασία του αντικειμένου Bounce
• κενό διάστημα (μη υπογεγραμμένο μεγάλο διάστημα)— ορίζει τον χρόνο κατά της αναπήδησης σε χιλιοστά του δευτερολέπτου
• κενή προσάρτηση (int pin)— ορίζει την ακίδα στην οποία είναι συνδεδεμένο το κουμπί και συνδέει την ενσωματωμένη αντίσταση έλξης σε αυτήν την ακίδα
• int update()- επειδή η Πήδημαδεν χρησιμοποιεί , "ενημερώνετε" το αντικείμενο πριν διαβάσετε την κατάστασή του και αυτό πρέπει να γίνεται συνεχώς (για παράδειγμα, μέσα βρόχος). Μέθοδος εκσυγχρονίζω ενημερώνει το αντικείμενο και επιστρέφει ΑΛΗΘΗΣ(1), εάν η κατάσταση της ακίδας έχει αλλάξει (το κουμπί πατήθηκε ή, αντίθετα, απελευθερώθηκε) και ΨΕΥΔΗΣ(0) διαφορετικά. Κλήση μεθόδου εκσυγχρονίζω μέσα βρόχοςχρειάζεται να γίνει μόνο μία φορά.
• int read()— επιστρέφει την ενημερωμένη κατάσταση του pin

Από προεπιλογή, η βιβλιοθήκη Bounce χρησιμοποιεί ένα διάστημα σταθεροποίησης ( σταθερό διάστημα) για την εφαρμογή anti-bounce. Αυτό είναι πιο κατανοητό και εξαλείφει την ανάγκη να γνωρίζουμε τη διάρκεια της φλυαρίας.

Παράμετρος σταθερό διάστημαΒιβλιοθήκες αναπήδησης

Έχοντας αποφασίσει

#define BOUNCE_LOCK-OUT

στο αρχείο Αναπήδηση.ηΜπορείτε να ενεργοποιήσετε μια εναλλακτική μέθοδο κατά του χτυπήματος. Αυτή η μέθοδος σάς επιτρέπει να αντιδράτε πιο γρήγορα στις αλλαγές στην κατάσταση του κουμπιού, ωστόσο, απαιτεί να ορίσετε τη διάρκεια της αναπήδησης και αυτή η τιμή, όπως σημείωσα παραπάνω, αυξάνεται με την πάροδο του χρόνου, πράγμα που σημαίνει ότι θα χρειαστεί να κάνετε αλλαγές στο κωδικό ή ορίστε μια εσκεμμένα μεγαλύτερη τιμή.

Ακολουθεί ένα παράδειγμα χρήσης αυτής της βιβλιοθήκης:

#περιλαμβάνω Bounce bouncer = Bounce(); void setup() ( pinMode(2,INPUT); // κουμπί στην καρφίτσα 2 digitalWrite(2,HIGH); bouncer .attach(2); // ορίστε το κουμπί bouncer .interval(5); Serial.begin(9600) . Serial .println("pressed"); //εμφάνιση μηνύματος σχετικά με το πάτημα ) other Serial.println("released"); //εμφάνιση μηνύματος σχετικά με την απελευθέρωση ) )

Και ένα ακόμη μικρό πρακτικά χρήσιμο παράδειγμα. Ας έχουμε ένα κουμπί που, όταν πατηθεί για λιγότερο από 2 δευτερόλεπτα, αλλάζει μια μεταβλητή τρέχουσα_λειτουργία, το οποίο αποθηκεύει τον τρέχοντα τρόπο λειτουργίας μιας συσκευής. Σε αυτό το παράδειγμα, η λειτουργία θα αλλάξει από 0 σε 5. Πιέζεται μία φορά - η λειτουργία είναι ο αριθμός 1. Πιέζεται ξανά - 2. Και ούτω καθεξής μέχρι το πέντε. Μετά από πέντε, με το επόμενο πάτημα, η τρέχουσα λειτουργία γίνεται η πρώτη και ξανά σε κύκλο. Εάν κρατήσετε πατημένο το κουμπί για περισσότερο από 2 δευτερόλεπτα, η μεταβλητή τρέχουσα_λειτουργίααποδίδεται η τιμή 0.

#περιλαμβάνω #define pressed_long 2000 // παρατεταμένο πάτημα = 2 δευτερόλεπτα #define num_modes 5 // μέγιστος αριθμός λειτουργίας short int max_mode = num_modes + 1; // βοηθητική μεταβλητή Bounce bouncer = Bounce(); //δημιουργία μιας παρουσίας της κλάσης Bounce unsigned long pressed_moment; // στιγμή πατήματος του κουμπιού int current_mode = 0; // τρέχουσα λειτουργία void setup() ( pinMode(2,INPUT); // κουμπί στην ακίδα 2 digitalWrite(2,HIGH); // συνδέστε το ενσωματωμένο pull-up resistor bouncer .attach(2); // install το κουμπί bouncer .interval( 5); // ορίστε το σταθερό διάστημα της παραμέτρου = 5 ms Serial.begin(9600); // ρύθμιση της σειριακής θύρας στα 9600 bps) void loop() ( if (bouncer.update()) ( //αν συνέβη συμβάν εάν (bouncer.read()==0) ( //αν πατηθεί το κουμπί pressed_moment = millis(); // θυμηθείτε την ώρα πατήματος ) αλλιώς ( // το κουμπί απελευθερωθεί εάν (( millis() - pressed_moment)< pressed_long) { // если кнопка была нажата кратковременно current_mode++; // увеличиваем счетчик текушего режима current_mode %= max_mode; // остаток от целочисленного деления if (current_mode == 0) current_mode = 1; // режим меняется от 1 до num_modes } else { // кнопка удерживалась долго current_mode = 0; pressed_moment = 0; // обнуляем момент нажатия } Serial.println("Current mode:"); Serial.println(current_mode); // выводим сообщение о текущем режиме } } }

/*
* Πειραματικό κιτ ArduinoKit
* Κωδικός προγράμματος για το πείραμα Νο. 5: σκίτσο 05
*
* ΚΟΥΜΠΙΑ
*
* Γράφτηκε για τον ιστότοπο http://site
*
*
* Βοήθεια από την κοινότητα του Arduino.
* Επισκεφθείτε τη διεύθυνση http://www.arduino.cc
*
* Σχόλιο για το πρόγραμμα που έγραψε
* 22 Ιανουαρίου 2014
* ειδικά για http://site
*/

ΚΟΥΜΠΙΑ.

Χρήση κουμπιών σε ψηφιακές εισόδους.

Παλαιότερα χρησιμοποιούσαμε αναλογικές θύρες (pins) για την εισαγωγή δεδομένων, αλλά τώρα θα δούμε τις ψηφιακές θύρες σε δράση. Επειδή οι ψηφιακές θύρες γνωρίζουν μόνο δύο επίπεδα σήματος —το υψηλό «+5» και το χαμηλό «0»—είναι ιδανικές για αλληλεπίδραση με κουμπιά και διακόπτες που έχουν επίσης μόνο δύο θέσεις, «On» και «Off».

Θα συνδέσουμε τη μία ακίδα του κουμπιού με ένα καλώδιο στη γείωση και την άλλη καρφίτσα στην ψηφιακή θύρα. Όταν πατήσετε το κουμπί, το κύκλωμα θα κλείσει και το άκρο γείωσης "-" θα συνδεθεί στην ψηφιακή θύρα, και επομένως το λαμβανόμενο σήμα θα θεωρείται "χαμηλό" από το Arduino.

Αλλά περιμένετε - τι συμβαίνει όταν το κουμπί δεν πατηθεί; Σε αυτή την κατάσταση, η θύρα είναι αποσυνδεδεμένη από τα πάντα, κρέμεται δηλαδή στον αέρα και αυτή την ακατανόητη κατάσταση την ονομάζουμε «ακαθόριστη» ή αιωρούμενη. Δηλαδή, δεν μπορούμε να πούμε με βεβαιότητα πώς θα αντιδράσει το Arduino σε μια τέτοια κατάσταση. Ανάλογα με τις διάφορες περιβαλλοντικές συνθήκες, αυτό μπορεί να γίνει αντιληπτό από αυτήν είτε ως ΥΨΗΛΟ (“HIGH” +5 Volts) είτε ως LOW (“LOW” - λογικό μηδέν).

Για να αποφύγουμε τυχόν αποκλίσεις και ο μικροελεγκτής γνωρίζει ακριβώς τι βρίσκεται αυτή τη στιγμή στην είσοδό του, θα συνδέσουμε επιπλέον τη θύρα Arduino μέσω μιας περιοριστικής αντίστασης (οποιαδήποτε με βαθμολογία 1KOhm - 10KOhm θα κάνει) στο δίαυλο +5 Volt. Αυτό το "pull-up" θα εγγυηθεί την παρουσία ενός σταθερού σήματος HIGH +5V και όταν πατήσετε το κουμπί, το κύκλωμα θα κλείσει στο Ground - "0", που σημαίνει για το Arduino, το σήμα εισόδου θα αλλάξει από HIGH σε LOW , δηλ. από ΥΨΗΛΟ +5V έως ΧΑΜΗΛΟ «0».

(Επιπλέον: Μόλις συνηθίσετε τις αντιστάσεις και μάθετε πότε χρειάζονται, μπορείτε να ενεργοποιήσετε τις εσωτερικές αντιστάσεις έλξης που βρίσκονται στον ίδιο τον επεξεργαστή ATmega. Για πληροφορίες, δείτε http://arduino.cc/en/Tutorial/ DigitalPins).

Σύνδεση εξοπλισμού:

Τα κουμπιά έχουν δύο επαφές, εάν πατηθεί το κουμπί, η επαφή είναι κλειστή, εάν δεν πατηθεί, η επαφή είναι ανοιχτή.

Στα κουμπιά θα χρησιμοποιήσουμε και δύο και τέσσερις επαφές, αλλά πρέπει να σημειωθεί ότι στα κουμπιά που θα χρησιμοποιήσουμε τώρα, δύο επαφές είναι παράλληλες.

Ο ευκολότερος τρόπος για να συνδέσετε ένα κουμπί είναι να συνδέσετε τα καλώδια στους ακροδέκτες - λοξά (διαγώνια).

Συνδέστε οποιαδήποτε ακίδα του κουμπιού 1 στη γείωση (GND).
Συνδέστε την άλλη ακίδα του κουμπιού στην ψηφιακή θύρα 2.

Συνδέστε οποιαδήποτε ακίδα του κουμπιού 2 στη γείωση (GND).
Συνδέστε την ακίδα του άλλου κουμπιού στην ψηφιακή θύρα 3.

Στα πόδια των κουμπιών που πηγαίνουν στις ψηφιακές θύρες 2,3, συνδέστε αντιστάσεις «pull-up» των 10K (καφέ/μαύρο/κόκκινο) και συνδέστε τους δεύτερους ακροδέκτες αυτών των αντιστάσεων στο κοινό «-» (GND). Αυτές οι αντιστάσεις διασφαλίζουν ότι η είσοδος θα είναι είτε +5V (το κουμπί δεν πατιέται) είτε "0" όταν πατηθεί, και τίποτα άλλο. (Και μην ξεχνάτε ότι, σε αντίθεση με τις αναλογικές εισόδους, οι ψηφιακές είσοδοι έχουν μόνο δύο καταστάσεις: ΥΨΗΛΗ και ΧΑΜΗΛΗ.)

Δίοδος εκπομπής φωτός:

Οι περισσότερες πλακέτες Arduino, συμπεριλαμβανομένου του UNO, έχουν ήδη εγκατεστημένο ένα LED, με αντίσταση περιορισμού ρεύματος, συνδεδεμένο στη θύρα 13. Και δεν χρειάζεται να εγκαταστήσετε τη δική σας.

Αλλά, εάν αποφασίσετε να συνδέσετε το δικό σας, για περισσότερες πληροφορίες, δεν θα είναι χειρότερο.

Συνδέστε το θετικό καλώδιο του LED στην ψηφιακή θύρα Arduino #13
Συνδέστε το αρνητικό καλώδιο του LED σε μια αντίσταση 330 ohm.
Συνδέστε τον άλλο ακροδέκτη της αντίστασης στο GND "-".

// Πρώτα θα δημιουργήσουμε σταθερές, δηλ. ας δώσουμε ονόματα στα κουμπιά που θα είναι
// παραμένει αμετάβλητο μέχρι το τέλος του κώδικα προγράμματος και δεσμεύει αυτά τα ονόματα στις θύρες Arduino.
// Αυτό διευκολύνει την κατανόηση και την εργασία με τον κώδικα του προγράμματος και επίσης επιτρέπει
// αναφερθείτε στο λιμάνι με το όνομα.

const int button1Pin = 2; // κουμπί αριθμός 1 - θύρα 2
const int button2Pin = 3; // κουμπί αριθμός 2 - θύρα 3
const int ledPin = 13; // Θύρα 13, για LED

void setup()
{
// Ορίστε τις θύρες κουμπιών ως εισερχόμενες:
pinMode(button1Pin, INPUT);
pinMode(button2Pin, INPUT);

// Ορίστε τη θύρα LED ως εξερχόμενη:
pinMode(ledPin, OUTPUT);
}

void loop()
{
int button1State, button2State; // μεταβλητές για αποθήκευση της κατάστασης των κουμπιών

// Επειδή τα κουμπιά έχουν μόνο δύο καταστάσεις (πατημένο και όχι πατημένο) θα το κάνουμε
// εργαστείτε μαζί τους χρησιμοποιώντας ψηφιακές θύρες εισόδου. Για να διαβάσω
// πληροφορίες θα χρησιμοποιήσουμε τη συνάρτηση digitalRead(). Αυτή η δυνατότητα επιτρέπει
// λαμβάνει μία παράμετρο από την ψηφιακή θύρα και επιστρέφει είτε HIGH (+5V),
// ή LOW (“0”).

// Εδώ διαβάζουμε την τρέχουσα κατάσταση των κουμπιών και βάζουμε την τιμή τους
// σε δύο μεταβλητές:

button1State = digitalRead(button1Pin);
button2State = digitalRead(button2Pin);

// Θυμηθείτε, εάν πατήσετε το κουμπί, η θύρα θα συνδεθεί στη γείωση ("-").
// Εάν δεν πατηθεί το κουμπί, η θύρα θα συνδεθεί στα +5 βολτ μέσω μιας αντίστασης έλξης.

// Έτσι η κατάσταση θύρας θα είναι LOW όταν πατηθεί το κουμπί,
// και HIGH (υψηλό) όταν δεν είναι πατημένο.

// Τώρα θα χρησιμοποιήσουμε την κατάσταση των θυρών για να ελέγξουμε το LED.

// Τι θέλουμε να κάνουμε, προϋπόθεση:
// "Εάν πατηθεί οποιοδήποτε κουμπί, το LED ανάβει"
// "Αλλά εάν πατηθούν και τα δύο κουμπιά, το LED δεν θα ανάψει"
// Ας το μεταφράσουμε σε κώδικα.

// Το Arduino έχει ειδικούς λογικούς τελεστές και τελεστές σύγκρισης,
// που χρησιμοποιούνται συχνά για τον έλεγχο συνθηκών, ιδίως:

// "==" (ισότητα) - Σωστό αν και οι δύο πλευρές είναι ίδιες
// Παράδειγμα:
// αν (x == y) (
// κατάσταση σώματος
//}

// "&&" (λογικό ΚΑΙ) - Σωστό μόνο εάν πληρούνται και οι δύο προϋποθέσεις
// Παράδειγμα:
// True αν και οι δύο εκφράσεις είναι True
// εάν (x > 0 && x< 5) {
// κατάσταση σώματος
//}

// "!" (λογικό ΟΧΙ)
// True αν ο τελεστής είναι false
// Παράδειγμα:
//αν (!x) (
// κατάσταση σώματος
//}

// "||" (λογικό Ή) - Σωστό εάν τουλάχιστον μία από τις συνθήκες είναι αληθής
// Παράδειγμα:
//αν (x > 0 || y > 0) (
// κατάσταση σώματος
// }

// Σε αυτήν την περίπτωση, θα χρησιμοποιήσουμε την κατασκευή "αν" για να μεταφράσουμε τα πάντα
// τα παραπάνω στις λογικές αλυσίδες του προγράμματος.
// (Μην ξεχνάτε, LOW σημαίνει ότι το κουμπί είναι πατημένο)

// "Εάν πατηθεί ένα από τα κουμπιά, το LED ανάβει"
// θα αποδειχθεί:
// if ((button1State == LOW) || (button2State == LOW)) // ανάβει το LED

// "Εάν πατηθούν και τα δύο κουμπιά, το LED δεν ανάβει"
// θα αποδειχθεί:
// εάν ((button1State == LOW) && (button2State == LOW)) // δεν ανάβει το LED

// Τώρα ας χρησιμοποιήσουμε τις παραπάνω συναρτήσεις και ας τις συνδυάσουμε σε μια πρόταση:

εάν (((button1State == LOW) || (button2State == LOW)) // συγκρίνετε εάν έχει πατηθεί ένα από τα κουμπιά
&& ! // και αν όχι
((button1State == LOW) && (button2State == LOW))) // συγκρίνετε εάν έχουν πατηθεί και τα δύο κουμπιά
// Επειτα…
{
digitalWrite(ledPin, HIGH); // ενεργοποιήστε το LED
}
αλλιώς // αλλιώς
{
digitalWrite(ledPin, LOW); // απενεργοποιήστε το LED
}

// Όπως ίσως έχετε παρατηρήσει, οι τελεστές μπορούν να συνδυαστούν
// για την επίλυση σύνθετων προβλημάτων

// Μην ξεχνάτε: Δεν μπορείτε να χρησιμοποιήσετε τον τελεστή "=" όταν συγκρίνετε τιμές
// "==" επειδή ο τελεστής "=" εκχωρεί μια τιμή σε μεταβλητές!
}

Σε επόμενο άρθρο θα δημοσιεύσουμε τον κώδικα του μαθήματος Νο 5 ως αρχείο.

Μιλήσαμε για τα βασικά του προγραμματισμού Arduino. Σήμερα θα μιλήσουμε για τα σήματα Arduino GPIO και PWM. Θα χρησιμοποιήσουμε κουμπιά και θα ελέγξουμε τη φωτεινότητα του LED χρησιμοποιώντας ένα σήμα PWM. Θα χρησιμοποιήσουμε επίσης συναρτήσεις στο περιβάλλον προγραμματισμού Arduino.

Αρχικά, ας προσπαθήσουμε να ελέγξουμε το LED χρησιμοποιώντας ένα κουμπί.

Θα χρειαστούμε:

1. Αντίστασηονομαστική αξία περίπου. 100-400 ohm.Για να περιορίσετε το ρεύμα που περνάει από το LED για να μην το καεί.
2. Αντίστασηονομαστική αξία περίπου. 10 δωμάτιαΓια να ανεβείτε λογικά επίπεδα στην είσοδο Arduino. Εάν δεν το εγκαταστήσετε, τότε το κουμπί μας θα λειτουργεί πολύ ασταθή, γιατί... Θα υπάρχει θόρυβος στην είσοδο Arduino αντί για χρήσιμο σήμα.
3. Δίοδος εκπομπής φωτός AL307ή όποιον σας αρέσει. Στην πραγματικότητα, θα το ανάψουμε.
4. Κουμπί τακτ IT-1102ή οποιοδήποτε άλλο. Θα χρησιμοποιηθεί για τον έλεγχο του LED.

Τώρα ήρθε η ώρα να συναρμολογήσετε ένα απλό κύκλωμα, μπορείτε να το κάνετε χρησιμοποιώντας την πλακέτα εντοπισμού σφαλμάτων BreadBoard ή χρησιμοποιώντας συγκολλητικό σίδερο και καλώδια.

Δίοδος εκπομπής φωτόςσυνδεδεμένη μέσω μιας αντίστασης περιορισμού ρεύματος 200 ohm στην έξοδο 10 του Arduino, η τιμή της αντίστασης μπορεί να ρυθμιστεί στα 200 ohms - 500 ohms, αυτό θα αλλάξει το ρεύμα που ρέει μέσω του LED και, κατά συνέπεια, τη φωτεινότητα του. Εάν συνδέσετε απευθείας ένα LED, θα τελειώσει άσχημα, ένα μεγάλο ρεύμα θα ρέει μέσω του LED, με αποτέλεσμα είτε το ίδιο το LED είτε η έξοδος Arduino να αποτύχει. Είναι επίσης απαραίτητο να ληφθεί υπόψη ότι ένα LED είναι τελικά δίοδος, έχει πολικότητα!

Εάν συνδέσετε λανθασμένα το LED, δεν θα ανάψει γιατί δεν θα περάσει ρεύμα (απλά θα κλείσει). Είναι εύκολο να προσδιοριστεί η πολικότητα ενός LED· το κοντό σκέλος του LED είναι αρνητικό (δηλαδή μηδέν ή GND) και το μακρύ σκέλος είναι +.

Κουμπίσυνδεδεμένο με τέτοιο τρόπο ώστε τη στιγμή του πατήματος να αλλάζει +5 volt στην είσοδο Νο 10 του Arduino, που αντιστοιχεί στη λογική μονάδα της ψηφιακής εισόδου Arduino. Τη στιγμή που δεν πατιέται το κουμπί, η αντίστασή μας 10 kohm θα τραβήξει την είσοδο Arduino στο GND (δηλαδή στο μηδέν) και η είσοδος Arduino θα είναι σταθερά λογικό μηδέν. Εάν δεν χρησιμοποιήσετε αυτήν την αντίσταση έλξης, τότε είναι πολύ πιθανό να προκύψουν ψευδείς συναγερμοί, αυτό οφείλεται στο γεγονός ότι δεν θα υπάρχει αντίσταση έλξης στην είσοδο Arduino και, κατά συνέπεια, η τάση δεν θα είναι μηδέν, θα αλλάξει χαοτικά, πράγμα που συνεπάγεται την εμφάνιση ψευδούς λογικής στην είσοδο Arduino.

Λοιπόν, ήρθε η ώρα να γράψετε ένα πρόγραμμα για το Arduino. Αρχικά, ας κρατήσουμε το LED αναμμένο όσο είναι πατημένο το κουμπί. Φυσικά, είναι πολύ εύκολο να λυθεί ένα τέτοιο πρόβλημα χωρίς μικροελεγκτή, αλλά πρέπει να ξεκινήσουμε από κάπου. Ανοίξτε το περιβάλλον προγραμματισμού Arduino (ο τρόπος προγραμματισμού του Arduino περιγράφεται λεπτομερώς στο Νο. 1) και Ας αρχίσουμε να γράφουμε τον κώδικα:

/*

Αναβοσβήνουμε το LED.
Θα διατηρήσουμε το LED αναμμένο όσο είναι πατημένο το κουμπί.

*/

{


}

{
if (digitalRead(switchPin) == HIGH) // Εάν πατηθεί το κουμπί, η μεταβλητή switchPin μας θα έχει την τιμή HIGH (λογικό 1) και θα εκτελεστεί ο ακόλουθος κώδικας. γραμμή
{
digitalWrite(ledPin, HIGH); // Ανάψτε το LED ρυθμίζοντας τη λογική 1 (επίπεδο HIGH) στην έξοδο 13
}
else // Εάν δεν πατηθεί το κουμπί, θα εκτελεστεί ο παρακάτω κώδικας.
{
digitalWrite(ledPin, LOW); // Απενεργοποιήστε το LED
}
}

Λοιπόν, τι λειτουργεί;! :)

Τώρα ας περιπλέκουμε την εργασία, βεβαιωθείτε ότι όταν πατάτε το κουμπί, το LED ανάβει και παραμένει αναμμένο μέχρι να το πατήσουμε ξανά και ούτω καθεξής σε κύκλο.

Ο κώδικας μας για αυτούς τους σκοπούς θα μοιάζει με αυτό:

/*
Μάθημα 2. GPIO, Κουμπιά και PWM στο Arduino

Θα ανάψουμε το LED αφού πατήσουμε το κουμπί και θα το σβήσουμε μετά το δεύτερο πάτημα.
Αυτός ο κωδικός επίδειξης λήφθηκε από το www.site
*/

int switchPin = 10; // Για ευκολία, ορίστε το όνομα "switchPin" για την ακίδα 10
int ledPin = 13; // Για ευκολία, ορίστε το όνομα "ledPin" για την ακίδα 13


void setup() // Το μπλοκ "Setup" εκτελείται μόνο 1 φορά όταν ξεκινά το Arduino, χρειάζεται για την προετοιμασία.
{
pinMode(switchPin, INPUT); // Ρύθμιση παραμέτρων Arduino pin 10 ως είσοδο. Επειδή θα διαβάσουμε την κατάσταση του κουμπιού.
pinMode(ledPin, OUTPUT); // Ρύθμιση παραμέτρων Arduino pin 13 ως έξοδο. Με αυτό θα ανάψουμε το LED.
}

void loop() // Το μπλοκ "loop" είναι ένας βρόχος, δηλ. κώδικας που λειτουργεί ξανά και ξανά ατελείωτα
{
if (digitalRead(switchPin) == HIGH && lastButton == LOW) // Εάν πατηθεί το κουμπί και η κατάσταση του τελευταίου κουμπιού ήταν "δεν πατήθηκε", τότε εκτελέστε τον ακόλουθο κωδικό
{

lastButton = ΥΨΗΛΟ; // Αλλάξτε την τιμή του lastButton σε λογική τιμή
}
αλλού
{
lastButton = digitalRead(switchPin); // Ορίστε τη μεταβλητή lastButton στην ίδια τιμή με τη μεταβλητή switchPin
}

}

Λοιπόν, πώς λειτουργεί;! Χμ... Παράξενο.. Μερικές φορές όλα λειτουργούν όπως αναμενόταν για εμάς, και μερικές φορές όχι... Γιατί μπορεί να συμβεί αυτό; Όλα έχουν να κάνουν με το εφέ "αναπήδησης επαφής":

Όπως μπορείτε να δείτε σε αυτόν τον παλμογράφο, στην πραγματικότητα, το κουμπί μας δεν λειτουργεί τέλεια... Και αν μετρήσουμε το κουμπί με υψηλή συχνότητα, τότε τη στιγμή της μετάβασης μπορούμε να μετρήσουμε και το ένα και το μηδέν. Θα ήταν καλύτερο να χρησιμοποιήσουμε λύσεις υλικού για το πρόβλημα, αλλά τώρα μιλάμε για τον κώδικά μας. Για να αποφύγουμε αυτό το κροτάλισμα θα πρέπει να τροποποιήσουμε το πρόγραμμα και απλά εισαγω χρονοκαθυστερηση:

/*
Μάθημα 2. GPIO, Κουμπιά και PWM στο Arduino
Ενεργοποιήστε/σβήστε το LED.
Θα ανάψουμε το LED αφού πατήσουμε το κουμπί και θα το σβήσουμε μετά το δεύτερο πάτημα και θα εξαλείψουμε την αναπήδηση των κουμπιών.
Αυτός ο κωδικός επίδειξης λήφθηκε από το www.site

int switchPin = 10; // Για ευκολία, ορίστε το όνομα "switchPin" για την ακίδα 10
int ledPin = 13; // Για ευκολία, ορίστε το όνομα "ledPin" για την ακίδα 13
Boolean lastButton = LOW; // Σε αυτή τη μεταβλητή θα αποθηκεύσουμε την κατάσταση του κουμπιού κατά την προηγούμενη επεξεργασία του βρόχου μας, και επίσης θα τη μηδενίσουμε.
boolean ledOn = ψευδής; // Σε αυτή τη μεταβλητή θα αποθηκεύσουμε την κατάσταση του LED έτσι ώστε να μπορούμε να το αλλάξουμε

void setup() // Το μπλοκ "Setup" εκτελείται μόνο 1 φορά όταν ξεκινά το Arduino, χρειάζεται για την προετοιμασία.
{
pinMode(switchPin, INPUT); // Ρύθμιση παραμέτρων Arduino pin 10 ως είσοδο. Επειδή θα διαβάσουμε την κατάσταση του κουμπιού.
pinMode(ledPin, OUTPUT); // Ρύθμιση παραμέτρων Arduino pin 13 ως έξοδο. Με αυτό θα ανάψουμε το LED.
}

{


{


}

}

void loop() // Το μπλοκ "loop" είναι ένας βρόχος, δηλ. κώδικας που λειτουργεί ξανά και ξανά ατελείωτα

{


{
ledOn = !ledOn; // Αλλάξτε την τιμή ledOn στο αντίθετο
}

digitalWrite(ledPin, ledOn); // Στην πραγματικότητα αυτή η γραμμή θα ανάψει και θα σβήσει το LED
}

Νομίζω ότι τώρα όλα λειτούργησαν όπως έπρεπε για όλους;)

Τώρα ήρθε η ώρα να αλλάξουμε το πρόγραμμά μας έτσι ώστε μετά από κάθε πάτημα του κουμπιού να αλλάζει η φωτεινότητα του LED, για αυτό θα χρησιμοποιήσουμε ένα σήμα PWM ή όπως λέγεται και PWM. Αν θέλετε να μάθετε περισσότερα για το PWM, μπορείτε να διαβάσετε σχετικά στο WIKI. Αλλά για εμάς αυτή τη στιγμή αρκεί να γνωρίζουμε μόνο ότι αλλάζοντας τις λογικές τιμές 0 και 1 σε μια συγκεκριμένη σειρά, μπορείτε να κάνετε το LED να λάμπει διαφορετικά, αλλά στην ουσία απλά θα αναβοσβήνει διαφορετικά, αλλά επειδή η συχνότητα αναβοσβήνει είναι ψηλά, θα φαίνεται στο μάτι ότι είναι απλώς αλλάζει φωτεινότητα.

Αλλά δυστυχώς δεν υποστηρίζουν όλες οι έξοδοι Arduino PWM, η υποστήριξη PWM υποδεικνύεται από το εικονίδιο ~ δίπλα στον αριθμό pin στη μεταξοτυπία του Arduino. Ένας από αυτούς τους ακροδέκτες είναι ο pin No. 11 και ο τρέχων pin No. 13 δεν υποστηρίζει PWM, επομένως πρέπει να αλλάξουμε το διάγραμμα σύνδεσης ως εξής:

Και επίσης κάντε αλλαγές στον κωδικό του προγράμματος, δηλαδή, πρέπει να αλλάξετε τον αριθμό επικοινωνίας και προσθέστε χρήση PWM:

/*
Μάθημα 2. GPIO, Κουμπιά και PWM στο Arduino
Αλλάξτε τη φωτεινότητα του LED.
Θα αλλάζουμε τη φωτεινότητα του LED μετά από κάθε πάτημα κουμπιού.
Αυτός ο κωδικός επίδειξης λήφθηκε από το www.site
*/

int switchPin = 10; // Για ευκολία, ορίστε το όνομα "switchPin" για την ακίδα 10
int ledPin = 11; // Για ευκολία, ορίστε το όνομα "ledPin" για την ακίδα 11
Boolean lastButton = LOW; // Σε αυτή τη μεταβλητή θα αποθηκεύσουμε την κατάσταση του κουμπιού κατά την προηγούμενη επεξεργασία του βρόχου μας, και επίσης θα τη μηδενίσουμε.
int ledLevel = 0; // Σε αυτή τη μεταβλητή θα αποθηκεύσουμε τη φωτεινότητα της λυχνίας LED, η φωτεινότητα μπορεί να έχει τιμή από 0 έως 255, τη στιγμή της αρχικοποίησης θα την ορίσουμε στο 0 για να μην ανάβει η λυχνία LED
Κουμπί δυαδικού ρεύματος = LOW; // Μεταβλητή για τη συνάρτηση αναπήδησης

void setup() // Το μπλοκ "Setup" εκτελείται μόνο 1 φορά όταν ξεκινά το Arduino, χρειάζεται για την προετοιμασία.
{
pinMode(switchPin, INPUT); // Ρύθμιση παραμέτρων Arduino pin 10 ως είσοδο. Επειδή θα διαβάσουμε την κατάσταση του κουμπιού.
pinMode(ledPin, OUTPUT); // Ρύθμιση παραμέτρων Arduino pin 13 ως έξοδο. Με αυτό θα ανάψουμε το LED.
}

boolean debounce(boolean last) //συνάρτηση για απομάκρυνση των επαφών του κουμπιού, θα επιστρέψει την προηγούμενη κατάστασή της
{
boolean ρεύμα = digitalRead(switchPin); // Γράψτε την τρέχουσα κατάσταση του κουμπιού σε τρέχουσα
if (τελευταίο != τρέχον) // Ελέγξτε αν έχει αλλάξει η κατάσταση του κουμπιού
{
καθυστέρηση(5); // Εάν ναι, κάνουμε μια καθυστέρηση 5 χιλιοστών του δευτερολέπτου, έτσι ώστε το κουμπί να σταματήσει να "κουδουνίζει"
τρέχον = digitalRead(switchPin); // Διαβάστε την τιμή του κουμπιού μετά από μια παύση, τώρα η φλυαρία θα έπρεπε να έχει περάσει
}
ρεύμα επιστροφής? // επιστρέψτε τη σταθερή τιμή του κουμπιού
}

void loop() // Το μπλοκ "loop" είναι ένας βρόχος, δηλ. κώδικας που λειτουργεί ξανά και ξανά ατελείωτα
{
currentButton = debounce(lastButton); // περάστε στο CurrentButton το αποτέλεσμα της συνάρτησης αναπήδησης με την κατάσταση του κουμπιού να μεταβιβαστεί σε αυτήν
εάν (lastButton == LOW && currentButton == HIGH) // Ελέγξτε εάν το κουμπί έχει πατηθεί
{
ledLevel = ledLevel + 51; // Αλλάξτε την τιμή φωτεινότητας σε 51
}
lastButton = τρέχον Κουμπί; // Ορίστε τη μεταβλητή lastButton στην ίδια τιμή με τη μεταβλητή currentButton

εάν (ledLevel > 255) ledLevel = 0; // Περιορίστε το μέγ. αξία 255
analogWrite(ledPin, ledLevel); // Στην πραγματικότητα αυτή η γραμμή θα ανάψει το LED με την απαιτούμενη φωτεινότητα
}

Ελπίζω ότι όλα λειτούργησαν για εσάς. Αυτό είναι το τέλος του μαθήματος.

Μπορείτε να κάνετε ερωτήσεις και να ζητήσετε συμβουλές στα σχόλια.

Η σύνδεση ενός αισθητήρα κουμπιού σε ένα Arduino απαιτεί ορισμένες γνώσεις και δεξιότητες. Σε αυτό το άρθρο θα μιλήσουμε για το τι είναι το κουμπί τακτ, τι είναι η αναπήδηση του κουμπιού, πώς να συνδέσετε σωστά ένα κουμπί με μια αντίσταση pull-up και pull-down, πώς μπορείτε να ελέγξετε τα LED και άλλες συσκευές χρησιμοποιώντας ένα κουμπί.

Ένα κουμπί (ή διακόπτης με κουμπιά) είναι ο απλούστερος και πιο προσιτός από όλους τους τύπους αισθητήρων. Κάνοντας κλικ σε αυτό, στέλνετε ένα σήμα στον ελεγκτή, το οποίο στη συνέχεια οδηγεί σε ορισμένες ενέργειες: ανάβουν τα LED, ακούγονται ήχοι, ξεκινούν οι κινητήρες. Στη ζωή μας, συναντάμε συχνά διαφορετικούς διακόπτες και είμαστε πολύ εξοικειωμένοι με αυτήν τη συσκευή.

Κουμπιά τακτ και κουμπιά διακόπτη

Ως συνήθως, ξεκινάμε την ενότητα με απλά πράγματα που είναι ενδιαφέροντα μόνο για αρχάριους. Εάν γνωρίζετε τα βασικά και θέλετε να μάθετε για τις διάφορες επιλογές για τη σύνδεση ενός κουμπιού σε ένα Arduino, μπορείτε να παραλείψετε αυτήν την παράγραφο.

Τι είναι ένα κουμπί; Στην ουσία πρόκειται για μια αρκετά απλή συσκευή που κλείνει και ανοίγει το ηλεκτρικό δίκτυο. Μπορείτε να εκτελέσετε αυτό το κλείσιμο/άνοιγμα σε διαφορετικούς τρόπους λειτουργίας, ενώ στερεώνετε ή όχι τη θέση σας. Κατά συνέπεια, όλα τα κουμπιά μπορούν να χωριστούν σε δύο μεγάλες ομάδες:

• Κουμπιά διακόπτη με στερέωση. Επιστρέφουν στην αρχική τους κατάσταση μετά την απελευθέρωση. Όταν, ανάλογα με την αρχική κατάσταση, χωρίζονται σε κανονικά κλειστά και κανονικά ανοιχτά κουμπιά.
• Στιγμιαία κουμπιά (κουμπιά τακτ). Διορθώνονται και παραμένουν στη θέση που είχαν αφεθεί.

Υπάρχουν πολλές επιλογές για διαφορετικά κουμπιά, αυτό είναι πραγματικά ένας από τους πιο συνηθισμένους τύπους ηλεκτρονικών εξαρτημάτων.

Κουμπιά Arduino για απλά έργα

Στα έργα μας θα εργαστούμε με πολύ απλά κουμπιά ρολογιού 4 ποδιών που συνοδεύονται σχεδόν από οποιοδήποτε κιτ Arduino. Το κουμπί είναι ένας διακόπτης με δύο ζεύγη επαφών. Οι επαφές σε ένα ζεύγος συνδέονται μεταξύ τους, επομένως δεν θα είναι δυνατή η εφαρμογή περισσότερων από έναν διακόπτη στο κύκλωμα, αλλά μπορείτε να ελέγξετε ταυτόχρονα δύο παράλληλα τμήματα, αυτό μπορεί να είναι χρήσιμο.

Ανάλογα με την κατάσταση, μπορείτε να δημιουργήσετε και τα δύο κυκλώματα με κανονικά κλειστές και κανονικά ανοιχτές επαφές - το μόνο που χρειάζεται να κάνετε είναι να κάνετε τις συνδέσεις στο κύκλωμα ανάλογα.

Για ευκολία στη χρήση, το κουμπί τακτ συνήθως συνοδεύεται από ένα πλαστικό καπάκι κάποιου χρώματος· ταιριάζει σαφώς πάνω από το κουμπί και δίνει στο έργο μια εμφάνιση λιγότερο σαν χάκερ.

Σύνδεση του κουμπιού Arduino

Ενεργοποίηση και απενεργοποίηση του LED χρησιμοποιώντας ένα κουμπί

Ας ξεκινήσουμε με τον απλούστερο τρόπο σύνδεσης ενός κουμπιού τακτ. Σκεφτείτε ένα κύκλωμα με ένα Arduino ως πηγή ενέργειας, ένα LED, μια περιοριστική αντίσταση 220 Ohm και ένα κουμπί που θα κλείσει και θα ανοίξει το κύκλωμα.

Όταν συνδέετε ένα κουμπί με δύο ζεύγη ποδιών, είναι σημαντικό να επιλέξετε τις σωστές επαφές NC. Κοιτάξτε προσεκτικά την εικόνα: ζεύγη ποδιών βρίσκονται στα πλάγια του κουμπιού. Το ίδιο το κουμπί είναι τετράγωνο, αλλά οι αποστάσεις μεταξύ των ζευγών επαφών είναι οπτικά αισθητές: μπορείτε να επιλέξετε αμέσως δύο στη μία πλευρά και δύο στην άλλη. Έτσι, μεταξύ ενός "ζεύγους" στο πλάι θα εφαρμοστεί ο διακόπτης. Για να συμπεριληφθεί στο κύκλωμα, συνδέουμε τη μία και την άλλη επαφή, μεταξύ των οποίων υπάρχει ελάχιστη απόσταση. Το δεύτερο ζεύγος επαφών απλώς αντιγράφει το πρώτο.

Εάν έχετε διαφορετικό τύπο διακόπτη, τότε μπορείτε να επιλέξετε με ασφάλεια επαφές από απέναντι γωνίες (σε ορισμένα κουμπιά υπάρχει ένα ειδικό σημάδι με τη μορφή εσοχής, με το οποίο μπορείτε να προσδιορίσετε σε ποια πλευρά βρίσκονται οι ζευγαρωμένες επαφές). Ο πιο αξιόπιστος τρόπος για να προσδιορίσετε τα σωστά πόδια είναι να δακτυλιώσετε τις επαφές με έναν ελεγκτή.

Το ίδιο το κύκλωμα με κουμπί, LED και ελεγκτής Arduino δεν χρειάζεται καμία ειδική εξήγηση. Το κουμπί διακόπτει το κύκλωμα, το LED δεν ανάβει. Όταν πατηθεί, το κύκλωμα κλείνει και το LED ανάβει. Εάν ανακατέψετε τις επαφές (ενεργοποιήστε τα κουμπιά μέσω κλειστών ζευγαρωμένων επαφών), το κουμπί δεν θα λειτουργήσει επειδή το κύκλωμα δεν θα ανοίξει ποτέ. Απλώς αλλάξτε τις επαφές.

Σύνδεση κουμπιού με αντίσταση έλξης

Ας συνδέσουμε τώρα το κουμπί στο Arduino για να μπορούμε να διαβάσουμε την κατάστασή του στο σκίτσο. Για να το κάνουμε αυτό, θα χρησιμοποιήσουμε το παρακάτω διάγραμμα.

Αναβοσβήνει το LED αφού πατήσετε το κουμπί

Στο προηγούμενο παράδειγμα με τα LED, συνδέσαμε ένα κουμπί σε μια πλακέτα Arduino και καταλάβαμε πώς λειτουργεί. Το LED άνοιξε και σβήνει, αλλά το έκανε σε εντελώς παθητική λειτουργία - ο ίδιος ο ελεγκτής ήταν απολύτως περιττός εδώ, θα μπορούσε να είχε αντικατασταθεί με μπαταρίες. Επομένως, ας κάνουμε το νέο μας έργο πιο «έξυπνο»: όταν πατάτε ένα κουμπί, θα κάνουμε το LED να αναβοσβήνει συνεχώς. Δεν μπορείτε να το κάνετε αυτό με ένα συμβατικό κύκλωμα με έναν λαμπτήρα και έναν διακόπτη - θα χρησιμοποιήσουμε τη δύναμη του μικροελεγκτή μας για να λύσουμε αυτό το, αν και απλό, αλλά όχι ασήμαντο έργο.

Ένα θραύσμα του κυκλώματος με ένα LED είναι ήδη γνωστό σε εμάς. Συναρμολογήσαμε έναν κανονικό φάρο με LED και περιοριστική αντίσταση. Αλλά στο δεύτερο μέρος βλέπουμε ένα οικείο κουμπί και μια άλλη αντίσταση. Αν και δεν θα μπούμε σε λεπτομέρειες, απλώς θα συναρμολογήσουμε το κύκλωμα και θα ανεβάσουμε ένα απλό σκίτσο στο Arduino. Όλα τα στοιχεία του κυκλώματος διατίθενται στα πιο απλά κιτ εκκίνησης Arduino.

/* Σκίτσο για ένα κύκλωμα χρησιμοποιώντας ένα κουμπί τακτ και ένα LED Το LED αναβοσβήνει ενώ πατιέται το κουμπί. Το κουμπί τραβιέται στο έδαφος, πατώντας το αντιστοιχεί σε HIGH στην είσοδο */const int PIN_BUTTON = 2; const int PIN_LED = 13; void setup() ( Serial.begin(9600); pinMode(PIN_LED, OUTPUT); ) void loop() ( // Λήψη της κατάστασης του κουμπιού int buttonState = digitalRead(PIN_BUTTON); Serial.println(buttonState); // Εάν το το κουμπί δεν είναι πατημένο, τότε δεν κάνουμε τίποτα εάν (!buttonState) ( delay(50); return; ) // Αυτό το μπλοκ κώδικα θα εκτελεστεί εάν πατηθεί το κουμπί // Αναβοσβήνει το LED digitalWrite(PIN_LED, HIGH); καθυστέρηση (1000); digitalWrite (PIN_LED , LOW); καθυστέρηση (1000); )

Πατήστε και κρατήστε πατημένο - το LED αναβοσβήνει. Αφήστε - σβήνει. Ακριβώς αυτό που θέλαμε. Χτυπάμε τα χέρια μας από χαρά και αρχίζουμε να αναλύουμε τι κάναμε.

Ας δούμε το σκίτσο. Βλέπουμε μια αρκετά απλή λογική σε αυτό.

1. Προσδιορίστε εάν το κουμπί είναι πατημένο.
2. Εάν το κουμπί δεν πατηθεί, τότε απλά βγαίνουμε από τη μέθοδο βρόχου χωρίς να ενεργοποιήσουμε ή να αλλάξουμε τίποτα.
3. Εάν πατηθεί το κουμπί, τότε αναβοσβήνουμε χρησιμοποιώντας ένα τμήμα ενός τυπικού σκίτσου:
   1. Ενεργοποιήστε το LED εφαρμόζοντας τάση στην επιθυμητή θύρα
   2. Κάνουμε την απαραίτητη παύση όταν το LED είναι αναμμένο
   3. Απενεργοποιήστε το LED
   4. Κάνουμε την απαραίτητη παύση με σβηστό το LED

Η λογική πίσω από τη συμπεριφορά του κουμπιού στο σκίτσο μπορεί να εξαρτάται από τη μέθοδο σύνδεσης με μια αντίσταση έλξης. Θα μιλήσουμε για αυτό στο επόμενο άρθρο.

Κουμπί Arduino που κροταλίζει

Ενώ εργαζόμαστε με κουμπιά, μπορεί να συναντήσουμε ένα πολύ δυσάρεστο φαινόμενο που ονομάζεται αναπήδηση κουμπιών. Όπως υποδηλώνει το ίδιο το όνομα, αυτό το φαινόμενο προκαλείται από κρότους των επαφών στο εσωτερικό του διακόπτη του κουμπιού. Οι μεταλλικές πλάκες δεν έρχονται σε επαφή η μία με την άλλη αμέσως (αν και πολύ γρήγορα για τα μάτια μας), έτσι οι υπερτάσεις και οι βυθίσεις τάσης συμβαίνουν για μικρό χρονικό διάστημα στην περιοχή επαφής. Εάν δεν προβλέπουμε την εμφάνιση τέτοιων σημάτων «σκουπιδιών», τότε θα αντιδρούμε σε αυτά κάθε φορά και μπορούμε να οδηγήσουμε το έργο μας στο σπίτι.

Για την εξάλειψη της αναπήδησης, χρησιμοποιούνται λύσεις λογισμικού και υλικού. Με λίγα λόγια, θα αναφέρουμε απλώς τις κύριες μεθόδους καταστολής της φλυαρίας:

• Προσθέτουμε μια παύση 10-50 χιλιοστών του δευτερολέπτου στο σκίτσο μεταξύ της συλλογής τιμών από τον ακροδέκτη Arduino.
• Αν χρησιμοποιήσουμε διακοπές, τότε η μέθοδος λογισμικού δεν μπορεί να χρησιμοποιηθεί και σχηματίζουμε προστασία υλικού. Το πιο απλό από αυτά είναι ένα φίλτρο RC με πυκνωτή και αντίσταση.
• Για πιο ακριβή αναπήδηση, χρησιμοποιείται ένα φίλτρο υλικού που χρησιμοποιεί μια σκανδάλη Schmidt. Αυτή η επιλογή θα σας επιτρέψει να λάβετε ένα σήμα σχεδόν ιδανικού σχήματος στην είσοδο του Arduino.

Μπορείτε να βρείτε πιο λεπτομερείς πληροφορίες σχετικά με τους τρόπους αντιμετώπισης της φλυαρίας σε αυτό.

Εναλλαγή λειτουργιών χρησιμοποιώντας ένα κουμπί

Για να προσδιορίσετε εάν πατήθηκε ένα κουμπί, πρέπει απλώς να καταγράψετε το γεγονός ότι πατήθηκε και να αποθηκεύσετε το χαρακτηριστικό σε μια ειδική μεταβλητή.

Καθορίζουμε το γεγονός του πατήματος χρησιμοποιώντας τη συνάρτηση digitalRead(). Ως αποτέλεσμα, θα λάβουμε HIGH (1, TRUE) ή LOW (0, FALSE), ανάλογα με τον τρόπο σύνδεσης του κουμπιού. Εάν συνδέσουμε το κουμπί χρησιμοποιώντας μια εσωτερική αντίσταση έλξης, τότε το πάτημα του κουμπιού θα προκαλέσει την είσοδο στο επίπεδο 0 (FALSE).

Για να αποθηκεύσετε πληροφορίες σχετικά με ένα κλικ κουμπιού, μπορείτε να χρησιμοποιήσετε μια δυαδική μεταβλητή:

boolean keyPressed = digitalRead(PIN_BUTTON)==LOW;

Γιατί χρησιμοποιούμε αυτήν την κατασκευή και δεν την κάνουμε έτσι:

boolean keyPressed = digitalRead(PIN_BUTTON);

Το θέμα είναι ότι η digitalRead() μπορεί να επιστρέψει HIGH, αλλά δεν θα υποδεικνύει ένα πάτημα κουμπιού. Στην περίπτωση χρήσης κυκλώματος με αντίσταση έλξης, το HIGH θα σημαίνει ότι το κουμπί, αντίθετα, δεν είναι πατημένο. Στην πρώτη επιλογή (digitalRead(PIN_BUTTON)==LOW), συγκρίναμε αμέσως την είσοδο με την τιμή που χρειαζόμασταν και διαπιστώσαμε ότι το κουμπί ήταν πατημένο, αν και το επίπεδο σήματος στην είσοδο ήταν πλέον χαμηλό. Και αποθηκεύτηκε η κατάσταση του κουμπιού σε μια μεταβλητή. Προσπαθήστε να υποδείξετε ρητά όλες τις λογικές λειτουργίες που εκτελείτε για να κάνετε τον κώδικά σας πιο διαφανή και να αποφύγετε περιττά ανόητα λάθη.

Πώς αλλάζετε τρόπους λειτουργίας αφού πατήσετε ένα κουμπί;

Συχνά προκύπτει μια κατάσταση όταν, χρησιμοποιώντας κουμπιά, πρέπει να λάβουμε υπόψη το γεγονός ότι όχι μόνο πατάμε, αλλά και αφήνουμε το κουμπί. Για παράδειγμα, πατώντας και αφήνοντας ένα κουμπί, μπορούμε να ανάψουμε το φως ή να αλλάξουμε τον τρόπο λειτουργίας του κυκλώματος. Με άλλα λόγια, πρέπει να καταγράψουμε με κάποιο τρόπο στον κώδικα το γεγονός ότι έγινε κλικ στο κουμπί και να χρησιμοποιήσουμε τις πληροφορίες στο μέλλον, ακόμα κι αν το κουμπί δεν πατιέται πλέον. Ας δούμε πώς μπορεί να γίνει αυτό.

Η λογική του προγράμματος είναι πολύ απλή:

• Θυμόμαστε το γεγονός του κλικ σε μια μεταβλητή υπηρεσίας.
• Περιμένουμε μέχρι να περάσουν τα φαινόμενα που σχετίζονται με το κροτάλισμα.
• Περιμένουμε να απελευθερωθεί το κουμπί.
• Θυμόμαστε το γεγονός της απελευθέρωσης και ορίζουμε σε μια ξεχωριστή μεταβλητή το σημάδι ότι το κουμπί πατήθηκε πλήρως.
• Διαγράψτε τη μεταβλητή υπηρεσίας.

Πώς να εντοπίσετε πολλαπλά πατήματα κουμπιών;

Απλά πρέπει να θυμάστε την κατάσταση κάθε κουμπιού στην αντίστοιχη μεταβλητή ή στον πίνακα Arduino. Το κύριο πράγμα που πρέπει να καταλάβετε εδώ είναι ότι κάθε νέο κουμπί είναι μια απασχολημένη καρφίτσα. Επομένως, εάν έχετε μεγάλο αριθμό κουμπιών, ενδέχεται να αντιμετωπίσετε έλλειψη δωρεάν επαφών. Μια εναλλακτική επιλογή είναι να χρησιμοποιήσετε κουμπιά συνδεδεμένα σε μια αναλογική ακίδα χρησιμοποιώντας ένα κύκλωμα με διαχωριστικό αντίστασης. Θα μιλήσουμε για αυτό στα επόμενα άρθρα.