Die Faszination der map()-Funktion

Stell dir vor, du möchtest zwei eigenständige Komponenten, wie einen Potentiometer und eine LED, auf intuitive Weise verbinden und koordinieren. Du willst, dass die Helligkeit der LED direkt durch den Potentiometer gesteuert wird. Wie lässt sich das erreichen? Die Antwort liegt in der bemerkenswerten Funktion namens map().

Die map()-Funktion dient als Brücke zwischen diesen beiden Komponenten. Sie nimmt den Eingabewert des Potentiometers, der normalerweise zwischen 0 und 1023 liegt, und transformiert ihn in einen neuen Wertebereich, der für die Steuerung der LED geeignet ist - typischerweise zwischen 0 und 255.

Dies ermöglicht eine direkte Steuerung der LED-Helligkeit basierend auf dem Potentiometerwert und erzeugt eine beinahe magische Interaktion zwischen den beiden Komponenten. Das Resultat ist eine haptische, intuitive Kontrolle über die Leuchtkraft der LED.

Der Sketch

Nun zur Umsetzung in die Praxis. Der folgende Code illustriert, wie man einen Potentiometer benutzt, um die Helligkeit einer LED zu steuern.

In diesem Code wird die analogRead()-Funktion verwendet, um den aktuellen Wert des Potentiometers zu lesen. Dieser Wert wird dann auf dem Serial Monitor ausgegeben, um dir eine Rückmeldung über den aktuellen Wert des Potentiometers zu geben. Beachte, dass eine kurze Verzögerung eingebaut wurde, um die Lesbarkeit der ausgegebenen Werte zu verbessern.

const int potiPin = A0; //Pin für den Potentiometer

void setup() 
{
  Serial.begin(9600); //Initialisiere die serielle Kommunikation
}

void loop() 
{
  int potiValue = analogRead(potiPin); //Wert des Potentiometers lesen
  Serial.println(potiValue); //Sensorwert auf dem Serial Monitor ausgeben

  delay(100); // Eine kurze Verzögerung für eine bessere Lesbarkeit
}

Aufbau und Verkabelung

In diesem Projekt werden wir ein LED-Modul und ein Potentiometer-Modul an den Arduino anschließen. Für das LED-Modul: Verbinde GND mit GND am Arduino, VCC mit 5V am Arduino und den Signal-Pin mit Pin 9 am Arduino. Für das Potentiometer-Modul: Verbinde GND mit GND am Arduino, VCC mit 5V am Arduino und den Signal-Pin mit dem analogen Pin A0 am Arduino. Bevor du mit der Verkabelung beginnst, stelle sicher, dass der Arduino ausgeschaltet ist. Sobald alles korrekt verbunden ist, schalte den Arduino ein und starte dein Programm.

Sketch-Details und Erläuterungen

Staune, wie diese ganze Aktion in nur zwei Zeilen Code passiert. In der ersten Zeile wird der Sensorwert abgefragt und das Ergebnis an die zweite Zeile weitergereicht. Durch die Verwendung der Variable "potiValue" in beiden Funktionen entsteht eine Verknüpfung. Diese Verbindung ermöglicht eine proportionale Übertragung des Potentiometerwerts direkt auf die LED.

Wenn du jedoch am Potentiometer drehst, beobachtest du dann etwas Ungewöhnliches mit der LED? Nimm dir einen Moment Zeit und versuche, das Rätsel zu lösen.

Siehst du das Problem? Bemerkt man, dass die LED ihre maximale Intensität erreicht, wenn das Potentiometer erst zu 25% aufgedreht ist? Versuche, den Grund dafür zu ergründen. Ein Hinweis: Öffne den Serial Monitor, drehe das Potentiometer auf die maximale Position und notiere den angezeigten Wert.

Jetzt zur Lösung: Es liegt an den unterschiedlichen Wertebereichen der beiden Funktionen. "analogRead()" liefert 1024 Werte, während "analogWrite()" nur 256 Werte aufnehmen kann. Sobald ein Viertel der Potentiometerrotation erreicht ist, ist das Maximum von "analogWrite()" erreicht: 256 ist ein Viertel von 1024. Um solche Wertebereichsunterschiede zu bewältigen, gibt es eine hilfreiche Funktion namens "map()". Diese Funktion kann einen Wertebereich auf einen anderen skalieren.

Die "map()" Funktion erfordert fünf Argumente. Das erste Argument ist der Wert oder die Variable, deren Wertebereich umgewandelt werden soll. Low1 und High1 bestimmen die Grenzen des ursprünglichen Bereichs. Im Fall des Potentiometers sind das die Werte 0 und 1023. Low2 und High2 definieren den neuen Bereich, in den der Wert umgewandelt wird. Da die LED mit "analogWrite()" 256 Helligkeitsstufen darstellen kann, wird der neue Bereich von 0 bis 255 festgelegt. Beachte dabei, dass "map()" mit Ganzzahlen arbeitet, Nachkommastellen werden abgeschnitten und nicht gerundet. Jedes Signal vom Potentiometer wird nun in einen entsprechenden Wert des neuen Bereichs umgewandelt. So entspricht zum Beispiel der Wert 256 im alten Bereich nun dem Wert 64 im neuen Bereich.

Mit folgender Zeile kannst du die beiden Wertebereiche ineinander überführen:

ledMap = map(sensorWert, 0, 1023, 0, 255);

Hier ist der oben genannte Sketch, jetzt erweitert mit der "map()" Funktion. Versuche nun den unteren Code alleine mit den Kommentaren im Sketch zu lesen. Die Kommentare erklären jeden Schritt des Codes. Zuerst werden die Pins für das Potentiometer und die LED definiert. Im setup() wird der LED-Pin als Ausgang eingestellt. In der loop() Funktion wird zuerst der aktuelle Wert des Potentiometers gelesen und dann mithilfe der map() Funktion in den Wertebereich umgewandelt, der von der analogWrite() Funktion erwartet wird. Schließlich wird dieser umgewandelte Wert verwendet, um die Helligkeit der LED einzustellen.

//Definiere den Pin, an dem das Potentiometer angeschlossen ist
int potPin = A0;

//Definiere den Pin, an dem die LED angeschlossen ist
int ledPin = 9;

void setup() 
{
  // Setze den LED-Pin als Ausgang
  pinMode(ledPin, OUTPUT);
}

void loop() 
{
  //Lese den aktuellen Wert des Potentiometers
  int potValue = analogRead(potPin); 

  //Wandele den gelesenen Potentiometerwert (0-1023) in einen neuen Wertebereich (0-255) um
  //Dies ist notwendig, da die Funktion analogWrite() nur Werte zwischen 0 und 255 akzeptiert
  int brightness = map(potValue, 0, 1023, 0, 255); 

  //Setze die Helligkeit der LED entsprechend des umgewandelten Potentiometerwerts
  analogWrite(ledPin, brightness); 
}