Componenten · 8 min leestijd

Arduino Leonardo-toetsenbord en -muis: bouw een macropad (HID)

Arduino Leonardo-toetsenbordgids: ATmega32U4, Keyboard.h en Mouse.h, een macropad, een joystickmuis, uploaden met dubbele reset en waarom een Uno geen USB-HID kan zijn.

De Arduino Leonardo kan als toetsenbord en muis fungeren: sluit hem met een USB-kabel aan op een computer en hij wordt herkend als een echt toetsenbord. Er is geen driver nodig; Windows, macOS, Linux en zelfs tablets zien hem als een gewoon USB-toetsenbord of een gewone USB-muis. Zo bouw je een macropad dat je favoriete sneltoetsen, tekstfragmenten of gamecommando's met één toets verstuurt, een muis die met een joystick wordt bediend of een eigen invoerapparaat voor gebruikers met een beperking. De kleine Pro Micro, die dezelfde chip heeft als de Leonardo, kan precies hetzelfde.

In deze gids leer je over de ATmega32U4-chip die de Leonardo onderscheidt van de Uno, over de commando's van de bibliotheken Keyboard.h en Mouse.h, en bouw je stap voor stap een sneltoetsenpad met vier toetsen en een joystickmuis. Daarna lossen we het meest gevreesde probleem op, de poort die na een upload verdwijnt, met de dubbele-resetmethode. Ook leggen we uit waarom een Uno geen toetsenbord kan zijn en laten we zien hoe je hetzelfde doet met een Raspberry Pi Pico. Wil je het aansluiten van knoppen even opfrissen, lees dan Een knop aansluiten.

Arduino Leonardo-board
Arduino Leonardo: even groot als de Uno, maar zonder aparte USB-serieel-chip; USB gaat rechtstreeks naar de hoofdprocessor ATmega32U4.

Het verschil van de ATmega32U4: waarom kan de Leonardo een toetsenbord zijn?

Elk USB-apparaat stelt zich voor met een klasse: seriële poort (CDC), opslag, audio of HID (Human Interface Device). Toetsenborden en muizen zijn HID-apparaten. De ATmega32U4 op de Leonardo heeft USB-hardware ingebouwd, waardoor je programma bepaalt hoe de USB-poort zich presenteert. De Arduino-core presenteert de chip tegelijk als seriële poort, toetsenbord en muis; zodra je Keyboard.begin() aanroept, vindt de computer een nieuw toetsenbord. De ATmega328P van de Uno heeft geen USB-hardware, en de verschillen gaan verder dan USB:

EigenschapLeonardo / Pro Micro (ATmega32U4)Uno R3 / Nano (ATmega328P)
Ingebouwde USBJa, kan HID zijnNee, gebruikt een aparte USB-serieel-chip
Flashgeheugen32 KB (4 KB bootloader, 28 KB bruikbaar)32 KB (0,5 KB bootloader)
SRAM2,5 KB2 KB
Analoge ingangen12 (A0-A5 + 6 op digitale pinnen)6 (8 op de Nano)
I2C-pinnenD2 (SDA), D3 (SCL)A4 (SDA), A5 (SCL)
Seriële poortenSerial = USB, Serial1 = D0/D1Eén Serial, gedeeld door USB en D0/D1
Pinnen voor externe interruptsD0, D1, D2, D3, D7D2, D3

De I2C-rij in de tabel is een kleine maar belangrijke valkuil: een OLED- of LCD-voorbeeld dat voor de Uno is geschreven werkt niet op de Leonardo, omdat SDA en SCL op D2/D3 zitten in plaats van op A4/A5 (de SDA/SCL-header in de bovenhoek komt op beide boards op de juiste plek uit). Een ander verschil is de seriële poort: op de Leonardo is Serial de USB-verbinding zelf, terwijl de hardware-seriële poort op pin D0/D1 Serial1 heet. De volledige pinindeling zie je in de Pinout-tool.

Waarom kan een Arduino Uno geen toetsenbord (HID) zijn?

Op de Uno R3 gaat de USB-kabel niet naar de hoofdprocessor, maar naar de kleine ATmega16U2-chip naast de USB-aansluiting. Af fabriek draait deze chip alleen USB-naar-serieel-firmware; de computer ziet hem altijd als een seriële poort en je sketch kan dat niet veranderen. Daarom geeft #include <Keyboard.h> op een Uno een compileerfout: "'Keyboard' was not declared in this scope". In theorie kun je een Uno tot toetsenbord maken door de 16U2 in DFU-modus opnieuw te flashen, maar dan kan het board niet meer op de normale manier worden geprogrammeerd; dat raden we beginners af. De Nano, Mega en Pro Mini kunnen om dezelfde reden geen HID zijn, en Nano-klonen met een CH340- of FT232-chip hebben die optie helemaal niet.

BoardUSB-toetsenbord/-muis (HID)Opmerking
Leonardo, Micro, Pro MicroJaATmega32U4, met Keyboard.h en Mouse.h
Uno R4 Minima / WiFiJaIngebouwde USB van de Renesas RA4M1-chip
Raspberry Pi PicoJaArduino-Pico-core of het MicroPython-pakket usb-device
ESP32-S2 / ESP32-S3JaUSBHIDKeyboard via de ingebouwde USB
Klassieke ESP32Alleen BluetoothKan als BLE-toetsenbord fungeren, niet via USB
Uno R3, Nano, Mega, Pro MiniNeeUSB komt van een aparte chip, alleen seriële poort

Commando's van Keyboard.h en Mouse.h

CommandoWat het doet
Keyboard.begin()Start het toetsenbord; neemt optioneel een indeling zoals KeyboardLayout_de_DE
Keyboard.print("tekst") / println()Typt de tekst letter voor letter; println voegt aan het eind Enter toe
Keyboard.write(c)Drukt één toets in en laat hem weer los
Keyboard.press(k) / release(k)Houdt een toets ingedrukt of laat hem los; gebruikt voor sneltoetsen
Keyboard.releaseAll()Laat alle ingedrukte toetsen los
KEY_LEFT_CTRL, KEY_LEFT_SHIFT, KEY_LEFT_ALT, KEY_LEFT_GUICtrl, Shift, Alt en de Windows-/Cmd-toets
KEY_RETURN, KEY_TAB, KEY_ESC, KEY_F1...Enter, Tab, Esc, functietoetsen en pijltoetsen (KEY_UP_ARROW enzovoort)
Mouse.move(x, y, wheel)Beweegt de cursor relatief in stappen van -128 tot 127
Mouse.click() / press() / release()Muisknop MOUSE_LEFT, MOUSE_RIGHT of MOUSE_MIDDLE
Koppel toetsenbordcode altijd aan een knop of schakelaar. Als je Keyboard.print() onvoorwaardelijk in loop() uitvoert, stuurt het board honderden tekens per seconde; je verliest de controle over de computer, kunt zelfs niet meer typen in de Arduino IDE en nieuwe code uploaden wordt lastig. Juist daarom heeft de macrocode in dit artikel een veiligheidsschakelaar op ENABLE_PIN: zolang D9 niet met GND is verbonden, verstuurt het pad helemaal geen toetsen.

Eerste test: tekst typen als je op een knop drukt

Sluit één pootje van een knop aan op D4 en het andere op GND; de interne pull-upweerstand wordt gebruikt, dus je hebt geen andere onderdelen nodig. Kies bij het board Arduino Leonardo onder Tools > Board (dit werkt ook voor een Pro Micro van 5 V, 16 MHz). Open na het uploaden een teksteditor, zet de cursor erin en druk op de knop.

C++ (Arduino IDE)
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}
De Keyboard-bibliotheek verstuurt tekens niet volgens de indeling van de computer, maar volgens de toetspositie, standaard uitgaand van een US-indeling. Op een Duitse, Franse of Spaanse computer geeft Keyboard.print() daarom verkeerde tekens (bijvoorbeeld y en z omgewisseld op QWERTZ). De bibliotheek ondersteunt andere indelingen: schrijf Keyboard.begin(KeyboardLayout_de_DE), fr_FR, es_ES, it_IT, da_DK of sv_SE. Sneltoetsen zoals Ctrl+C werken op elke indeling.

Macropad: bouw je eigen sneltoetsenbord

Nu bouwen we een echt sneltoetsenbord met vier knoppen. Elke knop stuurt een toetscombinatie; de code reageert alleen op het moment van indrukken en filtert contactdender met een debounce-tijd van 30 ms. Vervang de knoppen door mechanische toetsenbordschakelaars en print een behuizing op een 3D-printer, en je hebt een echte "stream deck" op je bureau. Wil je meer toetsen, sluit dan een 4x4-keypad aan in plaats van vier knoppen en definieer 16 macro's.

PinAansluitingWindows / LinuxmacOS (MAC = true)
D4Knop 1, ander pootje naar GNDCtrl+C (kopiëren)Cmd+C
D5Knop 2, ander pootje naar GNDCtrl+V (plakken)Cmd+V
D6Knop 3, ander pootje naar GNDCtrl+Shift+T (tabblad heropenen)Cmd+Shift+T
D7Knop 4, ander pootje naar GNDWin+L (scherm vergrendelen)Ctrl+Cmd+Q
D9Schakelaar of jumperdraad naar GNDVeiligheid: werkt alleen als hij is aangeslotenIdem
C++ (Arduino IDE)
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}
  • Gebruik kleine letters voor lettertoetsen ('c', 'v'); met een hoofdletter drukt de bibliotheek ook Shift in en verstuurt hij een andere sneltoets, zoals Ctrl+Shift+C.
  • sendCombo() drukt de toetsen in volgorde in, wacht 30 ms en laat ze allemaal los met releaseAll(); deze pauze is nodig zodat sommige programma's de sneltoets opmerken.
  • Elke knop houdt zijn eigen debounce-tijd bij, dus twee knoppen bijna tegelijk indrukken is geen probleem. Waarom de timing millis() gebruikt en niet delay(), lees je in millis() vs delay().
  • Volume- en mediatoetsen maken geen deel uit van Keyboard.h; daarvoor heb je een bibliotheek met Consumer Control-ondersteuning nodig, zoals HID-Project.

Een USB-muis bouwen met een joystick

Analoge joystickmodule
Analoge joystick met twee assen: de uitgangen VRx en VRy geven 0-5 V, en de uitgang SW wordt naar GND getrokken als je op de stick drukt.

Sluit VCC van de joystickmodule aan op 5V, GND op GND, VRx op A0, VRy op A1 en SW op D8. Bij het opstarten slaat de code de rustwaarde op als midden, negeert een zone van ±40 eromheen (de dode zone) en zet de uitslag om in een beweging van maximaal 10 pixels per stap. Raak de joystick niet aan terwijl je het board aansluit, anders wordt het verkeerde midden opgeslagen. Meer over de werking en de waardebereiken van de joystick lees je in het artikel over de joystickmodule.

C++ (Arduino IDE)
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}

De poort is verdwenen: uploaden met een dubbele reset

Omdat je sketch op de Leonardo de USB aanstuurt, kan de computer de poort niet zien als de sketch crasht, vastloopt in een eindeloze lus of USB nooit start. Normaal opent en sluit de Arduino IDE de poort kort op 1200 baud als een upload begint; deze "touch" stuurt het board naar de bootloader en de code is binnen enkele seconden geüpload. Als de poort weg is, kan die touch niet plaatsvinden, maar je kunt de bootloader met de hand starten: na een reset wacht de bootloader ongeveer 8 seconden op nieuwe code. Daarom verandert het poortnummer tijdens uploads ook even.

  1. Open een sketch waarvan je weet dat hij werkt (bijvoorbeeld File > Examples > Basics > Blink) met Leonardo als geselecteerd board.
  2. Klik op Upload en wacht tot het compileren klaar is in de uitvoer hieronder.
  3. Zodra "Uploading..." verschijnt, druk je één keer op de resetknop van de Leonardo; raak op een Pro Micro zonder knop de RST-pin twee keer snel kort aan GND.
  4. Als de led van het board langzaam "ademt", zit hij in de bootloader; de IDE vindt de nieuwe poort en uploadt de code.
  5. Lukt het niet, probeer het dan opnieuw met andere timing; binnen een paar pogingen vang je het juiste moment.
De Pro Micro bestaat in twee versies: 5 V / 16 MHz en 3,3 V / 8 MHz. Als je "Arduino Leonardo" selecteert en uploadt naar een board van 8 MHz, wordt de klok verkeerd ingesteld, werkt USB nooit en verdwijnt de poort. Installeer voor dat board het boardpakket van SparkFun en kies de juiste versie, en red het board dan door met de dubbele-resetmethode hierboven correcte code te uploaden. De versie herken je aan de opdruk op het kristal of de spanningsregelaar.

Een USB-toetsenbordalternatief met de Raspberry Pi Pico

De RP2040-chip van de Raspberry Pi Pico heeft ook ingebouwde USB en kost minder dan een Leonardo. Als je in de Arduino IDE het pakket Raspberry Pi Pico/RP2040 van Earle Philhower gebruikt, werken dezelfde commando's van Keyboard.h en Mouse.h bijna ongewijzigd; je past alleen de pinnummers aan op de GP-pinnen. Heb je liever MicroPython, dan verandert het officiële pakket usb-device-keyboard de Pico vanaf versie 1.23 in een toetsenbord. Installeer het vanaf je computer op het board met mpremote mip install usb-device-keyboard. Als de code draait, meldt de Pico zijn USB opnieuw aan met een toetsenbord, waardoor de Thonny-verbinding wegvalt; dat is normaal. Ben je nieuw met de Pico, begin dan met Wat is de Raspberry Pi Pico?.

MicroPython
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 debounce

Projectideeën voor een Arduino Leonardo-toetsenbord

  • Ontwikkelaarstoetsenbord: koppel sneltoetsen van je editor, zoals build, run, regel uitcommentariëren en terminal openen, aan losse toetsen.
  • Vergaderpaneel: wijs de sneltoetsen voor microfoon dempen en camera uit toe aan grote verlichte knoppen.
  • Scrollknop: scroll door pagina's met een rotary encoder door Mouse.move(0, 0, step) te sturen, als een muiswiel.
  • Toegankelijke muis: klik met grote knoppen of een voetpedaal en beweeg de cursor met een joystick.
  • Presentatieafstandsbediening: een kleine afstandsbediening met twee knoppen die de pijltoetsen links en rechts verstuurt.
  • Gamebedieningspaneel: een cockpit vol schakelaars en knoppen voor vlieg- of racegames.

Veelgemaakte fouten en hoe je ze oplost

SymptoomOorzaakOplossing
'Keyboard' was not declared in this scopeUno, Nano of Mega geselecteerdGebruik een Leonardo, Micro of Pro Micro
Poort verdwenen na uploadDe sketch liep vast of crashte USBUpload een werkende sketch met een dubbele reset
Board blijft toetsen sturenOnvoorwaardelijke Keyboard.print() of een zwevende knoppinGebruik INPUT_PULLUP en een veiligheidsschakelaar
Er verschijnen verkeerde tekensToetsenbordindeling komt niet overeenKeyboard.begin(KeyboardLayout_xx_XX) of schakel over op de US-indeling
Code start pas als de Serial Monitor opentwhile (!Serial); in setup()Verwijder die regel of voeg een time-out toe
OLED uit een Uno-voorbeeld werkt nietAndere I2C-pinnenSluit SDA aan op D2 en SCL op D3
Pro Micro verschijnt nooitCode voor 16 MHz geüpload naar een board van 8 MHzKies het juiste board met het SparkFun-pakket, dubbele reset
Als code zich niet laat uploaden, ligt het probleem niet altijd bij de toetsenbordcode; loop ook de checklist in de gids Arduino uploadt niet door voor algemene oorzaken zoals de kabel, drivers en poortkeuze.

De Leonardo en Pro Micro zijn de makkelijkste manier om je eerste elektronische apparaat te bouwen dat met een computer praat: een paar knoppen, een beetje code en je hebt je eigen sneltoetsenbord. In de BlueGrays-app vind je de projecten Arduino-ontwikkelaarstoetsenbord en Python-ontwikkelaarstoetsenbord, naast projecten met knoppen, keypads en joysticks, elk met schakelschema's en code stap voor stap, klaar om te combineren met de HID-technieken uit dit artikel.

Veelgestelde vragen

Hoe gebruik ik een Arduino Leonardo als toetsenbord?

Voeg #include <Keyboard.h> toe aan je sketch en roep Keyboard.begin() aan in setup(). Daarna kun je tekst typen met Keyboard.print() en sneltoetsen zoals Ctrl+C versturen met Keyboard.press() en releaseAll(). Koppel de code altijd aan een knop, anders blijft het board non-stop toetsen sturen.

Kan een Arduino Uno als toetsenbord worden gebruikt?

Niet rechtstreeks, omdat de Uno R3 een aparte ATmega16U2-chip gebruikt die USB alleen als seriële poort presenteert. Die chip opnieuw flashen via DFU kan, maar is lastig. Voor toetsenbord- en muisprojecten zijn een Leonardo, Pro Micro, Uno R4 of Raspberry Pi Pico veel makkelijker.

Wat is het verschil tussen de Leonardo en de Pro Micro?

Beide gebruiken dezelfde ATmega32U4-chip en draaien dezelfde code. De Pro Micro is veel kleiner, heeft meestal geen resetknop en bestaat in twee versies: 5 V/16 MHz en 3,3 V/8 MHz. Voor de Pro Micro van 5 V kun je in de Arduino IDE Arduino Leonardo selecteren.

De poort van mijn Arduino Leonardo verschijnt niet. Wat moet ik doen?

Je sketch kan zijn vastgelopen of USB hebben laten crashen. Start het uploaden van een werkende sketch en druk op reset zodra de IDE "Uploading" toont; raak op een Pro Micro de RST-pin twee keer snel kort aan GND. Het board blijft een paar seconden in de bootloader en de code wordt geüpload.

Waarom typt mijn Leonardo verkeerde tekens?

De Keyboard-bibliotheek stuurt toetsen volgens hun positie op een US-indeling. Op een computer die op een andere indeling staat, zoals Duits QWERTZ of Frans AZERTY, komen sommige letters en symbolen verkeerd uit. Roep Keyboard.begin(KeyboardLayout_de_DE) of een andere ondersteunde indeling aan, of schakel de computer over op de US-indeling.

Kan een Raspberry Pi Pico een USB-toetsenbord zijn?

Ja. Dankzij de ingebouwde USB van de RP2040 werkt de Pico als toetsenbord met Keyboard.h en Mouse.h in de Arduino-Pico-core, of met het pakket usb-device-keyboard in MicroPython 1.23 en hoger. Hij is goedkoop en krachtig, dus een goede keuze voor macropads.

Alle projecten bekijken
Arduino-ontwikkaarstoetsenbord
AR-65Gemiddeld
Premium

Arduino-ontwikkaarstoetsenbord

Als je het zat bent om tijdens het programmeren steeds dezelfde regels te typen, wordt dit kleine keypad je sneltoetsenbord.

4.7(40)
52
Python-ontwikkelaarstoetsenbord
AR-66Gemiddeld
Premium

Python-ontwikkelaarstoetsenbord

Als je het zat bent om tijdens het programmeren steeds dezelfde patronen te typen, is dit kleine toetsenbord iets voor jou.

4.6(35)
45
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
LED schakelen met een knop (aan/uit)
AR-10Beginner

LED schakelen met een knop (aan/uit)

Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

4.7(103)
177
3x4-keypad gebruiken
AR-61Beginner

3x4-keypad gebruiken

De Arduino weet direct welke toets je indrukt op een keypad met 12 toetsen dat op het toetsenbord van een telefoon lijkt, en schrijft die op het scherm van je computer.

4.5(24)
32
4x4-keypad gebruiken
AR-63Beginner
Premium

4x4-keypad gebruiken

Op het 4x4-keypad, dat veel lijkt op de toetsen van een telefoon, weet de Arduino direct welke toets je indrukt en schrijft die op je computerscherm.

4.5(27)
35
Led bedienen met joystick
AR-59Gemiddeld
Premium

Led bedienen met joystick

Duw het stokje van de joystick helemaal in een richting en de led voor die richting gaat branden: er zijn vier kleuren voor rechts, links, omhoog en omlaag.

4.7(50)
67
Servo's bedienen met joystick
AR-60Gemiddeld
Premium

Servo's bedienen met joystick

Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.

4.7(42)
58