Arduino Millis gegen Verzögerung
Was ist die Millis () -Funktion in Arduino?
Diese Funktion gibt die Gesamtzeit aus dem Ausführen des Arduino -Codes und wird weiter ausgeführt, bis das Programm ausgeführt wird. In ähnlicher Weise gibt diese Funktion die verstrichene Zeit in Millisekunden an und hat die Kapazität, 50 Tage lang zu laufen.
Die Bedeutung dieser Funktion ist, dass sie im Arduino -Programm verwendet werden kann, wenn eine Anweisung nur zu einem bestimmten Zeitpunkt ausgeführt werden soll. Zur weiteren Illustration haben wir die Arbeit der Millis -Funktion durch das Beispiel erklärt.
Angenommen, wir müssen nach allen 5 Sekunden eine Anweisung ausführen, damit wir zuerst die Zeit in Millisekunden definiert haben, wonach die spezifische Anweisung ausgeführt wird.
nicht signierte lange Ausführungszeit = 5000;
Also definieren wir die benannte konstante Variable Ausführungszeit Mit einem Wert von 5000 Millisekunden, um die aktuelle Zeit des Programms zu überprüfen Gegenwart Variable.
unsignierte lange Gegenwart;
Presentime = Millis ();
Als nächstes müssen wir die Bedingung für die Zeit machen, zu der die Anweisung ausgeführt wird. Wir erstellen also einen If -Bedingung. Für solche Bedingungen müssen wir auch eine andere Variable deklarieren, die die vorherige Zeit oder in der vergangenen Zeit speichert.
Wir können diesen Zustand so entwerfen. Nachdem die jeweilige Anweisung ausgeführt wurde, sparen Sie diese aktuelle Zeit in der Zeitvertreibsvariable.
nicht signierter langer Zeitvertreib = 0;
if (jungen-time-pastime> = ExecutionTime)
// die Anweisung ausführen
edestims = currentime;
Hier ist eine Sache zu erinnern, dass wir den langen Datentyp aufgrund der Millis () -Funktion verwendet haben.
Arduino -Code für die Arbeit von Millis () Funktion
Der vollständige Code für das Verständnis der Arbeit der Millis -Funktion wird angegeben als:
const unsigned long ExecutionTime = 5000; /*Zeit, auf der die Anweisung ausgeführt wird*/
unsignierte lange Vergangenheit = 0; // Variable für starke Zeit in der vergangenen Zeit
unsigned long juresime = 0; // Variable für die Speicherung der gegenwärtigen Zeit
void setup ()
Serie.Beginnen Sie (9600); // Initialisierung der seriellen Kommunikation
void Loop ()
Presentime = Millis (); // Aktualisierung des Wertes der Presentime
/ * Dies ist das Ereignis */
if (jungentime - pasttime> = ExecutionTime) / *Zeitbedingung, auf der der Anweisungen ausgeführt wird * /
Serie.print ("Die gegenwärtige Zeit ist:");
Serie.println (jungen); // die gegenwärtige Zeit anzeigen
Serie.print (""); // einschließlich Platz inklusive
Serie.print ("Anweisungen zum Ausführen:");
Serie.println ("Willkommen bei LinuxHint"); // Anweisungen, die ausgeführt werden soll
MALTHALT = Presentime; // den vergangenen Zeitwert aktualisieren
Der Arduino -Code wird so funktionieren, dass beispielsweise der Wert des Zeitvertreibs beispielsweise bei der Iteration Null ist, und sagen wir, die aktuelle Zeit beträgt 400 Millisekunden. Gemäß der IF -Bedingung beträgt die Antwort 400, was weniger als 5000 Millisekunden beträgt, sodass die If -Bedingung falsch ist.
In ähnlicher Weise beträgt die „Präsenzzeit“ in der dritten oder vierten Iteration 5000 Millisekunden, die Differenz beträgt 5000 Millisekunden, da der Wert der „Frist“ immer noch Null ist. Die Anweisung wird also ausgeführt und der Wert für den Zeitvertreib wird aktualisiert.
Auf diese Weise können wir die Millis -Funktion verwenden, um eine bestimmte Anweisung zu einem bestimmten Zeitpunkt auszuführen.
Ausgabe des Arduino -Codes für Millis () -Funktion
Im seriellen Monitor ist deutlich zu erkennen. Das unten veröffentlichte Bild zeigt die Werte der „Presentime“, bei der die IF -Bedingung wahr ist, und die Anweisung, die ausgeführt werden soll.
Wenn wir einfach den Wert der millis () -Funktion drucken, die im Variablennamen „Presentime“ gespeichert ist, sieht es so aus wie in dem unten angegebenen Bild:
Was ist eine Delay () -Funktion in Arduino
Die Delay () -Funktion wird hauptsächlich zur Pause des Arduino -Codes für einige Zeit verwendet. Mit anderen Worten, diese Funktion erstellt eine Verzögerung von einiger Zeit, die der Benutzer in der Funktionsweise des Arduino -Codes angegeben hat.
Diese Funktion kann im Programm verwendet werden, bei dem der Wert einer Variablen häufig aktualisiert werden soll. Wenn Sie also die Pause an das Arduino -Programm geben, wird es dem Sensor Zeit geben, seinen Wert zu aktualisieren.
In ähnlicher Weise können wir die Verzögerungsfunktion verwenden, um eine Pause zwischen der Ausführung mehrerer Anweisungen zu geben. Die Verzögerungsfunktion nimmt die Zeit in Millisekunden als Eingabe und die Syntax für die Verzögerungsfunktion ist unten angegeben:
Verzögerung (Zeit in Millisekunden);
Arduino -Code für die Verwendung der Verzögerungsfunktion
Um die Funktionalität der Delay () -Funktion zu demonstrieren, haben wir einen Arduino -Code zusammengestellt, der als:
void setup ()
Serie.Beginnen Sie (9600); // Initialisierung der seriellen Kommunikation
void Loop ()
Serie.print ("Hallo und willkommen"); // Anweisung vor Verzögerung
Verzögerung (5000); // Erstellen einer Pause von 5000 Millisekunden
Serie.println ("\ n zu LinuxHint.com "); // Anweisung nach Verzögerung
Im Arduino -Code haben wir zwei Anweisungen gegeben, mit denen die Daten auf dem seriellen Monitor gedruckt werden können. Beide Anweisungen werden mit einer Verzögerung von 5000 Millisekunden ausgeführt. Mit anderen Worten, nach der Ausführung der ersten Anweisung haben wir eine Verzögerungsfunktion verwendet, die den Arduino -Code für 5000 Millisekunden pausiert. Nach 5000 Millisekunden wird das Programm aus dem Ort gestartet, an dem es gestoppt wurde, und die zweite Anweisung wird ausgeführt.
Ausgabe des Arduino -Codes für die Verwendung von Delay () -Funktion
Das unten veröffentlichte Bild ist die erste Anweisung, vor der die Funktion Delay () verwendet wird.
Nach dieser Anweisung wird das Programm für 5000 Millisekunden unterbrochen, und dann findet die Ausführung der zweiten Anweisung statt. Die folgende Abbildung zeigt, dass das Programm die zweite Anweisung ausgelegt hat.
Vergleich der Funktion Millis () und Delay ())
Die Unterschiede zwischen Millis () und der Verzögerungsfunktion sind in der folgenden Tabelle angegeben:
| Millis () Funktion | Delay () Funktion |
|---|---|
| Es kann verwendet werden, um eine bestimmte Anweisung zu einem bestimmten Zeitpunkt auszuführen | Diese Funktion erstellt nur eine Pause im Fluss von Arduino Code |
| Diese Funktion gibt die Zeit in Millisekunden aus dem Zeitpunkt des Arduino -Code | Diese Funktion braucht in Millisekunden als Benutzereingabe Zeit und läuft für diese bestimmte Zeit |
| Diese Funktion pausiert nicht oder stoppt den Code nicht | Diese Funktion stoppt den gesamten Code für einige Zeit |
Wie kann ich Millis () anstelle von Dely () verwenden ()
Wir verwenden Millis -Funktion anstelle von Verzögerung, indem wir einfach die IF -Bedingung für die spezifische Zeit verwenden, zu der wir jede Anweisung ausführen möchten. Dies führt automatisch eine Verzögerung zwischen der Ausführung von zwei oder mehr Anweisungen und dem Zweck der Verzögerung kann zugestellt werden. Der Hauptvorteil für die Verwendung der Millis anstelle der Verzögerung besteht darin, dass das gesamte Arduino -Programm nicht aufhört. Nur die Ausführung einiger bestimmter Anweisungen wird gestoppt. Die Verzögerungsfunktion stoppt jedoch das gesamte Programm und die Verwendung der Verzögerungsfunktion kann die externen Eingaben zum Programm etwas verpassen, da das gesamte Programm gestoppt wird.
Um weiter zu veranschaulichen, haben wir Arduino -Code dafür bereitgestellt, wie wir die Millis -Funktion anstelle der Verzögerungsfunktion verwenden können:
const unsigned long ExecutionTime = 6000; /*Zeit, auf der die erste Anweisung ausgeführt wird*/
const unsigned long ExecutionTime1 = 2000; /*Zeit, auf der die zweite Anweisung ausgeführt wird*/
unsignierte lange Vergangenheit = 0; // Variable für starke Zeit der ersten Anweisung in der vergangenen Anweisung
unsigned long juresime = 0; // Variable für die Speicherung der gegenwärtigen Zeit
Unsigned Long Pasttime1 = 0; // Variable für starke Zeit der zweiten Anweisung in der vergangenen Anweisung
void setup ()
Serie.Beginnen Sie (9600); // Initialisierung der seriellen Kommunikation
void Loop ()
Presentime = Millis (); // Aktualisierung des Wertes der Presentime
/ * Dies ist das Ereignis */
if (jungentime - pasttime> = ExecutionTime) / *Zeitbedingung, auf der der Anweisungen ausgeführt wird * /
Serie.print ("Die gegenwärtige Zeit ist:");
Serie.println (jungen); // die gegenwärtige Zeit anzeigen
Serie.print (""); // einschließlich Platz inklusive
Serie.print ("Anweisungen zum Ausführen:");
Serie.println ("Halten Sie die Lichter aus"); // Anweisungen, die ausgeführt werden soll
MALTHALT = Presentime; // den vergangenen Zeitwert aktualisieren
if (jungentime - Pasttime1> = ExecutionTime1) / * Zeitbedingung, auf der die Anweisung ausgeführt wird * /
Serie.print ("die gegenwärtige Zeit");
Serie.println (jungen); // die gegenwärtige Zeit anzeigen
Serie.print (""); // einschließlich des Raums einschließlich des Raums
Serie.print ("Anweisungen zum Ausführen:");
Serie.println ("die Lichter einschalten"); // Instrkution zu ausgeführt werden
tusttime1 = jurestime; // Aktualisierung der gegenwärtigen Zeit der SCODN -Anweisung
Hier im Code haben wir die Millis -Funktion verwendet, um die beiden Anweisungen mit einer Verzögerung von fast 4 Sekunden auszuführen. Wir haben ein Bild der Ausgabe des Arduino -Codes veröffentlicht, um zu erklären, wie die Millis -Funktion verwendet werden kann, indem er durch die Verzögerung der Verzögerung ersetzt wird.
In der Ausgabe können wir sehen, dass die zweite Anweisung, wenn die Zeit 2 Sekunden beträgt, bis zur Zeit von 6 Sekunden erreicht wird. Wenn die Zeit 6 Sekunden erreicht, wird die erste Anweisung ausgeführt.
Abschluss
Um eine Logik jeder Aufgabe zu erstellen, die mit Arduino ausgeführt werden muss, gibt es mehrere Funktionen, die verwendet werden können. Diese Funktionen machen die Funktionalität des Arduino -Codes effizient und einfach zu implementieren, die erstellte Logik.Es gibt zwei Funktionen, die wir ausführlich besprochen haben, eine ist die Millis -Funktion und die andere ist die Verzögerungsfunktion. Die Millis -Funktion führt eine bestimmte Anweisung zu einem bestimmten Zeitpunkt aus, während die Verzögerungsfunktion den Arduino -Code für einige Zeit anhält.