Hast du jemals ein Arudino-Projekt gemacht und du willst, dass etwas in einem bestimmten Zeitintervall passiert? Vielleicht wollen Sie, dass sich alle 3 Sekunden ein Servo bewegt, oder vielleicht wollen Sie alle 1 Minute ein Status-Update an einen Webserver senden.

Wie machen Sie das? Gibt es eine Funktion, die einfach und unkompliziert ist und uns dabei hilft? Ja, die gibt es! Wir besprechen die Delay-Funktion sowie die millis()-Funktion im folgenden Video:

Dies ist Teil 2 unserer Miniserie zur millis()-Funktion. Teil 1 hilft uns zu verstehen, was die millis()-Funktion tut, Teil 2 bespricht enge Schleifen und blockierenden Code, und Teil 3 bespricht, wann die millis()-Funktion die delay()-Funktion in den Schatten stellt.

Themen dieser Lektion

• Enge Schleifen
• Blockierender Code
• Altes Rezept für inspirierende Musik

Millis() versus Delay()

Sie wollen also, dass etwas in einem bestimmten Intervall geschieht und suchen nach einer Lösung. Wenn deine Antwort ist, die Verzögerungsfunktion zu benutzen, dann hast du irgendwie recht. Aber es gibt noch einen anderen Weg.

Die coolere, schickere Option ist die Arduino millis() Funktion. Und je vertrauter du mit der Verwendung der millis-Funktion bist, um dir zu helfen, Ereignisse in deinem Arduino-Code zeitlich einzuordnen, desto einfacher wird es später sein, andere Teile in dein Programm einzubauen.

Wenn du erst einmal anfängst, die millis()-Funktion zu benutzen, wirst du glücklicher und fröhlicher sein, und verdammt, die Leute werden dich mögen.

Kleine Schleifen

Lassen Sie uns zuerst das Konzept einer engen Schleife besprechen. Und wenn wir von einer engen Schleife sprechen, was bedeutet das?

Werfen wir einen Blick auf einen Arduino-Sketch zur Demonstration einer engen Schleife. Wir beginnen mit dem einfachsten Sketch und haben nur zwei Funktionen: void setup und void loop. Und wie du vielleicht weißt, läuft void setup nur einmal, und dann übergibt es die Show an void loop.

Void loop geht dann durch jede Codezeile, die innerhalb der Schleife sein könnte (innerhalb dieser geschweiften Klammern).

Sie führt die erste Zeile aus, dann die zweite, dann die dritte und so weiter und so fort, bis sie am Ende angelangt ist. Und dann geht es zurück zum Anfang.

Wie schnell wird die Schleife ausgeführt? Das hängt davon ab, welches Arduino-Board du verwendest, aber ein Arduino Uno hat eine Taktrate von 16 Megahertz. Das bedeutet, dass jede Sekunde 16 Millionen Anweisungen auf dem Arduino ausgeführt werden!

Jede Codezeile ist nicht unbedingt eine Anweisung. Es ist sogar sehr wahrscheinlich, dass es mehrere Anweisungen sind. Aber trotzdem ist das relativ schnell (dein Computerprozessor läuft wahrscheinlich mit Gigahertz-Geschwindigkeit… das sind Milliarden).

Würdest du also diesen leeren Sketch als eine enge Schleife betrachten? Auf jeden Fall, das ist so schnell und so eng, wie man eine Schleife machen kann. Da es innerhalb der Schleife nichts auszuführen gibt, ist die Zeit, die benötigt wird, um die Skizze zu durchlaufen, praktisch gleich Null. Anders ausgedrückt, das Intervall zwischen dem Start der Schleife und dem Ende ist kurz (daher ist sie schnell oder „eng“).

Lassen Sie uns einige Codezeilen hinzufügen. Wir werden die serielle Kommunikation starten und dann etwas in das serielle Monitorfenster ausgeben.

Ist dies eine enge Schleife? D.h., vom Anfang der Schleife bis zum Ende der Schleife, dauert das sehr lange? Das ist eine schnelle, enge Schleife.

Es ist jedoch erwähnenswert, dass diese Schleife nicht so eng ist wie das vorherige Beispiel. Im vorherigen Beispiel hatten wir keinen Code. Also wurde die Schleife einfach durchlaufen. Jetzt, wo wir eine Funktion haben, nämlich serial print, dauert es (ein klein wenig) länger, „Ice Ice Baby“ auf den seriellen Monitor zu drucken.

Aber das ist immer noch eine ziemlich schnelle Schleife. Fügen wir also ein wenig mehr Code hinzu. Wir lassen das Programm prüfen, ob ein Knopf gedrückt ist, und wenn ja, wird etwas Neues an den seriellen Monitor gesendet

So haben wir einen Knopf deklariert und eine if-Anweisung verwendet, um zu prüfen, ob der Knopf gedrückt wurde. Ist die Spannung an Pin 5 hoch? Wenn ja, dann drucken wir etwas anderes in das serielle Monitorfenster.

Ist das eine enge Schleife? Also, vom Beginn der Schleife bis zum Ende der Schleife, ist das ziemlich schnell?

Ja, es ist immer noch ziemlich schnell. Das ist eine ziemlich enge Schleife. Wir haben vier Codezeilen. Wir drucken auf den seriellen Monitor, und dann prüfen wir kurz, ob eine Taste gedrückt wird. Und wenn das der Fall ist, drucken wir etwas aus. Immer noch knapp, immer noch schnell.

Als Nächstes fügen wir eine Verzögerung zu diesem Programm hinzu, indem wir die Arduino delay() Funktion verwenden. Du kannst unten sehen, dass wir eine Verzögerung von tausend Millisekunden (1 Sekunde) zur Schleife hinzugefügt haben.

Ist das immer noch eine enge Schleife? Ist die Zeit, die vom Start der Schleife bis zum Ende der Schleife vergeht, sehr lang? Nein, es handelt sich definitiv nicht um eine enge Schleife. Der Code fängt schnell an, wir machen den seriellen Druck, aber dann werden wir genau hier bei der Verzögerungsfunktion angehalten.

Das ganze Programm kommt zum Stillstand, während wir darauf warten, dass der Verzögerungscode beendet wird.

Wenn der Arduino zu dieser Codezeile kommt, ist es so, als ob man in den Lebensmittelladen geht. Du kommst in die Schlange mit den 12 Artikeln oder weniger, aber dann zieht der Typ vor dir sein Scheckbuch heraus und fängt an, einen Scheck auszustellen. Sie wissen, dass Sie dort eine Minute stehen werden. So ist es auch hier.

Das ist also keine enge Schleife. Die Zeit vom Beginn der Schleife bis zum Ende der Schleife ist ziemlich beträchtlich. Vor allem im Vergleich zu den letzten beiden Programmen. Die Größenordnung der Zeit ist enorm.

Was wir hier versucht haben zu zeigen, ist, dass diese ganze Idee von engen Schleifen relativ ist. Es hängt alles von Ihrer Anwendung ab. Wenn Sie den Status eines Sensors alle 10 Millionstel Sekunden überprüfen müssen, dann ist ein Programm mit drei Codezeilen vielleicht nicht eng genug, es kommt einfach darauf an.

Ein weiterer Punkt ist, dass nicht alle Codezeilen gleich viel Zeit zur Ausführung benötigen. Wenn du eine Funktion aufrufst, die eine Menge Dinge tut, wie z.B. Seriendruck, dann kann diese eine Codezeile viel länger dauern als 10 andere Codezeilen.

Die Enge einer Schleife ist also eine relative Idee.

Blockierender Code

Wenn ein Programm an einem bestimmten Punkt anhält und einige Zeit braucht, um einen Code auszuführen, kann dieser Code als blockierender Code bezeichnet werden. Dies ist ein allgemeiner Begriff.

In unserem Programm fungiert die Verzögerungsfunktion als blockierender Code. Keiner der Codes nach delay kann ausgeführt werden, bis die Verzögerung vorbei ist, also wird er blockiert.

Blockierender Code ist jedoch nicht nur, wenn wir die delay()-Funktion verwenden.

Lassen Sie uns unser Programm nehmen und delay loswerden, aber wir fügen eine for-Schleife ein. Unsere for-Schleife wird Zahlen und Text auf der seriellen Schnittstelle ausgeben.

Wie lange läuft diese Schleife nun? Sie wird eine Weile laufen, weil sie 100 Iterationen durchlaufen muss, bevor sie aufhört.

Und was ist mit dem Code nach dieser for-Schleife? Kann er ausgeführt werden? Nein, er muss warten, weil er von der for-Schleife blockiert wird.

Diese for-Schleife ist in die Hauptschleife eingebettet. Ist die for-Schleife eine „enge“ Schleife? Bevor du antwortest, lass uns noch einmal betonen, wie du darüber denken solltest: Braucht es viel Zeit, diese for-Schleife von oben nach unten zu durchlaufen?

Nun, eigentlich nicht. Sie besteht nur aus zwei Codezeilen. Es ist also eine ziemlich enge Schleife.

Aber es ist eine enge Schleife, die viele Iterationen durchlaufen muss, bevor das Programm den Code darunter erreichen kann. Also kann selbst eine enge Schleife, wenn sie gezwungen ist, mehrere Iterationen zu durchlaufen, unseren Code blockieren.

Mehr über die delay()-Funktion

Lassen Sie uns ein wenig mehr über diese delay-Funktion sprechen. Was haben wir bisher festgestellt?

Zunächst haben wir gesagt, dass die Verzögerungsfunktion die Dichtigkeit einer Schleife verringert. Wenn man eine enge Schleife hat und die Verzögerungsfunktion hinzufügt, dann braucht sie mehr Zeit und wird weniger eng. Das heißt, die Zeit, die man braucht, um vom Anfang der Schleife zum Ende zu gelangen, wird mit der Verzögerungsfunktion zunehmen.

Wir wissen auch, dass die Verzögerungsfunktion den Code blockiert. Das geht Hand in Hand mit dem, was wir gerade gesagt haben. Wenn die Verzögerungsfunktion ausgeführt wird, blockiert sie die Ausführung von anderem Code, während sie verzögert.

Man könnte meinen, dass diese Verzögerungsfunktion ein totaler Faulpelz ist! Sie wird in unseren Projekten nie etwas bewirken. Aber für viele einfache Programme, die wir schreiben, funktioniert die Verzögerungsfunktion fantastisch. Sie ist einfach zu benutzen, sie ist wirklich leicht zu buchstabieren, und sie tut genau das, was sie sagt.

So sollten wir die delay()-Funktion nicht unbedingt aus unserem Programmierwerkzeugkasten verbannen. Wir sollten einfach erkennen, dass es sich um eine einfache Programmierfunktion handelt, die in vielen Fällen funktionieren kann.

Es gibt jedoch einen Zeitpunkt, an dem man anfängt, auf Probleme zu stoßen. Das hat mit der blockierenden Wirkung zu tun, die die Verzögerungsfunktion in unserem Programm hat.

In der nächsten Lektion der Serie, Teil 3, werden wir herausfinden, wo dies wirklich ein Problem wird. Sie werden lernen, wann es sinnvoll ist, die Funktion delay() in einem Programm zu verwenden, und wann es an der Zeit ist, auf die Funktion millis() umzusteigen.

Rückblick

Zunächst haben wir über die Dichtigkeit einer Schleife gesprochen. Wir haben gesagt, dass die Enge einer Schleife relativ ist. Es hängt von der Anwendung ab.

Zweitens haben wir über blockierenden Code gesprochen, oder Code, der blockiert. Im Grunde ist das ein allgemeiner Begriff für Code, der eine gewisse Zeit für die Ausführung benötigt und andere Teile des Programms anhält, während er ausgeführt wird.

Wir hoffen, diese Lektion hat Ihnen gefallen! Im nächsten Teil dieser Serie setzen wir unsere Reise fort und lernen, wie man die millis-Funktion verwendet, um zeitgesteuerte, sich wiederholende Ereignisse in unserem Arduino-Code zu erstellen. Wir sehen uns beim nächsten Mal!