Arduino Leonardo come tastiera e mouse: tastierino macro HID
Arduino Leonardo come tastiera: ATmega32U4, Keyboard.h e Mouse.h, tastierino macro, mouse con joystick, doppio reset e perché l'Uno non può fare HID.
L'Arduino Leonardo può funzionare come tastiera e mouse: collegato al computer con un cavo USB viene riconosciuto come una vera tastiera. Non servono driver; Windows, macOS, Linux e perfino i tablet lo vedono come una normale tastiera o un mouse USB. Così puoi costruire un tastierino macro che invia le tue scorciatoie preferite, frammenti di testo o comandi di gioco con un solo tasto, un mouse comandato da joystick o un dispositivo di input su misura per persone con disabilità. Il piccolo Pro Micro, che usa lo stesso chip del Leonardo, fa esattamente la stessa cosa.
In questa guida conoscerai il chip ATmega32U4 che distingue il Leonardo dall'Uno e i comandi delle librerie Keyboard.h e Mouse.h, e costruirai passo passo un tastierino di scorciatoie a quattro tasti e un mouse con joystick. Poi risolveremo il problema più temuto, la porta che sparisce dopo il caricamento, con il metodo del doppio reset, spiegheremo perché un Uno non può fare da tastiera e vedremo come fare lo stesso con un Raspberry Pi Pico. Per un ripasso sul collegamento dei pulsanti, leggi Come collegare un pulsante.

La differenza dell'ATmega32U4: perché il Leonardo può fare da tastiera?
Ogni dispositivo USB si presenta con una classe: porta seriale (CDC), archiviazione, audio o HID (Human Interface Device). Tastiere e mouse sono dispositivi HID. L'ATmega32U4 del Leonardo ha l'hardware USB integrato, quindi è il tuo programma a decidere come si presenta la porta USB. Il core Arduino presenta il chip contemporaneamente come porta seriale, tastiera e mouse; quando chiami Keyboard.begin(), il computer trova una nuova tastiera. L'ATmega328P dell'Uno non ha hardware USB, e le differenze non finiscono qui:
| Caratteristica | Leonardo / Pro Micro (ATmega32U4) | Uno R3 / Nano (ATmega328P) |
|---|---|---|
| USB integrato | Sì, può essere HID | No, usa un chip USB-seriale separato |
| Memoria flash | 32 KB (4 KB di bootloader, 28 KB utilizzabili) | 32 KB (0,5 KB di bootloader) |
| SRAM | 2,5 KB | 2 KB |
| Ingressi analogici | 12 (A0-A5 + 6 su pin digitali) | 6 (8 sul Nano) |
| Pin I2C | D2 (SDA), D3 (SCL) | A4 (SDA), A5 (SCL) |
| Porte seriali | Serial = USB, Serial1 = D0/D1 | Un solo Serial, condiviso tra USB e D0/D1 |
| Pin di interrupt esterno | D0, D1, D2, D3, D7 | D2, D3 |
La riga dell'I2C nella tabella è una trappola piccola ma importante: un esempio OLED o LCD scritto per l'Uno non funziona sul Leonardo, perché SDA e SCL sono su D2/D3 e non su A4/A5 (il connettore SDA/SCL nell'angolo in alto porta al punto giusto su entrambe le schede). Un'altra differenza è la porta seriale: sul Leonardo Serial è la connessione USB stessa, mentre la seriale hardware dei pin D0/D1 si chiama Serial1. Puoi vedere la piedinatura completa nello strumento Pinout.
Perché un Arduino Uno non può essere una tastiera (HID)?
Sull'Uno R3 il cavo USB non arriva al processore principale ma al piccolo chip ATmega16U2 vicino alla presa USB. Di fabbrica questo chip esegue solo un firmware di conversione USB-seriale; il computer lo vede sempre come porta seriale e il tuo sketch non può cambiarlo. Per questo scrivere #include <Keyboard.h> su un Uno dà un errore di compilazione "'Keyboard' was not declared in this scope". In teoria si può trasformare un Uno in tastiera riprogrammando il 16U2 in modalità DFU, ma poi la scheda non si programma più nel modo normale; non è consigliato ai principianti. Nano, Mega e Pro Mini non possono fare HID per lo stesso motivo, e i cloni di Nano con chip CH340 o FT232 non hanno nemmeno questa possibilità.
| Scheda | Tastiera/mouse USB (HID) | Nota |
|---|---|---|
| Leonardo, Micro, Pro Micro | Sì | ATmega32U4, con Keyboard.h e Mouse.h |
| Uno R4 Minima / WiFi | Sì | USB integrato del chip Renesas RA4M1 |
| Raspberry Pi Pico | Sì | Core Arduino-Pico o pacchetto usb-device di MicroPython |
| ESP32-S2 / ESP32-S3 | Sì | USBHIDKeyboard tramite l'USB integrato |
| ESP32 classico | Solo Bluetooth | Può fare da tastiera BLE, non via USB |
| Uno R3, Nano, Mega, Pro Mini | No | L'USB passa da un chip separato, solo porta seriale |
Comandi di Keyboard.h e Mouse.h
| Comando | Cosa fa |
|---|---|
| Keyboard.begin() | Avvia la tastiera; accetta come opzione un layout come KeyboardLayout_it_IT |
| Keyboard.print("testo") / println() | Scrive il testo lettera per lettera; println aggiunge Invio alla fine |
| Keyboard.write(c) | Preme e rilascia un solo tasto |
| Keyboard.press(k) / release(k) | Tiene premuto o rilascia un tasto; serve per le scorciatoie |
| Keyboard.releaseAll() | Rilascia tutti i tasti premuti |
| KEY_LEFT_CTRL, KEY_LEFT_SHIFT, KEY_LEFT_ALT, KEY_LEFT_GUI | Ctrl, Maiusc, Alt e il tasto Windows/Cmd |
| KEY_RETURN, KEY_TAB, KEY_ESC, KEY_F1... | Invio, Tab, Esc, tasti funzione e frecce (KEY_UP_ARROW ecc.) |
| Mouse.move(x, y, rotella) | Sposta il cursore in modo relativo a passi da -128 a 127 |
| Mouse.click() / press() / release() | Pulsante MOUSE_LEFT, MOUSE_RIGHT o MOUSE_MIDDLE |
Prima prova: scrivere testo alla pressione di un pulsante
Collega un piedino di un pulsante a D4 e l'altro a GND; si usa la resistenza di pull-up interna, quindi non servono altri componenti. Come scheda scegli Arduino Leonardo in Strumenti > Scheda (vale anche per un Pro Micro da 5 V e 16 MHz). Dopo il caricamento apri un editor di testo, metti il cursore al suo interno e premi il pulsante.
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}Tastierino macro: costruisci la tua tastiera di scorciatoie
Ora costruiamo un vero tastierino di scorciatoie a quattro pulsanti. Ogni pulsante invia una combinazione di tasti; il codice reagisce solo al momento della pressione e filtra i rimbalzi con un debounce di 30 ms. Sostituisci i pulsanti con switch da tastiera meccanica, stampa una scatola in 3D e avrai un vero "stream deck" sulla scrivania. Se vuoi più tasti, collega un tastierino 4x4 al posto dei quattro pulsanti e definisci 16 macro.
| Pin | Collegamento | Windows / Linux | macOS (MAC = true) |
|---|---|---|---|
| D4 | Pulsante 1, altro piedino a GND | Ctrl+C (copia) | Cmd+C |
| D5 | Pulsante 2, altro piedino a GND | Ctrl+V (incolla) | Cmd+V |
| D6 | Pulsante 3, altro piedino a GND | Ctrl+Maiusc+T (riapri scheda) | Cmd+Maiusc+T |
| D7 | Pulsante 4, altro piedino a GND | Win+L (blocca schermo) | Ctrl+Cmd+Q |
| D9 | Interruttore o ponticello a GND | Sicurezza: funziona solo se collegato | Uguale |
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}- Usa lettere minuscole per i tasti lettera ('c', 'v'); con una maiuscola la libreria preme anche Maiusc e invia un'altra scorciatoia, come Ctrl+Maiusc+C.
- sendCombo() preme i tasti in ordine, aspetta 30 ms e li rilascia tutti con releaseAll(); questa pausa serve perché alcuni programmi riconoscano la scorciatoia.
- Ogni pulsante tiene il proprio tempo di debounce, quindi premerne due quasi insieme non crea problemi. Perché la temporizzazione usa millis() e non delay() lo trovi in millis() e delay() a confronto.
- I tasti volume e multimediali non fanno parte di Keyboard.h; servono librerie con supporto Consumer Control, come HID-Project.
Costruire un mouse USB con un joystick

Collega il VCC del modulo joystick a 5V, GND a GND, VRx ad A0, VRy ad A1 e SW a D8. All'avvio il codice memorizza il valore a riposo come centro, ignora una zona di ±40 attorno (zona morta) e trasforma lo scostamento in un movimento di al massimo 10 pixel per passo. Non toccare il joystick mentre colleghi la scheda, altrimenti viene salvato un centro sbagliato. Per la struttura interna del joystick e i suoi intervalli, leggi l'articolo sul modulo joystick.
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}La porta è sparita: caricare con il doppio reset
Poiché sul Leonardo l'USB è gestito dal tuo sketch, se lo sketch si blocca, resta in un ciclo infinito o non avvia mai l'USB, il computer non vede la porta. Normalmente l'Arduino IDE apre e chiude brevemente la porta a 1200 baud all'inizio del caricamento; questo "tocco" porta la scheda nel bootloader e il codice viene caricato in pochi secondi. Quando la porta è sparita il tocco non è possibile, ma puoi avviare il bootloader a mano: dopo un reset il bootloader aspetta circa 8 secondi nuovo codice. È anche il motivo per cui il numero di porta cambia per un attimo durante il caricamento.
- Apri uno sketch funzionante (per esempio File > Esempi > Basics > Blink) con Leonardo come scheda.
- Fai clic su Carica e aspetta che finisca la compilazione nell'output in basso.
- Appena compare "Caricamento...", premi una volta il pulsante di reset del Leonardo; su un Pro Micro senza pulsante tocca due volte in rapida successione il pin RST con GND.
- Se il LED della scheda "respira" lentamente, è nel bootloader; l'IDE trova la nuova porta e carica il codice.
- Se non funziona, riprova con un tempismo diverso; in pochi tentativi troverai il momento giusto.
Alternativa: tastiera USB con il Raspberry Pi Pico
Anche il chip RP2040 del Raspberry Pi Pico ha l'USB integrato e costa meno di un Leonardo. Se nell'Arduino IDE usi il pacchetto Raspberry Pi Pico/RP2040 di Earle Philhower, gli stessi comandi di Keyboard.h e Mouse.h funzionano quasi invariati; devi solo adattare i numeri dei pin ai pin GP. Se preferisci MicroPython, dalla versione 1.23 il pacchetto ufficiale usb-device-keyboard trasforma il Pico in una tastiera. Installalo sulla scheda dal computer con mpremote mip install usb-device-keyboard. Quando il codice parte, il Pico si ripresenta via USB come tastiera e la connessione di Thonny si interrompe; è normale. Se il Pico è nuovo per te, comincia da Che cos'è il 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 debounceIdee di progetti con l'Arduino Leonardo come tastiera
- Tastiera da programmatore: assegna a un solo tasto scorciatoie dell'editor come compila, esegui, commenta riga e apri terminale.
- Pannello per riunioni: metti le scorciatoie per silenziare il microfono e spegnere la videocamera su grandi pulsanti illuminati.
- Manopola di scorrimento: scorri le pagine con un encoder rotativo inviando Mouse.move(0, 0, passo) come una rotella del mouse.
- Mouse accessibile: clic con grandi pulsanti o un pedale e cursore controllato da joystick.
- Telecomando per presentazioni: un piccolo telecomando a due pulsanti che invia le frecce sinistra e destra.
- Pannello di controllo per giochi: un cockpit pieno di interruttori e pulsanti per giochi di volo o di corse.
Errori comuni e soluzioni
| Sintomo | Causa | Soluzione |
|---|---|---|
| 'Keyboard' was not declared in this scope | Selezionato Uno, Nano o Mega | Usa un Leonardo, un Micro o un Pro Micro |
| La porta è sparita dopo il caricamento | Lo sketch ha bloccato o mandato in crash l'USB | Carica uno sketch funzionante con il doppio reset |
| La scheda invia tasti di continuo | Keyboard.print() senza condizioni o pin del pulsante flottante | Usa INPUT_PULLUP e un interruttore di sicurezza |
| Compaiono caratteri sbagliati | Layout di tastiera diverso | Keyboard.begin(KeyboardLayout_it_IT) |
| Il codice parte solo aprendo il Monitor seriale | while (!Serial); in setup() | Togli la riga o aggiungi un timeout |
| L'OLED di un esempio per Uno non funziona | Pin I2C diversi | Collega SDA a D2 e SCL a D3 |
| Il Pro Micro non compare mai | Codice a 16 MHz caricato su una scheda a 8 MHz | Scegli la scheda giusta con il pacchetto SparkFun e fai il doppio reset |
Leonardo e Pro Micro sono il modo più semplice per costruire il tuo primo dispositivo elettronico che parla con il computer: qualche pulsante, un po' di codice e hai la tua tastiera di scorciatoie. Nell'app BlueGrays trovi i progetti Tastiera da programmatore con Arduino e Tastiera da programmatore con Python, oltre a progetti con pulsanti, tastierino e joystick, ognuno con schema e codice passo passo, da combinare con le tecniche HID di questo articolo.
Domande frequenti
Come si usa un Arduino Leonardo come tastiera?
Aggiungi #include <Keyboard.h> allo sketch e chiama Keyboard.begin() in setup(). Poi puoi scrivere testo con Keyboard.print() e inviare scorciatoie come Ctrl+C con Keyboard.press() e releaseAll(). Collega sempre il codice a un pulsante, altrimenti la scheda invia tasti senza sosta.
Si può usare un Arduino Uno come tastiera?
Non direttamente, perché l'Uno R3 usa un chip ATmega16U2 separato che presenta l'USB solo come porta seriale. Riprogrammare quel chip in DFU è possibile ma macchinoso. Per progetti di tastiera e mouse è molto più semplice un Leonardo, un Pro Micro, un Uno R4 o un Raspberry Pi Pico.
Che differenza c'è tra Leonardo e Pro Micro?
Entrambi usano lo stesso chip ATmega32U4 ed eseguono lo stesso codice. Il Pro Micro è molto più piccolo, di solito non ha il pulsante di reset ed esiste in due versioni, 5 V/16 MHz e 3,3 V/8 MHz. Per il Pro Micro a 5 V puoi selezionare Arduino Leonardo nell'Arduino IDE.
La porta del mio Arduino Leonardo non compare, cosa faccio?
Probabilmente lo sketch ha bloccato o mandato in crash l'USB. Avvia il caricamento di uno sketch funzionante e premi reset appena l'IDE mostra "Caricamento"; sul Pro Micro tocca due volte rapidamente RST con GND. La scheda resta qualche secondo nel bootloader e il codice viene caricato.
Perché il mio Leonardo scrive caratteri sbagliati?
La libreria Keyboard invia i tasti in base alla loro posizione su una tastiera americana. Su un computer con tastiera italiana, lettere accentate e molti simboli escono sbagliati. Chiama Keyboard.begin(KeyboardLayout_it_IT) perché il testo corrisponda al layout italiano.
Un Raspberry Pi Pico può diventare una tastiera USB?
Sì. Grazie all'USB integrato dell'RP2040, il Pico funziona come tastiera con Keyboard.h e Mouse.h nel core Arduino-Pico oppure con il pacchetto usb-device-keyboard in MicroPython 1.23 e successivi. È economico e potente, quindi è un'ottima scelta per i tastierini macro.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Tastiera per sviluppatori software Arduino
Se sei stanco di scrivere sempre le stesse righe mentre programmi, questo piccolo tastierino diventa la tua tastiera di scorciatoie.

Tastiera per sviluppatori Python
Se sei stanco di scrivere sempre gli stessi schemi mentre programmi, questa piccola tastiera fa per te.

Accendere un LED con un pulsante (Push)
Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

Accendere e spegnere un LED con un pulsante
Premi il pulsante una volta e la luce si accende, premilo di nuovo e si spegne, proprio come l'interruttore della tua stanza.

Funzionamento del tastierino 3x4
L'Arduino capisce subito quale tasto premi su un tastierino da 12 tasti simile a quello di un telefono, e lo scrive sullo schermo del tuo computer.

Funzionamento del tastierino 4x4
Sul tastierino 4x4, molto simile ai tasti di un telefono, l'Arduino capisce subito quale tasto hai premuto e lo scrive sullo schermo del computer.

Controllo LED con joystick
Spingi fino in fondo la levetta del joystick in una direzione e si accende il LED di quella direzione: ci sono quattro colori diversi per destra, sinistra, su e giù.

Servocomando con joystick
Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

