Grundlagen · 10 Min. Lesezeit

Arduino map() Funktion: Syntax, Beispiele und constrain()

Wie nutzt du die Arduino map() Funktion? Syntax, Integer-Falle, Begrenzen mit constrain, Beispiele mit Poti, Servo und PWM sowie ESP32 und Pico.

Die Arduino map() Funktion ist ein eingebauter Befehl, der einen Wert aus einem Zahlenbereich proportional auf einen anderen Bereich umrechnet. Wenn du den Wert 0–1023 eines Potentiometers in 0–180 Grad für einen Servo, in einen PWM-Wert 0–255 für die LED-Helligkeit oder in 0–100 Prozent für die Anzeige umwandeln willst, erledigt das eine einzige Zeile. Kurz gesagt: map() ist ein Maßstabsumrechner, der deine Skala an die Zielskala anpasst.

map() ist aber nicht so harmlos, wie es aussieht: Die Funktion arbeitet nur mit ganzen Zahlen, schneidet Nachkommastellen ab und begrenzt das Ergebnis nicht auf den Zielbereich. In diesem Beitrag siehst du Schritt für Schritt die Formel, die Überraschungen durch Integer-Division, den sicheren Einsatz mit constrain(), echte Beispiele vom Potentiometer zum Servo und vom Sensor zum PWM-Signal sowie dasselbe mit dem 12-Bit-ADC des ESP32 und mit MicroPython auf dem Raspberry Pi Pico.

Potentiometer für die Arduino map() Funktion
Das Potentiometer ist das häufigste Eingabebauteil für map(): Der gelesene Wert 0–1023 wird in einen Servowinkel oder PWM-Wert umgerechnet.

Was ist Arduino map() und wie funktioniert es?

map() stellt eine lineare Proportion zwischen zwei Bereichen her. Es ermittelt, an welcher prozentualen Position der Eingangswert in seinem Bereich liegt, und berechnet dann die Zahl an derselben Position im Zielbereich. Die Definition im Arduino-Core ist eine einzige Zeile: (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Alle Parameter und der Rückgabewert sind vom Typ long, auf dem Uno also 32-Bit-Ganzzahlen mit Vorzeichen. Die Syntax lautet map(Wert, vonMin, vonMax, zuMin, zuMax), und du musst dafür keine Bibliothek einbinden.

ParameterBedeutungBeispiel Poti → Servo
value (x)Der umzurechnende WertErgebnis von analogRead(A0)
fromLow (in_min)Untere Grenze des Eingangsbereichs0
fromHigh (in_max)Obere Grenze des Eingangsbereichs1023
toLow (out_min)Untere Grenze des Ausgangsbereichs0
toHigh (out_max)Obere Grenze des Ausgangsbereichs180
RückgabewertEntsprechung im Zielbereich (long)Winkel zwischen 0 und 180

Rechnen wir ein Beispiel: Steht das Potentiometer genau in der Mitte, liefert analogRead() etwa 512. Für map(512, 0, 1023, 0, 180) ergibt sich zuerst 512 - 0 = 512, das wird mit 180 - 0 = 180 multipliziert und ergibt 92160. Dann wird durch 1023 geteilt: 92160 / 1023 = 90,09. Da die Integer-Division die Nachkommastellen abschneidet, ist das Ergebnis 90 Grad; zum Schluss wird die untere Ausgangsgrenze 0 addiert. Vertauschst du die Ausgangsgrenzen, kehrt sich auch die Richtung um: map(x, 0, 1023, 255, 0) liefert einen Wert, der mit steigendem Poti sinkt. Auch negative Bereiche funktionieren problemlos; so kannst du eine Joystick-Achse mit map(x, 0, 1023, -255, 255) in eine Motorgeschwindigkeit vorwärts und rückwärts umrechnen. Die folgende Tabelle fasst die häufigsten Umrechnungen zusammen.

ZielCodeHinweis
Potentiometer → Servowinkelmap(x, 0, 1023, 0, 180)Für Servo.write()
Potentiometer → PWMmap(x, 0, 1023, 0, 255)Für analogWrite(); x / 4 verteilt gleichmäßiger
Analogwert → Prozentmap(x, 0, 1023, 0, 100)Zur Prozentanzeige auf dem Display
Joystick → Motorgeschwindigkeit und Richtungmap(x, 0, 1023, -255, 255)Vorzeichen = Richtung, Betrag = Tempo
Umgekehrte Richtung (dunkel → hell)map(x, 0, 1023, 255, 0)Ausgangsgrenzen vertauschen
ESP32 12-Bit-ADC → PWMmap(x, 0, 4095, 0, 255)Beim ESP32 liefert analogRead() 0–4095

Die Integer-Falle: Warum liefert map() keine Nachkommastellen?

Da die Division in map() mit ganzen Zahlen erfolgt, wird das Ergebnis immer Richtung null abgeschnitten; Nachkommastellen werden nicht gerundet, sondern einfach verworfen. In einem kleinen Zielbereich fällt das besonders auf. Wenn du zum Beispiel ein Poti mit map(x, 0, 1023, 0, 10) in eine Pegelanzeige von 0 bis 10 umrechnest, ergibt sich diese Tabelle:

Eingang (x)Exakter Anteilmap()-Ergebnis
00,0000
1020,9970
1031,0071
5125,0055
10229,9909
102310,00010

Das eigentliche Problem der Tabelle: Das Ergebnis 0 entsteht aus 103 verschiedenen Eingangswerten (0–102), der höchste Wert 10 aber nur aus einem einzigen, nämlich 1023. Drehst du das Poti nicht ganz bis zum Anschlag, erreicht deine Anzeige nie die 10. Für eine gleichmäßige Verteilung kannst du beide Obergrenzen um eins erhöhen und map(x, 0, 1024, 0, 11) schreiben; so entspricht jeder Ausgangswert etwa 93 Eingangswerten, und das Ergebnis bleibt trotzdem zwischen 0 und 10. Die zweite Einschränkung ist der Überlauf: Übersteigt das Zwischenprodukt (x - in_min) * (out_max - out_min) die 32-Bit-Grenze von long, also etwa 2,1 Milliarden, wird das Ergebnis falsch. Große Bereiche wie map(50000, 0, 100000, 0, 100000) erzeugen auf dem Uno ein Zwischenprodukt von 5 Milliarden und liefern ein falsches Ergebnis. Die dritte Einschränkung ist der Bedarf an Nachkommastellen: Schreibst du map(x, 0, 1023, 0, 5), um einen Analogwert in 0–5 V umzurechnen, erhältst du nur die Ergebnisse 0, 1, 2, 3, 4 und 5. In diesem Fall musst du mit derselben Formel eine eigene Funktion mit Kommazahlen schreiben:

C++ (Arduino IDE)
1// Ondalikli map fonksiyonu / Floating-point map function
2float mapFloat(float x, float inMin, float inMax, float outMin, float outMax) {
3  return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
4}
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(A0);                          // 0-1023 ham deger / raw value
12  float volt = mapFloat(raw, 0, 1023, 0.0, 5.0);     // 0.00-5.00 V
13  long milliVolt = map(raw, 0, 1023, 0, 5000);       // tamsayi mV / integer mV
14  int percent = map(raw, 0, 1023, 0, 100);           // tamsayi yuzde / integer percent
15
16  Serial.print(F("Ham / Raw: "));
17  Serial.print(raw);
18  Serial.print(F("  V: "));
19  Serial.print(volt, 2);
20  Serial.print(F("  mV: "));
21  Serial.print(milliVolt);
22  Serial.print(F("  %: "));
23  Serial.println(percent);
24  delay(500);
25}
Auf dem Uno sind float-Berechnungen mehrfach langsamer als Integer-Rechnungen und brauchen mehr Programmspeicher. Wenn du keine Nachkommastellen brauchst, nimm das Integer-map(); willst du mehr Genauigkeit, verkleinere die Zieleinheit. Berechne die Spannung zum Beispiel in Millivolt statt in Volt: map(raw, 0, 1023, 0, 5000) liefert 0–5000 mV, und das größte Zwischenprodukt (5.115.000) liegt weit unter der long-Grenze.

Die Kombination mit constrain

map() sieht den Zielbereich nicht als Grenze, sondern berechnet nur eine Proportion. Liegt der Eingangswert außerhalb des erwarteten Bereichs, läuft auch der Ausgang darüber hinaus. Angenommen, du hast gemessen, dass ein LDR in der Praxis Werte zwischen 200 und 900 liefert, und schreibst map(x, 200, 900, 0, 255). Wenn eine starke Taschenlampe den Wert auf 980 treibt, ergibt sich (980 - 200) * 255 / 700 = 284; fällt der Wert bei sehr dunkler Umgebung auf 150, erhältst du -18. Auf dem Uno interpretiert analogWrite() Werte über 255 je nach Pin unterschiedlich; an Pin 6 wird 284 zum Beispiel auf 8 Bit abgeschnitten und wird zu 28, also zu einer fast dunklen LED. Die Lösung ist die Funktion constrain(Wert, unten, oben): Sie presst den Wert in die angegebenen Grenzen. Es gibt zwei richtige Reihenfolgen: den Eingang vor map() begrenzen, also map(constrain(x, 200, 900), 200, 900, 0, 255), oder das Ergebnis nach map() begrenzen, also constrain(map(x, 200, 900, 0, 255), 0, 255). Beide verhindern Werte außerhalb von 0–255; bei einer Sensorkalibrierung ist das Begrenzen des Eingangs besser lesbar.

Beim Arduino Uno (AVR-Core) ist constrain() keine Funktion, sondern ein Makro und wertet seine Parameter mehrfach aus. Schreibst du constrain(analogRead(A0), 200, 900), kann analogRead() mehrmals ausgeführt werden, und der verglichene Wert kann sich vom zurückgegebenen unterscheiden. Lies den Wert zuerst in eine Variable ein und gib dann diese Variable in constrain() an.

Anschlusstabelle: Arduino Uno, ESP32 und Pico

AnschlussArduino UnoESP32Raspberry Pi Pico
Äußere Poti-Anschlüsse5V und GND3V3 und GND3V3 und GND
Mittlerer Poti-Anschluss (Schleifer)A0GPIO 34GP26 (ADC0)
Mittelpunkt LDR + 10-kΩ-SpannungsteilerA1GPIO 35GP27 (ADC1)
LED (mit 220-Ω-Widerstand)D6 (PWM)GPIO 25GP15
Servo-Signal (orangefarbenes Kabel)D9GPIO 13GP16
ADC-Lesebereich10 Bit (0–1023)12 Bit (0–4095)read_u16(): 0–65535
Die Analogeingänge von ESP32 und Pico vertragen höchstens 3,3 V. Schließt du die Poti-Enden aus Gewohnheit an den 5V-Pin an, liegen am Schleifer bis zu 5 V an, und der ADC-Eingang kann dauerhaft beschädigt werden. Versorge das Poti bei diesen Boards immer über den 3V3-Pin; bei einem Sensor mit 5-V-Ausgang senkst du den Pegel vorher mit einem Spannungsteiler.

Schritt für Schritt: Servowinkel mit dem Potentiometer einstellen

  1. Schließe die beiden äußeren Anschlüsse des 10-kΩ-Potentiometers an 5V und GND des Arduino an, den mittleren Anschluss an A0.
  2. Schließe das braune Kabel des SG90-Servos an GND, das rote an 5V und das orangefarbene Signalkabel an D9 an.
  3. Prüfe, ob die Servo-Bibliothek installiert ist; sie wird mit der Arduino IDE mitgeliefert, du musst nichts herunterladen.
  4. Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
  5. Drehe am Potentiometer und beobachte, wie sich Rohwert und Winkel gemeinsam ändern und der Servo zwischen 0 und 180 Grad dreht.
  6. Wenn der Servo an den Endpunkten brummt und sich abmüht, verengst du den map()-Ausgang auf einen kleineren Bereich wie 10–170.
C++ (Arduino IDE)
1#include <Servo.h>
2
3const int POT_PIN = A0;     // potansiyometre orta ucu / potentiometer wiper
4const int SERVO_PIN = 9;    // servo sinyal pini / servo signal pin
5
6Servo servo;
7
8void setup() {
9  servo.attach(SERVO_PIN);
10  Serial.begin(9600);
11}
12
13void loop() {
14  int raw = analogRead(POT_PIN);           // 0-1023 ham deger / raw value
15  int angle = map(raw, 0, 1023, 0, 180);   // dereceye cevir / convert to degrees
16  angle = constrain(angle, 0, 180);        // guvenlik siniri / safety limit
17  servo.write(angle);
18
19  Serial.print(F("Ham / Raw: "));
20  Serial.print(raw);
21  Serial.print(F("  Aci / Angle: "));
22  Serial.println(angle);
23  delay(20);                               // servoya zaman tani / give the servo time
24}

Im Code liefert analogRead() einen 10-Bit-Wert, map() rechnet ihn in Grad um, und constrain() garantiert, dass selbst bei späteren Änderungen am Bereich nie ein Winkel außerhalb von 0–180 beim Servo ankommt. Weil der ADC des Uno leicht rauscht, kann der Wert auch ohne Berührung des Potentiometers zwischen 511, 512 und 513 schwanken; das lässt den Servo zittern. Das Mitteln mehrerer Messungen oder ein Aufruf von servo.write() nur bei einer Winkeländerung von mehr als 2 Grad löst das Problem weitgehend. Details findest du in den Beiträgen Servo zittert und Sensordaten filtern. Willst du wissen, wie ein Servo funktioniert, ist Was ist ein Servomotor? ein guter Einstieg.

Vom Sensor zum PWM: automatische LED-Helligkeit mit LDR

map() ist nicht nur für Potentiometer nützlich, sondern für jeden Analogsensor. In diesem Beispiel hängt ein Ende des LDR an 5V, das andere an A1; zwischen A1 und GND sitzt ein 10-kΩ-Widerstand. Bei dieser Schaltung sinkt der Widerstand des LDR mit zunehmendem Licht, und die Spannung an A1 steigt. Notiere dir zuerst im Seriellen Monitor die Werte in einem dunklen Raum und bei Helligkeit, zum Beispiel 150 und 850. Diese beiden Zahlen sind deine Kalibriergrenzen. Der Code lässt die LED heller leuchten, je dunkler es wird, deshalb wird der Ausgangsbereich umgekehrt angegeben: von 255 bis 0. Zur Funktionsweise des LDR siehe LDR Lichtsensor, zu den Hintergründen von PWM Was ist PWM?.

C++ (Arduino IDE)
1const int LDR_PIN = A1;     // LDR + 10k bolucu / LDR + 10k divider
2const int LED_PIN = 6;      // PWM pini / PWM pin
3const int DARK = 150;       // karanlikta olculen / measured in the dark
4const int BRIGHT = 850;     // aydinlikta olculen / measured in bright light
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);
8  Serial.begin(9600);
9}
10
11void loop() {
12  int raw = analogRead(LDR_PIN);
13  int limited = constrain(raw, DARK, BRIGHT);       // once sinirla / limit first
14  int pwm = map(limited, DARK, BRIGHT, 255, 0);     // karanlik = parlak / dark = bright
15  analogWrite(LED_PIN, pwm);
16
17  Serial.print(raw);
18  Serial.print(F(" -> "));
19  Serial.println(pwm);
20  delay(100);
21}

map() auf dem ESP32: 12-Bit-ADC und LEDC-PWM

Auf dem ESP32 funktioniert map() genauso, nur der Eingangsbereich ist anders. Der ADC des ESP32 hat standardmäßig 12 Bit Auflösung, analogRead() liefert also 0–4095 statt 0–1023. Lässt du in Code vom Uno map(x, 0, 1023, ...) stehen, verbrauchst du den gesamten Ausgangsbereich schon im ersten Viertel des Potentiometers, und im Rest läuft der Wert bis auf das Vierfache des Zielbereichs über. Gib deshalb beim ESP32 den Eingang als 0–4095 an oder senke die Auflösung mit analogReadResolution(10) auf 10 Bit. Beim PWM nutzt der ESP32 die LEDC-Einheit; mit dem Arduino-Core 3.x kam ledcAttach(Pin, Frequenz, Auflösung), in 2.x werden die kanalbasierten ledcSetup() und ledcAttachPin() verwendet. Der Code unten lässt sich mit beiden Versionen kompilieren. Weil die ADC2-Pins bei aktivem WLAN nicht lesbar sind, schließen wir das Poti an GPIO 34 an, der zu ADC1 gehört. Willst du am ESP32 einen Servo ansteuern, kannst du mit der Bibliothek ESP32Servo nach derselben Logik die Zeile map(x, 0, 4095, 0, 180) verwenden.

C++ (Arduino IDE)
1const int POT_PIN = 34;      // ADC1 pini, yalniz giris / ADC1 pin, input only
2const int LED_PIN = 25;      // PWM cikisi / PWM output
3const int PWM_FREQ = 5000;   // 5 kHz
4const int PWM_RES = 8;       // 8 bit: 0-255
5
6#if ESP_ARDUINO_VERSION_MAJOR < 3
7const int PWM_CH = 0;        // 2.x icin LEDC kanali / LEDC channel for 2.x
8#endif
9
10void setup() {
11  Serial.begin(115200);
12  analogReadResolution(12);  // 0-4095
13#if ESP_ARDUINO_VERSION_MAJOR >= 3
14  ledcAttach(LED_PIN, PWM_FREQ, PWM_RES);
15#else
16  ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
17  ledcAttachPin(LED_PIN, PWM_CH);
18#endif
19}
20
21void loop() {
22  int raw = analogRead(POT_PIN);                // 0-4095
23  int duty = map(raw, 0, 4095, 0, 255);         // 12 bit -> 8 bit
24  duty = constrain(duty, 0, 255);
25#if ESP_ARDUINO_VERSION_MAJOR >= 3
26  ledcWrite(LED_PIN, duty);                     // 3.x: pin numarasi / pin number
27#else
28  ledcWrite(PWM_CH, duty);                      // 2.x: kanal numarasi / channel number
29#endif
30  Serial.printf("%d -> %d\n", raw, duty);
31  delay(20);
32}

Der ADC des ESP32 hat eine Eigenheit, die du kennen solltest: An den Endpunkten ist er nicht linear. Bei der Standarddämpfung werden Spannungen unter etwa 0,1 V als 0 gelesen, und ab etwa 3,1 V sättigt der Wert bei 4095; dazwischen ist die Messung leicht gekrümmt. Deshalb kann es sein, dass du 4095 erreichst, ohne das Poti ganz aufzudrehen, oder am Anfang einen toten Bereich spürst. Die praktische Lösung ist, die tatsächlich kleinsten und größten Messwerte zu ermitteln und diese Grenzen in map() und constrain() zu verwenden. Brauchst du eine Spannung, liefert statt map() die Funktion analogReadMilliVolts(), die die Werkskalibrierung nutzt, genauere Ergebnisse. Allgemeine Infos zum Board findest du in Was ist der ESP32?.

Raspberry Pi Pico und MicroPython: das Gegenstück zu map()

In MicroPython gibt es kein fertiges map() wie bei Arduino; das map() von Python macht etwas ganz anderes und wendet eine Funktion auf eine Liste an. Deshalb schreibst du die Formel selbst. Auf dem Pico liefert ADC.read_u16() die physikalische 12-Bit-Messung auf 16 Bit hochskaliert im Bereich 0–65535, und PWM.duty_u16() erwartet ebenfalls ein Tastverhältnis zwischen 0 und 65535. Da Python-Ganzzahlen beliebig groß sind, hast du das Überlaufproblem des Uno nicht. Beachten musst du, dass der Operator // immer Richtung minus unendlich rundet; das map() in C++ schneidet dagegen Richtung null ab, deshalb kann bei negativen Bereichen ein Unterschied von 1 zwischen beiden Sprachen auftreten. Willst du ein Ergebnis mit Nachkommastellen, nimm einfach / statt //. Im Code wird das Poti an GP26 gelesen, die LED an GP15 folgt der Helligkeit und der Servo an GP16 dem Winkel. Für die LED begrenzen wir den Eingang auf 500–65000, weil der ADC des Pico an den Enden selten genau 0 und 65535 erreicht. Beim Servo entsprechen bei 50 Hz PWM 0–180 Grad bei den meisten SG90 etwa einem Impuls von 500–2500 Mikrosekunden. Bist du neu beim Pico, starte mit Was ist der Raspberry Pi Pico? und den MicroPython-Grundlagen.

MicroPython
1from machine import ADC, Pin, PWM
2import time
3
4pot = ADC(26)                    # GP26 = ADC0
5led = PWM(Pin(15))               # LED GP15
6led.freq(1000)
7servo = PWM(Pin(16))             # servo sinyal GP16 / servo signal GP16
8servo.freq(50)                   # 50 Hz = 20 ms periyot / period
9
10def map_range(x, in_min, in_max, out_min, out_max):
11    # Arduino map() karsiligi (tamsayi) / Arduino map() equivalent (integer)
12    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
13
14def constrain(x, low, high):
15    # degeri sinirla / clamp the value
16    return max(low, min(x, high))
17
18while True:
19    raw = pot.read_u16()                                           # 0-65535
20    percent = map_range(raw, 0, 65535, 0, 100)                     # yuzde / percent
21    duty = map_range(constrain(raw, 500, 65000), 500, 65000, 0, 65535)
22    led.duty_u16(duty)                                             # LED parlakligi / LED brightness
23    angle = map_range(raw, 0, 65535, 0, 180)                       # derece / degrees
24    pulse_us = map_range(angle, 0, 180, 500, 2500)                 # darbe suresi / pulse width
25    servo.duty_ns(pulse_us * 1000)                                 # mikrosaniye -> nanosaniye / us -> ns
26    print(raw, percent, angle, pulse_us)
27    time.sleep_ms(50)

Projektideen mit map()

  • Pegelanzeige: Rechne den Wert von Poti oder Soundsensor mit map(x, 0, 1024, 0, 9) auf 0–8 um und zeige ihn auf einem Balken aus 8 LEDs an.
  • Joystick-gesteuertes Auto: Rechne die Joystick-Achse auf -255 bis 255 um und steuere mit dem L298N Richtung und Geschwindigkeit der Motoren.
  • Digitales Voltmeter: Rechne den Analogwert in Millivolt um und zeige ihn auf dem LCD an; Details im Beitrag Arduino Voltmeter bauen.
  • Bodenfeuchte in Prozent: Wandle die Kalibrierwerte (trocken und nass) des Bodenfeuchtesensors mit constrain() und map() in 0–100 Prozent um.
  • Instrument mit Licht: Rechne den LDR- oder Entfernungswert mit map() auf 200–2000 Hz um und gib ihn als Frequenz an tone().
  • LED-Lauflicht mit einstellbarer Geschwindigkeit: Rechne das Potentiometer mit map(x, 0, 1023, 50, 500) in eine Wartezeit in Millisekunden um.

Häufige Fehler und ihre Lösungen

SymptomUrsacheLösung
Ergebnis liegt außerhalb des Zielbereichsmap() begrenzt nichtEingang oder Ausgang mit constrain() begrenzen
Ergebnisse mit Nachkommastellen sind immer ganzzahligInteger-Division verwirft NachkommastellenmapFloat() schreiben oder Einheit verkleinern (mV statt V)
Der höchste Wert wird nie erreichtDer Maximalwert entsteht nur bei einem einzigen EingangMit map(x, 0, 1024, 0, max + 1) gleichmäßig verteilen
Unsinnige Ergebnisse bei großen ZahlenZwischenprodukt überschreitet die 32-Bit-long-GrenzeBereiche verkleinern oder mit float bzw. int64_t rechnen
Beim ESP32 erreicht der Wert viel zu früh die ObergrenzeCode ist für 0–1023 geschrieben, der ADC liefert 0–4095Eingangsbereich auf 0–4095 setzen
Richtung ist umgekehrtAusgangsgrenzen oder Sensoranschluss vertauschtUntere und obere Ausgangsgrenze tauschen
Ergebnis konstant und sinnlosin_min ist gleich in_max, also Division durch nullPrüfen, dass die Kalibriergrenzen verschieden sind
Schreibe die Kalibrierung nicht mit festen Zahlen, sondern miss sie zur Laufzeit: Lies in setup() einige Sekunden lang den Sensor, speichere den kleinsten und den größten Wert und verwende diese Variablen dann in map() und constrain(). Bleiben beide Werte gleich, greife auf Standardgrenzen zurück, um keine Division durch null zu erzeugen. So stellt sich derselbe Code auf verschiedene LDRs, Potentiometer und Umgebungen selbst ein. Die Hintergründe des Analogeinlesens findest du im Beitrag Was ist ein ADC?.

Die map()-Funktion ist der Übersetzer zwischen Sensorwelt und Ausgangswelt: Behalte die Integer-Division im Kopf, schütze die Grenzen mit constrain(), und wenn du die ADC-Auflösung deines Boards richtig angibst, funktioniert sie auf Uno, ESP32 und Pico nach derselben Logik. Die Grundlagen des Potentiometers kannst du im Beitrag Was ist ein Potentiometer? wiederholen. In der BlueGrays-App findest du Projekte mit map() wie ein LED-Lauflicht mit einstellbarer Geschwindigkeit, Lichtstärkemessung mit LDR, Servosteuerung per Potentiometer und PWM-Helligkeitsregelung mit dem ESP32, jeweils Schritt für Schritt mit Schaltplan und Code.

Häufige Fragen

Wofür ist die Arduino map() Funktion da?

map() rechnet eine Zahl aus einem Bereich proportional auf einen anderen Bereich um. Am häufigsten wird damit der Wert 0–1023 von analogRead() in 0–180 Grad für einen Servo oder in einen PWM-Wert 0–255 für analogWrite() umgewandelt. Sie braucht keine Bibliothek und ist im Arduino-Core enthalten.

Gibt map() Kommazahlen zurück?

Nein. map() arbeitet mit dem Typ long und verwirft bei der Division die Nachkommastellen; map(512, 0, 1023, 0, 5) ergibt zum Beispiel 2 statt 2,5. Brauchst du Nachkommastellen, schreibe mit derselben Formel eine mapFloat()-Funktion mit float-Parametern oder rechne das Ergebnis in einer kleineren Einheit wie Millivolt.

Was ist der Unterschied zwischen map() und constrain()?

map() rechnet einen Wert von einer Skala auf eine andere um, begrenzt ihn aber nicht; liegt der Eingang außerhalb, läuft auch der Ausgang darüber hinaus. constrain() ändert die Skala nicht, sondern presst den Wert nur zwischen eine untere und eine obere Grenze. Für sicheren Einsatz kombinierst du beide: map(constrain(x, 200, 900), 200, 900, 0, 255).

Wie stelle ich mit einem Potentiometer einen Servowinkel ein?

Schließe den mittleren Anschluss des Potentiometers an A0 und das Signalkabel des Servos an D9 an. Berechne in loop() den Winkel mit int winkel = map(analogRead(A0), 0, 1023, 0, 180); und sende ihn mit servo.write(winkel) an den Servo. Zittert der Servo, mittle mehrere Messungen oder ignoriere kleine Änderungen.

Funktioniert map() beim ESP32 anders?

Die Formel ist dieselbe, aber der ADC des ESP32 hat 12 Bit, deshalb liefert analogRead() 0–4095. Schreibe den Eingangsbereich daher als map(x, 0, 4095, 0, 255). Da der ESP32-ADC an den Enden nicht linear ist, liefert es bessere Ergebnisse, die tatsächlich kleinsten und größten Messwerte zu ermitteln und zu verwenden.

Gibt es in MicroPython ein Gegenstück zu Arduino map()?

Ein fertiges Gegenstück gibt es nicht; das map() von Python ist etwas anderes und wendet Funktionen auf Listen an. Du schreibst eine kurze Funktion mit der Formel (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min. Da read_u16() beim Pico 0–65535 liefert, ist der Eingangsbereich meist genau dieser.

Alle Projekte ansehen
LED-Lauflicht mit einstellbarer Geschwindigkeit
AR-7Mittel

LED-Lauflicht mit einstellbarer Geschwindigkeit

Sechs LEDs leuchten nacheinander auf, sodass das Licht von einem Ende zum anderen zu laufen scheint.

4.6(72)
148
Knight-Rider-Lauflicht mit einstellbarer Geschwindigkeit
AR-8Mittel

Knight-Rider-Lauflicht mit einstellbarer Geschwindigkeit

Ein Lichtpunkt läuft über sechs LEDs von einem Ende zum anderen, kehrt um und läuft wieder zurück.

4.5(60)
124
Lichtstärke messen mit LDR
AR-11Anfänger

Lichtstärke messen mit LDR

Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

4.6(83)
143
Servomotorbetrieb mit Potentiometer
AR-36Anfänger
Premium

Servomotorbetrieb mit Potentiometer

Während du am Knopf des Potentiometers drehst, dreht sich der Arm des Servomotors einfach mit: Das eine Ende des Knopfes bedeutet null Grad, das andere eine halbe Umdrehung.

4.6(37)
53
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32
ESP32-Servomotor (Steuerung über Potentiometer)
ES-16Mittel
Premium

ESP32-Servomotor (Steuerung über Potentiometer)

In diesem Projekt steuern wir einen SG90-Servomotor mit einem Potentiometer. Wir stellen den Servowinkel ein, indem wir den vom Potentiometer gelesenen Analogwert auf den Bereich von 0 bis 180 Grad abbilden. Die ESP32Servo-Bibliothek erzeugt Servosignale an geeigneten GPIO-Pins des ESP32, die als Ausgang verwendet werden können; in diesem Projekt wird GPIO 18 verwendet. Dies ist eine grundlegende Steuerungsmethode für Roboterarme, Kamera-Gimbals und automatische Türmechanismen.

4.3(29)
42
Servo-Steuerung mit Joystick
AR-60Mittel
Premium

Servo-Steuerung mit Joystick

Steuere zwei Motoren mit einem Joystick, genau wie beim Schwenken einer Überwachungskamera.

4.7(42)
58