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.
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*
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
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.
/* 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; } } }