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.

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:
| Eigenschap | Leonardo / Pro Micro (ATmega32U4) | Uno R3 / Nano (ATmega328P) |
|---|---|---|
| Ingebouwde USB | Ja, kan HID zijn | Nee, gebruikt een aparte USB-serieel-chip |
| Flashgeheugen | 32 KB (4 KB bootloader, 28 KB bruikbaar) | 32 KB (0,5 KB bootloader) |
| SRAM | 2,5 KB | 2 KB |
| Analoge ingangen | 12 (A0-A5 + 6 op digitale pinnen) | 6 (8 op de Nano) |
| I2C-pinnen | D2 (SDA), D3 (SCL) | A4 (SDA), A5 (SCL) |
| Seriële poorten | Serial = USB, Serial1 = D0/D1 | Eén Serial, gedeeld door USB en D0/D1 |
| Pinnen voor externe interrupts | D0, D1, D2, D3, D7 | D2, 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.
| Board | USB-toetsenbord/-muis (HID) | Opmerking |
|---|---|---|
| Leonardo, Micro, Pro Micro | Ja | ATmega32U4, met Keyboard.h en Mouse.h |
| Uno R4 Minima / WiFi | Ja | Ingebouwde USB van de Renesas RA4M1-chip |
| Raspberry Pi Pico | Ja | Arduino-Pico-core of het MicroPython-pakket usb-device |
| ESP32-S2 / ESP32-S3 | Ja | USBHIDKeyboard via de ingebouwde USB |
| Klassieke ESP32 | Alleen Bluetooth | Kan als BLE-toetsenbord fungeren, niet via USB |
| Uno R3, Nano, Mega, Pro Mini | Nee | USB komt van een aparte chip, alleen seriële poort |
Commando's van Keyboard.h en Mouse.h
| Commando | Wat 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_GUI | Ctrl, 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 |
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.
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}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.
| Pin | Aansluiting | Windows / Linux | macOS (MAC = true) |
|---|---|---|---|
| D4 | Knop 1, ander pootje naar GND | Ctrl+C (kopiëren) | Cmd+C |
| D5 | Knop 2, ander pootje naar GND | Ctrl+V (plakken) | Cmd+V |
| D6 | Knop 3, ander pootje naar GND | Ctrl+Shift+T (tabblad heropenen) | Cmd+Shift+T |
| D7 | Knop 4, ander pootje naar GND | Win+L (scherm vergrendelen) | Ctrl+Cmd+Q |
| D9 | Schakelaar of jumperdraad naar GND | Veiligheid: werkt alleen als hij is aangesloten | Idem |
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

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.
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.
- Open een sketch waarvan je weet dat hij werkt (bijvoorbeeld File > Examples > Basics > Blink) met Leonardo als geselecteerd board.
- Klik op Upload en wacht tot het compileren klaar is in de uitvoer hieronder.
- 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.
- Als de led van het board langzaam "ademt", zit hij in de bootloader; de IDE vindt de nieuwe poort en uploadt de code.
- Lukt het niet, probeer het dan opnieuw met andere timing; binnen een paar pogingen vang je het juiste moment.
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?.
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 debounceProjectideeë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
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| 'Keyboard' was not declared in this scope | Uno, Nano of Mega geselecteerd | Gebruik een Leonardo, Micro of Pro Micro |
| Poort verdwenen na upload | De sketch liep vast of crashte USB | Upload een werkende sketch met een dubbele reset |
| Board blijft toetsen sturen | Onvoorwaardelijke Keyboard.print() of een zwevende knoppin | Gebruik INPUT_PULLUP en een veiligheidsschakelaar |
| Er verschijnen verkeerde tekens | Toetsenbordindeling komt niet overeen | Keyboard.begin(KeyboardLayout_xx_XX) of schakel over op de US-indeling |
| Code start pas als de Serial Monitor opent | while (!Serial); in setup() | Verwijder die regel of voeg een time-out toe |
| OLED uit een Uno-voorbeeld werkt niet | Andere I2C-pinnen | Sluit SDA aan op D2 en SCL op D3 |
| Pro Micro verschijnt nooit | Code voor 16 MHz geüpload naar een board van 8 MHz | Kies het juiste board met het SparkFun-pakket, dubbele reset |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
Arduino-ontwikkaarstoetsenbord
Als je het zat bent om tijdens het programmeren steeds dezelfde regels te typen, wordt dit kleine keypad je sneltoetsenbord.

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

LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

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.

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.

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.

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.

Servo's bedienen met joystick
Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

