Skip to content

Technik Blog

Programmieren | Arduino | ESP32 | MicroPython | Python | Raspberry Pi | Raspberry Pi Pico

Menu
  • Smarthome
  • Arduino
  • ESP32 & Co.
  • Raspberry Pi & Pico
  • Solo Mining
  • Über mich
  • Deutsch
  • English
Menu

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

Posted on 5. Februar 20255. Februar 2025 by Stefan Draeger

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

Für die Schaltung habe ich verwendet:

  • einen Mikrocontroller der Arduino Familie
  • einen 50 kOhm Drehpotentiometer*
  • fünf LEDs*
  • einen 220 Ohm Vorwiderstand*
  • diverse Breadboardkabel*, 10 cm
  • ein 400 Pin Breadboard*
Schaltung - Arduino UNO R3 - Drehpotentiometer - LEDs
Schaltung – Arduino UNO R3 – Drehpotentiometer – LEDs

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!

Schaltung - Arduino UNO R4 Minima - Drehpotentiometer und LEDs
Schaltung – Arduino UNO R4 Minima – Drehpotentiometer und LEDs

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.

Programm: flexible Timerschaltung am Arduino mit DrehpotentiometerHerunterladen

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

Nachdem wir bereits gezeigt haben, wie eine flexible Timersteuerung mit einem Potentiometer funktioniert, möchte ich das Prinzip nun auf einen SG90-Servomotor übertragen. Die Idee ist einfach: Anstatt eine feste Geschwindigkeit für den Servo vorzugeben, kann diese über das Potentiometer stufenlos angepasst werden.

Auch hier setzen wir wieder auf eine millis()-basierte Zeitsteuerung, sodass der Servo sich kontinuierlich bewegt und die Geschwindigkeit jederzeit verändert werden kann – ohne Verzögerungen oder blockierende delay()-Befehle.

Im folgenden Code zeige ich dir, wie du diese Steuerung umsetzt.

Schaltung - Arduino UNO R4 Minima mit Servomotor SG90 und Drehpotentiometer
Schaltung – Arduino UNO R4 Minima mit Servomotor SG90 und Drehpotentiometer
Programm: flexible Timerschaltung am Arduino mit Servomotor SG90 & DrehpotentiometerHerunterladen
/*
  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;
    }
  }
}

5 thoughts on “Flexibler Timer für Arduino: Wie du die Zeit per Poti regulierst”

  1. Schmelzer sagt:
    10. Februar 2025 um 15:23 Uhr

    Hallo Stefan,(da ich mitlerweile 70 Jahre zähle, denke ich, da kann ich so schreiben)
    Jetzt noch eine rückwärts zählende Digital Anzeige, egal ob 7 Segment oder andere, sprich mittels Poti einstellbare Eieruhr, wäre meine Idee, da ich aber mit programieren nichts am Hut habe, brauche ich Vorlagen
    Harald

    Antworten
    1. Stefan Draeger sagt:
      10. Februar 2025 um 15:32 Uhr

      Hi,

      klaro kannst du gerne beim du bleiben, das hört sich nach einem kleinen aber feinen Projekt an 🙂

      Gruß, Stefan

      Antworten
  2. Tom Jackson sagt:
    6. März 2025 um 09:32 Uhr

    Vielen Dank für Ihren Artikel, er ist für mich sehr hilfreich.

    Antworten
  3. Benjamin sagt:
    14. März 2025 um 20:24 Uhr

    Hallo

    Ich bin neu in der ganzen sache und und lerne immer mehr Dazu danke erstmal für die Erklärung
    soweit hat das schon einmal Funktioniert 🙂
    aber wenn ich mein Poti auf schnell dreh ist das mir zu Langsam wie bekomme ich das schneller hin?
    wenn ich das Programm hochfahre oder drauflade bewegt der Servo sich gut und schnell..
    Und ich würde gern den Winkel ändern habe schon versucht die Zahl zu ändern (die 180und so)
    aber da fährt er immer nur in eine Richtung und bleibt stehen
    Ich benutze ein Servo wie auf dem Bild ein von Te.u .. ein SG90

    Ich hoffe ihr könnt mir da weiter helfen was ich da falsch mach

    Antworten
    1. Stefan Draeger sagt:
      15. März 2025 um 09:55 Uhr

      Hallo Benjamin,

      du kannst die Geschwindigkeit anpassen möchtest, dann musst du den Code:
      pause = map(potiValue, 0, 1023, 0, PAUSE_MILLIS);
      anpassen bzw. die Konstante PAUSE_MILLIS. Der Wert von PAUSE_MILLIS ist der maximale Wert, je kleiner dieser ist desto schneller bewegt sich dieser je nach Stellung des Drehpotis.

      Gruß, Stefan

      Antworten

Schreibe einen Kommentar Antworten abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Fragen oder Feedback?

Du hast eine Idee, brauchst Hilfe oder möchtest Feedback loswerden?
Support-Ticket erstellen

Newsletter abonnieren

Bleib auf dem Laufenden: Erhalte regelmäßig Updates zu neuen Projekten, Tutorials und Tipps rund um Arduino, ESP32 und mehr – direkt in dein Postfach.

Jetzt Newsletter abonnieren

Unterstütze meinen Blog

Wenn dir meine Inhalte gefallen, freue ich mich über deine Unterstützung auf Tipeee.
So hilfst du mit, den Blog am Leben zu halten und neue Beiträge zu ermöglichen.

draeger-it.blog auf Tipeee unterstützen

Vielen Dank für deinen Support!
– Stefan Draeger

Kategorien

Tools

  • Unix-Zeitstempel-Rechner
  • ASCII Tabelle
  • Spannung, Strom, Widerstand und Leistung berechnen
  • Widerstandsrechner
  • 8×8 LED Matrix Tool
  • 8×16 LED Matrix Modul von Keyestudio
  • 16×16 LED Matrix – Generator

Links

Blogverzeichnis Bloggerei.de TopBlogs.de das Original - Blogverzeichnis | Blog Top Liste Blogverzeichnis trusted-blogs.com

Stefan Draeger
Königsberger Str. 13
38364 Schöningen

Tel.: 01778501273
E-Mail: info@draeger-it.blog

Folge mir auf

  • Impressum
  • Datenschutzerklärung
  • Disclaimer
  • Cookie-Richtlinie (EU)
©2025 Technik Blog | Built using WordPress and Responsive Blogily theme by Superb
Cookie-Zustimmung verwalten
Wir verwenden Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wir tun dies, um das Surferlebnis zu verbessern und um personalisierte Werbung anzuzeigen. Wenn Sie diesen Technologien zustimmen, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn Sie Ihre Zustimmung nicht erteilen oder zurückziehen, können bestimmte Funktionen beeinträchtigt werden.
Funktional Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt. Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
Optionen verwalten Dienste verwalten Verwalten von {vendor_count}-Lieferanten Lese mehr über diese Zwecke
Einstellungen anzeigen
{title} {title} {title}