Arduino Leonardo als Tastatur und Maus: Makro-Keypad mit HID
Arduino Leonardo als Tastatur: ATmega32U4, Keyboard.h und Mouse.h, Makro-Keypad, Joystick-Maus, Doppel-Reset-Upload und warum der Uno kein USB-HID sein kann.
Der Arduino Leonardo kann als Tastatur und Maus arbeiten: Steckst du ihn per USB an einen Computer, wird er wie eine echte Tastatur erkannt. Ein Treiber ist nicht nötig; Windows, macOS, Linux und sogar Tablets sehen ihn als gewöhnliche USB-Tastatur oder -Maus. So baust du ein Makro-Keypad, das deine häufigsten Tastenkürzel, Textbausteine oder Spielbefehle auf Knopfdruck sendet, eine Maus mit Joystick oder ein eigenes Eingabegerät für Menschen mit Einschränkungen. Der kleine Pro Micro mit demselben Chip wie der Leonardo kann genau dasselbe.
In dieser Anleitung lernst du den Chip ATmega32U4 kennen, der den Leonardo vom Uno unterscheidet, sowie die Befehle der Bibliotheken Keyboard.h und Mouse.h, und baust Schritt für Schritt ein Shortcut-Keypad mit vier Tasten und eine Joystick-Maus. Danach lösen wir das gefürchtetste Problem, den verschwundenen Port nach dem Hochladen, mit der Doppel-Reset-Methode, erklären, warum ein Uno keine Tastatur sein kann, und zeigen dasselbe mit dem Raspberry Pi Pico. Wie man Taster anschließt, kannst du in Taster richtig anschließen nachlesen.

Der ATmega32U4-Unterschied: Warum kann der Leonardo Tastatur sein?
Jedes USB-Gerät meldet sich mit einer Klasse an: serielle Schnittstelle (CDC), Speicher, Audio oder HID (Human Interface Device). Tastaturen und Mäuse gehören zur HID-Klasse. Der ATmega32U4 im Leonardo hat USB-Hardware eingebaut, dein Programm bestimmt also selbst, wie sich der USB-Anschluss zeigt. Der Arduino-Core meldet den Chip gleichzeitig als serielle Schnittstelle sowie als Tastatur und Maus; rufst du Keyboard.begin() auf, findet der Computer eine neue Tastatur. Der ATmega328P im Uno hat keine USB-Hardware, und die Unterschiede gehen über USB hinaus:
| Merkmal | Leonardo / Pro Micro (ATmega32U4) | Uno R3 / Nano (ATmega328P) |
|---|---|---|
| Eingebautes USB | Ja, kann HID sein | Nein, nutzt einen separaten USB-Seriell-Chip |
| Flash-Speicher | 32 KB (4 KB Bootloader, 28 KB nutzbar) | 32 KB (0,5 KB Bootloader) |
| SRAM | 2,5 KB | 2 KB |
| Analoge Eingänge | 12 (A0-A5 + 6 auf Digitalpins) | 6 (beim Nano 8) |
| I2C-Pins | D2 (SDA), D3 (SCL) | A4 (SDA), A5 (SCL) |
| Serielle Schnittstellen | Serial = USB, Serial1 = D0/D1 | Eine Serial, USB und D0/D1 teilen sie |
| Externe Interrupt-Pins | D0, D1, D2, D3, D7 | D2, D3 |
Die I2C-Zeile in der Tabelle ist eine kleine, aber wichtige Falle: Ein für den Uno geschriebenes OLED- oder LCD-Beispiel läuft auf dem Leonardo nicht, weil SDA und SCL auf D2/D3 statt auf A4/A5 liegen (die SDA/SCL-Pins in der oberen Ecke führen auf beiden Boards an die richtige Stelle). Ein weiterer Unterschied ist die serielle Schnittstelle: Beim Leonardo ist Serial die USB-Verbindung selbst, die Hardware-Schnittstelle an D0/D1 heißt Serial1. Die komplette Pinbelegung siehst du im Pinout-Tool.
Warum kann ein Arduino Uno keine Tastatur (HID) sein?
Beim Uno R3 führt das USB-Kabel nicht zum Hauptprozessor, sondern zum kleinen ATmega16U2 neben der USB-Buchse. Ab Werk läuft auf diesem Chip nur eine USB-Seriell-Firmware; der Computer sieht ihn immer als serielle Schnittstelle, und dein Sketch kann das nicht ändern. Deshalb gibt #include <Keyboard.h> auf dem Uno einen Kompilierfehler: "'Keyboard' was not declared in this scope". Theoretisch lässt sich der Uno durch Neuflashen des 16U2 im DFU-Modus zur Tastatur machen, dann ist das Board aber nicht mehr normal programmierbar; für Einsteiger nicht empfehlenswert. Nano, Mega und Pro Mini können aus demselben Grund kein HID sein, und Nano-Klone mit CH340- oder FT232-Chip haben diese Option gar nicht.
| Board | USB-Tastatur/-Maus (HID) | Hinweis |
|---|---|---|
| Leonardo, Micro, Pro Micro | Ja | ATmega32U4, mit Keyboard.h und Mouse.h |
| Uno R4 Minima / WiFi | Ja | Eingebautes USB des Renesas RA4M1 |
| Raspberry Pi Pico | Ja | Arduino-Pico-Core oder MicroPython-Paket usb-device |
| ESP32-S2 / ESP32-S3 | Ja | USBHIDKeyboard über das eingebaute USB |
| Klassischer ESP32 | Nur Bluetooth | Kann BLE-Tastatur sein, nicht über USB |
| Uno R3, Nano, Mega, Pro Mini | Nein | USB über separaten Chip, nur serielle Schnittstelle |
Befehle von Keyboard.h und Mouse.h
| Befehl | Was er macht |
|---|---|
| Keyboard.begin() | Startet die Tastatur; optional mit Layout wie KeyboardLayout_de_DE |
| Keyboard.print("Text") / println() | Tippt den Text Zeichen für Zeichen; println hängt Enter an |
| Keyboard.write(c) | Drückt eine einzelne Taste und lässt sie los |
| Keyboard.press(k) / release(k) | Hält eine Taste gedrückt oder lässt sie los; für Tastenkürzel |
| Keyboard.releaseAll() | Lässt alle gedrückten Tasten los |
| KEY_LEFT_CTRL, KEY_LEFT_SHIFT, KEY_LEFT_ALT, KEY_LEFT_GUI | Strg, Umschalt, Alt und Windows-/Cmd-Taste |
| KEY_RETURN, KEY_TAB, KEY_ESC, KEY_F1... | Enter, Tab, Esc, Funktions- und Pfeiltasten (KEY_UP_ARROW usw.) |
| Mouse.move(x, y, rad) | Bewegt den Zeiger relativ in Schritten von -128 bis 127 |
| Mouse.click() / press() / release() | Taste MOUSE_LEFT, MOUSE_RIGHT oder MOUSE_MIDDLE |
Erster Test: Text tippen, wenn ein Taster gedrückt wird
Schließe ein Bein eines Tasters an D4 und das andere an GND an; der interne Pull-up-Widerstand wird genutzt, weitere Bauteile brauchst du nicht. Wähle unter Werkzeuge > Board den Arduino Leonardo (das funktioniert auch für einen Pro Micro mit 5 V und 16 MHz). Öffne nach dem Hochladen einen Texteditor, setze den Cursor hinein und drücke den Taster.
1// Leonardo: butona basınca yazı yaz / type text when the button is pressed
2#include <Keyboard.h>
3
4const int BUTTON_PIN = 4; // buton diğer ucu GND / other leg of the button to GND
5
6void setup() {
7 pinMode(BUTTON_PIN, INPUT_PULLUP);
8 Keyboard.begin(); // ya da Keyboard.begin(KeyboardLayout_de_DE) / or pick a layout
9}
10
11void loop() {
12 if (digitalRead(BUTTON_PIN) == LOW) {
13 Keyboard.println("Hello BlueGrays"); // yaz ve Enter'a bas / type and press Enter
14 delay(50);
15 while (digitalRead(BUTTON_PIN) == LOW) {} // bırakılmasını bekle / wait for release
16 delay(50);
17 }
18}Makro-Keypad: deine eigene Shortcut-Tastatur
Jetzt bauen wir ein echtes Shortcut-Keypad mit vier Tasten. Jede Taste sendet eine Tastenkombination; der Code reagiert nur im Moment des Drückens und filtert das Prellen mit einer Entprellzeit von 30 ms. Tauschst du die Taster gegen mechanische Tastaturschalter und druckst ein Gehäuse im 3D-Drucker, steht ein echtes "Stream Deck" auf deinem Schreibtisch. Brauchst du mehr Tasten, schließe statt vier Tastern ein 4x4-Keypad an und lege 16 Makros fest.
| Pin | Anschluss | Windows / Linux | macOS (MAC = true) |
|---|---|---|---|
| D4 | Taster 1, anderes Bein an GND | Strg+C (kopieren) | Cmd+C |
| D5 | Taster 2, anderes Bein an GND | Strg+V (einfügen) | Cmd+V |
| D6 | Taster 3, anderes Bein an GND | Strg+Umschalt+T (Tab wiederherstellen) | Cmd+Shift+T |
| D7 | Taster 4, anderes Bein an GND | Win+L (Bildschirm sperren) | Ctrl+Cmd+Q |
| D9 | Schalter oder Drahtbrücke nach GND | Sicherheit: aktiv nur wenn verbunden | Gleich |
1// Leonardo / Pro Micro makro tuş takımı / macro keypad
2#include <Keyboard.h>
3
4const bool MAC = false; // macOS için true / true for macOS
5const int ENABLE_PIN = 9; // GND'ye bağlıyken çalışır / works only when tied to GND
6const int KEY_PINS[4] = {4, 5, 6, 7}; // butonlar, diğer uç GND / buttons, other leg to GND
7const unsigned long DEBOUNCE_MS = 30;
8
9int lastState[4] = {HIGH, HIGH, HIGH, HIGH};
10unsigned long lastChange[4] = {0, 0, 0, 0};
11
12void sendCombo(uint8_t k1, uint8_t k2 = 0, uint8_t k3 = 0) {
13 Keyboard.press(k1); // tuşlara sırayla bas / press the keys in order
14 if (k2) Keyboard.press(k2);
15 if (k3) Keyboard.press(k3);
16 delay(30);
17 Keyboard.releaseAll(); // hepsini bırak / release them all
18}
19
20void runMacro(int i) {
21 const uint8_t MOD = MAC ? KEY_LEFT_GUI : KEY_LEFT_CTRL; // Cmd ya da Ctrl / Cmd or Ctrl
22 switch (i) {
23 case 0: sendCombo(MOD, 'c'); break; // kopyala / copy
24 case 1: sendCombo(MOD, 'v'); break; // yapıştır / paste
25 case 2: sendCombo(MOD, KEY_LEFT_SHIFT, 't'); break; // kapanan sekmeyi aç / reopen closed tab
26 case 3: // ekranı kilitle / lock the screen
27 if (MAC) sendCombo(KEY_LEFT_CTRL, KEY_LEFT_GUI, 'q');
28 else sendCombo(KEY_LEFT_GUI, 'l');
29 break;
30 }
31}
32
33void setup() {
34 pinMode(ENABLE_PIN, INPUT_PULLUP);
35 for (int i = 0; i < 4; i++) pinMode(KEY_PINS[i], INPUT_PULLUP);
36 Keyboard.begin();
37}
38
39void loop() {
40 bool enabled = digitalRead(ENABLE_PIN) == LOW; // güvenlik anahtarı / safety switch
41 for (int i = 0; i < 4; i++) {
42 int s = digitalRead(KEY_PINS[i]);
43 if (s != lastState[i] && millis() - lastChange[i] > DEBOUNCE_MS) {
44 lastChange[i] = millis();
45 lastState[i] = s;
46 if (s == LOW && enabled) runMacro(i); // yalnız basış anında / only on press
47 }
48 }
49}- Verwende für Buchstabentasten Kleinbuchstaben ('c', 'v'); bei einem Großbuchstaben drückt die Bibliothek zusätzlich Umschalt, und es kommt ein anderes Kürzel wie Strg+Umschalt+C an.
- sendCombo() drückt die Tasten nacheinander, wartet 30 ms und lässt alle mit releaseAll() los; die Pause brauchen manche Programme, um das Kürzel zu erkennen.
- Jeder Taster hat seine eigene Entprellzeit, zwei fast gleichzeitige Tastendrücke sind also kein Problem. Warum das Timing mit millis() statt delay() läuft, erklärt millis() oder delay().
- Lautstärke- und Medientasten gehören nicht zu Keyboard.h; dafür brauchst du eine Bibliothek mit Consumer-Control-Unterstützung wie HID-Project.
Eine USB-Maus mit Joystick bauen

Verbinde VCC des Joystick-Moduls mit 5V, GND mit GND, VRx mit A0, VRy mit A1 und SW mit D8. Beim Start speichert der Code die Ruhestellung als Mitte, ignoriert eine Zone von ±40 darum herum (Totzone) und wandelt die Auslenkung in eine Bewegung von höchstens 10 Pixeln pro Schritt um. Fass den Joystick beim Einstecken nicht an, sonst wird eine falsche Mitte gespeichert. Zum Aufbau des Joysticks und seinen Wertebereichen siehe den Artikel zum Joystick-Modul.
1// Leonardo: joystick ile fare / joystick mouse
2#include <Mouse.h>
3
4const int X_PIN = A0; // joystick VRx
5const int Y_PIN = A1; // joystick VRy
6const int SW_PIN = 8; // joystick SW (basınca GND / pulls to GND when pressed)
7const int DEADZONE = 40; // merkezdeki titreşimi yok say / ignore jitter around the centre
8const int MAX_SPEED = 10; // adım başına en fazla piksel / max pixels per step
9
10int centerX, centerY;
11
12int axis(int raw, int center) {
13 int d = raw - center;
14 if (abs(d) < DEADZONE) return 0;
15 return map(d, -512, 512, -MAX_SPEED, MAX_SPEED);
16}
17
18void setup() {
19 pinMode(SW_PIN, INPUT_PULLUP);
20 centerX = analogRead(X_PIN); // açılışta merkez ölçümü, joystick'e dokunma / centre calibration, don't touch
21 centerY = analogRead(Y_PIN);
22 Mouse.begin();
23}
24
25void loop() {
26 int dx = axis(analogRead(X_PIN), centerX);
27 int dy = axis(analogRead(Y_PIN), centerY); // ters ise -axis(...) yaz / use -axis(...) if inverted
28 if (dx != 0 || dy != 0) Mouse.move(dx, dy, 0);
29
30 if (digitalRead(SW_PIN) == LOW) {
31 if (!Mouse.isPressed(MOUSE_LEFT)) Mouse.press(MOUSE_LEFT); // sol tık basılı / left button down
32 } else if (Mouse.isPressed(MOUSE_LEFT)) {
33 Mouse.release(MOUSE_LEFT); // bırak / release
34 }
35 delay(10); // saniyede yaklaşık 100 güncelleme / about 100 updates per second
36}Port verschwunden: Hochladen per Doppel-Reset
Weil beim Leonardo dein Sketch das USB steuert, sieht der Computer keinen Port, wenn der Sketch abstürzt, in einer Endlosschleife hängt oder USB nie startet. Normalerweise öffnet und schließt die Arduino IDE zu Beginn des Uploads kurz den Port mit 1200 Baud; diese "Berührung" schickt das Board in den Bootloader, und der Code ist in Sekunden oben. Ist der Port weg, geht das nicht, aber du kannst den Bootloader per Hand starten: Nach einem Reset wartet er etwa 8 Sekunden auf neuen Code. Deshalb wechselt beim Hochladen auch kurz die Portnummer.
- Öffne einen funktionierenden Sketch (zum Beispiel Datei > Beispiele > Basics > Blink) mit Leonardo als Board.
- Klicke auf Hochladen und warte in der Ausgabe unten, bis das Kompilieren fertig ist.
- Sobald "Hochladen..." erscheint, drücke einmal den Reset-Taster des Leonardo; beim Pro Micro ohne Taster tippst du RST zweimal schnell hintereinander an GND.
- "Atmet" die LED des Boards langsam, ist es im Bootloader; die IDE findet den neuen Port und lädt den Code hoch.
- Klappt es nicht, versuch es mit anderem Timing erneut; nach ein paar Versuchen triffst du den richtigen Moment.
Alternative: USB-Tastatur mit dem Raspberry Pi Pico
Auch der RP2040 des Raspberry Pi Pico hat eingebautes USB und ist günstiger als ein Leonardo. Nutzt du in der Arduino IDE das Paket Raspberry Pi Pico/RP2040 von Earle Philhower, laufen dieselben Befehle aus Keyboard.h und Mouse.h fast unverändert; du passt nur die Pinnummern an die GP-Pins an. Magst du MicroPython, machst du den Pico ab Version 1.23 mit dem offiziellen Paket usb-device-keyboard zur Tastatur. Installiere es vom Computer aus mit mpremote mip install usb-device-keyboard auf dem Board. Läuft der Code, meldet sich der Pico per USB neu als Tastatur an, deshalb bricht die Thonny-Verbindung ab; das ist normal. Ist der Pico neu für dich, beginne mit Was ist der Raspberry Pi Pico?.
1# Raspberry Pi Pico: MicroPython USB makro klavye / USB macro keyboard
2# Önce / first: mpremote mip install usb-device-keyboard (MicroPython 1.23+)
3import time
4import usb.device
5from usb.device.keyboard import KeyboardInterface, KeyCode
6from machine import Pin
7
8MACROS = (
9 (Pin(2, Pin.IN, Pin.PULL_UP), (KeyCode.LEFT_CTRL, KeyCode.C)), # kopyala / copy
10 (Pin(3, Pin.IN, Pin.PULL_UP), (KeyCode.LEFT_CTRL, KeyCode.V)), # yapıştır / paste
11 (Pin(4, Pin.IN, Pin.PULL_UP), (KeyCode.LEFT_UI, KeyCode.L)), # Windows: ekranı kilitle / lock screen
12)
13
14kb = KeyboardInterface()
15usb.device.get().init(kb, builtin_driver=True) # USB'yi klavyeyle yeniden tanıt / re-enumerate with a keyboard
16
17
18def tap(keys):
19 kb.send_keys(keys) # tuşlara bas / press the keys
20 time.sleep_ms(20)
21 kb.send_keys(()) # hepsini bırak / release all
22
23
24last = [1] * len(MACROS)
25while True:
26 if kb.is_open():
27 for i, (pin, keys) in enumerate(MACROS):
28 v = pin.value()
29 if v == 0 and last[i] == 1: # basış anı / moment of press
30 tap(keys)
31 last[i] = v
32 time.sleep_ms(10) # basit debounce / simple debounceProjektideen mit dem Arduino Leonardo als Tastatur
- Entwickler-Tastatur: Editor-Kürzel wie Kompilieren, Ausführen, Zeile auskommentieren und Terminal öffnen auf je eine Taste legen.
- Meeting-Panel: Kürzel für Mikrofon stumm und Kamera aus auf große, beleuchtete Taster legen.
- Scroll-Drehknopf: Mit einem Drehencoder scrollen, indem du wie ein Mausrad Mouse.move(0, 0, schritt) sendest.
- Barrierefreie Maus: Klicken über große Taster oder ein Fußpedal, Zeigersteuerung per Joystick.
- Präsentations-Fernbedienung: Eine kleine Fernbedienung mit zwei Tasten, die die Pfeiltasten links und rechts sendet.
- Spiele-Bedienfeld: Ein Cockpit voller Schalter und Knöpfe für Flug- oder Rennspiele.
Häufige Fehler und Lösungen
| Symptom | Ursache | Lösung |
|---|---|---|
| 'Keyboard' was not declared in this scope | Uno, Nano oder Mega gewählt | Leonardo, Micro oder Pro Micro verwenden |
| Port nach dem Hochladen verschwunden | Sketch hat USB blockiert oder ist abgestürzt | Per Doppel-Reset einen funktionierenden Sketch laden |
| Board sendet ständig Tasten | Bedingungsloses Keyboard.print() oder offener Tasterpin | INPUT_PULLUP und Sicherheitsschalter nutzen |
| Falsche Zeichen erscheinen | Unterschiedliches Tastaturlayout | Keyboard.begin(KeyboardLayout_de_DE) |
| Code startet erst mit offenem seriellen Monitor | while (!Serial); in setup() | Zeile entfernen oder Zeitlimit einbauen |
| OLED aus einem Uno-Beispiel geht nicht | Andere I2C-Pins | SDA an D2 und SCL an D3 anschließen |
| Pro Micro taucht nie auf | 16-MHz-Code auf ein 8-MHz-Board geladen | Mit SparkFun-Paket richtiges Board wählen, Doppel-Reset |
Leonardo und Pro Micro sind der einfachste Weg zu deinem ersten Elektronikgerät, das mit dem Computer spricht: ein paar Taster, etwas Code, und du hast deine eigene Shortcut-Tastatur. In der BlueGrays-App findest du die Projekte Arduino-Entwicklertastatur und Python-Entwicklertastatur sowie Projekte mit Tastern, Keypad und Joystick, jeweils mit Schaltplan und Code Schritt für Schritt, die du mit den HID-Techniken aus diesem Artikel kombinieren kannst.
Häufige Fragen
Wie benutze ich einen Arduino Leonardo als Tastatur?
Füge #include <Keyboard.h> in deinen Sketch ein und rufe in setup() Keyboard.begin() auf. Danach tippst du mit Keyboard.print() Text und sendest mit Keyboard.press() und releaseAll() Kürzel wie Strg+C. Binde den Code immer an einen Taster, sonst sendet das Board ununterbrochen Tasten.
Kann ein Arduino Uno als Tastatur verwendet werden?
Nicht direkt, denn der Uno R3 nutzt einen separaten ATmega16U2, der USB nur als serielle Schnittstelle anbietet. Diesen Chip per DFU neu zu flashen ist möglich, aber umständlich. Für Tastatur- und Mausprojekte sind Leonardo, Pro Micro, Uno R4 oder Raspberry Pi Pico deutlich einfacher.
Was ist der Unterschied zwischen Leonardo und Pro Micro?
Beide nutzen denselben ATmega32U4 und führen denselben Code aus. Der Pro Micro ist viel kleiner, hat meist keinen Reset-Taster und existiert in zwei Versionen: 5 V/16 MHz und 3,3 V/8 MHz. Für den 5-V-Pro-Micro kannst du in der Arduino IDE Arduino Leonardo wählen.
Mein Arduino Leonardo wird nicht mehr erkannt. Was tun?
Dein Sketch hat USB vermutlich blockiert oder ist abgestürzt. Starte das Hochladen eines funktionierenden Sketches und drücke Reset, sobald die IDE "Hochladen" anzeigt; beim Pro Micro tippst du RST zweimal schnell an GND. Das Board bleibt einige Sekunden im Bootloader, und der Code wird übertragen.
Warum tippt mein Leonardo falsche Zeichen, z. B. y statt z?
Die Keyboard-Bibliothek sendet Tasten nach ihrer Position auf einem US-Layout. Auf einem deutschen Rechner mit QWERTZ sind deshalb y und z vertauscht, und Sonderzeichen stimmen nicht. Rufe Keyboard.begin(KeyboardLayout_de_DE) auf, dann passt die Ausgabe zum deutschen Layout.
Kann ein Raspberry Pi Pico eine USB-Tastatur sein?
Ja. Dank des eingebauten USB des RP2040 arbeitet der Pico mit Keyboard.h und Mouse.h im Arduino-Pico-Core oder mit dem Paket usb-device-keyboard ab MicroPython 1.23 als Tastatur. Er ist günstig und leistungsstark und damit gut für Makro-Keypads geeignet.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Arduino Software Entwickler Tastatur
Hast du keine Lust mehr, beim Programmieren immer wieder dieselben Zeilen zu tippen? Dann wird dieses kleine Tastenfeld deine Kürzel-Tastatur.

Python-Entwickler-Tastatur
Wenn du es leid bist, beim Programmieren immer wieder dieselben Muster zu tippen, ist diese kleine Tastatur genau das Richtige.

LED mit Taster schalten (Push)
Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

LED mit Taster ein- und ausschalten
Einmal drücken und das Licht geht an, noch einmal drücken und es geht aus, genau wie der Lichtschalter in deinem Zimmer.

3x4-Tastenfeld verwenden
Der Arduino erkennt sofort, welche Taste du auf einem 12-Tasten-Feld drückst, das wie eine Telefontastatur aussieht, und schreibt sie auf deinen Computerbildschirm.

4x4-Tastenfeld verwenden
Auf dem 4x4-Tastenfeld, das an die Tasten eines Telefons erinnert, erkennt der Arduino sofort, welche Taste du gedrückt hast, und schreibt sie auf deinen Computerbildschirm.

Led-Steuerung mit Joystick
Drück den kleinen Hebel des Joysticks ganz in eine Richtung, und die LED für diese Richtung leuchtet: Für rechts, links, oben und unten gibt es vier verschiedene Farben.

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

