Arduino millis() Tutorial: Zeitgesteuerte Programme ohne Blockierung

Heute zeige ich dir, wie du mit der Arduino millis()-Funktion präzise Zeitmessungen durchführst – ohne dass dein Programm durch delay() blockiert wird. Die millis()-Funktion ist ein mächtiges Werkzeug, das ich dir für professionelle Arduino-Projekte wärmstens empfehle. Du wirst sehen, wie du damit zeitgesteuerte Aktionen realisierst, LEDs blinken lässt und Timer-Funktionen implementierst, während dein Programm gleichzeitig andere Aufgaben erledigt.

Was du für dieses Arduino millis() Tutorial brauchst

Für dieses Tutorial benötigst du keine speziellen elektronischen Bauteile. Ich zeige dir die Grundlagen anhand der seriellen Kommunikation:

Zusätzlich brauchst du die Arduino IDE auf deinem Computer – diese kannst du kostenlos von der offiziellen Arduino-Website herunterladen.

Technische Grundlagen: Was ist Arduino millis()?

Die millis()-Funktion gibt dir die Anzahl der Millisekunden zurück, die seit dem Start deines Arduino-Programms vergangen sind. Ich nutze diese Funktion besonders gerne, weil sie im Gegensatz zu delay() dein Programm nicht blockiert.

Syntax der millis()-Funktion

Die Verwendung ist denkbar einfach:

zeit = millis();

Wichtige technische Details

Hier sind die wichtigsten Eigenschaften, die du kennen solltest:

• Rückgabewert: unsigned long (positive Ganzzahl von 0 bis 4.294.967.295)
• Überlauf: Nach etwa 49,7 Tagen läuft der Zähler über und beginnt wieder bei 0
• Auflösung: 1 Millisekunde bei Standard-Arduino-Boards (16 MHz)
• Genauigkeit: Sehr präzise für die meisten Anwendungen

Warum Arduino millis() besser als delay() ist

Ich rate dir, millis() anstelle von delay() zu verwenden, weil:

• Dein Programm bleibt reaktionsfähig: Während delay() alles anhält, läuft dein Code mit millis() weiter
• Mehrere Timer parallel: Du kannst gleichzeitig mehrere Zeitintervalle überwachen
• Keine Blockierung: Dein Arduino kann während Wartezeiten andere Aufgaben erledigen
• Professionellerer Code: In fortgeschrittenen Projekten ist millis() Standard

Typische Anwendungsfälle

Ich setze millis() besonders häufig ein für:

• Nicht-blockierende Wartezeiten und Pausen
• Messung von Zeitintervallen zwischen Ereignissen
• Implementierung von Timeouts (z.B. Sensorabfragen)
• Periodische Ereignisse wie Blinken, Messungen oder Datenübertragung
• Entprellung von Tastern und Schaltern

Verkabelung für das Arduino millis() Beispiel

Für dieses grundlegende Tutorial brauchst du keine externe Verkabelung. Ich zeige dir die Funktion anhand der seriellen Kommunikation:

Anschluss:

1. Verbinde deinen Arduino über das USB-Kabel mit deinem Computer
2. Das USB-Kabel dient gleichzeitig zur Stromversorgung und Datenübertragung
3. Keine weiteren Komponenten erforderlich

Der serielle Monitor der Arduino IDE zeigt dir die Ausgaben an – mehr brauchst du für den Einstieg nicht.

Der Arduino millis() Code erklärt

Ich zeige dir jetzt ein einfaches Beispielprogramm, das die vergangene Zeit kontinuierlich im Seriellen Monitor ausgibt:

unsigned long time;

void setup() {
  Serial.begin(115200);
}
void loop() {
  Serial.print("Vergangene Zeit:\t");
  time = millis();
  Serial.println(time); // zeigt vergangene Millisekunden im Seriellen Monitor
  delay(1000);          // warte eine Sekunde
}

Code-Erklärung im Detail

Lass mich dir die einzelnen Elemente erklären:

Variable deklarieren:

• unsigned long time; – Ich verwende den Datentyp unsigned long, weil millis() sehr große Zahlen zurückgibt (bis über 4 Milliarden). Ein normales int würde hier nicht ausreichen.

Setup-Funktion:

• Serial.begin(115200); – Hier starte ich die serielle Kommunikation mit einer Baudrate von 115200. Diese Rate ist schnell genug für flüssige Datenübertragung.

Loop-Funktion:

• Serial.print("Vergangene Zeit:\t"); – Gibt einen beschreibenden Text aus, das \t fügt einen Tabulator ein
• time = millis(); – Hier hole ich mir den aktuellen Zeitwert und speichere ihn in der Variable
• Serial.println(time); – Zeigt den Zeitwert an und springt in eine neue Zeile
• delay(1000); – Wartet 1000 Millisekunden (1 Sekunde) bis zur nächsten Ausgabe

So verwendest du den Code

Ich empfehle dir folgende Schritte:

1. Code kopieren: Kopiere den Code in die Arduino IDE
2. Board auswählen: Gehe zu Werkzeuge → Board und wähle dein Arduino-Modell
3. Port auswählen: Unter Werkzeuge → Port wählst du den richtigen COM-Port
4. Hochladen: Klicke auf den Upload-Button (Pfeil nach rechts)
5. Seriellen Monitor öffnen: Drücke Strg+Shift+M oder gehe zu Werkzeuge → Serieller Monitor
6. Baudrate einstellen: Stelle unten rechts im Seriellen Monitor 115200 ein
7. Beobachten: Du siehst nun jede Sekunde die vergangene Zeit in Millisekunden

Was du im Seriellen Monitor siehst

Die Ausgabe sieht ungefähr so aus:

Vergangene Zeit:    1001
Vergangene Zeit:    2002
Vergangene Zeit:    3003
Vergangene Zeit:    4004

Du erkennst, dass die Werte jede Sekunde um etwa 1000 Millisekunden steigen. Die leichten Abweichungen kommen durch die Verarbeitungszeit des Codes selbst.

Erweiterte Techniken mit Arduino millis()

Nicht-blockierendes Blinken (ohne delay)

Ich zeige dir ein fortgeschrittenes Beispiel, wie du eine LED ohne delay() blinken lassen kannst:

unsigned long previousMillis = 0;
const long interval = 1000;
int ledState = LOW;

void loop() {
  unsigned long currentMillis = millis();
  
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    ledState = !ledState;
    digitalWrite(LED_BUILTIN, ledState);
  }
  // Hier kannst du weiteren Code ausführen, der nicht blockiert wird!
}

Überlauf-Problem beachten

Nach etwa 49,7 Tagen läuft millis() über und beginnt wieder bei 0. Ich empfehle dir, Zeitdifferenzen immer so zu berechnen:

if ((unsigned long)(currentMillis - previousMillis) >= interval) {
  // Dein Code
}

Diese Methode funktioniert auch beim Überlauf korrekt.

Fazit: Arduino millis() für bessere Projekte

Die Arduino millis()-Funktion ist ein unverzichtbares Werkzeug, das ich dir für alle ernsthaften Projekte ans Herz lege. Sie ermöglicht dir präzise Zeitmessungen, ohne dein Programm zu blockieren – ein entscheidender Vorteil gegenüber der delay()-Funktion.

Die wichtigsten Punkte zusammengefasst

• millis() gibt dir die Millisekunden seit Programmstart zurück
• Ideal für nicht-blockierende Programmierung und reaktionsschnelle Anwendungen
• Verwende immer den Datentyp unsigned long für die Zeitvariablen
• Beachte den Überlauf nach etwa 50 Tagen kontinuierlichem Betrieb
• Perfekt für parallele Timer und zeitgesteuerte Ereignisse

Deine nächsten Schritte

Ich empfehle dir, jetzt selbst aktiv zu werden:

1. Experimentiere: Ändere die Zeitintervalle im Beispielcode und beobachte die Auswirkungen
2. LED-Blinken: Baue das nicht-blockierende LED-Beispiel auf und erweitere es mit mehreren LEDs
3. Mehrere Timer: Implementiere zwei oder drei parallele Timer für verschiedene Aufgaben
4. Timeout-System: Erstelle einen Timeout für Sensorabfragen, der nach 5 Sekunden eine Warnung ausgibt

Mit diesem Wissen über Arduino millis() bist du nun in der Lage, deutlich professionellere und effizientere Arduino-Projekte zu entwickeln. Du wirst den Unterschied in der Reaktionsfähigkeit deiner Programme sofort bemerken!

---

Wenn dir das Projekt gefallen hat und du von weiteren interessanten Projekten inspiriert werden willst, sieh dir doch mal mein neues E-Book »Arduino Projekte Volume 1« an!

• Die beliebtesten Arduino-Projekte von StartHardware
• Inklusive Schaltplan, Beschreibung und Code
• Arduino-Schnellstart-Kapitel
• Kompakter Programmierkurs

Jetzt ansehen!

---