Grundlegende Arduino-Programmierung lernen - Tutorial für die Newcomer

In diesem Tutorial lernen wir anhand von Beispielcodes und Beispielprogrammen, wie man grundlegende Arduino-Programmierungen durchführt. Dieses Tutorial kann ein äußerst wertvoller Kurs für alle Neulinge sein, die die Grundlagen in einer einfachen, verständlichen Sprache verstehen möchten.

Einführung

Gemäß Wikipedia Ein Mikrocontroller entspricht einem Mini-Computer, der in einem einzelnen IC-Chip eingebaut ist und über einen eigenen Kernprozessor, programmierbare Eingänge, Speicher und Ausgangsperipheriegeräte verfügt.

Ein Mikrocontroller wird für einen Benutzer so nützlich, da er einen eingebauten Prozessor, Speicher und Eingabe- / Ausgabeports (auch GPIO oder Allzweck-Eingabe- / Ausgabepins genannt) bietet, die vom Benutzer gemäß den gewünschten Spezifikationen gesteuert werden können.

In diesem Tutorial arbeiten wir mit einem Arduino Uno-Board, um die Programme zu lernen und zu testen. Zum Testen und Integrieren der Hardware-Baugruppe verwenden wir ein Steckbrett.

Lassen Sie uns jetzt schnell vorankommen und lernen, wie Sie mit einer Arduino-Programmierung beginnen.

1.2 Installieren der Software (Windows)

Dazu benötigen Sie Zugang zum Internet, das Sie offensichtlich auf Ihrem Computer haben würden. Bitte gehen Sie zum folgenden Link und laden Sie die IDE-Software herunter:

Windows ZIP-Datei für Nicht-Administrator-Installation

Nach dem Herunterladen finden Sie das Arduino-Setup-Symbol im Download-Ordner, das folgendermaßen aussehen würde:

Sobald Sie dies erhalten haben, können Sie einfach darauf doppelklicken und die integrierte Entwicklungsumgebung (IDE) von Arduino auf Ihrem Computer installieren. Der gesamte Vorgang kann im folgenden Video visualisiert werden:

1.4 Beginnend mit unserer ersten Schaltung

Bevor wir mit dem Erlernen der eigentlichen Programmiertechniken beginnen, ist es für jeden Neuling hilfreich, mit einer grundlegenden Komponente wie einer LED zu beginnen und zu verstehen, wie diese mit einem Arduino verbunden wird.

Wie wir wissen, ist eine LED eine Leuchtdiode, die eine Polarität hat und nicht leuchtet, wenn sie nicht mit den richtigen Versorgungspolen verbunden ist.

Ein weiterer Aspekt bei LEDs ist, dass diese Geräte mit geringem Strom arbeiten und sofort beschädigt werden können, wenn ein entsprechend berechneter Widerstand nicht in Reihe mit einem seiner Pins geschaltet wird.

Als Faustregel gilt, dass ein 330 Ohm 1/4 Watt für jeden Anstieg des Versorgungseingangs um 5 V ideal ist, um den Strom auf ein erforderliches sicheres Niveau zu begrenzen. Daher kann es für 5 V 330 Ohm sein, für 10 V können es 680 Ohm sein und so weiter.

Verwenden von Breadboard für die Montage

Bitte stellen Sie sicher, dass Sie wissen, wie man a verwendet Steckbrett bevor Sie das in diesem Kapitel erläuterte Tutorial ausprobieren, da wir hier für alle Experimente ein Steckbrett verwenden würden.

Der grundlegende Aufbau der LED-Verbindung ist unten aufgeführt:

Sie können 3 grundlegende Komponenten oben sehen:

1. Eine 5mm, 20mA LED
2. ein 330 Ohm 1/4 Watt Widerstand
3. Ein Arduino Board

Montieren Sie das System einfach gemäß Diagramm.

Schließen Sie als nächstes die 5 V vom Computer-USB an das Arduino an. Sobald Sie dies tun, leuchtet die LED auf.

Ich weiß, dass das ziemlich einfach ist, aber es ist immer gut, von vorne zu beginnen. Seien Sie versichert, dass die Dinge im Laufe der Zeit immer interessanter werden.

1.5 LED mit Arduino steuern

Jetzt lernen wir, wie man eine LED mit einem Arduino-Programm steuert.

Um ein Programm zu schreiben, müssen mindestens 2 Funktionen in jedem Programm vorhanden sein.

Eine Funktion kann als eine Reihe von Programmieranweisungen verstanden werden, denen ein Name zugewiesen werden kann, wie unten angegeben:

1. installieren() Dies wird beim Start des Programms aufgerufen oder ausgeführt.
2. Schleife() Dies wird während der gesamten Betriebsdauer des Arduino wiederholt aufgerufen oder ausgeführt.

Daher kann ein kürzestes legitimes Arduino-Programm geschrieben werden, obwohl es möglicherweise keine praktische Funktionalität hat:

Einfachstes Programm

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

Möglicherweise haben Sie bemerkt, dass das System in vielen Programmiersprachen zunächst einen einfachen Ausdruck 'Hallo Welt' auf dem Bildschirm anzeigt

Das elektronische Äquivalent für diesen Satz in der Mikrocontroller-Interpretation besteht darin, eine LED ein- und auszuschalten.

Dies ist das grundlegendste Programm, das geschrieben und implementiert werden kann, um eine korrekte Funktionsweise des Systems anzuzeigen.

Wir werden versuchen, die Prozedur durch den folgenden Code zu implementieren und zu verstehen:

Listing 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)
}

OK, jetzt wollen wir verstehen, was jede Zeile des Codes bedeutet und wie es funktioniert, um die Funktion auszuführen:

const int kPinLed = 13

Dies funktioniert wie eine Konstante, die es uns ermöglicht, sie während des gesamten Programmierkurses zu verwenden, ohne den tatsächlichen Wert verwenden zu müssen, der dagegen eingestellt ist.

Nach den Standardregeln werden solche Konstanten mit dem Anfangsbuchstaben erkannt zu . Dies ist zwar nicht obligatorisch, macht die Dinge jedoch klarer und verständlicher, wenn Sie die Codedetails durchgehen möchten.

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

Dieser Code konfiguriert den spezifischen Pin, an den unsere LED angeschlossen ist. Mit anderen Worten, der Code weist das Arduino an, den 'Schreib'-Aspekt auf diesem Pin zu steuern, anstatt ihn' zu lesen '.

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

Die obigen Zeilen geben die tatsächliche Ausführung der Anwendung an. Der Code beginnt mit dem Schreiben und Rendern eines HIGH-Outs für die entsprechende LED-Verbindung, wobei die LED eingeschaltet wird.

Hier bedeutet der Begriff HIGH einfach, + 5V an den betreffenden Pin des Arduino zu bringen. Der komplementäre Term LOW gibt einfach eine Null oder 0 V am angegebenen Pin an.

Als nächstes rufen wir delay() auf deren Funktion darin besteht, eine Verzögerung von Millisekunden (1/1000 Sekunde) zu erzeugen. Da die Zahl 500 eingegeben wird, wird die implementierte Verzögerung eine halbe Sekunde betragen.

Sobald diese 1/2 Sekunde verstrichen ist, wird die nächste Zeile ausgeführt, die die LED mit dem LOW-Term am selben Pin ausschaltet.

Die nachfolgende Zeile erzeugt erneut die Verzögerung von 1/2 Sekunde, damit die LED 1/2 Sekunden lang AUS bleibt.

Und der Prozess wird durch die Ausführung der Codezeilen unendlich fortgesetzt, solange der Arduino mit Strom versorgt wird.

Bevor Sie mit der nächsten Stufe fortfahren, würde ich Ihnen empfehlen, den obigen Code zu programmieren und zu prüfen, ob Sie die LED ON / OF-Sequenz korrekt implementieren können oder nicht.

Da die Standard-LED in Arduino mit Pin 13 verbunden ist, sollte sie sofort auf das obige Programm reagieren und zu blinken beginnen. Wenn Sie jedoch feststellen, dass Ihre externe LED nicht blinkt, liegt möglicherweise ein Verbindungsfehler mit Ihrer LED vor. Sie können versuchen, die Polarität Ihrer LED umzukehren, und hoffentlich auch blinken.

Sie können mit der Verzögerungszeit spielen, indem Sie die Zahl '500' auf einen anderen Wert ändern und feststellen, dass die LED die Befehle 'abhört' und sie gemäß den angegebenen Verzögerungswerten blinken lässt.

Denken Sie jedoch daran, dass wenn Sie sehen, dass die LED unabhängig von Ihrer Änderung der Verzögerungszeit nicht mit einer konstanten Rate von 1 Sekunde blinkt, dies möglicherweise darauf hinweist, dass der Code aufgrund eines Fehlers nicht funktioniert. Da der Arduino standardmäßig mit einer Blinkrate von 1 Sekunde programmiert wird. Daher muss diese Rate durch Ihren Code variiert werden, um die korrekte Funktion zu bestätigen.

1.7 Kommentare

Die Codezeilen, die wir oben verstanden haben, wurden speziell für die Computersoftware geschrieben.

Um jedoch sicherzustellen, dass der Benutzer die Bedeutung der Zeilen referenzieren und verstehen kann, kann es oft nützlich und sinnvoll sein, die Erklärung neben die gewünschten Codezeilen zu schreiben.

Diese nennt man Bemerkungen Diese sind nur für Personen- oder Benutzerreferenzen geschrieben und so codiert, dass die Computer sie sicher ignorieren können.

Die Sprache dieser Kommentare ist in verschiedenen Formaten verfasst:

1. Der Blockstil des Kommentars, wobei die Kommentarbeschreibung unter dem Startsymbol / * und dem Endsymbol * / steht
2. Dies muss nicht in einer Zeile eingeschränkt werden, sondern kann abhängig von der Länge des Kommentars oder der Beschreibung auf die nächsten nachfolgenden Zeilen erweitert werden, wie im folgenden Beispiel gezeigt:

/ * Dies ist ein Kommentar * /

/* Also das ist */

/* Und
* Dies
* wie
* Gut */

Um eine schnelle einzeilige Beschreibung für einen Kommentar zu schreiben, sind zwei // Schrägstriche am Anfang ausreichend. Dies teilt dem Computer mit, dass diese Zeile nichts mit dem tatsächlichen Code zu tun hat und ignoriert werden muss. Zum Beispiel:

// Dies ist ein Kommentar, den Computer ignorieren.

Hier ist ein Beispiel als Referenz:

/*
* 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 Fehlerbehebung

Wenn Sie feststellen, dass Ihr Programm beim Kompilieren einen Fehler oder ein anderes Problem anzeigt, helfen Ihnen die folgenden Tipps wahrscheinlich dabei, Ihren Code erneut zu überprüfen, um die Hürde zu beseitigen.

1. Ihre Programmsprache unterscheidet zwischen Groß- und Kleinschreibung. Zum Beispiel der Ausdruck myVar kann nicht geschrieben werden als MyVar.
2. Alle Arten von Leerzeichen, die durch die Eingabe Ihrer Tastatur ausgeführt werden können, werden letztendlich als ein einzelnes Leerzeichen gerendert und sind nur für Sie sichtbar oder verständlich. Der Computer berücksichtigt dies nicht. Einfach ausgedrückt, haben freie Speicherplätze jeglicher Art keine Auswirkungen auf die Codeergebnisse.
3. Jeder Codeblock muss in linke und rechte geschweifte Klammern eingeschlossen sein. '{' und '}'
4. Ziffern sollten nicht durch Kommas getrennt werden. Beispielsweise kann 1000 nicht als 1.000 geschrieben werden.
5. Jede Codezeile zwischen den geschweiften Klammern muss mit einem Semikolon abgeschlossen werden

Erstellen einer interessanten LED-Lichtsequenz mit Arduino

In unserem vorherigen Kapitel haben wir gelernt, wie man eine LED kontinuierlich mit einer konstanten Verzögerungsrate ein- und ausschaltet.

Jetzt lernen wir, wie verschiedene Verzögerungsmuster auf derselben LED ausgeführt werden können, indem der Programmcode aktualisiert wird.

Wir werden keine externe LED verwenden, sondern die Standard-LED, die in die Arduino-Platine an Pin 13 integriert ist. Sie finden diese winzige SMD-LED direkt hinter dem USB-Anschluss.

2.2 IF-Anweisungen verstehen

In diesem Abschnitt erfahren Sie, wie Steuerungsstrukturen es uns ermöglichen, einzelne Codes nach Bedarf und manchmal sogar wiederholt auszuführen.

Die Aussage wenn wird die 1. Kontrollstruktur. Die folgende Implementierung zeigt, wie es verwendet wird:

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)
}

Wir werden versuchen, den obigen Code schrittweise zu verstehen und zu lernen, wie dies für andere ähnliche Ausführungen verwendet werden kann.

Die Codes zwischen der 1. und 7. Zeile ähneln genau unserem ursprünglichen Programm.

Die erste Änderung erfolgt tatsächlich in der 8. Zeile.

int delayTime = 1000

Sie können feststellen, dass dies dem Code in der ersten Zeile ähnlich ist, außer dass der Begriff fehlt const.

Dies liegt einfach daran, dass dieser Code keine Konstante ist. Stattdessen wird dies als definiert Variable , die im Verlauf der Programmierung die Eigenschaft eines variablen Wertes hat.

Im obigen Beispiel sehen Sie, dass dieser Variablen ein Wert von 1000 zugewiesen wird. Denken Sie daran, dass solche Variablen, die in geschweiften Klammern eingeschlossen sind, nur in Paaren von geschweiften Klammern geschrieben werden müssen und als 'lokale' Variablen bezeichnet werden.

Alternativ werden Variablen, die außerhalb der geschweiften Klammern stehen sollen, wie die, die wir gerade diskutieren, als 'global' erkannt und können fast überall in einem Programmcode ausgeführt werden.

Wenn Sie fortfahren, können Sie sehen, dass die Codes zwischen Zeile 9 und 11 auch dem ersten Programm ähneln. Dennoch werden die Dinge nach Zeile 11 interessant. Mal sehen, wie!

delayTime = delayTime - 100

In diesem Code sehen wir, dass der Standardwert der Verzögerungszeit wird durch Subtrahieren von 100 davon modifiziert.

Die Bedeutung 100 wird von ihrem Anfangswert von 1000 abgezogen, was einen neuen Wert von 900 ergibt.

Anhand des folgenden Bildes werden wir versuchen, einige der in der Arduino-Sprache verwendeten mathematischen Operatoren zu verstehen.

Lassen Sie uns nun die Codes zwischen Zeile 13 und 15 bewerten.

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

Das Hauptziel des obigen Codes besteht darin, sicherzustellen, dass die LED ohne Unterbrechung weiter blinkt.

Aufgrund der Tatsache, dass 100 vom Original abgezogen werden Verzögerungszeit verhindert, dass die blinkende LED Null erreicht, und lässt das Blinken kontinuierlich weiterlaufen.

Das folgende Bild zeigt einige Vergleichsoperatoren, die wir in unseren Codes verwenden würden:

In unserem obigen Code hätten wir den Code als if(delayTime == 0) testen können.

Da es jedoch genauso schlecht sein kann, eine negative Zahl zu sein, haben wir uns nicht dafür entschieden, und dies ist eine empfohlene Vorgehensweise.

Überlegen Sie, was das Ergebnis gewesen sein könnte, wenn wir versucht hätten, 300 statt 100 von delayTime abzuziehen?

Jetzt haben Sie vielleicht erkannt, dass wenn die delayTime Wird als kleiner oder gleich Null geschrieben, wird die Verzögerungszeit auf die ursprüngliche Zahl 1000 zurückgesetzt.

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

Die letzten 4 Zeilen des Codes, wie oben gezeigt, sind dafür verantwortlich, die LED kontinuierlich ein- und auszuschalten.

Hier können Sie deutlich erkennen, dass wir anstelle einer Anzahl von Zahlen eine Variable zum Zuweisen der Verzögerungszeit verwendet haben, damit wir sie während der Betriebsdauer des Codes nach Belieben anpassen können. Das ist cool, oder?

2.3 SONSTIGE Anweisungen

Hier erfahren wir warum und wie ein wenn Begriff kann eine Klausel haben sonst damit es die Situation für den Fall entscheidet wenn Aussage ist falsch.

Es tut mir leid, wenn das zu verwirrend klingt, keine Sorge, wir werden versuchen, es anhand des folgenden Beispiels zu verstehen:

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)
}

Oben sehen Sie, dass in der 10. Zeile der Code nur ausgeführt wird, wenn delayTime ist kleiner oder gleich 100, wenn nicht, dann wird der Code in der 13. Zeile ausgeführt, aber beide zusammen können niemals passieren, entweder die 10. Zeile oder der 13. Zeilencode werden implementiert, niemals beide.

Sie haben vielleicht bemerkt, dass wir im Gegensatz zu dem, was wir in unserem vorherigen Abschnitt 2.2 getan haben, hier nicht mit 0 verglichen haben, sondern mit 100. Dies liegt daran, dass wir in diesem Beispiel verglichen haben, BEVOR wir 100 subtrahiert haben, im Gegensatz dazu haben wir in Abschnitt 2.2 NACH uns verglichen subtrahiert. Können Sie sagen, was hätte passieren können, wenn wir 0 statt 100 verglichen hätten?

2.4 WHILE-Anweisungen

ZU während Aussage ist ziemlich ähnlich zu wenn Anweisung, mit Ausnahme der Tatsache, dass ein Codeblock (der sich möglicherweise in geschweiften Klammern befindet) wiederholt ausgeführt wird, solange die Bedingungen zutreffen, und dies funktioniert ohne sonst Erklärung.

Das folgende Beispiel hilft Ihnen, dies besser zu verstehen

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)
}
}

Können Sie sich vorstellen, wozu der obige Code programmiert ist? Nun, es ist so konzipiert, dass die LED schneller und dann langsamer blinkt.

2.5 Was ist wahr und falsch?

In der Programmiersprache falsch bezieht sich auf Null (0). Tatsächlich wird 'wahr' nicht verwendet, stattdessen wird angenommen, dass alles, was enthalten ist, wahr ist, wenn nichts falsch ist.

Es sieht ein wenig seltsam aus, macht aber den Job ziemlich gut.

Wir werden versuchen, die Situation anhand des folgenden Beispiels zu erfassen.

Manchmal stoßen Sie auf einen Code wie folgt:

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

Dieser Code sieht so aus, als würde die LED-Ausführung für immer weiterlaufen, solange Strom zur Verfügung steht.

Ein Nachteil dieser Art von Code kann jedoch auftreten, wenn der Benutzer versehentlich ein = anstelle von == anwendet.

Ich bin sicher, Sie wissen bereits, dass = eine Zuweisung bedeutet, dh, es wird verwendet, um einen ausgewählten Wert für eine Variable zu bestimmen, während a == zum Erzwingen eines Tests verwendet wird, wenn der Wert gleich war.

Angenommen, Sie benötigen eine LED, um mit einem sequentiell beschleunigten Muster und wiederholt zu blinken, verwenden jedoch fälschlicherweise ein = anstelle von ==.

Der Code würde dann wie folgt aussehen:

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
}

Der Fehler weist delayTime 0 zu und führt zu wenn Anweisung, um zu überprüfen, ob 0 wahr ist oder nicht. Da 0 auf false verweist, wird es denken, dass es nicht wahr ist, und die Durchsetzung von delayTime = 1000 stoppen, sondern stattdessen die Funktion delayTime wird im Verlauf der Schleife () auf 0 gehalten.

Das sieht sehr unerwünscht aus !!

Überprüfen Sie Ihr Programm also immer noch einmal, um sicherzustellen, dass Sie keine solchen dummen Fehler gemacht haben.

2.6 Kombinationen

Manchmal haben Sie das Bedürfnis, mehrere Dinge zusammen zu testen. Vielleicht möchten Sie untersuchen, ob eine Variable zwischen zwei Zahlen liegt. Dies kann zwar mehrmals mit der if-Anweisung implementiert werden, es kann jedoch bequemer sein, logische Kombinationen zum besseren und einfacheren Lesen zu verwenden.

Das Implementieren von Kombinationen unter logischen Begriffen kann mit drei Methoden erfolgen, wie in der folgenden Tabelle gezeigt:

Es wäre interessant zu wissen, dass der NOT-Operator als Umschalter für eine Variable arbeiten kann, die als eine von beiden bezeichnet werden kann wahr oder falsch (oder NIEDRIG oder HOCH).

Das folgende Beispiel veranschaulicht den Zustand:

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

Hier das ledState wird LOW sein und anschließend, sobald ledState = !ledState, wird es HIGH. Die folgende Schleife verursacht ledState hoch sein, wenn ledState = !ledState ist niedrig.

2.7 FOR-Anweisungen

Jetzt werden wir versuchen, eine andere Kontrollstruktur zu verstehen, nämlich a zum Schleife. Dies kann sehr praktisch sein, wenn Sie etwas mehrmals implementieren möchten.

Lassen Sie uns dies anhand des folgenden Beispiels verstehen:

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
}

Sie können etwas Einzigartiges in der Zeile mit finden zum.

Es ist der Code i ++? . Dies ist nützlich für Programmierer, die eher faul sind und die Codierung über praktische Verknüpfungen implementieren möchten

Der obige Begriff ist als zusammengesetzte Operatoren bekannt, da sie die Aufgabe haben, einen Zuweisungsoperator mit einem anderen Zuweisungsoperator zu kombinieren. Die beliebtesten davon können in der folgenden Tabelle dargestellt werden:

Sie werden feststellen, dass eine for-Anweisung 3 Unteranweisungen enthält. Es ist wie folgt aufgebaut:

for (statement1conditionstatement2){
// statements
}

Die Anweisung Nr. 1 kommt gleich zu Beginn und nur einmal vor. Der Zustand wird jedes Mal im Verlauf der Schleife getestet. Wann immer es ist wahr In den geschweiften Klammern wird die nachfolgende Anweisung Nr. 2 erzwungen. Im Falle eines falsch, Das System springt zum nächsten Codeblock.

Weitere LEDs anschließen

OK, jetzt werden wir sehen, wie wir mehr LEds verbinden können, um interessantere Effekte zu erzielen.

Bitte verbinden Sie die LEDs und das Arduino wie unten gezeigt. Der rote Draht ist eigentlich nicht notwendig, aber da es immer eine gute Idee ist, beide Versorgungsschienen im Steckbrett zu haben, ist die Einrichtung sinnvoll.

Lassen Sie uns nun ein Programm reparieren, mit dem wir überprüfen können, ob unsere Hardware richtig konfiguriert ist oder nicht.

Es wird immer empfohlen, kleine Programmbits schrittweise zu codieren und auszuführen, um zu überprüfen, ob die jeweiligen Hardwares korrekt verdrahtet sind oder nicht.

Dies hilft bei der schnellen Fehlerbehebung.

Das folgende Codebeispiel gibt den LEDs 2 bis 5 ein bestimmtes Muster, indem sie zyklisch nacheinander gedreht werden.

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)
}

Wie Sie vielleicht bemerken, ist an dem Code nichts auszusetzen, außer der Tatsache, dass er lang aussieht und daher fehleranfällig ist.

Natürlich gibt es bessere Möglichkeiten, den obigen Code zu schreiben. Der folgende Abschnitt wird es zeigen.

2.9 Einführung in Arrays

Arrays können eine Gruppe von Variablen sein, die mit Indexnummern indiziert werden können. Das folgende Beispiel hilft uns, es besser zu verstehen.

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)
}
}

OK, jetzt gehen wir jeden Abschnitt durch und verstehen, wie sie tatsächlich funktionieren.

const int k_numLEDs = 4

Der obige Code definiert, wie viele maximale Elemente wir im Array haben sollen. Dieser Code hilft uns in den folgenden Abschnitten sicherzustellen, dass alles in ein Array geschrieben wird und nichts, sobald das Array endet.

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

In dieser nächsten Zeile richten wir die Array-Struktur ein. Die Zahlen in der Klammer geben die Anzahl der Elemente im Array an. Obwohl die tatsächliche Menge hätte geschrieben werden können, funktioniert das Schreiben als Konstanten besser. Die Werte werden normalerweise in der Klammer mit Kommas angezeigt und geben die Werte für das Array an.

Wenn Sie ein Array finden, das mit der Nummer 0 indiziert ist, gibt dies das allererste Element im Array an, wie in code: k_LEDPins is k_LEDPins[0] gezeigt.

In ähnlicher Weise wird das letzte Element als k_LEDPins[3] angezeigt, da die Anzahl von 0 bis 3 4 beträgt.

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

Der obige Code zeigt die Verwendung einer Schleife zum Durchlaufen der einzelnen Array-Elemente und zum Festlegen dieser als AUSGÄNGE. Wir implementieren eckige Klammern zusammen mit dem Index, um jedes der Elemente im Array zu erreichen.

Wenn Sie sich fragen, ob es möglich ist, Pin 2 bis Pin 5 ohne Arrays zu verwenden, lautet die Antwort 'Ja'. Aber in diesem Beispiel wird es nicht gemacht, weil wir es nicht so gemacht haben. In den folgenden Abschnitten können Sie den Array-Ansatz entfernen, wenn die ausgewählten Ausgangspins nicht in einer Linie liegen.

Lassen Sie uns sehen, was der nächste Codeblock bewirkt:

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

Hier durchläuft der Code jede der LEDs, um sie nacheinander mit einer Lücke oder Verzögerung von 100 Millisekunden einzuschalten.

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

Die Verwendung des obigen Codes zeigt, wie die Anwendung von für Schleife könnte verwendet werden, um sich auch in umgekehrter Reihenfolge durch die Schleife zu bewegen.

Es beginnt mit k_numLEDs - 1, da Arrays mit Null indiziert sind. Wir beginnen nicht mit k_LEDPins[4] denn das würde dazu führen, dass das Ende des Arrays überschritten wird.

Der Code verwendet> = 0, um zu überprüfen, ob das erste Element am Index 0 nicht übersehen oder ignoriert wird.

Kapitel 3

Was ist ein Input?

So haben wir gelernt, wie man Dinge mit Arduino bedient. In diesem Kapitel werden wir diskutieren, wie man die reale Welt erfasst, indem man Eingaben von externen Parametern miteinander verbindet.

3.1 Drucktasten verwenden

Wir alle wissen, was ein Druckknopf ist und wie er funktioniert. Es ist eine Art Schalter oder Knopf, der ein Signal von einer Schaltungsstufe zu einer anderen vorübergehend verbindet, während es sich im gedrückten Zustand befindet, und das Signal bricht, wenn es losgelassen wird.

3.1.1 Eine Taste und eine LED

Wir verbinden den Arduino mit einem Druckknopf mit Arduino gemäß den oben gezeigten Details und lernen die grundlegende Arbeitsweise und Implementierung des Setups.

Der angegebene Druckknopf, der auch als Mikroschalter-Druckknopf bezeichnet wird, hat insgesamt 4 Stifte (2 Paare auf jeder Seite). Beim Drücken wird jedes Paar Stifte intern verbunden und ermöglicht eine Verbindung oder Leitung zwischen ihnen.

In diesem Beispiel verwenden wir nur ein Paar dieser Pins oder Kontakte, das andere Paar ist irrelevant und wird daher ignoriert.

Lassen Sie uns fortfahren, indem Sie den folgenden Code anwenden und überprüfen, ob er funktioniert!

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)
}
}

Möglicherweise finden Sie hier einige Dinge, die ungewöhnlich aussehen. Lassen Sie uns sie schrittweise herausfinden.

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

Das erste, was wir tun, ist das zu beheben buttonPin als die EINGANG. Nun, das ist ziemlich einfach, ich weiß.

Als nächstes weisen wir zu HOCH zum EINGANG Stift. Sie fragen sich, wie es möglich sein kann, etwas am Eingang zu schreiben? Sicher, das kann interessant sein.

Wenn Sie einem Arduino-Eingang ein HIGH zuweisen, wird ein interner 20-kOhm-Pull-up-Widerstand eingeschaltet (ein LOW an diesem Pin schaltet ihn aus).

Eine andere Frage, die Sie möglicherweise stellen, ist, was ein Pull-up-Widerstand ist. Ich habe einen umfassenden Beitrag über Pull-up-Widerstände behandelt, den Sie lerne es hier .

OK, weiter, jetzt schauen wir uns den Hauptschleifencode an:

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

Wenn Sie den Druckknopf drücken, wird der verdrahtete Stift mit Masse verbunden, wodurch a NIEDRIG zu diesem Stift. Und im ungedrückten Zustand wird derselbe Stift festgehalten HOCH oder + 5V über den internen 20K-Pull-up-Widerstand.

Hier möchten wir, dass der Arduino die LED aufleuchtet, wenn der Druckknopf gedrückt wird (LOW), daher schreiben wir HIGH für den Ausgang für jede Antwort eines LOW vom Druckknopf, während er gedrückt wird.

3.1.2 Zwei Tasten und eine LED

Nun, Sie werden sich vielleicht fragen, ob die oben gezeigte Aktion auch ohne Arduino hätte durchgeführt werden können. Ich verstehe jedoch, dass dies ein durchtränkter Stein ist, um zu lernen, wie der Druckknopf mit Arduno verwendet werden kann.

Bis zu diesem Punkt haben wir das Schreiben von Codes zum Einschalten (HIGH) oder Ausschalten (LOW) einer LED untersucht.

Nun wollen wir sehen, wie die Helligkeit der LED mit einem Arduino gesteuert werden kann.

Dies kann mit zwei Methoden erfolgen:

1. Durch Beschränken der Strommenge auf die LED
2. Durch die Nutzung PWM oder Pulsweitenmodulation, bei der die Versorgung der LED sehr schnell mit einer gewünschten Rate ein- und ausgeschaltet wird, wodurch eine durchschnittliche Beleuchtung erzeugt wird, deren Intensität von der PWM abhängen würde.

In einer Arduino-Platine ist PWM-Unterstützung für mit einer Tilde (~) gekennzeichnete Pins verfügbar, bei denen es sich um die Pins 3, 4,5,9,10 und 11 bei 500 Hz (500 Mal pro Sekunde) handelt. Der Benutzer kann einen beliebigen Wert zwischen 0 und 255 angeben, wobei 0 für kein HIGH oder kein + 5 V steht und 255 Arduino anweist, ständig ein HIGH oder + 5 V zu erhalten. Um diese Befehle zu initiieren, müssen Sie mit dem gewünschten Wert auf analogWrite () zugreifen.

Sie können davon ausgehen, dass PWM x / 255 ist, wobei x der gewünschte Wert ist, den Sie über analogWrite() senden möchten.

Richten Sie das Arduino und andere Parameter wie oben gezeigt ein.

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)
}

Möglicherweise finden Sie hier 3 Zeilen, die einer Erklärung bedürfen.

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

Die Zeile: ledBrightness = constrain(ledBrightness, 0, 255) veranschaulicht eine einzigartige Funktion in Arduino, die als constrain () bekannt ist.

Diese interne Funktion umfasst Code, der dem folgenden ähnelt:

int constrain (int value, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Alle zuvor besprochenen Codes begannen mit Leere , was bedeutete, nichts zurückzugeben (nichtig). Während der obige Code mit beginnt int , was anzeigt, dass eine Ganzzahl zurückgegeben wird. Wir werden in den späteren Abschnitten mehr darüber diskutieren. Denken Sie im Moment daran, dass eine Ganzzahl keine Bruchteile enthält.

Richtig, das impliziert also den Code: ledBrightness = constrain(ledBrightness, 0, 255) weist das ledBrightness to be within the range of 0 and 255 zu.

In der nächsten Zeile wird analogWrite verwendet um Arduino zu befehlen, PWM auf den ausgewählten Pin mit dem gewünschten Wert anzuwenden.

Die nächste Zeile erzeugt eine Verzögerung von 20 Millisekunden. Dies soll sicherstellen, dass wir den Ate nicht schneller als 50 Hz oder 50 Mal pro Sekunde einstellen. Dies liegt daran, dass Menschen viel langsamer sein können als ein Arduino. Wenn die Verzögerung nicht eingestellt wird, kann das Programm das Gefühl vermitteln, dass durch Drücken der ersten Taste die LED ausgeschaltet und durch Drücken der zweiten Taste eingeschaltet wird (versuchen Sie es selbst, um dies zu bestätigen).

3.2 Potentiometer

Lassen Sie uns weitermachen und lernen, wie man es benutzt Potentiometer mit Arduino.

Um zu wissen, wie Potentiometer oder ein Topf funktionieren, können Sie dies lesen Artikel .

Verbinden Sie die angezeigten Parameter wie oben gezeigt mit Ihrem Arduino.

Ein Topf hat 3 Terminals. Das mittlere Terminal wird mit ANALOG IN 0 auf dem Arduino verbunden. Die beiden anderen äußeren Klemmen können an + 5V- und 0V-Versorgungsschienen angeschlossen werden.

Lassen Sie uns die Ergebnisse programmieren und überprüfen:

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)
}

Sie werden einige Dinge finden, die möglicherweise völlig neu aussehen und in keinem unserer früheren Codes enthalten sind.

1. Die Konstante kPinPot wird als A0 zugewiesen, wobei A die Abkürzung zur Beschreibung eines der analogen Pins ist. A0 bezieht sich jedoch auch auf Pin Nr. 14, A1 auf Pin Nr. 15 usw. Mit diesen können Sie als digitale Ein- / Ausgänge verwendet werden, falls Ihnen für ein Experiment die Pins ausgehen. Denken Sie jedoch daran, dass Sie digitale Pins nicht als analoge Pins verwenden können.
2. Die Zeile: ledBrightness = map(sensorValue, 0, 1023, 0, 255) präsentiert eine neue Insider-Funktion in Arduino, bekannt als Karte(). Diese Funktion wird von einem bestimmten Bereich in einen anderen neu kalibriert map (Wert, fromLow, fromHigh, toLow, toHigh). Dies kann seit analogueRead von entscheidender Bedeutung sein gibt einen Wert im Bereich von 0-1023 aus, aber analogWrite kann einen Wert von 0-255 akzeptieren.

Sie können denken, dass, da es möglich ist, die Helligkeit einer LED durch einen sich ändernden Widerstand zu steuern, einfach ein Topf für den Zweck ausreichend gewesen sein könnte, warum die Verwendung von Arduino. Nun, wieder ist es nur die Grundlage, um zu zeigen, wie ein Topf mit einem Arduino konfiguriert werden kann.

Keine Probleme, jetzt machen wir etwas, was ohne ein Arduino nicht geht.

In diesem Experiment werden wir sehen, wie der unterschiedliche Widerstand eines Topfes zur Steuerung der Blinkgeschwindigkeit oder -rate einer LED verwendet werden kann.

Hier ist das Programm:

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 Vermeidung von Verzögerungen ()

Der obige Code sieht gut aus, aber die LED kann den Topfwert erst überprüfen, wenn er jeden vollen Zyklus durchlaufen hat. Bei längeren Verzögerungen wird dieser Vorgang länger. Der Benutzer muss warten, bis die Pot-Antwort angezeigt wird, während er sie bewegt. Diese Verzögerung kann mit einer intelligenten Programmierung vermieden werden, so dass der Benutzer den Wert ohne minimale Verzögerungen überprüfen kann. Hier ist der Code.

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)
}
}

Was ist also anders im obigen Code? Es ist die folgende Zeile, die den Unterschied macht.

long lastTime = 0

Bis zu diesem Abschnitt haben wir über die Variable int diskutiert. Es kann jedoch zahlreiche weitere Typvariablen geben, auf die Sie zugreifen können. Die Liste kann unten gelesen werden:

Gegenwärtig ist es möglicherweise nur entscheidend zu wissen, dass für die Speicherung relativ großer Zahlen für die int Variable, könnten Sie den Begriff verwenden lange oder ein lange int.

Hier sehen Sie eine weitere interessante Funktion namens millis ().

Dies ergibt die Zeitspanne in Millisekunden, die der Arduino von Anfang an in seinem Betriebsablauf gearbeitet hat (dies wird alle 50 Tage auf 0 zurückgesetzt). Hier gibt es eine lange zurück, denn wenn es zurückkehrt int Eine längere Zählung ist möglicherweise nicht möglich. Könnten Sie genau wie lange antworten? Die Antwort ist 32.767 Sekunden.

Anstatt delay () zu verwenden, suchen wir daher nach Millis (), und sobald die bestimmte Anzahl von Millisekunden verstrichen ist, ändern wir die LED. Folglich speichern wir die Zeit, in der wir sie zuletzt geändert haben letztes Mal variabel, so dass wir es jederzeit wieder überprüfen können.

3.3 RGB-LEDs

Bisher haben wir mit einer einfarbigen LED gespielt. Die LED-Farbe könnte zwar durch Ersetzen der LED durch eine andere Farbe geändert werden, aber wie wäre es mit der Verwendung von RGB-LEDs? LED-Farben ändern ohne die LEDs zu wechseln?

Eine RGB-LED ist im Grunde eine LED mit einer roten, grünen und blauen LED, die in eine einzelne LED eingebettet und zusammengeführt wird. Es hat eine gemeinsame Leitung, die zur Masse oder zur 0-V-Versorgungsschiene führt, während die anderen 3 Leitungen mit diversifizierten PWM-positiven Signalen zur Umsetzung der beabsichtigten Leitung gespeist werden Farbmischung .

Sie können das Setup wie folgt verkabeln:

Es mag ein wenig komplex aussehen, aber tatsächlich ist es eine Nachbildung unseres früheren LED-Steuerungsdesigns mit PWM.

Hier ist ein Übungsprogrammcode:

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)
}

Nachdem Sie diesen Code hochgeladen haben, sehen Sie einfach, wie die Topfanpassungen einen interessanten Lichteffekt auf das RGB erzeugen. Es kann ein echter Spaß sein.

Sie werden feststellen, dass, wenn alle 3 Töpfe maximal positioniert sind, anstelle einer weißen Farbe Rot angezeigt wird. Dies liegt daran, dass die rote Farbe unter den drei Farben am stärksten hervorgehoben wird und daher in dieser Situation dominiert. Sie können jedoch mit der Funktion experimentieren Karte() vor dem Ausführen auf den roten Teil der LED, um ein vernünftigeres Gleichgewicht zu schaffen.

Audio mit Arduino

In diesem Abschnitt erfahren Sie, wie Sie einem Arduino-Setup grundlegenden Sound und Musik hinzufügen.

Wir werden sehen, wie ein Signal an einen angeschlossenen Lautsprecher mit einer gewünschten Frequenz umgeschaltet wird.

Genauer gesagt wird eine mittlere A-Note ausprobiert, bei der es sich um eine 440-Hz-Frequenznote handelt.

Dazu spielen wir einfach eine mittlere A-Note und optimieren das Sinuswellensignal mit der Rechteckwelle.

Außerdem berechnen wir die Zeitdauer, in der ein Lautsprecher eingeschaltet bleiben kann, indem wir die folgende Formel verwenden:

Zeitverzögerung = 1 Sekunde / 2 x Tonfrequenz.

Zeitverzögerung = 1 Sekunde / 2 x 440

Zeitverzögerung = 1136 Mikrosekunden

4.1 Schließen wir das Arduino Board an

4.2 Hinzufügen einer einfachen Notiz

Wir haben bereits über die Funktion diskutiert verzögern() Wenn sich die Einheit in Millisekunden (Sekunde / 1000) befindet, finden Sie jedoch noch eine weitere Funktion delayMicroseconds() wobei sich die Einheit in Mikrosekunden befindet (Millisekunde / 1000).

Für das vorliegende Setup programmieren wir einen Code zum Ein- und Ausschalten von + 5 V an dem ausgewählten Pin, der mit dem Lautsprecher verbunden ist, mit einer Rate von 440 Impulsen pro Sekunde.

Denken Sie daran, dass wir in der letzten Diskussion den Wert 1136 Mikrosekunden für die beabsichtigte Audio-Note bestimmt haben.

Hier ist das Programm dafür, mit dem Sie eine Audio-Note von 440 Hz hören können, sobald Sie das Arduino mit angeschlossenem Lautsprecher programmieren.

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)
}

Mit der obigen Anwendung ist es möglich, eine Audio-Notiz zu erstellen, was auch bedeutet, dass wir eine Musik nach unserer eigenen Wahl erstellen können.

Aus dem Code geht hervor, dass Arduino einige integrierte Funktionen enthält, die zusätzlich zur Erstellung von Musik beitragen.

Der erste ist Ton() Dies funktioniert mit 2 Elementen zusammen mit einem dritten optionalen Element, das als bezeichnet wird Ton (Pin, Frequenz, Dauer). oder Ton (Pin, Frequenz)

Beide sind für die Ausführung des von Ihnen zugewiesenen Zeitraums vorgesehen.

In Abwesenheit eines Zeitraums wird die Musik bis zum Anruf weiter abgespielt Ton() wird erneut ausgeführt oder bis Sie ausführen nicht eins ().

Dies muss mithilfe einer Verzögerungsfunktion erfolgen, falls die Musikwiedergabe das einzige grundlegende Element ist, das Sie implementieren.

Die Zeitdauer kann von entscheidender Bedeutung sein, da hiermit angegeben werden kann, wie lange die Musik abgespielt wird, sodass Sie andere Dinge tun können. Sobald die Dauer abgelaufen ist, stoppt die Musik.

Die nächste Funktion nicht eins () behandelt einen einzelnen Parameter und stoppt den ausgewählten Ton an einem bestimmten zugewiesenen Pin.

Eine besondere Warnung: Jederzeit wann Ton() Wenn die Funktion implementiert ist, stoppt die PWM-Funktion an Pin 3 und 11 den Betrieb.

Verwenden Sie daher bei Verwendung eines Lautsprecheraufsatzes im Programm nicht den genannten Stift für die Lautsprecher, sondern versuchen Sie es mit anderen Stiften für den Lautsprecheraufsatz.

OK, hier ist ein Programm zum Implementieren von Musik auf einem Lautsprecher, obwohl es sich nicht um eine echte Musik handelt, sondern um eine C-Note der Basisskala.

#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)
}

Im obigen Code haben Sie möglicherweise etwas Neues bemerkt, und das ist es #definieren .

Dieser Begriff funktioniert wie ein Such- und Ersetzungsbefehl für den Computer, während das Kompilieren durchgeführt wird.

Immer wenn es das erste vor einem Leerzeichen findet, ersetzt es es durch den verbleibenden Teil der Zeile (Makros genannt).

Also in diesem Beispiel, wenn der Computer sieht HINWEIS_E4 es ersetzt es schnell durch die Menge 330.

Weitere Hinweise und Anpassungen finden Sie in einer Datei auf Ihrem USB-Stick mit dem Namen Stellplätze.h , wo die meisten Frequenzen für Ihre Präferenz gefunden werden konnten.

4.4 Musik mit Funktionen

Der obige Code sieht gut aus, scheint aber viele Wiederholungen zu haben. Es sollte eine Methode geben, um diese Wiederholungen zu verkürzen, oder?

Bisher haben wir mit zwei wesentlichen Funktionen gearbeitet, die in Arduino enthalten sind. Jetzt ist es vielleicht an der Zeit, unsere eigenen Funktionen zu erstellen.

Jede Funktion muss mit dem Variablentyp beginnen, dem sie zugeordnet sein kann. Zum Beispiel die Funktion Leere bezieht sich auf einen Typ, der nichts zurückgibt, daher der Name void. Beachten Sie, dass wir in unseren früheren Abschnitten bereits eine Liste von Variablen besprochen haben. Sie können auf diese verweisen.

Folglich erhält der jeweilige Funktionsname eine offene Klammer '(' gefolgt von einer Liste von durch Kommas getrennten Parametern.

Jeder der Parameter erhält seinen Typ zusammen mit einem Namen und schließlich einem Abschluss ')' Klammern.

Diese Parameter können innerhalb der Funktion in Form von Variablen angewendet werden.

Sehen wir uns unten ein Beispiel an, in dem wir eine Funktion namens aufrufen ourTone () entworfen, um die zu verschmelzen Ton() mit verzögern() Linien, so dass die Funktion nicht mehr zurückkehrt, bis die Note den Ton wiedergegeben hat.

Wir implementieren diese Funktionen in unserem vorherigen Code und erhalten das folgende Programm, siehe die letzten Zeilen:

#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)
}

Funktionen können sehr praktisch sein, um das Verständnis eines Programms zu erleichtern.

Das folgende Beispiel zeigt, wie wir die Wahl des Tons festlegen können, den wir mit zwei Arrays spielen möchten. Ein Array zum Beibehalten der Noten, das andere zum Beibehalten der Beats.

#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)
}

Sie können in der ersten Zeile die Einführung von deutlich sehen #einschließen Erklärung. Die Aufgabe dieser Anweisung besteht darin, die gesamte Datei zwischen den Anführungszeichen aufzunehmen und an der Position des zu platzieren #einschließen Erklärung. Gemäß den Standardregeln werden diese strikt zu Beginn des Programms platziert.

Kapitel 5

Temperatur messen

Denken Sie daran, anstatt große Programme zu schreiben, ist es immer ratsam, kleine Teile von Codes zu schreiben und zu analysieren, um Fehler schnell aufzuspüren.

5.1 Serieller Monitor

Bis jetzt scheinen die besprochenen Codes nicht so einfach zu sein, um eine schnelle Fehlerbehebung zu ermöglichen. Hier werden wir versuchen, die Überwachung und Lösung eines möglichen Problems zu vereinfachen.

Das Arduino verfügt über eine Funktion, die es ihm ermöglicht, mit dem Computer zurück zu sprechen. Sie können beobachten, dass Pin0 und Pin1 nebeneinander als RX und TX markiert sind. Diese Pins werden tatsächlich von einem separaten IC in Arduino verfolgt, der sie so aktualisiert, dass sie über das USB-Kabel gelesen werden können, während es an den PC angeschlossen ist.

Der folgende Abschnitt zeigt ein vollwertiges Programm. Bitte gehen Sie es durch, wir werden danach mehr über die neuen Einträge im Code erfahren. Dieser Code ist mit Abschnitt 2.2 identisch, mit der Ausnahme, dass er einige zusätzliche Daten enthält, mit denen wir identifizieren können, wofür er codiert wurde.

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)
}

Sie können hier zwei neue Dinge identifizieren, eine neue Zeile in der installieren() Funktion.

Serial.begin(9600)

Diese Zeile drückt einfach die Notwendigkeit der Verwendung von aus Serial1 Code, um es mit 9600 Baud zu erzwingen. (hier bezieht sich seriell auf Bits nacheinander gesendet, und Baud bedeutet die Rate, mit der es gesendet wird). Dieser Baudwert und der im seriellen Monitor (wir werden dies später erfahren) müssen gleich sein, sonst zeigen die Daten im seriellen Monitor Müll. 9600 als Standard wird bequemer zu bedienen.

Der zweite neue Eintrag lautet wie folgt

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

Hier schlägt die zweite Zeile vor, dass das nachfolgende Element, das von der seriellen Schnittstelle kommt, in der nächsten Zeile beginnt. So unterscheidet sich die zweite Linie von der ersten Linie.

Eine weitere Sache, die Sie sehen können, sind Anführungszeichen ('). Dies ist als Zeichenfolge bekannt, die hier nur wie Konstanten verwendet wird, da die weitere Diskussion zu diesem Thema zu ausführlich und über den Rahmen hinausgehen kann.

OK, wir können jetzt den obigen Code in Arduino hochladen und sehen, was passiert.

Was, oops nichts scheint passiert zu sein, die Arduino Pin # 13 LED blinkte und stoppte, während die Tx LED blinkte.

Das liegt daran, dass das Serial Monitor-Fenster noch nicht repariert ist.

Sie müssen in Ihrer IDE wie oben gezeigt auf das Feld Serieller Monitor klicken. Vergessen Sie nicht, die Baudrate unten rechts zu überprüfen. Standardmäßig sollte sie 9600 betragen und entspricht dem Code. Wenn dies nicht der Fall ist, wählen Sie 9600 aus.

Der folgende Videoclip erklärt, wie es gemacht wird.

Lassen Sie uns nun fortfahren und erfahren, wie die oben genannte Funktion für den seriellen Monitor bei der Verarbeitung von unterstützt werden kann Messung der Temperatur mit Arduino

Wir werden den IC TMP36 als Temperatursensor mit einem Bereich von -40 bis 150 Grad Celsius verwenden.

Das Setup ist unten zu sehen:

Der folgende Code leitet die Temperaturmessung ein, indem er die Ausgabe des TMP36-Sensors liest und an den seriellen Monitor der ID sendet.

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
}

Lassen Sie uns den Code von oben verstehen.

float temperatureC = getTemperatureC()

Hier sehen Sie, dass wir den Variablentyp aufgenommen haben schweben.

Dies ist der einzige Variablentyp, bei dem alles außer Ganzzahlen (Zahlen ohne Dezimal- oder Bruchteile) gespeichert wird.

Die Genauigkeit einer Float-Variablen kann bis zu 6 bis 7 Stellen betragen.

Der nebenstehende Code getTemperatureC() ist unsere eigene Funktion, die die erfasste Spannungsdifferenz vom TMP36-Sensor mathematisch berechnet und in Grad Celsius umwandelt.

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
}

Im nächsten Abschnitt der Codes, da der Begriff analogIn() Wird eine Zahl zwischen 1 und 1023 zurückgegeben, können wir die Spannung vom Sensor bewerten, indem wir unseren Messwert mit 5 multiplizieren und dann durch 1024 dividieren.

Der Sensor TMP36 spezifiziert 0,5 V bei 0 Grad Celsius und anschließend 10 mV für jeden einzelnen Anstieg von Grad Celsius.

Hier ist die Annäherung, die wir durch die Berechnungen generieren können:

Sie können sich als Ihre erste Funktion betrachten, die einen Wert zurückgibt (beachten Sie, dass alle verbleibenden Funktionen bisher keinen Wert zurückgegeben haben, da sie vom Typ waren Leere ).

Sie können verstehen, dass Sie nur hinzufügen müssen, um einen Wert aus einer Funktion zu erhalten Rückkehr gefolgt von der gewünschten Nummer, die Sie zurückgeben möchten.

Wenn wir sagen Rückkehr Dies bedeutet, dass die Funktion bei jedem Aufruf eine Antwort oder eine Antwort zurückgibt, die auf eine Variable angewendet werden kann.

Wenn dies an den seriellen Monitor gesendet wird, wird der Messwert durch in Fahrenheit umgerechnet convertToF ().

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

Diese Funktion erfasst den Celsius-Bereich und konvertiert ihn in Fahrenheit.

Für die Umrechnung von Fahrenheit in Celsius implementieren wir die Formel Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Anschließen eines LCD

Lassen Sie uns nun untersuchen, wie eine Schnittstelle hergestellt oder verbunden wird LCD Bildschirm mit Arduino für die visuelle Anzeige der erforderlichen Ausgänge.

In unserer Anwendung werden wir ein grafisches 84x48-LCD mit 84 Pixeln oder Punkten horizontal und einer vertikalen Auflösung von 48 Pixel verwenden. Da ein dedizierter Controller für alle LCDs unabdingbar wird, enthält das vorliegende Gerät auch einen Controller in Form eines PCD8544-Controllers.

In diesem Tutorial verbinden wir das oben angegebene LCD-Modul mit Arduino und wenden bestimmte Routinen an, um Textnachrichten auf dem Display zu erstellen.

In der folgenden Abbildung finden Sie Details zur Schnittstelle des LCD sowie eine kleine 3,3 V Spannungsregler . Dieser Regler ist erforderlich, da das LCD für eine 3,3-V-Versorgung ausgelegt ist.

Sie können auch 8 Pinbelegungen auf dem LCD-Modul sehen. Die Pinbelegungsspezifikationen können der folgenden Tabelle entnommen werden:

Nun wollen wir sehen, wie wir das LCD und die relevanten Parameter mit unserem Arduino verbinden können. Die Details können in der folgenden Abbildung dargestellt werden:

5.4 Kommunikation mit dem LCD

Obwohl es möglich ist, ausgefeilte Coeds für die Interaktion mit LCD von Arduino zu schreiben, lernen wir lieber, wie man dasselbe mit Bibliotheken macht.

Bibliotheken umfassen eine Reihe von Codes, die schnell für ein ausgewähltes Arduino-Programm angewendet werden können.

Auf diese Weise kann der Benutzer mühelos eine Funktion aufrufen, ohne komplexe Codierungsarbeiten durchführen zu müssen.

5.4.1 So installieren Sie die Bibliothek

Dazu müssen Sie in Ihrem Computer ein Verzeichnis namens Bibliotheken in der Arduino IDE erstellen, wie erläutert Hier

5.4.2 Implementieren der LCD-Operationen

Genau wie bei unserem vorherigen Ansatz werden wir zuerst den gesamten Code auschecken und dann versuchen, die Details der einzelnen Zeilen zu verstehen.

#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())
}

Die Zeile enthält den Code #include

Der Code #include weist den PC an, die erwähnte Datei aufzunehmen und das Element #include während des Kompilierens des Programms durch den Dateiinhalt zu ersetzen.

Das Element #include kann spitze Klammern enthalten, die die Suche im Bibliotheksverzeichnis anzeigen. Alternativ kann es auch Anführungszeichen enthalten, die die Suche in demselben Verzeichnis anzeigen, in dem sich das Programm befindet.

Die folgenden Codezeilen drücken die LCD-Pinbelegung aus, und dann schreiben wir eine neue Form der Variablen:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Hier drücken wir eine Variable mit dem Namen lcd vom Typ PCD8544 aus und weisen den PC an, seine dem Arduino zugeordneten Pinbelegungen neu zu bewerten.

In diesem Prozess beschreiben wir die Variable für den PC, indem wir anweisen, wie Pin Clk, Din, DC und Reset mit dem Arduino verbunden sind.

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

Die Zeile lcd.init() Initialisiert den LCD-Betrieb. Sobald dies ausgeführt wurde, erzwingt die nächste Zeile einen Cursor oben links in der Anzeige. In der nächsten Zeile wird versucht, die Nachricht 'Hallo Welt' auszudrucken.

Dies sieht ziemlich identisch mit der Technik aus, mit der wir Nachrichten über den seriellen Monitor gesendet haben. Der einzige Unterschied ist die Verwendung des Codes lcd.print anstelle von serial.print.

Der nächste Codeblock wird tatsächlich wiederholt aufgerufen.

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

Mit dieser Zeile lcd.setCursor(0,1) Wir fixieren den Cursor auf die 0. Spalte ganz links in der 1. Zeile über dem LCD-Display.

In der nächsten Zeile wird eine Verknüpfung verwendet: lcd.print(millis())

Wenn Sie sich erinnern, haben wir mit millis() gearbeitet In unseren früheren Codes hätten wir dasselbe auch hier durch die Codes anwenden können:

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

Da hier jedoch keine Zeiträume in Millisekunden beteiligt sind, erreichen wir dies durch einfaches Senden von millis() Funktion direkt zu lcd.print() .

5.5 Das Ganze kombinieren

OK, jetzt kombinieren wir alle Codes, die wir oben für die Erstellung des LCD-Temperaturkreislaufs gelernt haben, und sehen, wie er aussieht:

#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
}

Im obigen Programm sieht alles normal aus, außer der Verwendung der Funktion setCursor () . Dies wird verwendet, um den Text so weit wie möglich um die Mitte der Anzeige auszurichten.

Großartig! Und herzlichen Glückwunsch, Sie haben gerade Ihre eigene kleine LCD-Temperaturanzeige mit Arduino programmiert.

Praktische Arduino-Anwendungen

Da wir zu diesem Zeitpunkt die verschiedenen Programmiertechniken ausführlich behandelt haben, ist es an der Zeit, sie durch Anwendung einiger nützlicher praktischer Implementierungen durchzugehen.

Wir beginnen mit Sensoren und sehen, wie Sensorgeräte mit Arduino verwendet werden können, indem wir einige Beispielcodes ausführen.

7.1 Einführung in Sensoren

In diesem Tutorial lernen wir die Vielzahl von Sensoren kennen, die mit Arduino verwendet werden können. Dies können Geräte wie Lichtsensor LDR, magnetischer Hall-Effekt-Sensor, Neigungssensoren, Vibrationssensor, Drucksensor usw. sein.

Wir beginnen mit der Schnittstelle von Lichtsensor LDR mit Arduino, wie im folgenden Diagramm gezeigt:

Wie wir alle wissen, ist LDR ein lichtabhängiges Widerstandsgerät, dessen Widerstand von der Intensität der auf seine Oberfläche einfallenden Umgebung abhängt.

Die Lichtintensität ist umgekehrt proportional zum Widerstandswert des LDR.

Hier erfahren Sie, wie diese Eigenschaft in Arduino integriert werden kann, um eine nützliche Anwendung auszuführen:

Der vollständige Programmcode kann wie folgt visualisiert werden:

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)
}

Alle im Code verwendeten Parameter wurden bereits in unserem bisher erlernten Kurs besprochen. Sie können die Zeilen anhand der entsprechenden Abschnitte überprüfen.

Die Werte wurden zufällig ausgewählt, Sie können sie ganz einfach nach Ihren Wünschen ändern.

Neigungssensor

Ein Neigungssensor ist ein einfaches Gerät, mit dem eine Neigungsaktion an jedem Objekt erfasst werden kann, an dem er installiert ist. Das Gerät hat im Wesentlichen eine Metallkugel im Inneren, die beim Kippen über ein Kontaktpaar rollt und eine Leitung über diese Kontakte verursacht. Diese Kontakte, die als Leitungen des Neigungsschalters abgeschlossen sind, werden mit einem externen Schaltkreis zum Erfassen der Leitung aufgrund einer Kippwirkung und zum Aktivieren der gewünschten Ausgangsanwendung verwendet.

Nun wollen wir sehen, wie ein Neigungssensor Gerät könnte verkabelt sein. Das Bild unten gibt uns eine Vorstellung von der vollständigen Konfiguration:

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)
}
}

In diesem Beispiel wird die Standard-LED Nr. 13 als Neigungsanzeige verwendet.

Sie können die Aufnahme des Pull-up-Widerstands hier deutlich sehen, ganz ähnlich wie in Abschnitt 3.1. Daher zeigt der Begriff LOW an, dass die Neigungsfunktion nicht ausgelöst wird.

7.4 Reedschalterrelais (Miniaturmagnet-aktiviertes Relais)

Nun wollen wir sehen, wie ein Relaisschalter oder ein Magnetfeldsensor mit Arduino verbunden wird. Ein Reed-Relais ist eine Art Schalter, der aktiviert oder leitet, wenn ein Magnetfeld oder ein Magnet in seine Nähe gebracht wird. Grundsätzlich hat es ein Paar ferromagnetischer Kontakte in einem Miniaturglasgehäuse, die sich aufgrund magnetischer Zugkraft verbinden oder berühren, wenn sich ein Magnet in unmittelbarer Nähe befindet. In diesem Fall zeigen die Klemmen der Kontakte eine Leitung aufgrund des Schließens der Kontakte.

Auch hier verwenden wir die Pin # 13 LED zur Anzeige der Antwort. Sie können bei Bedarf gemäß diesen früheren Erläuterungen eine externe LED an diesen Pin anschließen.

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)
}
}

Die Codebegriffe sollten vertraut und selbsterklärend sein.

7.5 Vibrationssensor mit Piezo-Wandler

Im nächsten Beispielprogramm werden wir sehen, wie a Piezo-Wandler kann als Vibrationssensor verwendet werden, um eine LED durch Arduino zu beleuchten.

Ein Piezoelement ist tatsächlich ein Gerät, das Vibrationen oder Schwingungen erzeugt, wenn eine Frequenz an seine Anschlüsse angelegt wird. Der gleiche Piezo könnte jedoch im umgekehrten Verfahren für verwendet werden Erzeugen elektrischer Impulse als Reaktion auf Vibrationen, die auf seinen Körper ausgeübt werden. Diese Vibration kann in Form eines Klopfens oder Schlags auf die Oberfläche des Piezo auftreten.

Richten Sie das Arduino und ein Piezoelement wie in der folgenden Abbildung gezeigt ein

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
}
}

Die Schwelle 100 wird nur eingeführt, um sicherzustellen, dass der Arduino nur auf echte Vibrationen durch Stöße reagiert und nicht auf andere kleinere Vibrationen wie laute Geräusche oder Hörner.

Die Auswahl des A5-Pins ist nicht obligatorisch. Sie können beliebige andere Analogeingänge nach Ihren Wünschen auswählen und diese im Programmcode abgleichen.

Servomotor mit Arduino verwenden

Ein Servomotor ist eine Art Gleichstrommotor, der je nach Anforderung einer bestimmten Anwendung in präzise Winkel gedreht werden kann. Dies kann durch Anwenden eines berechneten Befehls auf die relevanten Eingänge des Motors erfolgen, um einen genauen Dreh- oder Drehwinkel innerhalb eines Bereichs von 180 Grad am Motor zu erzeugen.

Typischerweise hat ein Servomotor 3 Drähte oder Eingänge. Das Pluskabel hat normalerweise eine rote Farbe, das Minus- oder Erdungskabel ist schwarz, das Befehlskabel oder das Signalisierungskabel ist normalerweise weiß oder gelb.

Arduino erleichtert die Steuerung von Servomotoren durch eine integrierte Unterstützungssprache, wodurch die Steuerung sehr bequem und ideal für Servomotoren ist.

Das folgende Beispiel zeigt uns das grundlegende Setup-Programm für die Implementierung der Servomotorsteuerung über Arduino:

Der Code ist unten angegeben:

#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)
}

Wir können hier einige neue Einträge sehen. Eine, die dem angeschlossenen Kabel des Servos mitteilt, welchem ​​Pin es zugewiesen ist. Der andere ist der Code, der dem Pin einen Wert zwischen 0 und 180 zur Bestimmung des Drehwinkels am Servo liefert.

Fazit

Das Arduino-Thema kann unendlich lang sein und daher den Rahmen dieses Artikels sprengen. Ich hoffe jedoch, dass das obige Tutorial Ihnen sicherlich dabei geholfen haben sollte, die Grundlagen von Arduino zu erlernen und wichtige Parameter anhand der verschiedenen Beispielanwendungscodes zu verstehen.

Hoffentlich werden hier von Zeit zu Zeit weitere Informationen aktualisiert, sobald sie verfügbar sind.

In der Zwischenzeit viel Spaß mit Ihrem Programmierkurs, Happy Arduinoing an Sie!