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.

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.
| Parameter | Bedeutung | Beispiel Poti → Servo |
|---|---|---|
| value (x) | Der umzurechnende Wert | Ergebnis von analogRead(A0) |
| fromLow (in_min) | Untere Grenze des Eingangsbereichs | 0 |
| fromHigh (in_max) | Obere Grenze des Eingangsbereichs | 1023 |
| toLow (out_min) | Untere Grenze des Ausgangsbereichs | 0 |
| toHigh (out_max) | Obere Grenze des Ausgangsbereichs | 180 |
| Rückgabewert | Entsprechung 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.
| Ziel | Code | Hinweis |
|---|---|---|
| Potentiometer → Servowinkel | map(x, 0, 1023, 0, 180) | Für Servo.write() |
| Potentiometer → PWM | map(x, 0, 1023, 0, 255) | Für analogWrite(); x / 4 verteilt gleichmäßiger |
| Analogwert → Prozent | map(x, 0, 1023, 0, 100) | Zur Prozentanzeige auf dem Display |
| Joystick → Motorgeschwindigkeit und Richtung | map(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 → PWM | map(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 Anteil | map()-Ergebnis |
|---|---|---|
| 0 | 0,000 | 0 |
| 102 | 0,997 | 0 |
| 103 | 1,007 | 1 |
| 512 | 5,005 | 5 |
| 1022 | 9,990 | 9 |
| 1023 | 10,000 | 10 |
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:
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}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.
Anschlusstabelle: Arduino Uno, ESP32 und Pico
| Anschluss | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Äußere Poti-Anschlüsse | 5V und GND | 3V3 und GND | 3V3 und GND |
| Mittlerer Poti-Anschluss (Schleifer) | A0 | GPIO 34 | GP26 (ADC0) |
| Mittelpunkt LDR + 10-kΩ-Spannungsteiler | A1 | GPIO 35 | GP27 (ADC1) |
| LED (mit 220-Ω-Widerstand) | D6 (PWM) | GPIO 25 | GP15 |
| Servo-Signal (orangefarbenes Kabel) | D9 | GPIO 13 | GP16 |
| ADC-Lesebereich | 10 Bit (0–1023) | 12 Bit (0–4095) | read_u16(): 0–65535 |
Schritt für Schritt: Servowinkel mit dem Potentiometer einstellen
- Schließe die beiden äußeren Anschlüsse des 10-kΩ-Potentiometers an 5V und GND des Arduino an, den mittleren Anschluss an A0.
- Schließe das braune Kabel des SG90-Servos an GND, das rote an 5V und das orangefarbene Signalkabel an D9 an.
- Prüfe, ob die Servo-Bibliothek installiert ist; sie wird mit der Arduino IDE mitgeliefert, du musst nichts herunterladen.
- Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
- Drehe am Potentiometer und beobachte, wie sich Rohwert und Winkel gemeinsam ändern und der Servo zwischen 0 und 180 Grad dreht.
- Wenn der Servo an den Endpunkten brummt und sich abmüht, verengst du den map()-Ausgang auf einen kleineren Bereich wie 10–170.
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?.
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.
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.
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
| Symptom | Ursache | Lösung |
|---|---|---|
| Ergebnis liegt außerhalb des Zielbereichs | map() begrenzt nicht | Eingang oder Ausgang mit constrain() begrenzen |
| Ergebnisse mit Nachkommastellen sind immer ganzzahlig | Integer-Division verwirft Nachkommastellen | mapFloat() schreiben oder Einheit verkleinern (mV statt V) |
| Der höchste Wert wird nie erreicht | Der Maximalwert entsteht nur bei einem einzigen Eingang | Mit map(x, 0, 1024, 0, max + 1) gleichmäßig verteilen |
| Unsinnige Ergebnisse bei großen Zahlen | Zwischenprodukt überschreitet die 32-Bit-long-Grenze | Bereiche verkleinern oder mit float bzw. int64_t rechnen |
| Beim ESP32 erreicht der Wert viel zu früh die Obergrenze | Code ist für 0–1023 geschrieben, der ADC liefert 0–4095 | Eingangsbereich auf 0–4095 setzen |
| Richtung ist umgekehrt | Ausgangsgrenzen oder Sensoranschluss vertauscht | Untere und obere Ausgangsgrenze tauschen |
| Ergebnis konstant und sinnlos | in_min ist gleich in_max, also Division durch null | Prüfen, dass die Kalibriergrenzen verschieden sind |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED-Lauflicht mit einstellbarer Geschwindigkeit
Sechs LEDs leuchten nacheinander auf, sodass das Licht von einem Ende zum anderen zu laufen scheint.

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.

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…

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.

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.

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.

Servo-Steuerung mit Joystick
Steuere zwei Motoren mit einem Joystick, genau wie beim Schwenken einer Überwachungskamera.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

