Componentes · 9 min de lectura

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.

Placa Arduino Leonardo
Arduino Leonardo: mismo tamaño que el Uno pero sin chip USB-serie aparte; el USB va directo al procesador principal ATmega32U4.

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ísticaLeonardo / Pro Micro (ATmega32U4)Uno R3 / Nano (ATmega328P)
USB integradoSí, puede ser HIDNo, usa un chip USB-serie aparte
Memoria flash32 KB (4 KB de bootloader, 28 KB útiles)32 KB (0,5 KB de bootloader)
SRAM2,5 KB2 KB
Entradas analógicas12 (A0-A5 + 6 en pines digitales)6 (8 en el Nano)
Pines I2CD2 (SDA), D3 (SCL)A4 (SDA), A5 (SCL)
Puertos serieSerial = USB, Serial1 = D0/D1Un solo Serial, compartido por USB y D0/D1
Pines de interrupción externaD0, D1, D2, D3, D7D2, 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.

PlacaTeclado/ratón USB (HID)Nota
Leonardo, Micro, Pro MicroSíATmega32U4, con Keyboard.h y Mouse.h
Uno R4 Minima / WiFiSíUSB integrado del chip Renesas RA4M1
Raspberry Pi PicoSíNúcleo Arduino-Pico o paquete usb-device de MicroPython
ESP32-S2 / ESP32-S3SíUSBHIDKeyboard con el USB integrado
ESP32 clásicoSolo BluetoothPuede ser un teclado BLE, no por USB
Uno R3, Nano, Mega, Pro MiniNoEl USB sale de un chip aparte, solo puerto serie

Comandos de Keyboard.h y Mouse.h

ComandoQué 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_GUICtrl, 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
Vincula siempre el código de teclado a un pulsador o un interruptor. Si ejecutas Keyboard.print() sin condiciones dentro de loop(), la placa envía cientos de caracteres por segundo; pierdes el control del ordenador, ni siquiera puedes escribir en el Arduino IDE y cargar código nuevo se complica. Por eso el código de macros de este artículo tiene un interruptor de seguridad ENABLE_PIN: mientras D9 no esté conectado a GND, el teclado no envía ninguna tecla.

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.

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}
La librería Keyboard no envía los caracteres según la distribución del ordenador sino según la posición de la tecla, y por defecto supone un teclado de EE. UU. En un ordenador con teclado español, Keyboard.print() da caracteres incorrectos con la ñ, los acentos y muchos signos. La solución viene incluida: escribe Keyboard.begin(KeyboardLayout_es_ES) y el texto saldrá bien. Los atajos como Ctrl+C funcionan con cualquier distribución.

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.

PinConexiónWindows / LinuxmacOS (MAC = true)
D4Botón 1, otra pata a GNDCtrl+C (copiar)Cmd+C
D5Botón 2, otra pata a GNDCtrl+V (pegar)Cmd+V
D6Botón 3, otra pata a GNDCtrl+Mayús+T (reabrir pestaña)Cmd+Mayús+T
D7Botón 4, otra pata a GNDWin+L (bloquear pantalla)Ctrl+Cmd+Q
D9Interruptor o puente a GNDSeguridad: solo funciona conectadoIgual
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}
  • 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

Módulo joystick analógico
Joystick analógico de dos ejes: las salidas VRx y VRy dan de 0 a 5 V y la salida SW se lleva a GND al pulsar la palanca.

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.

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}

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.

  1. Abre un sketch que funcione (por ejemplo Archivo > Ejemplos > Basics > Blink) con Leonardo elegido como placa.
  2. Pulsa Subir y espera a que termine la compilación en la salida de abajo.
  3. 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.
  4. Si el LED de la placa "respira" despacio, está en el bootloader; el IDE encuentra el puerto nuevo y carga el código.
  5. Si falla, prueba de nuevo con otro momento; en unos pocos intentos darás con el instante justo.
El Pro Micro tiene dos versiones: 5 V / 16 MHz y 3,3 V / 8 MHz. Si eliges "Arduino Leonardo" y cargas código en la de 8 MHz, el reloj queda mal configurado, el USB nunca funciona y el puerto desaparece. Para esa placa instala el paquete de placas de SparkFun, elige la versión correcta y recupera la placa cargando el código bueno con el método de doble reset de arriba. La versión se reconoce por la inscripción del cristal o del regulador.

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?.

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

Ideas 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íntomaCausaSolución
'Keyboard' was not declared in this scopeUno, Nano o Mega seleccionadoUsa un Leonardo, Micro o Pro Micro
El puerto desapareció tras cargarEl sketch bloqueó o colgó el USBCarga un sketch que funcione con doble reset
La placa no para de enviar teclasKeyboard.print() sin condición o pin de botón al aireUsa INPUT_PULLUP y un interruptor de seguridad
Salen caracteres incorrectosDistribución de teclado distintaKeyboard.begin(KeyboardLayout_es_ES)
El código no arranca hasta abrir el Monitor Seriewhile (!Serial); en setup()Quita esa línea o añade un tiempo límite
La OLED de un ejemplo del Uno no funcionaPines I2C distintosConecta SDA a D2 y SCL a D3
El Pro Micro nunca apareceCódigo de 16 MHz cargado en una placa de 8 MHzElige la placa correcta con el paquete de SparkFun y haz doble reset
Si el código no se carga, el problema no siempre es el código de teclado; repasa también la lista de la guía Arduino no sube el código para causas generales como el cable, los controladores o el puerto elegido.

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.

Ver todos los proyectos
Teclado para desarrolladores de software Arduino
AR-65Intermedio
Premium

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.

4.7(40)
52
Teclado para desarrolladores de Python
AR-66Intermedio
Premium

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.

4.6(35)
45
Encender un LED con pulsador (Push)
AR-9Principiante

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.

4.8(114)
253
Encender y apagar un LED con un botón
AR-10Principiante

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.

4.7(103)
177
Funcionamiento del teclado 3x4
AR-61Principiante

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.

4.5(24)
32
Funcionamiento del teclado 4x4
AR-63Principiante
Premium

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.

4.5(27)
35
Control Led con Joystick
AR-59Intermedio
Premium

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.

4.7(50)
67
Servocontrol con joystick
AR-60Intermedio
Premium

Servocontrol con joystick

Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.

4.7(42)
58