Εκμάθηση βασικού προγραμματισμού Arduino - Εκμάθηση για τους νεοεισερχόμενους

Δοκιμάστε Το Όργανο Μας Για Την Εξάλειψη Των Προβλημάτων





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

Εισαγωγή

Σύμφωνα με wikipedia ένας μικροελεγκτής είναι ισοδύναμος με έναν μίνι υπολογιστή που είναι ενσωματωμένος σε ένα μόνο τσιπ IC, με τον δικό του πυρήνα επεξεργαστή, προγραμματιζόμενες εισόδους, μνήμη και περιφερειακά εξόδου.



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

Σε αυτό το σεμινάριο θα συνεργαστούμε με έναν πίνακα Arduino Uno για μάθηση και δοκιμή των προγραμμάτων. Για τη δοκιμή και την ενσωμάτωση συναρμολόγησης υλικού θα χρησιμοποιήσουμε ένα breadboard.



Τώρα ας προχωρήσουμε γρήγορα και να μάθουμε πώς να ξεκινήσουμε με έναν προγραμματισμό Arduino.

1.2 Εγκατάσταση του λογισμικού (Windows)

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

Αρχείο ZIP των Windows για εγκατάσταση εκτός διαχειριστή

Μετά τη λήψη θα βρείτε το εικονίδιο εγκατάστασης του Arduino στο φάκελο λήψης, ο οποίος θα μοιάζει με αυτό:

εικονίδιο λήψης arduino

Μόλις το αποκτήσετε, μπορείτε απλά να κάνετε διπλό κλικ πάνω του και να εγκαταστήσετε το Arduino το Ολοκληρωμένο Περιβάλλον Ανάπτυξης (IDE) στον υπολογιστή σας. Η πλήρης διαδικασία μπορεί να απεικονιστεί στο ακόλουθο βίντεο:

https://youtu.be/x7AMn1paCeU

1.4 Ξεκινώντας με το πρώτο μας κύκλωμα

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

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

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

Κατά κανόνα, τα 330 ohm 1/4 watt είναι αρκετά ιδανικά για κάθε αύξηση 5V στην είσοδο τροφοδοσίας για τον περιορισμό του ρεύματος σε ένα απαιτούμενο ασφαλές επίπεδο. Επομένως για 5V μπορεί να είναι 330 ohms, για 10V μπορεί να είναι 680 ohms και ούτω καθεξής.

Χρησιμοποιώντας Breadboard για τη Συνέλευση

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

Η βασική ρύθμιση σύνδεσης LED φαίνεται παρακάτω:

LED με Arduino

Μπορείτε να δείτε 3 βασικά στοιχεία παραπάνω:

  1. LED 5mm, 20mA
  2. αντίσταση 330 ohm 1/4 watt
  3. Ενα Διοικητικό Συμβούλιο Arduino

Απλώς συναρμολογήστε το σύστημα σύμφωνα με το διάγραμμα.

Στη συνέχεια, συνδέστε το 5V από τον υπολογιστή USB στο Arduino. Μόλις το κάνετε αυτό, θα δείτε το LED να ανάβει.

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

1.5 Έλεγχος LED με Arduino

Τώρα θα μάθουμε πώς να ελέγχουμε ένα LED με ένα πρόγραμμα Arduino.

Για να γράψουμε ένα πρόγραμμα πρέπει να έχουμε τουλάχιστον 2 λειτουργίες σε κάθε πρόγραμμα.

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

  1. ρύθμιση () Αυτό καλείται ή εκτελείται κατά την έναρξη του προγράμματος.
  2. βρόχος() Αυτό καλείται ή εκτελείται επαναλαμβανόμενα κατά τη διάρκεια ολόκληρης της επιχειρησιακής περιόδου του Arduino.

Επομένως, αν και δεν έχει πρακτική λειτουργικότητα, τεχνικά ένα συντομότερο νόμιμο πρόγραμμα Arduino μπορεί να γραφτεί ως:

Απλούστερο πρόγραμμα

void setup()
{
}
void loop()
{
}

Ίσως έχετε παρατηρήσει ότι σε πολλές από τις γλώσσες προγραμματισμού, το σύστημα ξεκινά με μια απλή εκτύπωση, «Γεια, Κόσμος» στην οθόνη

Το ηλεκτρονικό ισοδύναμο για αυτήν τη φράση στην ερμηνεία του μικροελεγκτή είναι να αναβοσβήνει ένα LED ON και OFF.

Αυτό είναι το πιο βασικό πρόγραμμα που μπορεί κανείς να γράψει και να εφαρμόσει για να δείξει τη σωστή λειτουργία του συστήματος.

Θα προσπαθήσουμε να εφαρμόσουμε και να κατανοήσουμε τη διαδικασία μέσω του ακόλουθου κώδικα:

Λίστα 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

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

const int kPinLed = 13

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

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

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Αυτός ο κωδικός διαμορφώνει τον ειδικό πείρο στον οποίο συνδέεται το LED μας. Με άλλα λόγια, ο κώδικας λέει στο Arduino να ελέγχει την πτυχή «γραφής» σε αυτό το pin, αντί να το «διαβάζει».

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

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

Εδώ, ο όρος ΥΨΗΛΟΣ σημαίνει απλά να πάρει + 5V στον αντίστοιχο πείρο του Arduino. Ο συμπληρωματικός όρος LOW δείχνει απλώς ένα μηδέν ή 0V στον καθορισμένο πείρο.

Στη συνέχεια, καλούμε delay() του οποίου η λειτουργία είναι να δημιουργήσει καθυστέρηση στα χιλιοστά του δευτερολέπτου (1 / 1000ο του δευτερολέπτου). Αφού εισαχθεί το σχήμα 500, η ​​καθυστέρηση που εφαρμόζεται θα είναι για 1/2 δευτερόλεπτο.

Μόλις λήξει αυτό το 1/2 δευτερόλεπτο, εκτελείται η επόμενη γραμμή που απενεργοποιεί το LED με τον όρο LOW στον ίδιο πείρο.

Η επόμενη γραμμή παράγει και πάλι καθυστέρηση 1/2 δευτερολέπτου, προκειμένου να επιτρέψει στο LED να παραμείνει σβηστό για 1/2 δευτερόλεπτα.

Και η διαδικασία συνεχίζεται απεριόριστα με την εκτέλεση των γραμμών κώδικα, αρκεί το Arduino να διατηρείται σε λειτουργία.

Πριν προχωρήσετε στο επόμενο επίπεδο, θα σας συνιστούσα να προγραμματίσετε τον παραπάνω κωδικό και να ελέγξετε αν μπορείτε να εφαρμόσετε σωστά ή όχι την ακολουθία LED ON / OF.

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

Μπορείτε να παίξετε με το χρόνο καθυστέρησης αλλάζοντας το σχήμα '500' σε κάποια άλλη τιμή και βρείτε το LED 'ακούγοντας' τις εντολές και αναγκάζοντάς το να αναβοσβήνει σύμφωνα με τις καθορισμένες τιμές καθυστέρησης.

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

1.7 Σχόλια

Οι γραμμές κωδικών που κατανοήσαμε παραπάνω γράφτηκαν ειδικά για το λογισμικό του υπολογιστή.

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

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

Η γλώσσα αυτών των σχολίων είναι γραμμένη με δύο μορφές:

  1. Το στυλ αποκλεισμού σχολίων, όπου η περιγραφή σχολίων περικλείεται κάτω από το σύμβολο έναρξης / * και το σύμβολο λήξης * /
  2. Αυτό δεν χρειάζεται να περιοριστεί σε μια γραμμή, αλλά θα μπορούσε να επεκταθεί στις επόμενες επόμενες γραμμές ανάλογα με το μήκος του σχολίου ή την περιγραφή, όπως φαίνεται στο ακόλουθο παράδειγμα:

/ * Αυτό είναι ένα σχόλιο * /

/ * Έτσι είναι αυτό * /

/* Και
* Αυτό
* όπως και
* Καλά */

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

// Αυτό είναι ένα σχόλιο που οι υπολογιστές θα αγνοήσουν.

Ακολουθεί ένα παράδειγμα αναφοράς:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Αντιμετώπιση προβλημάτων

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

  1. Η γλώσσα του προγράμματος θα είναι κεφαλαία. Για παράδειγμα, η έκφραση myVar δεν μπορεί να γραφτεί ως MyVar.
  2. Όλοι οι λευκοί χώροι που μπορεί να εκτελεστούν με την πληκτρολόγηση του πληκτρολογίου σας, αποδίδονται τελικά ως ένα μόνο διάστημα και είναι ορατό ή κατανοητό μόνο από εσάς, ο υπολογιστής δεν θα το λάβει υπόψη. Με απλά λόγια, οι ελεύθεροι χώροι οποιουδήποτε είδους δεν θα έχουν καμία επίδραση στα αποτελέσματα του κώδικα.
  3. Κάθε μπλοκ κώδικα πρέπει να περικλείεται με αγκύλες αριστερά και δεξιά, '{' και '}'
  4. Τα αριθμητικά ψηφία δεν πρέπει να διαχωρίζονται με κόμματα. Για παράδειγμα, 1000 δεν μπορούν να γραφτούν ως 1.000.
  5. Κάθε γραμμή κώδικα που περικλείεται μεταξύ των αγκυλών πρέπει να τελειώνει με ερωτηματικό

Δημιουργία ενδιαφέρουσας ακολουθίας φωτός LED με το Arduino

Στο προηγούμενο κεφάλαιο μάθαμε πώς να αναβοσβήνουμε συνεχώς ένα ON / OFF LED με σταθερό ρυθμό καθυστέρησης.

Τώρα θα μάθουμε πώς θα μπορούσαν να εκτελεστούν διαφορετικά μοτίβα καθυστέρησης στο ίδιο LED με την αναβάθμιση του κώδικα προγράμματος.

Δεν θα χρησιμοποιούμε εξωτερικό LED, αντί να χρησιμοποιούμε το προεπιλεγμένο LED ενσωματωμένο στην πλακέτα Arduino στον ακροδέκτη # 13. Μπορείτε να βρείτε αυτό το μικροσκοπικό LED SMD ακριβώς πίσω από την υποδοχή USB.

2.2 Κατανόηση των δηλώσεων IF

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

Η ΔΗΛΩΣΗ αν γίνεται η 1η δομή ελέγχου. Η ακόλουθη εφαρμογή δείχνει πώς χρησιμοποιείται:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

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

Οι κωδικοί μεταξύ 1ης και 7ης γραμμής είναι ακριβώς παρόμοιοι με το αρχικό μας πρόγραμμα.

Η πρώτη τροποποίηση συμβαίνει στην 8η γραμμή.

int delayTime = 1000

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

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

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

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

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

delayTime = delayTime - 100

Σε αυτόν τον κώδικα βλέπουμε ότι η προεπιλεγμένη τιμή του χρόνος καθυστέρησης τροποποιείται αφαιρώντας το 100 από αυτό.

Το 100 σημαίνει ότι αφαιρείται από την αρχική του τιμή 1000, παρέχοντας μια νέα τιμή 900.

Μέσα από την ακόλουθη εικόνα θα προσπαθήσουμε να κατανοήσουμε μερικούς από τους τελεστές Μαθηματικών που χρησιμοποιούνται στη γλώσσα Arduino.

Σύμβολα χειριστή Arduino Math

Τώρα ας αξιολογήσουμε τους κωδικούς μεταξύ της γραμμής 13 και του 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

Ο κύριος στόχος του παραπάνω κώδικα είναι να διασφαλίσει ότι το LED συνεχίζει να αναβοσβήνει χωρίς διακοπή.

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

Η παρακάτω εικόνα δείχνει μερικούς τελεστές σύγκρισης που θα χρησιμοποιούσαμε στους κωδικούς μας:

χειριστής σύγκρισης για κωδικούς arduino

Στον παραπάνω κώδικα, θα μπορούσαμε να δοκιμάσουμε τον κωδικό να είναι if(delayTime == 0).

Ωστόσο, επειδή η αρνητική φιγούρα μπορεί να είναι εξίσου κακή, δεν το κάναμε, και αυτή είναι μια συνιστώμενη πρακτική.

Σκεφτείτε τι θα μπορούσε να ήταν το αποτέλεσμα αν προσπαθούσαμε να αφαιρέσουμε 300 αντί 100 από το delayTime;

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

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

Οι τελευταίες 4 γραμμές του κώδικα, όπως φαίνεται παραπάνω, είναι υπεύθυνες για τη συνεχή ενεργοποίηση / απενεργοποίηση του LED, ON / OFF.

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

2.3 Δηλώσεις ELSE

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

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

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

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

Ίσως έχετε παρατηρήσει ότι σε αντίθεση με αυτό που κάναμε στην προηγούμενη ενότητα 2.2, εδώ δεν συγκρίναμε με το 0, μάλλον σε σύγκριση με το 100. Αυτό συμβαίνει επειδή σε αυτό το παράδειγμα συγκρίθηκε ΠΡΙΝ αφαιρέσαμε το 100, αντίθετα στο τμήμα 2.2, συγκρίναμε ΑΥΤΟ αφαιρείται Μπορείτε να πείτε τι θα μπορούσε να είχε συμβεί αν συγκρίναμε 0 αντί 100;

2.4 ΟΧΙ δηλώσεις

ΠΡΟΣ ΤΗΝ ενώ η δήλωση είναι αρκετά παρόμοια με αν δήλωση, εκτός από την αλήθεια ότι προκαλεί επαναλαμβανόμενη εκτέλεση σε ένα μπλοκ κώδικα (το οποίο μπορεί να είναι ανάμεσα σε αγκύλες) για τόσο μεγάλο χρονικό διάστημα οι συνθήκες ισχύουν και αυτό λειτουργεί χωρίς αλλού δήλωση.

Το παρακάτω παράδειγμα θα σας βοηθήσει να το κατανοήσετε καλύτερα

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Μπορείτε να μαντέψετε τι έχει προγραμματιστεί να κάνει ο παραπάνω κώδικας; Λοιπόν, είναι σχεδιασμένο να αναβοσβήνει τα LED πιο γρήγορα και αργότερα.

2.5 Τι είναι αληθινό και ψεύτικο;

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

Φαίνεται λίγο παράξενο, αλλά κάνει τη δουλειά πολύ ωραία.

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

Μπορεί μερικές φορές να συναντήσετε έναν κωδικό όπως δίνεται παρακάτω:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

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

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

Είμαι βέβαιος ότι γνωρίζετε ήδη ότι = σημαίνει μια ανάθεση, που σημαίνει ότι χρησιμοποιείται για τον προσδιορισμό μιας επιλεγμένης τιμής σε μια μεταβλητή, ενώ a == χρησιμοποιείται για την επιβολή μιας δοκιμής εάν η τιμή ήταν ίδια.

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

Ο κωδικός θα εμφανιστεί ως εξής:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

Το λάθος θα αντιστοιχίσει 0 στο delayTime και θα οδηγήσει στο αν δήλωση για να ελέγξετε αν το 0 ήταν αλήθεια ή όχι. Εφόσον το 0 αναφέρεται σε ψευδές, θα πιστεύει ότι δεν είναι αλήθεια και θα σταματήσει την επιβολή του delayTime = 1000, αλλά αντ 'αυτού η συνάρτηση delayTime κρατείται στο 0 κατά τη διάρκεια του βρόχου ().

Αυτό φαίνεται πολύ ανεπιθύμητο !!

Επομένως, ελέγχετε πάντα το πρόγραμμά σας για να βεβαιωθείτε ότι δεν έχετε κάνει τέτοια ανόητα λάθη.

2.6 Συνδυασμοί

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

Η εφαρμογή συνδυασμών με λογικούς όρους θα μπορούσε να γίνει με 3 μεθόδους, όπως φαίνεται στον παρακάτω πίνακα:

Πίνακας που δείχνει μεθόδους συνδυασμού Arduino

Θα ήταν ενδιαφέρον να γνωρίζουμε ότι ο τελεστής ΔΕΝ μπορεί να λειτουργήσει ως διακόπτης για μια μεταβλητή που μπορεί να οριστεί ως μία αληθής ή ψευδής (ή ΧΑΜΗΛΗ ή ΥΨΗΛΗ).

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

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Εδώ το ledState θα είναι χαμηλή και, στη συνέχεια, μόλις ledState = !ledState, θα γίνει ΥΨΗΛΗ. Ο παρακάτω βρόχος θα προκαλέσει ledState να είναι ΥΨΗΛΟ όταν ledState = !ledState είναι χαμηλό.

2.7 ΓΙΑ δηλώσεις

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

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

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

Μπορείτε να βρείτε κάτι μοναδικό σύμφωνα με το Για.

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

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

χειριστές σύνθετων arduino

Θα διαπιστώσετε ότι υπάρχουν 3 δευτερεύουσες δηλώσεις στο a for statement. Είναι δομημένο όπως φαίνεται παρακάτω:

for (statement1conditionstatement2){
// statements
}

Η δήλωση # 1 εμφανίζεται ακριβώς στην αρχή και μόνο μία φορά. Η κατάσταση ελέγχεται κάθε φορά κατά τη διάρκεια του βρόχου. Όποτε είναι αληθής μέσα στις αγκύλες, η επόμενη δήλωση # 2 εφαρμόζεται. Σε περίπτωση α ψευδής, το σύστημα μεταβαίνει στο επόμενο μπλοκ κώδικα.

Σύνδεση περισσότερων LED

Εντάξει, τώρα θα δούμε πώς μπορούμε να συνδέσουμε περισσότερο αριθμό LEds για να έχουμε πιο ενδιαφέροντα εφέ.

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

Arduino πολλαπλές συνδέσεις LED

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

Συνιστάται πάντοτε να κωδικοποιείτε και να εκτελείτε μικρά κομμάτια προγραμμάτων, για να ελέγξετε αν τα αντίστοιχα λογισμικά συνδέονται σωστά ή όχι.

Αυτό βοηθά στην γρήγορη αντιμετώπιση ενός πιθανού σφάλματος.

Το παρακάτω παράδειγμα κώδικα παρέχει στο LED 2 έως 5 ένα συγκεκριμένο μοτίβο γυρίζοντάς τα το ένα μετά το άλλο με κυκλικό τρόπο.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

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

Φυσικά υπάρχουν καλύτεροι τρόποι για να γράψετε τον παραπάνω κώδικα, η ακόλουθη ενότητα θα τον αποκαλύψει.

2.9 Παρουσιάζοντας πίνακες

Οι πίνακες μπορούν να είναι μια ομάδα μεταβλητών που μπορούν να ευρετηριαστούν με αριθμούς ευρετηρίου. Το παρακάτω παράδειγμα θα μας βοηθήσει να το κατανοήσουμε καλύτερα.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

Εντάξει, τώρα ας δούμε κάθε ενότητα και να καταλάβουμε πώς λειτουργούν πραγματικά.

const int k_numLEDs = 4

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

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

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

Όταν βρείτε έναν πίνακα ευρετηριασμένο με τον αριθμό 0, αυτό δείχνει το πρώτο στοιχείο του πίνακα, όπως φαίνεται στο code: k_LEDPins is k_LEDPins[0].

Παρομοίως, το τελευταίο στοιχείο θα εμφανίζεται ως k_LEDPins[3], αφού ο αριθμός από 0 έως 3 είναι 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

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

αν αναρωτιέστε εάν είναι δυνατό να χρησιμοποιήσετε τον πινέλο # 2 έως τον πινέλο # 5 χωρίς συστοιχίες, η απάντηση είναι ναι, είναι δυνατόν. Αλλά σε αυτό το παράδειγμα δεν γίνεται επειδή δεν το κάναμε με αυτόν τον τρόπο. Στις ακόλουθες ενότητες μπορείτε να εξαλείψετε την προσέγγιση πίνακα εάν οι επιλεγμένοι ακροδέκτες εξόδου δεν ευθυγραμμίζονται.

Προχωρώντας, ας δούμε τι κάνει το επόμενο μπλοκ κώδικα:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Εδώ ο κώδικας προχωρά μέσω κάθε LED για να τα ανάψει διαδοχικά με κενό ή καθυστέρηση 100 χιλιοστά του δευτερολέπτου.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

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

Ξεκινά από k_numLEDs - 1 επειδή οι πίνακες είναι μηδενικές. Δεν ξεκινάμε από k_LEDPins[4] γιατί αυτό θα οδηγούσε στο πέρασμα του πίνακα.

Ο κωδικός χρησιμοποιεί> = 0 για έλεγχο, ώστε να μην χαθεί ή να αγνοηθεί το πρώτο στοιχείο στο ευρετήριο 0.

κεφάλαιο 3

Τι είναι μια είσοδος

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

3.1 Χρήση κουμπιών

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

3.1.1 Ένα κουμπί και ένα LED

μπουτόν διεπαφής με το Arduino

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

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

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

Ας συνεχίσουμε να εφαρμόζουμε τον ακόλουθο κώδικα και να το ελέγξουμε!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Μπορεί να βρείτε μερικά πράγματα που φαίνονται ασυνήθιστα εδώ. Ας τα καταλάβουμε βήμα σοφό.

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

Το πρώτο πράγμα που κάνουμε είναι να διορθώσουμε το κουμπίPin ως το ΕΙΣΑΓΩΓΗ. Λοιπόν αυτό είναι πολύ βασικό, το ξέρω.

Στη συνέχεια, εκχωρούμε ΥΨΗΛΟΣ στο ΕΙΣΑΓΩΓΗ καρφίτσα. Αναρωτιέστε, πώς είναι δυνατόν να γράψετε κάτι στην είσοδο; Σίγουρα, αυτό μπορεί να είναι ενδιαφέρον.

Στην πραγματικότητα, η αντιστοίχιση ενός ΥΨΗΛΟΥ σε μια είσοδο Arduino εναλλάσσει μια εσωτερική αντίσταση pull-up 20k Ohm ON (ένα LOW σε αυτόν τον πείρο το απενεργοποιεί).

Μια άλλη ερώτηση που μπορείτε να κάνετε είναι τι είναι μια αντίσταση pull-up. Έχω καλύψει μια περιεκτική ανάρτηση σε αντιστάσεις pull-up που εσείς μάθετε εδώ .

Εντάξει, συνεχίζοντας, τώρα ας δούμε τον κύριο κωδικό βρόχου:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Όταν πατάτε το κουμπί, το ενσύρματο πείρο συνδέεται με τη γείωση, γεγονός που καθιστά ένα ΧΑΜΗΛΟΣ σε αυτόν τον πείρο. Και ενώ σε μη συμπιεσμένη κατάσταση διατηρείται ο ίδιος πείρος ΥΨΗΛΟΣ ή + 5V μέσω της εσωτερικής pull-up αντίστασης 20K.

Εδώ θέλουμε το Arduino να ανάψει το LED όταν πατηθεί το κουμπί (LOW), επομένως γράφουμε ΥΨΗΛΗ για την έξοδο για κάθε απόκριση LOW από το κουμπί, ενώ πατάμε.

3.1.2 Δύο κουμπιά και ένα LED

Λοιπόν, μπορεί να αναρωτιέστε ότι η παραπάνω δράση θα μπορούσε να είχε γίνει χωρίς Arduino. Καταλαβαίνω, ωστόσο, αυτό είναι μια απότομη πέτρα για να μάθω πώς θα μπορούσε να χρησιμοποιηθεί το μπουτόν με τον Arduno.

Μέχρι αυτό το σημείο, μελετήσαμε τους κωδικούς γραφής είτε για το ON (HIGH) είτε για το OFF (LOW) ένα LED.

Τώρα ας δούμε πώς θα μπορούσε να ελεγχθεί η φωτεινότητα των LED με ένα Arduino.

Μπορεί να γίνει χρησιμοποιώντας δύο μεθόδους:

  1. Περιορίζοντας την ποσότητα ρεύματος στο LED
  2. Με τη χρήση PWM ή διαμόρφωση πλάτους παλμού, στην οποία η τροφοδοσία στο LED ανάβει / απενεργοποιείται πολύ γρήγορα με κάποιο επιθυμητό ρυθμό, παράγοντας ένα μέσο φωτισμό του οποίου η ένταση θα εξαρτάται από το PWM.

Σε μια πλακέτα Arduino, η υποστήριξη PWM διατίθεται σε καρφίτσες που φέρουν μια πινελιά (~), οι οποίες είναι ακίδες 3, 4,5,9,10 και 11) στα 500Hz (500 φορές το δευτερόλεπτο). Ο χρήστης είναι σε θέση να παρέχει οποιαδήποτε τιμή μεταξύ 0 και 255, όπου το 0 αναφέρεται σε όχι HIGH ή όχι + 5V, και το 255 λέει στον Arduino να παίρνει HIGH ή + 5V όλη την ώρα. Για την εκκίνηση αυτών των εντολών θα πρέπει να έχετε πρόσβαση στο analogWrite () με την επιθυμητή τιμή.

Μπορείτε να υποθέσετε ότι το PWM είναι x / 255 όπου x είναι η επιθυμητή τιμή που θέλετε να στείλετε μέσω analogWrite().

Έλεγχος Arduino PWM

Ρυθμίστε το Arduino και άλλες παραμέτρους όπως φαίνεται παραπάνω.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

Μπορείτε να βρείτε 3 γραμμές εδώ που χρειάζονται κάποια εξήγηση.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

Η γραμμή: ledBrightness = constrain(ledBrightness, 0, 255) απεικονίζει μια μοναδική λειτουργία μέσα στο Arduino γνωστό ως περιορισμός ().

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

int περιορισμός (int τιμή, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

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

Σωστά, έτσι αυτό σημαίνει, ο κωδικός: ledBrightness = constrain(ledBrightness, 0, 255) εκχωρεί το ledBrightness to be within the range of 0 and 255.

Η επόμενη γραμμή απασχολεί analogWrite στις εντολές του Arduino να εφαρμόσει PWM στον επιλεγμένο πείρο με την επιθυμητή τιμή.

Η επόμενη γραμμή δημιουργεί καθυστέρηση 20 χιλιοστών του δευτερολέπτου, για να διασφαλιστεί ότι δεν θα προσαρμόσουμε το φαγητό γρηγορότερα από 50 Hz ή 50 φορές το δευτερόλεπτο. Αυτό συμβαίνει επειδή οι άνθρωποι μπορούν να είναι πολύ πιο αργοί από έναν Arduino. Ως εκ τούτου, εάν δεν γίνει η καθυστέρηση, το πρόγραμμα θα μπορούσε να μας κάνει να νιώσουμε ότι πατώντας το πρώτο κουμπί απενεργοποίησε το LED και πατώντας το δεύτερο κουμπί το ενεργοποίησε (δοκιμάστε το μόνοι σας για επιβεβαίωση).

3.2 Ποτενσιόμετρα

Ας προχωρήσουμε και να μάθουμε πώς να το χρησιμοποιήσουμε ποτενσιόμετρα με Arduino.

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

Χρησιμοποιώντας ποτενσιόμετρο με Arduino

Συνδέστε τις παραμέτρους που εμφανίζονται με το Arduino σας όπως φαίνεται παραπάνω.

Ένα pot θα έχει 3 τερματικά. Το μεσαίο τερματικό θα συνδεθεί με το ANALOG IN 0 στο Arduino. Οι άλλοι δύο εξωτερικοί ακροδέκτες μπορούν να συνδεθούν σε ράγες τροφοδοσίας + 5V και 0V.

Ας προγραμματίσουμε και δείτε τα αποτελέσματα:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

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

  1. Η σταθερά kPinPot έχει αντιστοιχιστεί ως Α0, όπου το Α είναι η συντόμευση για την περιγραφή μιας από τις αναλογικές ακίδες. Ωστόσο, το A0 αναφέρεται επίσης στον ακροδέκτη # 14, τον Α1 στον ακροδέκτη # 15 και ούτω καθεξής, και αυτά σας επιτρέπουν να χρησιμοποιείτε ως ψηφιακές εισόδους / εξόδους σε περίπτωση που εξαντληθούν οι ακίδες για ένα πείραμα. Αλλά θυμηθείτε ότι δεν μπορείτε να χρησιμοποιήσετε ψηφιακές καρφίτσες ως αναλογικές καρφίτσες.
  2. Η γραμμή: ledBrightness = map(sensorValue, 0, 1023, 0, 255) παρουσιάζει μια νέα εσωτερική λειτουργία στο Arduino γνωστή ως χάρτης(). Αυτή η δυνατότητα βαθμονομείται εκ νέου από ένα δεδομένο εύρος σε ένα άλλο, που ονομάζεται ως χάρτης (τιμή, fromLow, fromHigh, toLow, toHigh). Αυτό μπορεί να γίνει κρίσιμο αφού analogueRead δίνει μια τιμή εντός του εύρους 0-1023, αλλά το analogWrite μπορεί να δεχτεί μια τιμή από 0-255.

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

Κανένα ζήτημα, τώρα θα κάνουμε κάτι που δεν μπορεί να γίνει χωρίς Arduino.

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

Εδώ είναι το πρόγραμμα:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 Αποφυγή καθυστέρησης ()

Ο παραπάνω κωδικός φαίνεται καλός, αλλά το LED δεν μπορεί να ελέγξει την τιμή του ποτ έως ότου περάσει σε κάθε πλήρη κύκλο. Για μεγαλύτερες καθυστερήσεις αυτή η διαδικασία μεγαλώνει, ο χρήστης πρέπει να περιμένει να δει την απόκριση του pot ενώ το μετακινεί. Αυτή η καθυστέρηση μπορεί να αποφευχθεί με κάποιο έξυπνο προγραμματισμό, έτσι ώστε να επιτρέπει στον χρήστη να ελέγχει την τιμή χωρίς ελάχιστες καθυστερήσεις. Εδώ είναι ο κωδικός.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

Λοιπόν, τι διαφέρει στον παραπάνω κώδικα; Είναι η ακόλουθη γραμμή που κάνει τη διαφορά.

long lastTime = 0

Μέχρι αυτήν την ενότητα, έχουμε συζητήσει για τη μεταβλητή int. Ωστόσο, ενδέχεται να υπάρχουν πολλές περισσότερες μεταβλητές τύπων στις οποίες μπορείτε να αποκτήσετε πρόσβαση. Η λίστα μπορεί να διαβαστεί παρακάτω:

Τύποι μεταβλητών Arduino

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

Εδώ μπορείτε να δείτε μια άλλη ενδιαφέρουσα λειτουργία που ονομάζεται χιλιοστά ().

Αυτό παράγει το χρονικό διάστημα σε χιλιοστά του δευτερολέπτου που το Arduino λειτούργησε στην πορεία λειτουργίας του από την αρχή (αυτό θα επανέλθει στο 0 μετά από κάθε 50 ημέρες). Εδώ επιστρέφει πολύ γιατί αν επέστρεψε int , η μέτρηση για μεγάλα χρονικά διαστήματα ενδέχεται να μην είναι δυνατή. Θα μπορούσατε να απαντήσετε ακριβώς πόσο καιρό; Η απάντηση είναι 32.767 δευτερόλεπτα.

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

3,3 RGB LED

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

Ένα RGB LED είναι βασικά ένα LED με κόκκινο, πράσινο και μπλε LED ενσωματωμένο και συγχωνευμένο σε ένα μόνο LED. Έχει ένα κοινό καλώδιο που πηγαίνει στο έδαφος ή 0V σιδηροτροχιά τροφοδοσίας, ενώ τα άλλα 3 καλώδια τροφοδοτούνται με διαφοροποιημένα θετικά σήματα PWM για την εφαρμογή του επιδιωκόμενου ανάμειξη χρώματος .

Μπορείτε να συνδέσετε τη συσκευή όπως φαίνεται παρακάτω:

Ελέγξτε το RGB με το Arduino

Μπορεί να φαίνεται λίγο περίπλοκο, αλλά στην πραγματικότητα είναι ένα αντίγραφο του προηγούμενου σχεδιασμού ελέγχου LED με χρήση PWM.

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

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

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

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

Ήχος με το Arduino

Σε αυτήν την ενότητα θα μάθουμε πώς να προσθέτουμε βασικό ήχο και μουσική σε μια ρύθμιση Arduino.

Θα δούμε πώς να αλλάζουμε ένα σήμα σε ένα συνδεδεμένο ηχείο με την επιθυμητή συχνότητα.

Για να είμαστε πιο ακριβείς, θα δοκιμάσουμε μια μεσαία σημείωση Α, που είναι μια σημείωση συχνότητας 440 Hz.

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

Επίσης, θα υπολογίσουμε το χρονικό διάστημα που ένα μεγάφωνο μπορεί να παραμείνει ΕΝΕΡΓΟ, μηνύοντας τον τύπο:

timeDelay = 1 δευτερόλεπτο / 2 x τόνος Συχνότητα.

timeDelay = 1 δευτερόλεπτο / 2 x 440

timeDelay = 1136 μικροδευτερόλεπτα

4.1 Ας συνδέσουμε το Arduino Board

Χρησιμοποιώντας ηχητικό εφέ στο Arduino

4.2 Προσθήκη μιας απλής σημείωσης

Έχουμε ήδη συζητήσει για τη λειτουργία καθυστέρηση() όπου η μονάδα είναι σε χιλιοστά του δευτερολέπτου (δευτερόλεπτο / 1000), ωστόσο θα βρείτε μια ακόμη λειτουργία delayMicroseconds() όπου η μονάδα είναι σε μικροδευτερόλεπτα, (χιλιοστά του δευτερολέπτου / 1000).

Για την παρούσα ρύθμιση προγραμματίζουμε έναν κωδικό για εναλλαγή + 5V ON / OFF στον επιλεγμένο πείρο που συνδέεται με το ηχείο, με ρυθμό 440 παλμούς ανά δευτερόλεπτο.

Θυμηθείτε, στην τελευταία συζήτηση προσδιορίσαμε την τιμή 1136 μικροδευτερόλεπτα για την επιδιωκόμενη σημείωση ήχου.

Εδώ είναι το πρόγραμμα για αυτό, το οποίο θα σας επιτρέψει να ακούσετε μια ηχητική σημείωση 440 Hz μόλις προγραμματίσετε το arduino με συνδεδεμένο ηχείο.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

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

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

Το πρώτο είναι τόνος() που λειτουργεί με 2 στοιχεία μαζί με ένα 3ο προαιρετικό στοιχείο, που ορίζεται ως τόνος (ακίδα, συχνότητα, διάρκεια). ή τόνος (ακίδα, συχνότητα)

Και οι δύο έχουν σχεδιαστεί για να εκτελούν αντίστοιχα τη χρονική περίοδο που σας έχει εκχωρηθεί.

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

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

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

Η επόμενη συνάρτηση ούτε ένα () χειρίζεται μία μόνο παράμετρο και σταματά τον επιλεγμένο τόνο σε μια συγκεκριμένη καρφίτσα.

Μια περίεργη προειδοποίηση: Οποτεδήποτε όταν τόνος() Η λειτουργία εφαρμόζεται, η λειτουργία PWM στον ακροδέκτη 3 και 11 θα σταματήσει να λειτουργεί.

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

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

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

Στον παραπάνω κώδικα μπορεί να έχετε παρατηρήσει κάτι νέο και αυτό είναι #καθορίζω .

Αυτός ο όρος λειτουργεί σαν εντολή αναζήτησης και αντικατάστασης για τον υπολογιστή ενώ γίνεται η μεταγλώττιση.

Όποτε βρίσκει το πρώτο πράγμα πριν από ένα κενό διάστημα, το αντικαθιστά με το υπόλοιπο τμήμα της γραμμής (που ονομάζεται μακροεντολές).

Έτσι σε αυτό το παράδειγμα όταν βλέπει ο υπολογιστής ΣΗΜΕΙΩΣΗ_E4 το αντικαθιστά γρήγορα με την ποσότητα 330.

Για περισσότερες σημειώσεις και προσαρμογές, μπορείτε να ανατρέξετε σε ένα αρχείο στο USB stick που ονομάζεται pitches.h , όπου οι περισσότερες από τις συχνότητες θα μπορούσαν να βρεθούν για την προτίμησή σας.

4.4 Μουσική με λειτουργίες

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

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

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

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

Κάθε παράμετρος αποκτά τον τύπο της μαζί με ένα όνομα και τέλος ένα κλείσιμο «)» παρένθεση.

Αυτές οι παράμετροι μπορούν να εφαρμοστούν στη συνάρτηση με τη μορφή μεταβλητών.

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

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

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Οι λειτουργίες μπορεί να είναι εξαιρετικά βολικές για να κάνουν ένα πρόγραμμα πιο κατανοητό.

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

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

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

Κεφάλαιο 5

Μέτρηση θερμοκρασίας

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

5.1 Σειριακή οθόνη

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

Το Arduino διαθέτει ένα χαρακτηριστικό που του επιτρέπει να «μιλάει πίσω» με τον υπολογιστή. Μπορεί να παρατηρήσετε ότι τα pin0 και pin1 επισημαίνονται ως RX και TX το ένα δίπλα στο άλλο. Αυτές οι καρφίτσες παρακολουθούνται πραγματικά από ένα ξεχωριστό IC εντός του Arduino το οποίο τα αναβαθμίζει για να διαβάσει το καλώδιο USB ενώ είναι συνδεδεμένο στον υπολογιστή.

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

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Μπορείτε να εντοπίσετε δύο νέα πράγματα εδώ, μια νέα γραμμή στο ρύθμιση () λειτουργία.

Serial.begin(9600)

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

Η δεύτερη νέα καταχώρηση έχει ως εξής

Serial.print('delayTime = ')
Serial.println(delayTime)

Εδώ η δεύτερη γραμμή δείχνει ότι το επόμενο πράγμα που βγαίνει από τη σειριακή θύρα θα ξεκινήσει στην επόμενη γραμμή. Έτσι η δεύτερη γραμμή είναι διαφορετική από την πρώτη γραμμή.

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

Εντάξει, μπορούμε τώρα να ανεβάσουμε τον παραπάνω κωδικό στο Arduino και να δούμε τι θα συμβεί.

Όχι, δεν φαίνεται να έχει συμβεί τίποτα, το Arduino pin # 13 LED αναβοσβήνει και σταμάτησε, ενώ το Tx LED παρέμεινε αναβοσβήνει.

Λοιπόν, αυτό συμβαίνει επειδή το παράθυρο Serial Monitor δεν έχει διορθωθεί ακόμα.

Πρέπει να κάνετε κλικ στο πλαίσιο Serial Monitor στο IDE σας όπως φαίνεται παραπάνω. Μην ξεχάσετε να ελέγξετε τον ρυθμό baud που βρίσκεται κάτω δεξιά, από προεπιλογή θα πρέπει να είναι 9600 και θα ταιριάζει με τον κωδικό. Εάν δεν είστε βέβαιοι να επιλέξετε 9600.

Το παρακάτω βίντεο κλιπ εξηγεί πώς γίνεται.

https://youtu.be/ENg8CUyXm10

Τώρα ας προχωρήσουμε και μάθετε πώς η παραπάνω δυνατότητα Serial Monitor μπορεί να βοηθήσει στην επεξεργασία του μέτρηση της θερμοκρασίας χρησιμοποιώντας το Arduino

Θα χρησιμοποιήσουμε το IC TMP36 ως αισθητήρα θερμοκρασίας, με εύρος από -40 έως 150 βαθμούς Κελσίου.

Η εγκατάσταση μπορεί να δει παρακάτω:

TMP36 με Arduino για μέτρηση θερμοκρασίας

Ο ακόλουθος κωδικός θα ξεκινήσει τη μέτρηση της θερμοκρασίας διαβάζοντας την έξοδο από τον αισθητήρα TMP36 και στέλνοντάς τις στη σειριακή οθόνη του αναγνωριστικού.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

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

float temperatureC = getTemperatureC()

Εδώ μπορείτε να δείτε ότι έχουμε συμπεριλάβει τον τύπο μεταβλητής φλοτέρ.

Αυτός είναι ο μόνος τύπος μεταβλητής που διαθέτει την αποθήκευση όλων εκτός από ακέραιους αριθμούς (αριθμοί χωρίς δεκαδικά ή κλασματικά μέρη).

Η ακρίβεια από μια μεταβλητή float μπορεί να είναι έως 6 έως 7 ψηφία.

Ο παρακείμενος κωδικός getTemperatureC() είναι η δική μας λειτουργία που υπολογίζει μαθηματικά και μετατρέπει την αισθητή διαφορά τάσης από τον αισθητήρα TMP36 σε βαθμούς Κελσίου.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

Στην επόμενη ενότητα των κωδικών, αφού ο όρος analogIn() έχει ανατεθεί να επιστρέψει μια τιμή μεταξύ 1 και 1023, καθίσταται δυνατό για εμάς να εκτιμήσουμε την τάση από τον αισθητήρα πολλαπλασιάζοντας την ανάγνωσή μας με 5 και στη συνέχεια διαιρώντας την με 1024.

Ο αισθητήρας TMP36 έχει οριστεί να παράγει 0,5V στους 0 βαθμούς Κελσίου και στη συνέχεια παράγει 10mV για κάθε αύξηση του βαθμού Κελσίου.

Ακολουθεί η προσέγγιση που μπορούμε να δημιουργήσουμε μέσω των υπολογισμών:

Βαθμονόμηση θερμοκρασίας Arduino

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

Μπορείτε να καταλάβετε ότι για να λάβετε μια τιμή από μια συνάρτηση, απλά πρέπει να προσθέσετε ΕΠΙΣΤΡΟΦΗ ακολουθούμενο από τον επιθυμητό αριθμό που θέλετε να επιστρέψετε.

Όταν λέμε ΕΠΙΣΤΡΟΦΗ Αυτό σημαίνει ότι η συνάρτηση επιστρέφει μια απάντηση ή μια απάντηση όποτε καλείται, η οποία θα μπορούσε να εφαρμοστεί σε μια μεταβλητή.

Όταν αποστέλλεται στο Serial Monitor, η ανάγνωση μετατρέπεται σε Fahrenheit convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Αυτή η λειτουργία παίρνει το εύρος Κελσίου και το μετατρέπει σε Φαρενάιτ.

Για τη μετατροπή του Φαρενάιτ σε Κελσίου εφαρμόζουμε τον τύπο Φαρενάιτ = 9 / 5 (Κελσίου) + 32.

5.3 Διασύνδεση LCD

Τώρα ας μελετήσουμε τον τρόπο διασύνδεσης ή σύνδεσης οθόνη LCD με το Arduino για λήψη οπτικής προβολής για τις απαιτούμενες εξόδους.

Στην εφαρμογή μας πρόκειται να χρησιμοποιήσουμε μια γραφική οθόνη LCD 84x48, οριζόντια με 84 pixel ή κουκκίδες και κατακόρυφη ανάλυση 48 pixel. Δεδομένου ότι ένας αποκλειστικός ελεγκτής καθίσταται επιτακτικός για όλες τις LCD, η παρούσα συσκευή ενσωματώνει επίσης έναν με τη μορφή ελεγκτή PCD8544.

Σε αυτό το σεμινάριο θα συνδέσουμε την παραπάνω καθορισμένη μονάδα LCD με το Arduino και θα εφαρμόσουμε συγκεκριμένες ρουτίνες για τη δημιουργία μηνυμάτων κειμένου στην οθόνη.

Στο παρακάτω σχήμα μπορείτε να βρείτε λεπτομέρειες σχετικά με τη διασύνδεση της οθόνης LCD, μαζί με μια μικρή Ρυθμιστής τάσης 3.3V . Αυτός ο ρυθμιστής είναι απαραίτητος δεδομένου ότι η οθόνη LCD έχει καθοριστεί για να λειτουργεί με τροφοδοσία 3.3V.

Μπορείτε επίσης να δείτε 8 pinouts από τη μονάδα LCD, οι προδιαγραφές pinout μπορούν να μελετηθούν από τον ακόλουθο πίνακα:

Λεπτομέρειες pinout LCD

Τώρα ας δούμε πώς μπορούμε να συνδέσουμε την οθόνη LCD και τις σχετικές παραμέτρους με το Arduino μας. Οι λεπτομέρειες μπορούν να απεικονιστούν στην παρακάτω εικόνα:

Βασική μάθηση Arduino

5.4 Επικοινωνία με την οθόνη LCD

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

Οι βιβλιοθήκες περιλαμβάνουν μια ποικιλία κωδικών που μπορούν να εφαρμοστούν γρήγορα για ένα επιλεγμένο πρόγραμμα Arduino.

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

5.4.1 Πώς εγκαθιστάτε τη βιβλιοθήκη

Για αυτό θα πρέπει να δημιουργήσετε έναν κατάλογο που ονομάζεται βιβλιοθήκες στον υπολογιστή σας Arduino IDE, όπως εξηγείται εδώ

5.4.2 Εφαρμογή των λειτουργιών LCD

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

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Η γραμμή περιλαμβάνει τον κωδικό #include

Ο κωδικός #include δίνει εντολή στον υπολογιστή να παραλάβει το αναφερόμενο αρχείο και να αντικαταστήσει το στοιχείο #include με τα περιεχόμενα του αρχείου κατά τη διάρκεια της κατάρτισης του προγράμματος.

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

Οι επόμενες γραμμές κώδικα εκφράζουν τα pinouts LCD και μετά γράφουμε μια νέα μορφή μεταβλητής:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Εδώ εκφράζουμε μια μεταβλητή με το όνομα lcd που έχει τον τύπο PCD8544 και δίνει εντολή στον υπολογιστή να επανακαθορίζει τα pinouts του που σχετίζονται με το Arduino.

Σε αυτήν τη διαδικασία περιγράφουμε τη μεταβλητή στον υπολογιστή καθοδηγώντας τον τρόπο διασύνδεσης των pin clk, din, dc και reset με το Arduino.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

Η γραμμή lcd.init() αρχικοποιεί τη λειτουργία LCD. Μόλις εκτελεστεί, η επόμενη γραμμή επιβάλλει έναν κέρσορα πάνω αριστερά στην οθόνη. Και η επόμενη επόμενη γραμμή προσπαθεί να εκτυπώσει το μήνυμα «Γεια, Κόσμος».

Αυτό μοιάζει αρκετά με την τεχνική στην οποία στείλαμε μηνύματα μέσω της σειριακής οθόνης. Η μόνη διαφορά είναι η χρήση του κωδικού lcd.print αντί του serial.print.

Το επόμενο μπλοκ κώδικα ονομάζεται στην πραγματικότητα επαναλαμβανόμενα.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Χρήση αυτής της γραμμής lcd.setCursor(0,1) διορθώνουμε τον κέρσορα στην 0η στήλη αριστερά της 1ης σειράς, πάνω από την οθόνη LCD.

Η επόμενη γραμμή χρησιμοποιεί μια συντόμευση: lcd.print(millis())

Αν θυμάστε ότι έχουμε συνεργαστεί με millis() στους προηγούμενους κωδικούς μας, θα μπορούσαμε να εφαρμόσουμε το ίδιο και εδώ μέσω των κωδικών:

long numMillis = millis()
lcd.print(numMillis)

Ωστόσο, λόγω του γεγονότος ότι εδώ δεν περιλαμβάνονται χρονικές περιόδους σε χιλιοστά του δευτερολέπτου, επομένως το επιτυγχάνουμε στέλνοντας απλώς millis() λειτουργία απευθείας στο lcd.print() .

5.5 Συνδυάζοντας ολόκληρο το πράγμα

Εντάξει, τώρα ας συνδυάσουμε όλους τους κωδικούς που μάθαμε παραπάνω για την κατασκευή του κυκλώματος θερμοκρασίας LCD και ας δούμε πώς φαίνεται:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Όλα φαίνονται στάνταρ στο παραπάνω πρόγραμμα, εκτός από τη χρήση της λειτουργίας setCursor () . Αυτό χρησιμοποιείται για την ευθυγράμμιση του κειμένου όσο το δυνατόν περισσότερο στο κέντρο της οθόνης.

Μεγάλος! Και συγχαρητήρια, μόλις προγραμματίσατε τη δική σας μικρή ένδειξη θερμοκρασίας LCD χρησιμοποιώντας το Arduino.

Πρακτικές εφαρμογές Arduino

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

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

7.1 Εισαγωγή στους αισθητήρες

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

Θα ξεκινήσουμε με τη διασύνδεση του αισθητήρας φωτός LDR με το Arduino, όπως φαίνεται στο ακόλουθο διάγραμμα:

χρησιμοποιήστε LDR με Arduino

Όπως όλοι γνωρίζουμε, το LDR είναι μια συσκευή αντίστασης που εξαρτάται από το φως και η αντίστασή της εξαρτάται από την ένταση του περιβαλλοντικού συμβάντος στην επιφάνειά του.

Η ένταση του φωτός είναι αντιστρόφως ανάλογη με την αντίσταση του LDR.

Εδώ θα μάθουμε πώς αυτή η ιδιότητα μπορεί να ενσωματωθεί στο Arduino για την εκτέλεση μιας χρήσιμης εφαρμογής:

Ο πλήρης κωδικός προγράμματος μπορεί να απεικονιστεί όπως δίνεται παρακάτω:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

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

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

Αισθητήρας κλίσης

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

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

αισθητήρας κλίσης εσωτερικού χώρου με το Arduino

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

Σε αυτό το παράδειγμα, η προεπιλεγμένη ένδειξη # 13 LED χρησιμοποιείται ως ένδειξη κλίσης.

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

7.4 Ρελέ διακόπτη Reed (Ρελέ ενεργοποιημένου μαγνήτη μικροσκοπίου)

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

Εδώ επίσης χρησιμοποιούμε το pin # 13 LED για να δείξουμε την απόκριση. Μπορείτε να συνδέσετε ένα εξωτερικό LED από αυτόν τον πείρο, εάν απαιτείται σύμφωνα με τις προηγούμενες εξηγήσεις μας.

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Οι κωδικοί όροι πρέπει να είναι οικείοι και αυτονόητοι.

7.5 Αισθητήρας δόνησης με χρήση Piezo Transducer

Στο επόμενο δείγμα προγράμματος θα δούμε πώς ένα μορφοτροπέας πιεζο μπορεί να χρησιμοποιηθεί ως αισθητήρας δόνησης για να φωτίσει ένα LED μέσω του Arduino.

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

Ρυθμίστε το Arduino και ένα piezo στοιχείο όπως δίνεται στο παρακάτω σχήμα

χρησιμοποιώντας το piezo ως αισθητήρα δόνησης με το Arduino

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

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

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

Χρήση Servo Motor με Arduino

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

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

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

Το ακόλουθο παράδειγμα θα μας δείξει το βασικό πρόγραμμα εγκατάστασης για την εφαρμογή του σερβο κινητήρα ελέγχου μέσω του Arduino:

Έλεγχος σερβο κινητήρα Arduino

Ο κωδικός δίνεται παρακάτω:

#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}

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

συμπέρασμα

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

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

Εν τω μεταξύ, απολαύστε το πρόγραμμα προγραμματισμού σας, Happy Arduinoing σε εσάς !!




Προηγούμενο: Κύκλωμα μετρητή ανιχνευτή αλκοόλ χρησιμοποιώντας μονάδα αισθητήρα MQ-3 Επόμενο: Κύκλωμα τροφοδοσίας σκυλιών ελεγχόμενο από κινητό τηλέφωνο