Arduino Leonardo como teclado y ratón: teclado de macros HID
Arduino Leonardo como teclado: ATmega32U4, Keyboard.h y Mouse.h, teclado de macros, ratón con joystick, carga con doble reset y por qué el Uno no puede ser HID.
El Arduino Leonardo puede funcionar como teclado y ratón: al conectarlo al ordenador por USB se reconoce como un teclado de verdad. No hace falta instalar controladores; Windows, macOS, Linux e incluso las tabletas lo ven como un teclado o ratón USB normal. Así puedes crear un teclado de macros que envíe tus atajos favoritos, fragmentos de texto o comandos de juego con una sola tecla, un ratón manejado con joystick o un dispositivo de entrada adaptado para personas con discapacidad. El pequeño Pro Micro, que usa el mismo chip que el Leonardo, puede hacer exactamente lo mismo.
En esta guía conocerás el chip ATmega32U4 que distingue al Leonardo del Uno y los comandos de las librerías Keyboard.h y Mouse.h, y construirás paso a paso un teclado de atajos de cuatro teclas y un ratón con joystick. Después resolveremos el problema más temido, la desaparición del puerto tras cargar el código, con el método del doble reset, explicaremos por qué un Uno no puede ser un teclado y veremos cómo hacer lo mismo con una Raspberry Pi Pico. Si quieres repasar cómo se conecta un pulsador, consulta Cómo conectar un pulsador.

La diferencia del ATmega32U4: ¿por qué el Leonardo puede ser un teclado?
Todo dispositivo USB se presenta con una clase: puerto serie (CDC), almacenamiento, audio o HID (Human Interface Device, dispositivo de interfaz humana). Los teclados y ratones son HID. El ATmega32U4 del Leonardo lleva el hardware USB integrado, así que es tu programa quien decide cómo se presenta el USB. El núcleo de Arduino presenta el chip a la vez como puerto serie y como teclado y ratón; cuando llamas a Keyboard.begin(), el ordenador encuentra un teclado nuevo. El ATmega328P del Uno no tiene hardware USB, y las diferencias van más allá del USB:
| Característica | Leonardo / Pro Micro (ATmega32U4) | Uno R3 / Nano (ATmega328P) |
|---|---|---|
| USB integrado | Sí, puede ser HID | No, usa un chip USB-serie aparte |
| Memoria flash | 32 KB (4 KB de bootloader, 28 KB útiles) | 32 KB (0,5 KB de bootloader) |
| SRAM | 2,5 KB | 2 KB |
| Entradas analógicas | 12 (A0-A5 + 6 en pines digitales) | 6 (8 en el Nano) |
| Pines I2C | D2 (SDA), D3 (SCL) | A4 (SDA), A5 (SCL) |
| Puertos serie | Serial = USB, Serial1 = D0/D1 | Un solo Serial, compartido por USB y D0/D1 |
| Pines de interrupción externa | D0, D1, D2, D3, D7 | D2, D3 |
La fila del I2C en la tabla es una trampa pequeña pero importante: un ejemplo de OLED o LCD escrito para el Uno no funciona en el Leonardo, porque SDA y SCL están en D2/D3 y no en A4/A5 (el conector SDA/SCL de la esquina superior va al sitio correcto en las dos placas). Otra diferencia es el puerto serie: en el Leonardo Serial es la propia conexión USB, mientras que el puerto serie de hardware de los pines D0/D1 se llama Serial1. Puedes ver la distribución completa de pines en la herramienta Pinout.
¿Por qué un Arduino Uno no puede ser un teclado (HID)?
En el Uno R3 el cable USB no llega al procesador principal sino al pequeño chip ATmega16U2 junto al conector USB. De fábrica, este chip solo ejecuta un firmware de conversión USB-serie; el ordenador siempre lo ve como un puerto serie y tu sketch no puede cambiarlo. Por eso, al escribir #include <Keyboard.h> en un Uno obtienes un error de compilación "'Keyboard' was not declared in this scope". En teoría se puede convertir un Uno en teclado regrabando el 16U2 en modo DFU, pero entonces la placa ya no se programa de la forma normal; no se recomienda a principiantes. El Nano, el Mega y el Pro Mini no pueden ser HID por la misma razón, y los clones del Nano con chip CH340 o FT232 ni siquiera tienen esa opción.
| Placa | Teclado/ratón USB (HID) | Nota |
|---|---|---|
| Leonardo, Micro, Pro Micro | Sí | ATmega32U4, con Keyboard.h y Mouse.h |
| Uno R4 Minima / WiFi | Sí | USB integrado del chip Renesas RA4M1 |
| Raspberry Pi Pico | Sí | Núcleo Arduino-Pico o paquete usb-device de MicroPython |
| ESP32-S2 / ESP32-S3 | Sí | USBHIDKeyboard con el USB integrado |
| ESP32 clásico | Solo Bluetooth | Puede ser un teclado BLE, no por USB |
| Uno R3, Nano, Mega, Pro Mini | No | El USB sale de un chip aparte, solo puerto serie |
Comandos de Keyboard.h y Mouse.h
| Comando | Qué hace |
|---|---|
| Keyboard.begin() | Inicia el teclado; opcionalmente recibe una distribución como KeyboardLayout_es_ES |
| Keyboard.print("texto") / println() | Escribe el texto letra a letra; println añade Enter al final |
| Keyboard.write(c) | Pulsa y suelta una sola tecla |
| Keyboard.press(k) / release(k) | Mantiene pulsada o suelta una tecla; sirve para atajos |
| Keyboard.releaseAll() | Suelta todas las teclas pulsadas |
| KEY_LEFT_CTRL, KEY_LEFT_SHIFT, KEY_LEFT_ALT, KEY_LEFT_GUI | Ctrl, Mayús, Alt y la tecla Windows/Cmd |
| KEY_RETURN, KEY_TAB, KEY_ESC, KEY_F1... | Enter, Tab, Esc, teclas de función y flechas (KEY_UP_ARROW, etc.) |
| Mouse.move(x, y, rueda) | Mueve el cursor de forma relativa en pasos de -128 a 127 |
| Mouse.click() / press() / release() | Botón MOUSE_LEFT, MOUSE_RIGHT o MOUSE_MIDDLE |
Primera prueba: escribir texto al pulsar un botón
Conecta una pata de un pulsador a D4 y la otra a GND; se usa la resistencia pull-up interna, así que no hacen falta más componentes. Al elegir la placa, selecciona Arduino Leonardo en Herramientas > Placa (también sirve para un Pro Micro de 5 V y 16 MHz). Tras cargar el código, abre un editor de texto, coloca el cursor dentro y pulsa el botón.
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}Teclado de macros: crea tu propio teclado de atajos
Ahora construyamos un teclado de atajos real con cuatro botones. Cada botón envía una combinación de teclas; el código solo reacciona en el momento de la pulsación y filtra los rebotes con un antirrebote de 30 ms. Cambia los pulsadores por interruptores de teclado mecánico, imprime una caja en 3D y tendrás un "stream deck" de verdad en tu mesa. Si quieres más teclas, conecta un teclado matricial 4x4 en lugar de los cuatro botones y define 16 macros.
| Pin | Conexión | Windows / Linux | macOS (MAC = true) |
|---|---|---|---|
| D4 | Botón 1, otra pata a GND | Ctrl+C (copiar) | Cmd+C |
| D5 | Botón 2, otra pata a GND | Ctrl+V (pegar) | Cmd+V |
| D6 | Botón 3, otra pata a GND | Ctrl+Mayús+T (reabrir pestaña) | Cmd+Mayús+T |
| D7 | Botón 4, otra pata a GND | Win+L (bloquear pantalla) | Ctrl+Cmd+Q |
| D9 | Interruptor o puente a GND | Seguridad: solo funciona conectado | Igual |
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 minúsculas en las teclas de letra ('c', 'v'); con una mayúscula la librería pulsa también Mayús y se envía otro atajo, como Ctrl+Mayús+C.
- sendCombo() pulsa las teclas en orden, espera 30 ms y las suelta todas con releaseAll(); esa pausa hace falta para que algunos programas detecten el atajo.
- Cada botón guarda su propio tiempo de antirrebote, así que pulsar dos casi a la vez no da problemas. Por qué se usa millis() y no delay() lo encontrarás en millis() frente a delay().
- Las teclas de volumen y multimedia no están en Keyboard.h; necesitan una librería con soporte Consumer Control, como HID-Project.
Crear un ratón USB con un joystick

Conecta el VCC del módulo joystick a 5V, GND a GND, VRx a A0, VRy a A1 y SW a D8. Al arrancar, el código guarda el valor en reposo como centro, ignora una zona de ±40 a su alrededor (zona muerta) y convierte la desviación en un movimiento de como máximo 10 píxeles por paso. No toques el joystick al conectar la placa o se guardará un centro erróneo. Para el funcionamiento interno del joystick y sus rangos, consulta el artículo del módulo 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}El puerto ha desaparecido: cargar con doble reset
Como en el Leonardo el USB lo gestiona tu sketch, si este se cuelga, se queda en un bucle infinito o nunca inicia el USB, el ordenador no ve el puerto. Normalmente el Arduino IDE abre y cierra brevemente el puerto a 1200 baudios al empezar la carga; ese "toque" pasa la placa al bootloader y el código se carga en segundos. Si el puerto ha desaparecido, ese toque no es posible, pero puedes arrancar el bootloader a mano: tras un reset, el bootloader espera unos 8 segundos código nuevo. Por eso también el número de puerto cambia un instante durante la carga.
- Abre un sketch que funcione (por ejemplo Archivo > Ejemplos > Basics > Blink) con Leonardo elegido como placa.
- Pulsa Subir y espera a que termine la compilación en la salida de abajo.
- En cuanto aparezca "Subiendo...", pulsa una vez el botón de reset del Leonardo; en un Pro Micro sin botón, toca dos veces seguidas y rápido el pin RST con GND.
- Si el LED de la placa "respira" despacio, está en el bootloader; el IDE encuentra el puerto nuevo y carga el código.
- Si falla, prueba de nuevo con otro momento; en unos pocos intentos darás con el instante justo.
Alternativa: teclado USB con la Raspberry Pi Pico
El chip RP2040 de la Raspberry Pi Pico también tiene USB integrado y cuesta menos que un Leonardo. Si usas en el Arduino IDE el paquete Raspberry Pi Pico/RP2040 de Earle Philhower, los mismos comandos de Keyboard.h y Mouse.h funcionan casi sin cambios; solo ajustas los números de pin a los pines GP. Si prefieres MicroPython, desde la versión 1.23 el paquete oficial usb-device-keyboard convierte la Pico en teclado. Instálalo en la placa desde el ordenador con mpremote mip install usb-device-keyboard. Al ejecutarse el código, la Pico vuelve a presentarse por USB con un teclado y la conexión de Thonny se corta; es normal. Si la Pico es nueva para ti, empieza por ¿Qué es la 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 debounceIdeas de proyectos con el Arduino Leonardo como teclado
- Teclado de programador: asigna a una sola tecla atajos del editor como compilar, ejecutar, comentar línea y abrir terminal.
- Panel para reuniones: pon los atajos de silenciar el micrófono y apagar la cámara en botones grandes e iluminados.
- Rueda de desplazamiento: desplázate por las páginas con un encoder rotativo enviando Mouse.move(0, 0, paso) como una rueda de ratón.
- Ratón accesible: haz clic con botones grandes o un pedal y mueve el cursor con un joystick.
- Mando de presentaciones: un pequeño mando de dos botones que envía las flechas izquierda y derecha.
- Panel de control para juegos: una cabina llena de interruptores y botones para juegos de vuelo o carreras.
Errores frecuentes y cómo solucionarlos
| Síntoma | Causa | Solución |
|---|---|---|
| 'Keyboard' was not declared in this scope | Uno, Nano o Mega seleccionado | Usa un Leonardo, Micro o Pro Micro |
| El puerto desapareció tras cargar | El sketch bloqueó o colgó el USB | Carga un sketch que funcione con doble reset |
| La placa no para de enviar teclas | Keyboard.print() sin condición o pin de botón al aire | Usa INPUT_PULLUP y un interruptor de seguridad |
| Salen caracteres incorrectos | Distribución de teclado distinta | Keyboard.begin(KeyboardLayout_es_ES) |
| El código no arranca hasta abrir el Monitor Serie | while (!Serial); en setup() | Quita esa línea o añade un tiempo límite |
| La OLED de un ejemplo del Uno no funciona | Pines I2C distintos | Conecta SDA a D2 y SCL a D3 |
| El Pro Micro nunca aparece | Código de 16 MHz cargado en una placa de 8 MHz | Elige la placa correcta con el paquete de SparkFun y haz doble reset |
El Leonardo y el Pro Micro son la forma más fácil de crear tu primer dispositivo electrónico que habla con el ordenador: unos cuantos botones, un poco de código y tendrás tu propio teclado de atajos. En la app BlueGrays encontrarás los proyectos Teclado de programador con Arduino y Teclado de programador con Python, además de proyectos con pulsadores, teclado matricial y joystick, cada uno con esquema y código paso a paso, listos para combinarlos con las técnicas HID de este artículo.
Preguntas frecuentes
¿Cómo uso un Arduino Leonardo como teclado?
Añade #include <Keyboard.h> al sketch y llama a Keyboard.begin() en setup(). Después puedes escribir texto con Keyboard.print() y enviar atajos como Ctrl+C con Keyboard.press() y releaseAll(). Vincula siempre el código a un botón; si no, la placa envía teclas sin parar.
¿Se puede usar un Arduino Uno como teclado?
No directamente, porque el Uno R3 usa un chip ATmega16U2 aparte que presenta el USB solo como puerto serie. Regrabar ese chip por DFU es posible, pero engorroso. Para proyectos de teclado y ratón es mucho más fácil un Leonardo, un Pro Micro, un Uno R4 o una Raspberry Pi Pico.
¿Qué diferencia hay entre el Leonardo y el Pro Micro?
Los dos usan el mismo chip ATmega32U4 y ejecutan el mismo código. El Pro Micro es mucho más pequeño, normalmente no tiene botón de reset y existe en dos versiones, 5 V/16 MHz y 3,3 V/8 MHz. Para el Pro Micro de 5 V puedes elegir Arduino Leonardo en el Arduino IDE.
El puerto de mi Arduino Leonardo no aparece, ¿qué hago?
Puede que tu sketch haya bloqueado o colgado el USB. Empieza a cargar un sketch que funcione y pulsa reset en cuanto el IDE muestre "Subiendo"; en un Pro Micro, toca RST con GND dos veces rápido. La placa se queda unos segundos en el bootloader y el código se carga.
¿Por qué mi Leonardo escribe caracteres equivocados?
La librería Keyboard envía las teclas según su posición en un teclado de EE. UU. En un ordenador con teclado español, la ñ, los acentos y muchos signos salen mal. Llama a Keyboard.begin(KeyboardLayout_es_ES) para que el texto coincida con la distribución española.
¿Puede una Raspberry Pi Pico ser un teclado USB?
Sí. Gracias al USB integrado del RP2040, la Pico funciona como teclado con Keyboard.h y Mouse.h en el núcleo Arduino-Pico o con el paquete usb-device-keyboard en MicroPython 1.23 o posterior. Es barata y potente, así que es una buena opción para teclados de macros.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Teclado para desarrolladores de software Arduino
Si te cansa escribir las mismas líneas una y otra vez mientras programas, este pequeño teclado se convierte en tu teclado de atajos.

Teclado para desarrolladores de Python
Si te cansa escribir los mismos patrones una y otra vez mientras programas, este pequeño teclado está hecho para ti.

Encender un LED con pulsador (Push)
Como un timbre: la luz se enciende mientras pulsas y se apaga cuando sueltas. El Arduino escucha el botón todo el rato; mientras está pulsado enciende el LED, y en cuanto levantas el dedo lo apaga.

Encender y apagar un LED con un botón
Pulsas el botón una vez y la luz se enciende, lo pulsas otra vez y se apaga, igual que el interruptor de tu habitación.

Funcionamiento del teclado 3x4
El Arduino sabe al instante qué tecla pulsas en un teclado de 12 teclas parecido al de un teléfono, y la escribe en la pantalla de tu ordenador.

Funcionamiento del teclado 4x4
En el teclado de 4x4, muy parecido a las teclas de un teléfono, el Arduino sabe al instante qué tecla has pulsado y la escribe en la pantalla del ordenador.

Control Led con Joystick
Empuja hasta el fondo la palanquita del joystick en cualquier dirección y se enciende el LED de esa dirección: hay cuatro colores distintos para derecha, izquierda, arriba y abajo.

Servocontrol con joystick
Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

