Ratgeber · 8 Min. Lesezeit

ESP32 Servo steuern per Webserver: Slider auf dem Handy

ESP32 Servo per Webserver steuern: Bibliothek ESP32Servo, Web-Slider mit fetch, Pinwahl, Stromversorgung und gemeinsame Masse, Zittern vermeiden und Pan-Tilt.

Am meisten Spaß macht es, einen ESP32 Servo per Webserver zu steuern und dabei in Echtzeit mit einem Slider auf dem Handy zu drehen: Du schiebst den Finger, und der Servo folgt, ganz ohne App auf dem Telefon. In diesem Beitrag machen wir den ESP32 zum Webserver, schicken den Wert des Sliders von der Seite im Browser mit dem JavaScript-Befehl fetch an den ESP32 und fahren den Servo mit der Bibliothek ESP32Servo auf diesen Winkel.

Neben dem Code erklären wir ausführlich die Hardware, denn die meisten WLAN-Servo-Projekte scheitern nicht an der Software, sondern an der Stromversorgung: Der Servo zittert, der ESP32 startet neu oder die Verbindung bricht ab. Schritt für Schritt siehst du, welchen Pin du wählst, womit du den Servo versorgst, warum eine gemeinsame Masse Pflicht ist, wie du das Zittern verhinderst und zum Schluss, wie du eine Pan-Tilt-Mechanik mit zwei Servos aufbaust.

SG90 Mikroservo
SG90-Mikroservo: dreht von 0 bis 180 Grad, läuft mit 4,8–6 V und wird über die Impulsbreite eines 50-Hz-PWM-Signals positioniert.

So funktioniert es: vom Slider zum Servo

  1. Der Browser des Handys öffnet die IP-Adresse des ESP32, und der ESP32 schickt eine kleine HTML-Seite mit einem Slider zurück.
  2. Während du den Slider bewegst, schickt JavaScript auf der Seite den Winkel per fetch an eine Adresse wie /set?angle=120; die Seite lädt dabei nicht neu.
  3. Der Webserver auf dem ESP32 nimmt die Anfrage an, liest den Winkel und begrenzt ihn auf 0–180.
  4. Die Bibliothek ESP32Servo rechnet den Winkel in eine Impulsbreite um: etwa 500 µs für 0 Grad und 2400 µs für 180 Grad, 50-mal pro Sekunde gesendet.
  5. Die Steuerplatine im Servo liest den Impuls, fährt den Motor auf diesen Winkel und hält ihn dort.

Wie ein Servo funktioniert und wie Impulsbreite und Winkel zusammenhängen, haben wir in Was ist ein Servomotor? ausführlich erklärt. Wichtig ist hier: Die Standard-Servo-Bibliothek von Arduino läuft auf dem ESP32 nicht, weil der ESP32 PWM mit anderer Hardware (LEDC) erzeugt. Deshalb nutzen wir ESP32Servo; sie bietet dieselben Befehle attach() und write() und ist mit den ESP32-Cores 2.x und 3.x kompatibel.

Das brauchst du

  • Ein ESP32-Entwicklungsboard (DevKit, NodeMCU-32S oder ähnlich)
  • Einen SG90- oder MG90S-Servo (für die Pan-Tilt-Version zwei Stück und eine Pan-Tilt-Halterung)
  • Ein externes 5-V-Netzteil mit mindestens 2 A oder einen Batteriehalter für 4 AA-Zellen
  • Einen Elektrolytkondensator mit 470–1000 µF (mindestens 10 V)
  • Steckbrett und Jumperkabel
  • Das ESP32-Boardpaket in der Arduino IDE und die Bibliothek ESP32Servo aus dem Bibliotheksverwalter

Pinwahl: An welchen GPIO kommt der Servo?

Fast jeder Ausgangspin des ESP32 kann PWM erzeugen, aber nicht jeder eignet sich gleich gut für einen Servo. Manche Pins geben beim Booten kurze Signale aus, sodass der Servo bei jedem Einschalten zuckt; andere sind reine Eingänge. Die komplette Pinbelegung deines Boards findest du im Pinout-Tool:

PinsFür den ServoGrund
GPIO 13, 25, 26, 27, 32, 33EmpfohlenBeim Booten ruhig, jeder kann PWM (LEDC) ausgeben
GPIO 4, 16, 17, 18, 19, 21, 22, 23GeeignetSichere Allzweck-Pins; bei I2C (21, 22) oder SPI (18, 19, 23) diese freihalten
GPIO 2, 5, 12, 14, 15MeidenStrapping-Pins oder PWM beim Booten; der Servo kann zucken oder das Board startet nicht
GPIO 34–39Nicht nutzbarReine Eingänge, kein PWM-Ausgang möglich
GPIO 6–11Nicht nutzbarMit dem internen Flash verbunden
GPIO 1 und 3Nicht nutzbarUSB-Seriell-Leitung (TX, RX)

Servo-Stromversorgung und gemeinsame Masse

Ein SG90 zieht im Leerlauf etwa 10 mA, doch sobald er anläuft oder eine Last hält, springt der Strom auf 500–700 mA. Der ESP32 selbst zieht beim Senden über WLAN Spitzen von rund 250 mA. Versorgst du beide über dieselbe schwache USB-Leitung, bricht die Spannung ein und der ESP32 startet mit "Brownout detector was triggered" neu. Die Lösung: Den Servo aus einem eigenen 5-V-Netzteil versorgen und die Massen beider Schaltungen verbinden:

ServokabelAnschlussHinweis
Braun oder schwarz (GND)Minuspol des externen Netzteils und GND-Pin des ESP32Gemeinsame Masse ist Pflicht: Sie ist die Bezugsgröße des Signals
Rot (V+)Externes 5-V-Netzteil (4,8–6 V)Niemals an den 3V3-Pin des ESP32
Orange oder gelb (Signal)GPIO 13Ein 3,3-V-Signal reicht für SG90 und MG90S
Vergiss die gemeinsame Masse nicht. Das Servosignal ist eine Spannung, gemessen gegen die Masse des ESP32. Verbindest du den Minuspol des externen Netzteils nicht mit dem GND-Pin des ESP32, bewegt sich der Servo zufällig oder gar nicht. Und versorge den Servo niemals über den 3V3-Pin des ESP32: Der Spannungsregler des Boards schafft diesen Strom nicht, und der ESP32 startet ständig neu.
AufbauEmpfohlene QuelleHinweis
1 SG90, Test ohne Last5V-Pin (VIN) des ESP32-Boards, über USBNur für kurze Tests; zusammen mit WLAN sind Brownouts möglich
2 SG90 (Pan-Tilt)5-V-Netzteil, mindestens 2 AEinen Kondensator mit 470–1000 µF an die Versorgung setzen
1–2 MG996R5–6 V, mindestens 3 ADer Blockierstrom kann 2,5 A pro Servo erreichen
Mobiles Projekt4 AA-Batterien (Alkali, 6 V)NiMH-Akkus liefern 4,8 V, das reicht ebenfalls

Schritt 1: erster Test mit ESP32Servo

Bevor WLAN ins Spiel kommt, prüfst du, ob Servo und Versorgung richtig funktionieren. Such im Bibliotheksverwalter nach ESP32Servo, installiere die Bibliothek von Kevin Harrington und John K. Bennett und lade dann den Sketch unten hoch. Der Servo sollte langsam zwischen 0 und 180 Grad hin und her fahren; tut er das nicht, liegt das Problem an der Verdrahtung oder der Versorgung, nicht an der Software.

C++ (Arduino IDE)
1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 13;                  // açılışta sessiz, güvenli pin / quiet at boot, safe pin
4Servo servo;
5
6void setup() {
7  servo.setPeriodHertz(50);                // standart servo 50 Hz / standard servo, 50 Hz
8  servo.attach(SERVO_PIN, 500, 2400);      // 0° = 500 µs, 180° = 2400 µs (SG90)
9}
10
11void loop() {
12  for (int a = 0; a <= 180; a += 2) {      // 0 → 180°
13    servo.write(a);
14    delay(15);
15  }
16  for (int a = 180; a >= 0; a -= 2) {      // 180 → 0°
17    servo.write(a);
18    delay(15);
19  }
20}
Die beiden Zahlen in attach(pin, 500, 2400) sind die Impulsbreiten für 0 und 180 Grad in Mikrosekunden. Die meisten SG90-Klone arbeiten in diesem Bereich. Brummt der Servo an den Enden oder fährt gegen seinen Anschlag, verkleinere den Bereich (zum Beispiel 600 und 2300) oder halte den Winkel zwischen 5 und 175 Grad.

Schritt 2: Servo mit einem Slider auf der Webseite steuern

Jetzt zum eigentlichen Projekt. Der Sketch unten verbindet den ESP32 mit deinem Heimnetz, liefert eine Seite mit Slider und schreibt den Winkel, der an /set ankommt, in den Servo. Die HTML-Seite steckt als Raw-String direkt im Code, du musst also keine separate Datei hochladen. Trag WLAN-Name und Passwort ein, lade den Sketch hoch und öffne die im Seriellen Monitor angezeigte IP-Adresse im Browser deines Handys.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 13;
8
9WebServer server(80);
10Servo servo;
11int currentAngle = 90;                    // açılışta ortada / centred at start
12
13// Telefonda açılan sayfa / page opened on the phone
14const char PAGE[] PROGMEM = R"rawliteral(
15<!DOCTYPE html><html><head><meta charset="utf-8">
16<meta name="viewport" content="width=device-width,initial-scale=1">
17<title>ESP32 Servo</title>
18<style>
19body{font-family:sans-serif;text-align:center;margin-top:40px}
20input{width:85%;height:40px}
21#v{font-size:56px;font-weight:bold}
22</style></head><body>
23<h2>ESP32 Servo</h2>
24<p><span id="v">%ANGLE%</span>°</p>
25<input type="range" id="s" min="0" max="180" value="%ANGLE%">
26<script>
27const s = document.getElementById('s');
28const v = document.getElementById('v');
29let last = 0, timer = null;
30function send() {
31  fetch('/set?angle=' + s.value);          // açıyı gönder / send the angle
32  last = Date.now();
33}
34s.addEventListener('input', () => {
35  v.textContent = s.value;
36  clearTimeout(timer);
37  if (Date.now() - last > 100) send();     // en fazla 10 istek/sn / at most 10 requests/s
38  else timer = setTimeout(send, 100);      // son değer mutlaka gider / the last value always goes out
39});
40</script></body></html>
41)rawliteral";
42
43void handleRoot() {
44  String html = PAGE;
45  html.replace("%ANGLE%", String(currentAngle));   // slider doğru yerde başlar / slider starts at the right spot
46  server.send(200, "text/html", html);
47}
48
49void handleSet() {
50  if (!server.hasArg("angle")) {
51    server.send(400, "text/plain", "angle?");
52    return;
53  }
54  int angle = constrain(server.arg("angle").toInt(), 0, 180);   // güvenli aralık / safe range
55  if (angle != currentAngle) {             // aynı açıyı tekrar yazma / don't rewrite the same angle
56    servo.write(angle);
57    currentAngle = angle;
58  }
59  server.send(200, "text/plain", String(currentAngle));
60}
61
62void setup() {
63  Serial.begin(115200);
64  servo.setPeriodHertz(50);
65  servo.attach(SERVO_PIN, 500, 2400);
66  servo.write(currentAngle);
67
68  WiFi.mode(WIFI_STA);
69  WiFi.begin(WIFI_SSID, WIFI_PASS);
70  while (WiFi.status() != WL_CONNECTED) {  // bağlanana kadar bekle / wait until connected
71    delay(500);
72    Serial.print(".");
73  }
74  Serial.println();
75  Serial.print("IP: ");
76  Serial.println(WiFi.localIP());          // bu adresi telefonda aç / open this address on your phone
77
78  server.on("/", handleRoot);
79  server.on("/set", handleSet);
80  server.begin();
81}
82
83void loop() {
84  server.handleClient();
85}

Zwei Stellen im Code sind entscheidend. Erstens schickt das JavaScript nicht bei jeder Bewegung des Sliders eine Anfrage: Es wartet mindestens 100 ms zwischen zwei Anfragen und sendet den letzten Wert immer, wenn du den Finger hebst. Ein Slider kann 60 Ereignisse pro Sekunde erzeugen; alle zu senden verstopft den Webserver des ESP32 und lässt den Servo ruckeln. Zweitens begrenzt constrain() auf der Serverseite den Winkel auf 0–180, sodass der Servo selbst dann nicht überlastet wird, wenn jemand einen falschen Wert in die Adresszeile tippt.

Bei jedem Aufruf der Seite wird der Platzhalter %ANGLE% durch den aktuellen Winkel des Servos ersetzt, deshalb startet der Slider auch nach dem Schließen und erneuten Öffnen des Browsers an der richtigen Stelle. Mehrere Handys können sich gleichzeitig verbinden; es gilt der zuletzt gesendete Winkel. Willst du eine Live-Oberfläche, die sich auf allen Handys sofort aktualisiert, wechsle zum Ansatz aus ESP32 Async Webserver und WebSocket.

Kein Router? Dann baut der ESP32 sein eigenes WLAN auf

Nutzt du das Projekt auf einer Messe, im Garten oder irgendwo ohne Heimnetz, lass den ESP32 im Access-Point-Modus (AP) laufen. Ersetze in setup() die Zeilen WiFi.mode und WiFi.begin sowie die Schleife, die auf die Verbindung wartet, durch die folgenden Zeilen; dann verbindest du das Handy mit dem Netz ESP32-Servo und öffnest 192.168.4.1 im Browser:

C++ (Arduino IDE)
1// Router yoksa: ESP32 kendi ağını kurar / No router: the ESP32 creates its own network
2WiFi.softAP("ESP32-Servo", "12345678");    // şifre en az 8 karakter / password, at least 8 characters
3Serial.print("IP: ");
4Serial.println(WiFi.softAPIP());           // genellikle 192.168.4.1 / usually 192.168.4.1

Servo-Zittern verhindern

  • Eigene Versorgung und gemeinsame Masse: Ursache Nummer eins für Zittern ist eine schwache Versorgung; nimm ein 5-V-Netzteil mit mindestens 2 A und verbinde die Massen.
  • Kondensator: Setz einen Elko mit 470–1000 µF nahe am Servo an seine Versorgungsleitungen; er glättet den Spannungseinbruch beim Anlaufen. Die Aufdrucke auf Kondensatoren entschlüsselst du mit dem Kondensator-Code-Tool.
  • Anfragen begrenzen: Schick nicht jedes Slider-Ereignis; die 100-ms-Grenze im Code entlastet Netzwerk und Servo.
  • Denselben Winkel nicht erneut schreiben: Die Abfrage if (angle != currentAngle) im Code verhindert unnötige Schreibvorgänge.
  • Richtiger Impulsbereich: Brummt der Servo an den Enden, drückt er gegen seinen Anschlag; verkleinere den attach()-Bereich oder die Winkelgrenzen.
  • Kurze Signalleitung: Bei Kabeln über 30 cm führst du Signal und GND nebeneinander, am besten verdrillt.
  • Letzter Ausweg detach(): Rufst du nach Erreichen der Position detach() auf, verschwindet das Signal und damit das Zittern, der Servo hält die Last dann aber nicht mehr.

Bleibt das Problem, schau in Servo zittert: Ursachen und Lösungen, wo wir alle Ursachen mit Messungen erklären. Läuft dein Projekt mit Batterien, schätzt du die Laufzeit vorab mit dem Akkulaufzeit-Rechner ab.

Schritt 3: Pan-Tilt-Version mit zwei Servos

Eine Pan-Tilt-Mechanik besteht aus zwei Servos: Der untere dreht waagerecht (Pan), der obere senkrecht (Tilt). Mit einer Kamera, einem Laser oder einem Ultraschallsensor obendrauf bekommst du ein Auge, das du aus der Ferne ausrichtest. Schließ den Pan-Servo an GPIO 13 und den Tilt-Servo an GPIO 27 an und versorge beide aus demselben externen 5-V-Netzteil. Diese Version bringt zwei Neuerungen: Die Seite hat zwei Slider, und die Servos springen nicht schlagartig auf den neuen Winkel, sondern fahren alle 10 ms um ein Grad weiter, bis sie ihn erreichen. Das macht die Bewegung flüssiger und verhindert, dass beide Servos im selben Moment viel Strom ziehen.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
7const int PAN_PIN = 13;                   // yatay servo / pan servo
8const int TILT_PIN = 27;                  // dikey servo / tilt servo
9
10WebServer server(80);
11Servo pan, tilt;
12int panTarget = 90, tiltTarget = 90;      // hedef açılar / target angles
13int panNow = 90, tiltNow = 90;            // anlık açılar / current angles
14unsigned long lastStep = 0;
15
16const char PAGE[] PROGMEM = R"rawliteral(
17<!DOCTYPE html><html><head><meta charset="utf-8">
18<meta name="viewport" content="width=device-width,initial-scale=1">
19<title>ESP32 Pan-Tilt</title>
20<style>body{font-family:sans-serif;text-align:center}input{width:85%;height:40px}</style>
21</head><body>
22<h2>ESP32 Pan-Tilt</h2>
23<p>Pan: <b id="pv">%PAN%</b>°</p>
24<input type="range" id="pan" min="0" max="180" value="%PAN%">
25<p>Tilt: <b id="tv">%TILT%</b>°</p>
26<input type="range" id="tilt" min="20" max="160" value="%TILT%">
27<script>
28const pan = document.getElementById('pan');
29const tilt = document.getElementById('tilt');
30let last = 0, timer = null;
31function send() {
32  fetch('/set?pan=' + pan.value + '&tilt=' + tilt.value);   // iki açı tek istekte / both angles in one request
33  last = Date.now();
34}
35function changed() {
36  document.getElementById('pv').textContent = pan.value;
37  document.getElementById('tv').textContent = tilt.value;
38  clearTimeout(timer);
39  if (Date.now() - last > 100) send();
40  else timer = setTimeout(send, 100);
41}
42pan.addEventListener('input', changed);
43tilt.addEventListener('input', changed);
44</script></body></html>
45)rawliteral";
46
47void handleRoot() {
48  String html = PAGE;
49  html.replace("%PAN%", String(panTarget));
50  html.replace("%TILT%", String(tiltTarget));
51  server.send(200, "text/html", html);
52}
53
54void handleSet() {
55  if (server.hasArg("pan"))  panTarget  = constrain(server.arg("pan").toInt(), 0, 180);
56  if (server.hasArg("tilt")) tiltTarget = constrain(server.arg("tilt").toInt(), 20, 160);   // braket sınırı / bracket limit
57  server.send(200, "text/plain", "OK");
58}
59
60// Her 10 ms'de hedefe 1 derece yaklaş: yumuşak hareket, düşük akım
61// Step 1 degree toward the target every 10 ms: smooth motion, lower current peaks
62void moveSmoothly() {
63  if (millis() - lastStep < 10) return;
64  lastStep = millis();
65  if (panNow != panTarget) {
66    panNow += (panTarget > panNow) ? 1 : -1;
67    pan.write(panNow);
68  }
69  if (tiltNow != tiltTarget) {
70    tiltNow += (tiltTarget > tiltNow) ? 1 : -1;
71    tilt.write(tiltNow);
72  }
73}
74
75void setup() {
76  Serial.begin(115200);
77  pan.setPeriodHertz(50);
78  tilt.setPeriodHertz(50);
79  pan.attach(PAN_PIN, 500, 2400);
80  tilt.attach(TILT_PIN, 500, 2400);
81  pan.write(panNow);
82  tilt.write(tiltNow);
83
84  WiFi.mode(WIFI_STA);
85  WiFi.begin(WIFI_SSID, WIFI_PASS);
86  while (WiFi.status() != WL_CONNECTED) {
87    delay(500);
88    Serial.print(".");
89  }
90  Serial.println();
91  Serial.print("IP: ");
92  Serial.println(WiFi.localIP());
93
94  server.on("/", handleRoot);
95  server.on("/set", handleSet);
96  server.begin();
97}
98
99void loop() {
100  server.handleClient();                   // istekleri işle / handle requests
101  moveSmoothly();                          // servoları hedefe taşı / move the servos toward their targets
102}

Die Tilt-Achse ist auf 20–160 Grad begrenzt, weil bei den meisten Pan-Tilt-Halterungen aus Kunststoff der obere Servo an den Enden gegen das Gehäuse stößt. Fahr den Servo an deinem Aufbau langsam an die Enden, notiere den Winkel kurz vor dem Anstoßen und passe damit sowohl min und max des Sliders als auch die constrain()-Grenzen im Code an. Brauchst du mehr Servos, macht ein 16-Kanal-PCA9685-Servotreiber statt der ESP32-Pins Verdrahtung und Versorgung viel einfacher.

Häufige Fehler und ihre Lösung

  • Der Servo bewegt sich überhaupt nicht: Die Massen sind nicht verbunden, der Servo hängt an 3V3, oder das Signalkabel steckt an einem der reinen Eingänge GPIO 34–39.
  • Der ESP32 startet neu, wenn sich der Servo bewegt: Die Versorgung reicht nicht; versorge den Servo aus einem eigenen 5-V-Netzteil und ergänze einen Kondensator.
  • Fehler "This library only supports boards with an AVR...": Die Servo-Bibliothek von Arduino unterstützt den ESP32 nicht; nimm #include <ESP32Servo.h>.
  • Die Seite öffnet sich nicht: Handy und ESP32 sind nicht im selben Netz, das Handy ist auf mobile Daten gewechselt, oder das Netz funkt mit 5 GHz; der ESP32 verbindet sich nur mit 2,4-GHz-Netzen. Bei anderen Verbindungsproblemen hilft ESP32 verbindet sich nicht mit dem WLAN.
  • Der Servo folgt dem Slider verzögert: Es stauen sich zu viele Anfragen; behalte die 100-ms-Grenze im JavaScript bei oder erhöhe sie auf 150 ms.
  • Der Servo zuckt bei jedem Einschalten: Das Signal hängt an einem Pin, der beim Booten PWM ausgibt (GPIO 2, 5, 12, 14, 15); leg es auf GPIO 13, 25–27 oder 32–33 um.

Einen Servo per Slider vom Handy aus zu steuern, ist die Grundlage vieler Projekte: Roboterarme, ausrichtbare Kameras, smarte Türschlösser und Klappen, die sich aus der Ferne öffnen. Willst du einen kräftigeren Servo einsetzen, rechne die Versorgung mit MG996R-Servomotor durch. In der BlueGrays App findest du die Servosteuerung per Potentiometer am ESP32, das RFID-Türschloss mit Servo und die ESP32-Webserver-Projekte Schritt für Schritt mit Schaltplan und Code.

Häufige Fragen

Wie steuert man einen Servomotor mit dem ESP32?

Installiere die Bibliothek ESP32Servo, schließ das Signalkabel des Servos an einen sicheren Pin wie GPIO 13 an, starte ihn mit servo.attach(13, 500, 2400) und nutze dann servo.write(Winkel). Versorge den Servo aus einem externen 5-V-Netzteil statt aus dem ESP32 und verbinde die Massen.

Warum funktioniert Servo.h nicht auf dem ESP32?

Die Standard-Servo-Bibliothek von Arduino ist für Prozessoren wie AVR und SAMD geschrieben und kennt die PWM-Hardware des ESP32 (LEDC) nicht. Die Bibliothek ESP32Servo bietet dieselben Befehle und läuft auf den ESP32-Cores 2.x und 3.x.

Reicht das 3,3-V-Signal des ESP32 für einen Servo?

Die meisten gängigen Servos wie SG90, MG90S und MG996R erkennen ein 3,3-V-Signal problemlos. Das Problem liegt fast immer bei der Versorgung, nicht beim Signal: Das rote Kabel des Servos gehört an eine 5–6-V-Quelle, die genug Strom liefert.

Wie viele Servos kann ein ESP32 ansteuern?

Die LEDC-Einheit des klassischen ESP32 hat 16 PWM-Kanäle, theoretisch steuerst du also bis zu 16 Servos. In der Praxis gehen vorher die geeigneten Pins oder die Stromversorgung aus; ab mehr als vier Servos ist ein PCA9685-Treiberboard per I2C die sauberere Lösung.

Kann ich einen Servo mit dem ESP32 ohne Router steuern?

Ja. Im Access-Point-Modus mit WiFi.softAP() baut der ESP32 sein eigenes WLAN auf. Du verbindest das Handy mit diesem Netz, öffnest 192.168.4.1 im Browser und nutzt dieselbe Slider-Seite.

Warum zittert mein Servo am ESP32?

Die häufigsten Ursachen sind eine zu schwache Versorgung, eine fehlende gemeinsame Masse und zu viele Befehle pro Sekunde. Versorge den Servo aus einem eigenen 5-V-Netzteil, setz einen Kondensator mit 470–1000 µF dazu und begrenze die Anfragen der Webseite auf eine alle 100 ms.

Alle Projekte ansehen
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
ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)
ES-35Fortgeschritten
Premium

ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)

Wir bauen ein smartes Türschloss mit ESP32, RFID-Modul RC522, Servo SG90, SSD1306-OLED, aktivem Summer und 2 LEDs. Die UID einer gescannten Karte wird mit den im Code hinterlegten Karten verglichen; passt sie, öffnet der Servo das Schloss (grüne LED + 2 kurze Pieptöne) und verriegelt nach 5 Sekunden wieder. Bei einer fremden Karte leuchtet die rote LED, es piept 3-mal schnell und das OLED zeigt die UID.

4.8(9)
16
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
ES-28Fortgeschritten
Premium

ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)

In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

4.5(14)
23
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

ESP32-WLAN-STA-Verbindung (mit LCD-Display)

In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

4.4(21)
38
ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
ES-29Fortgeschritten
Premium

ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)

Wir ergänzen den ESP32 um einen mDNS-Dienst (Multicast DNS), damit du ihn statt über eine IP-Adresse unter einem lesbaren Hostnamen wie bluegrays-esp.local erreichst. Auch wenn sich die per DHCP vergebene IP ändert, bleibt der Name gleich. Ein kleiner Webserver auf dem Board lässt dich die LED im Browser unter http://bluegrays-esp.local/ steuern.

4.8(14)
23
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