Flexibler Timer für Arduino: Wie du die Zeit per Poti regulierst

Manchmal entstehen die besten Ideen für neue Blogbeiträge aus der Community – und genau das ist hier der Fall! In einem Kommentar zu meinem Beitrag „Intervall-Ausführung leicht gemacht: Timer für Arduino“ fragte ein Leser, wie sich der Timer flexibel gestalten lässt, indem die Zeit über einen Analogwert, beispielsweise von einem Potentiometer, eingestellt wird.

Flexibler Timer für Arduino: Wie du die Zeit per Poti regulierst

Dieses Video auf YouTube ansehen.

Diese Idee fand ich spannend, denn sie zeigt, wie einfach und praktisch sich Arduino-Projekte anpassen lassen. In diesem Beitrag zeige ich dir, wie du mit wenigen Zeilen Code den Timer-Wert dynamisch mit einem Potentiometer steuern kannst – eine einfache und effektive Lösung!

Braucht du Hilfe oder hast Fragen?
Falls du Unterstützung benötigst oder weitere Fragen hast, kannst du mir gerne einen Kommentar unter diesem Beitrag hinterlassen oder mich direkt per E-Mail unter info@draeger-it.blog kontaktieren. Ich freue mich immer über Feedback und Austausch mit der Community!

Inhaltsverzeichnis

• Timerschaltung mit einem Drehpotentiometer am Arduino
• Arduino-Code: Flexibler Timer mit Potentiometer steuern – ohne delay()!
• Servo mit flexibler Timersteuerung – Bewegungsgeschwindigkeit per Potentiometer regeln

Timerschaltung mit einem Drehpotentiometer am Arduino

Nachfolgend die kleine Schaltung am Arduino, du kannst diese mit jedem Mikrocontroller der Arduino Familie nachbauen (Micro, Nano, Leonard und auch Mega).

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Arduino-Code: Flexibler Timer mit Potentiometer steuern – ohne delay()!

In vielen Arduino-Projekten wird die Funktion delay() verwendet, um eine Pause zwischen Aktionen einzulegen. Das Problem dabei: Während der delay()-Zeit bleibt der Mikrocontroller untätig und kann keine neuen Eingaben verarbeiten. In diesem Code verzichten wir bewusst auf delay() und setzen stattdessen auf eine millis()-basierte Zeitsteuerung.

Der Vorteil? Du kannst die Pause jederzeit mit dem Potentiometer verändern, und die Änderung wirkt sich sofort aus. Der Mikrocontroller bleibt aktiv, sodass er kontinuierlich den Potentiometer-Wert auslesen und die LED-Wechsel in Echtzeit anpassen kann.

Das folgende Programm zeigt, wie du mit dieser Methode eine dynamische LED-Steuerung umsetzt:

/*
  Flexibler Timer für Arduino: Wie du die Zeit per Poti regulierst

  Dieses Programm steuert fünf LEDs mit einem variablen Zeitintervall, das über ein Potentiometer angepasst wird.
  Je nachdem, welchen Wert das Potentiometer liefert, ändert sich die Pause zwischen den LED-Wechseln.

  Author: Stefan Draeger
  Webseite: https://draeger-it.blog
*/

#define led1 9    // Pin für LED 1
#define led2 10   // Pin für LED 2
#define led3 11   // Pin für LED 3
#define led4 12   // Pin für LED 4
#define led5 13   // Pin für LED 5

#define poti A0   // Analogeingang für das Potentiometer

// Array mit den LED-Pins für einfache Iteration
int leds[] = { led1, led2, led3, led4, led5 };

unsigned long lastAction = -1L;  // Zeitpunkt der letzten Aktion
int pause = 0;  // Variable für die Pausenzeit zwischen den LED-Wechseln

int ledIndex = 0;  // Index für die aktuell leuchtende LED

const int PAUSE_MILLIS = 3000;  // Maximale Pausenzeit in Millisekunden

void setup() {
  Serial.begin(9600);  // Serielle Kommunikation starten (für Debugging)

  // LEDs als Ausgang definieren
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);

  pinMode(poti, INPUT);  // Potentiometer als Eingang definieren
}

// Setzt alle LEDs auf LOW (ausgeschaltet)
void resetLEDs() {
  for (int index = 0; index <= 4; index++) {
    digitalWrite(leds[index], LOW);
  }
}

void loop() {
  // Analogen Wert vom Potentiometer auslesen
  int potiValue = analogRead(poti);
  Serial.println("potiValue: " + String(potiValue, DEC));  // Debug-Ausgabe

  // Potentiometerwert auf eine Pause zwischen 0 und PAUSE_MILLIS umrechnen
  pause = map(potiValue, 0, 1023, 0, PAUSE_MILLIS);
  Serial.println("Pause: " + String(pause, DEC));  // Debug-Ausgabe

  // Aktuelle Zeit in Millisekunden abfragen
  long currentMillis = millis();

  // Prüfen, ob die definierte Pause abgelaufen ist
  if ((lastAction + pause) < currentMillis) {
    lastAction = currentMillis;  // Zeitpunkt der letzten Aktion aktualisieren
    resetLEDs();  // Alle LEDs ausschalten

    // Nächste LED einschalten
    if (ledIndex < 4) {
      ledIndex++;
    } else {
      ledIndex = 0;
    }

    int ledPin = leds[ledIndex];  // Pin der aktuellen LED bestimmen
    digitalWrite(ledPin, HIGH);   // LED einschalten
  }
}

Servo mit flexibler Timersteuerung – Bewegungsgeschwindigkeit per Potentiometer regeln

/*
  Flexibler Timer für Arduino: Servomotor SG90 mit variabler Geschwindigkeit steuern

  Dieses Programm steuert einen SG90-Servomotor mit einer variablen Pausenzeit, 
  die über ein Potentiometer eingestellt wird. Anstatt die Bewegung mit `delay()` 
  zu verlangsamen, wird `millis()` genutzt, sodass die Pause jederzeit angepasst werden kann.

  Der Servo bewegt sich von 0° bis 180° und zurück, wobei die Geschwindigkeit über 
  das Potentiometer geregelt wird.

  Author: Stefan Draeger
  Webseite: https://draeger-it.blog
*/

#include <Servo.h>   // Bibliothek für die Servosteuerung einbinden

#define servoPin 6   // Pin für den Servo
#define poti A0      // Analogeingang für das Potentiometer

Servo servo;   // Servo-Objekt erstellen

unsigned long lastAction = -1L;  // Zeitpunkt der letzten Servo-Bewegung
int pause = 0;  // Variable für die Pausenzeit zwischen Bewegungen
const int PAUSE_MILLIS = 1000;  // Maximale Pausenzeit (in Millisekunden)

int servoPos = 0;      // Aktuelle Position des Servos
bool moveForward = true;  // Richtung der Bewegung (true = vorwärts, false = rückwärts)

void setup() {
  Serial.begin(9600);   // Serielle Kommunikation für Debugging starten

  pinMode(servoPin, OUTPUT);  // Servomotor als Ausgang setzen
  servo.attach(servoPin);     // Servomotor an den definierten Pin binden

  pinMode(poti, INPUT);  // Potentiometer als Eingang definieren
}

void loop() {
  // Potentiometerwert auslesen und in eine Pausenzeit umwandeln
  int potiValue = analogRead(poti);
  pause = map(potiValue, 0, 1023, 0, PAUSE_MILLIS);
  
  // Aktuelle Zeit abrufen
  long currentMillis = millis();

  // Prüfen, ob die definierte Pause abgelaufen ist
  if ((lastAction + pause) < currentMillis) {
    lastAction = currentMillis;  // Zeitpunkt der letzten Bewegung aktualisieren

    Serial.println(servoPos);  // Aktuelle Position zur Kontrolle ausgeben

    servo.write(servoPos);  // Servo auf die neue Position setzen

    // Servo in die richtige Richtung bewegen
    if (moveForward && servoPos <= 179) {
      servoPos++;  // Vorwärts bewegen
    } else if (moveForward && servoPos == 180) {
      moveForward = false;  // Richtung umkehren
      servoPos = 179;
    } else if (!moveForward && servoPos > 0) {
      servoPos--;  // Rückwärts bewegen
    } else if (!moveForward && servoPos == 0) {
      moveForward = true;  // Richtung wieder nach vorne ändern
      servoPos = 1;
    }
  }
}

Letzte Aktualisierung am: 05. Februar 2025