База знаний · Датчики и модули

USB-клавиатура, мышь и геймпад на Arduino

Leonardo и Pro Micro умеют притворяться клавиатурой, мышью и геймпадом, а Uno — нет. Макропад, ручка громкости, русский текст без мусора и настоящая USB-клавиатура в Arduino.

Плату на Arduino можно научить притворяться клавиатурой. Нажали кнопку — и компьютер вставил текст, выполнил сочетание клавиш или убавил громкость. Компьютер видит такую плату как обычное устройство ввода (USB HID) и драйвера не просит. Но умеет это не каждая плата: USB должен быть встроен в сам микроконтроллер. Ниже — какие платы подходят, пять проверенных скетчей (макропад, русский текст, ручка громкости, геймпад и мышь) и обратная задача: как подключить к Arduino настоящую USB-клавиатуру.

Какие платы так умеют

Главный признак — USB в самом микроконтроллере. У классической Uno разъём USB обслуживает отдельный чип-переходник, и всё, что он умеет, — изображать COM-порт.

ПлатаКлавиатура и мышьЧто учесть
Uno R3, Nano, Mega 2560, Pro MiniНетUSB у них — через переходник: ATmega16U2, FT232RL или CH340, у Pro Mini — отдельная плата. Сам ATmega328P или 2560 USB не умеет
Leonardo, Micro, Pro Micro (ATmega32U4)Да. Keyboard и Mouse входят в Trema IDE, громкость и геймпад — библиотека HID-ProjectПункта «Pro Micro» в списке плат нет: версию на 5 В прошивают как «Arduino Leonardo», на 3,3 В — как «LilyPad Arduino USB»
UNO R4 Minima, UNO R4 WiFi, Nano R4Да: Keyboard и MouseHID-Project не собирается. У R4 WiFi со скетчем-клавиатурой пропадает COM-порт
Zero, MKR, Nano 33 IoT (SAMD21)Да, и HID-Project тожеУ Zero — только через разъём Native USB, пункт «Arduino Zero (Native USB Port)»
Raspberry Pi Pico и Pico 2Да: Keyboard, Mouse и Joystick — в пакете платыГромкость — Keyboard.consumerPress(). HID-Project не нужна и не собирается
ESP32-S2 и ESP32-S3Да, средствами пакета платы: USBHIDKeyboard, USBHIDMouse, USBHIDGamepadУ S3 в параметрах платы нужен USB Mode «USB-OTG (TinyUSB)», у S2 другого режима нет. Скетчи из этой статьи придётся переписать
ESP32, ESP32-C3, ESP32-C6, ESP8266НетУ C3 и C6 USB только для прошивки и монитора порта, у ESP32 и ESP8266 его в чипе нет вовсе
Digispark (ATtiny85)Да, программным USB: библиотека DigiKeyboardСвоя библиотека и только английская раскладка

Скетчи на Keyboard и Mouse из этой статьи без изменений собираются и для UNO R4, и для Raspberry Pi Pico. Скетчи на HID-Project — для Leonardo, Micro, Pro Micro и плат на SAMD21. Только помните про питание: Pico, Zero, MKR и Nano 33 IoT работают от 3,3 В, и джойстик с энкодером на них питают от вывода 3V3, а не от 5V. Пять вольт на аналоговом входе такой платы могут его сжечь. Про ESP32-S3 и его настройки USB — на странице ESP32-S3, про программный USB у ATtiny85 — на странице Digispark.

Плата жмёт клавиши, а не печатает буквы

Клавиатура не передаёт компьютеру буквы. Она сообщает, какие клавиши сейчас зажаты: их номера и отдельно — нажаты ли Shift, Ctrl, Alt и Win. Библиотека Keyboard каждый раз отправляет такой отчёт целиком: восемь модификаторов и до шести обычных клавиш, седьмую она уже не добавит. А букву по номеру клавиши выбирает сам компьютер — по той раскладке, что включена у него в эту секунду.

Плата шлёт номера клавиш, а букву выбирает компьютер32U4Leonardo или Pro MicroKeyboard.print("Hello");по USB уходят нажатия клавиш, а не буквыShiftотдельноHР0x0BEУ0x08LД0x0FLД0x0FOЩ0x12+раскладка ENHelloраскладка RUРуддщВ одном отчёте до шести клавиш и отдельно Shift, Ctrl, Alt и Win — левые и правые
Клавиатура — и настоящая, и плата с библиотекой Keyboard — сообщает компьютеру только номера зажатых клавиш и отдельно модификаторы. Под клавишами подписаны их номера по стандарту USB. Букву выбирает компьютер по включённой раскладке: те же нажатия дают «Hello» в английской и «Руддщ» в русской.

По умолчанию Keyboard.print("Hello") печатает в американской раскладке: для «H» нажимает Shift и клавишу H. Немецкая, французская и ещё шесть раскладок в библиотеке есть, русской нет. Если в Windows включён русский, на экране появится «Руддщ» — те же клавиши, другие буквы. Узнать раскладку плата не может: компьютер сообщает клавиатуре только, гореть ли индикаторам Caps Lock, Num Lock и Scroll Lock.

С русскими буквами хуже. В скетче они записаны в UTF-8, по два байта на букву, а библиотека понимает только однобайтовые символы из таблицы раскладки. Всё, что больше 127, она считает номером служебной клавиши или модификатора. Первый байт русской буквы превращается в нажатие Pause или Insert, второй — во что придётся. В слове «привет» буква «в» нажимает Backspace и стирает предыдущий символ, а «т» — клавишу Alt, и фокус уходит в меню окна. А Keyboard.print("утро") первой же буквой нажмёт и отпустит клавишу Windows — откроется меню «Пуск». Поэтому русский текст печатают отдельной функцией, она ниже.

Первый скетч и предохранитель

Проще всего начать со встроенного примера Trema IDE: откройте «Примеры» на боковой панели и найдите USB_KeyboardButton — кнопка на D2 печатает фразу. Распиновка, прошивка и два порта Serial у плат на 32U4 разобраны на странице про Leonardo, Micro и Pro Micro.

Правило для любой платы-клавиатуры одно: она жмёт клавиши только по событию — по кнопке или по команде. Скетч, который печатает в цикле без условия, заваливает буквами все окна, включая Trema IDE, и перепрошить такую плату трудно. В макропаде ниже для этого есть предохранитель, а мышь после включения платы выключена.

Если плата уже «взбесилась», выручит загрузчик: после сброса он ждёт новую программу 8 секунд. Отключите плату, уберите из скетча печать без условия и нажмите «Проверить» — сборка будет готова заранее и потом не съест эти секунды. Подключите плату, нажмите «Загрузить» и сразу зажмите RESET: пока он зажат, плата молчит. Отпустите его, когда сборка закончится и начнётся загрузка. У Pro Micro кнопки RESET нет, а одиночный сброс у неё обычно держит загрузчик меньше секунды — в этот момент замкните вывод RST на GND проводком дважды подряд. Если плата успела напечатать что-то прямо в скетч, сотрите это и повторите.

Пункта «Pro Micro» в списке плат Trema IDE нет. Плату на 5 В и 16 МГц прошивают как «Arduino Leonardo», на 3,3 В и 8 МГц — как «LilyPad Arduino USB»: за этим пунктом тот же ATmega32U4 на 8 МГц. Путать нельзя. Ядро настраивает USB под частоту кварца, и с чужой частотой плата перестанет определяться компьютером. Лечится это тем же двойным сбросом и прошивкой с правильной платой.

Макропад: кнопки с сочетаниями клавиш

Четыре кнопки — четыре сочетания: копировать, вставить, отменить и заблокировать компьютер. Кнопки подключаются без резисторов, между выводом и GND: подтяжку включает сам скетч. Та же проводка пригодится геймпаду и мыши ниже.

Пульт на Pro Micro: четыре кнопки и джойстикPro Micro32U4TXRXGNDGND23456789RAWGNDRSTVCCA3A2A1A015141610GNDкнопка 1кнопка 2кнопка 3кнопка 4резисторы не нужны:подтяжку включает скетчGVYXджойстик TremaX растёт вправо, Y — вверхкнопка — на выводGNDVCCось X — на A0ось Y — на A1
Кнопки включены между выводом и GND: скетч включает внутреннюю подтяжку, и нажатая кнопка читается как LOW. Выводы 2 и 3 у ATmega32U4 — шина I²C, их оставили свободными для дисплея. Джойстик берёт питание с VCC: у Pro Micro на 5 В это 5 В, у версии на 3,3 В — 3,3 В, джойстик работает от обоих. На Leonardo провода идут на те же номера выводов, а VCC там называется 5V.
// Макропад: четыре кнопки жмут сочетания клавиш — копировать, вставить,
// отменить и заблокировать компьютер. Leonardo, Micro или Pro Micro.
// Кнопки — между выводами 4, 5, 6, 7 и GND, резисторы не нужны.
// Предохранитель: если при включении держать первую кнопку, плата не жмёт
// ничего, и её спокойно можно перепрошить.
#include <Keyboard.h>

const byte BUTTONS[4] = {4, 5, 6, 7};
const unsigned long STABLE_MS = 20;   // столько кнопка должна не дребезжать

bool stablePressed[4];     // состояние после подавления дребезга
bool lastRaw[4];           // что прочитали в прошлый раз
unsigned long changedAt[4];
bool silent = false;

void setup() {
  for (byte i = 0; i < 4; i++) {
    pinMode(BUTTONS[i], INPUT_PULLUP);
  }
  silent = digitalRead(BUTTONS[0]) == LOW;  // первая кнопка зажата при включении
  Keyboard.begin();
}

// Нажать сочетание и обязательно отпустить: пока клавиша в отчёте,
// компьютер считает её зажатой и начинает повторять.
void combo(uint8_t modifier, char key) {
  Keyboard.press(modifier);
  Keyboard.press(key);
  delay(20);
  Keyboard.releaseAll();
}

void onPress(byte i) {
  switch (i) {
    case 0: combo(KEY_LEFT_CTRL, 'c'); break;  // копировать
    case 1: combo(KEY_LEFT_CTRL, 'v'); break;  // вставить
    case 2: combo(KEY_LEFT_CTRL, 'z'); break;  // отменить
    case 3: combo(KEY_LEFT_GUI, 'l'); break;   // Win+L — заблокировать Windows
  }
}

void loop() {
  if (silent) {
    return;
  }
  for (byte i = 0; i < 4; i++) {
    bool raw = digitalRead(BUTTONS[i]) == LOW;
    if (raw != lastRaw[i]) {          // контакт шевельнулся — засекаем время
      lastRaw[i] = raw;
      changedAt[i] = millis();
    }
    if (raw != stablePressed[i] && millis() - changedAt[i] >= STABLE_MS) {
      stablePressed[i] = raw;
      if (raw) {
        onPress(i);                   // срабатываем один раз — в момент нажатия
      }
    }
  }
}

На Leonardo скетч занимает 6 066 байт флеша из 28 672 и 255 байт ОЗУ. Две вещи в нём важнее остального. Первая: press() не нажимает-и-отпускает, а держит клавишу, пока её не отпустят. Компьютер видит зажатую клавишу и через долю секунды начинает её повторять, поэтому после сочетания обязательно releaseAll(). Вторая — дребезг: контакт кнопки несколько миллисекунд дрожит, и без проверки «20 мс без изменений» одно нажатие иногда превращается в два Ctrl+V.

Сочетания в Windows срабатывают и в русской раскладке: Ctrl+C остаётся Ctrl+C, раскладка влияет только на буквы. На Mac вместо KEY_LEFT_CTRL нужен KEY_LEFT_GUI — это клавиша Cmd. Свои сочетания собираются так же: KEY_LEFT_ALT, KEY_LEFT_SHIFT, KEY_TAB, KEY_F1…KEY_F24, KEY_PRINT_SCREEN — полный список лежит в файле Keyboard.h.

Русский текст

Раз плата жмёт клавиши, русский текст печатают теми клавишами, на которых нарисованы русские буквы: «а» — это F, «б» — запятая, «я» — Z. Функция printRu() ниже переводит строку в такие нажатия. Условие одно: на компьютере в этот момент должна быть включена русская раскладка.

// Печать русского текста USB-клавиатурой: Leonardo, Micro или Pro Micro.
// Клавиатура передаёт компьютеру номера клавиш, а не буквы, поэтому плата
// жмёт те клавиши, на которых нарисованы русские буквы. На компьютере должна
// быть включена русская раскладка: узнать её плата не может.
// Кнопка — между выводом 4 и GND.
#include <Keyboard.h>

// Клавиши для букв от «а» до «я» по алфавиту, без «ё»:
// «а» — клавиша F, «б» — клавиша с запятой, «в» — D и так далее.
const char RU_KEYS[] = "f,dult;pbqrkvyjghcnea[wxio]sm'.z";
const char KEY_YO = 96;    // «ё» — клавиша слева от единицы

void tap(char key, bool shift) {
  if (shift) {
    Keyboard.press(KEY_LEFT_SHIFT);   // заглавная — та же клавиша с Shift
  }
  Keyboard.write(key);
  if (shift) {
    Keyboard.release(KEY_LEFT_SHIFT);
  }
}

void printRu(const char *text) {
  while (*text) {
    byte c = *text++;
    if ((c == 0xD0 || c == 0xD1) && *text) {     // русская буква: два байта
      unsigned int code = ((c & 0x1F) << 6) | (*text++ & 0x3F);
      if (code >= 0x430 && code <= 0x44F) {
        tap(RU_KEYS[code - 0x430], false);          // а…я
      } else if (code >= 0x410 && code <= 0x42F) {
        tap(RU_KEYS[code - 0x410], true);           // А…Я
      } else if (code == 0x451) {
        tap(KEY_YO, false);                         // ё
      } else if (code == 0x401) {
        tap(KEY_YO, true);                          // Ё
      }
    } else if (c == '.') {
      tap('/', false);     // в русской раскладке точка — на клавише «/»
    } else if (c == ',') {
      tap('/', true);      // запятая — там же, с Shift
    } else if (c == '?') {
      tap('7', true);
    } else if (c == ';') {
      tap('4', true);
    } else if (c == ':') {
      tap('6', true);
    } else if (c == '"') {
      tap('2', true);
    } else if (c < 128) {
      Keyboard.write(c);   // цифры, пробел, ! - = ( ) совпадают
    }
  }
}

void setup() {
  pinMode(4, INPUT_PULLUP);
  Keyboard.begin();
}

void loop() {
  if (digitalRead(4) == LOW) {
    printRu("Съешь же ещё этих мягких французских булок, да выпей же чаю.");
    Keyboard.write(KEY_RETURN);
    delay(1000);           // пока держат кнопку — не чаще раза в секунду
  }
}

Фраза в скетче содержит все 33 буквы — так удобно проверить таблицу целиком. Заглавная буква — та же клавиша с Shift, «ё» живёт слева от единицы. Точка и запятая в русской раскладке стоят на другой клавише, поэтому функция переводит и их, и знаки «?», «;», «:» и кавычки. Цифры, пробел, «!», «-» и круглые скобки в обеих раскладках на одних и тех же клавишах. И проверьте Caps Lock: при включённом регистр всех букв перевернётся — это касается и обычного Keyboard.print().

Латиницу так не напечатать: при русской раскладке она станет кириллицей. Если в тексте есть и то и другое, раскладку придётся переключать. Плата может нажать Win+Пробел, но это переключение «на следующую», и какая раскладка включится, плата не узнает. Надёжнее повесить русские и английские фразы на разные кнопки, а раскладку переключать руками.

Ручка громкости и медиаклавиши

Клавиш громкости в библиотеке Keyboard нет: они живут в другом разделе стандарта HID — Consumer Control, клавиши бытовой техники. Их умеет HID-Project из каталога библиотек. Trema IDE найдёт её по имени файла сама: после неудачной сборки предложит поставить библиотеку и собрать проект заново. Кроме громкости в HID-Project есть пауза и переключение треков (MEDIA_PLAY_PAUSE, MEDIA_NEXT), яркость экрана, клавиши сна и питания, геймпад и мышь с абсолютными координатами.

// Ручка громкости для компьютера: крутят энкодер — громкость меняется,
// нажимают на ручку — звук выключается и включается.
// Leonardo, Micro или Pro Micro и библиотека HID-Project из каталога.
// Trema-модуль «Энкодер»: A — вывод 8, B — 9, S — 10, G — GND, V — 5V
// (у Pro Micro вывод называется VCC, у плат на 3,3 В модуль питают от 3V3).
#include <HID-Project.h>

const byte PIN_A = 8;
const byte PIN_B = 9;
const byte PIN_S = 10;     // у Trema-модуля кнопка даёт единицу при нажатии

// Таблица переходов: индекс — старые и новые уровни A и B, значение —
// куда повернули. Нули — «ничего не изменилось» и «шаг пропущен»; дребезг
// даёт пары +1 и −1 и гасит сам себя.
const int8_t STEPS[16] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};

byte previous;
int quarters = 0;          // на один щелчок приходится четыре перехода
bool buttonStable = false;
bool buttonRaw = false;
unsigned long buttonChangedAt = 0;

void setup() {
  pinMode(PIN_A, INPUT_PULLUP);
  pinMode(PIN_B, INPUT_PULLUP);
  pinMode(PIN_S, INPUT);
  previous = (digitalRead(PIN_A) << 1) | digitalRead(PIN_B);
  Consumer.begin();
}

void loop() {
  byte now = (digitalRead(PIN_A) << 1) | digitalRead(PIN_B);
  if (now != previous) {
    quarters += STEPS[(previous << 2) | now];
    previous = now;
  }
  // Громкость идёт не в ту сторону — поменяйте местами PIN_A и PIN_B.
  if (quarters >= 4) {
    Consumer.write(MEDIA_VOLUME_UP);
    quarters -= 4;
  } else if (quarters <= -4) {
    Consumer.write(MEDIA_VOLUME_DOWN);
    quarters += 4;
  }

  bool raw = digitalRead(PIN_S) == HIGH;
  if (raw != buttonRaw) {
    buttonRaw = raw;
    buttonChangedAt = millis();
  }
  if (raw != buttonStable && millis() - buttonChangedAt >= 20) {
    buttonStable = raw;
    if (raw) {
      Consumer.write(MEDIA_VOLUME_MUTE);
    }
  }
}

Скетч занимает 5 504 байта. Энкодер читается без библиотеки — опросом по таблице переходов, как в статье про энкодеры и джойстики: на один щелчок Trema-модуля приходится четыре перехода, поэтому громкость меняется, когда счёт дошёл до четырёх. Шаг громкости задаёт Windows: щелчок ручки — то же, что нажатие клавиши громкости на ноутбуке. Кнопка в вале у Trema-модуля даёт единицу при нажатии, так в скетче и написано. У китайского KY-040 наоборот — там нужны INPUT_PULLUP и сравнение с LOW.

Если в том же скетче нужны и обычные клавиши, подключайте только HID-Project: в ней своя Keyboard, а вместе с Keyboard.h она не соберётся. Команды те же, но коды клавиш у неё другого типа: KEY_LEFT_CTRL — не число, а KeyboardKeycode. Если перенести сюда макропад, в функции combo() объявите параметр modifier этим типом. Иначе Ctrl и Win молча пропадут, и вместо Ctrl+C напечатается «c».

Геймпад

Геймпад — тоже из HID-Project: 32 кнопки, четыре оси по 16 бит, две по 8 бит и две крестовины. Важная мелочь: press() и xAxis() только меняют отчёт в памяти платы, а уходит он компьютеру по write().

// Геймпад для компьютера: джойстик и четыре кнопки.
// Leonardo, Micro или Pro Micro и библиотека HID-Project из каталога.
// Trema-джойстик: X — A0, Y — A1, G — GND, V — 5V (у Pro Micro — VCC,
// у плат на 3,3 В — 3V3: пять вольт на аналоговом входе такой платы вредны).
// Кнопки — между выводами 4, 5, 6, 7 и GND.
// Проверка в Windows: Win+R, joy.cpl, «Свойства» — оси и кнопки видны там.
#include <HID-Project.h>

const byte BUTTONS[4] = {4, 5, 6, 7};
const int DEAD_ZONE = 8;   // в центре ручка дрожит на несколько делений

int centerX, centerY;
int16_t sentX, sentY;
uint8_t sentButtons;

// Отклонение от центра — в число от -32767 до 32767, как ждёт компьютер.
int16_t axis(int raw, int center) {
  long d = raw - center;
  if (abs(d) <= DEAD_ZONE) {
    return 0;
  }
  long span = (d > 0) ? 1023 - center : center;   // до края в эту сторону
  if (span < 1) {
    span = 1;
  }
  return constrain(d * 32767L / span, -32767L, 32767L);
}

void setup() {
  for (byte i = 0; i < 4; i++) {
    pinMode(BUTTONS[i], INPUT_PULLUP);
  }
  // Центр у каждого джойстика свой, не 512: запоминаем его при включении,
  // поэтому ручку в этот момент не трогают.
  centerX = analogRead(A0);
  centerY = analogRead(A1);
  Gamepad.begin();
}

void loop() {
  int16_t x = axis(analogRead(A0), centerX);
  // У Trema-джойстика Y растёт, когда ручку толкают вверх, а у геймпада
  // «вверх» — это минус. Другой джойстик ведёт себя наоборот — уберите минус.
  int16_t y = -axis(analogRead(A1), centerY);
  uint8_t buttons = 0;
  for (byte i = 0; i < 4; i++) {
    if (digitalRead(BUTTONS[i]) == LOW) {
      buttons |= 1 << i;
    }
  }
  // Отчёт уходит, только когда что-то изменилось.
  if (x != sentX || y != sentY || buttons != sentButtons) {
    Gamepad.xAxis(x);
    Gamepad.yAxis(y);
    for (byte i = 0; i < 4; i++) {
      if (buttons & (1 << i)) {
        Gamepad.press(i + 1);       // кнопки у геймпада нумеруются с единицы
      } else {
        Gamepad.release(i + 1);
      }
    }
    Gamepad.write();                // без write() компьютер ничего не узнает
    sentX = x;
    sentY = y;
    sentButtons = buttons;
  }
  delay(5);
}

Флеша — 5 910 байт. Проверить геймпад можно без игр: Win+R, joy.cpl, кнопка «Свойства» — там видно, как ходит крестик осей и загораются кнопки. Центр джойстика скетч запоминает при включении: у каждого экземпляра он свой и редко равен 512, а без этого персонаж будет медленно ползти сам. У Trema-джойстика ось Y растёт, когда ручку толкают вверх, а у геймпада «вверх» — это минус. Поэтому в скетче перед осью Y стоит минус.

Игры, которые понимают только геймпады Xbox, такой геймпад могут не увидеть: Windows показывает его как обычный игровой контроллер. В играх из Steam может выручить Steam Input — он умеет выдавать игре обычный геймпад за геймпад Xbox. Библиотека XInput из каталога делает плату «геймпадом Xbox» сама, но ей нужен свой пакет плат с изменённым ядром, а такого пакета в Trema IDE из коробки нет.

Осторожно со скетчами из интернета, где геймпад делают библиотекой Joystick (строка Joystick_ Joystick;): такой библиотеки в каталоге нет. Под тем же именем там лежит другая — она только читает аналоговый джойстик, и сборка падает на ошибке 'Joystick_' does not name a type.

Мышь из джойстика

Тот же джойстик может водить курсор — библиотека Mouse тоже входит в Trema IDE. Чем дальше ручку отклонили, тем быстрее идёт курсор: скорость растёт как квадрат отклонения. У центра курсор сдвигается на единицу за шаг, у края — до 16.

// Мышь из джойстика: ручка двигает курсор, кнопка на выводе 4 — левая
// кнопка мыши, на выводе 5 — правая, на выводе 7 — включить или выключить мышь.
// Leonardo, Micro или Pro Micro. Trema-джойстик: X — A0, Y — A1, G — GND,
// V — 5V (у Pro Micro — VCC, у плат на 3,3 В — 3V3). Кнопки — между выводом и GND.
// Мышь при включении выключена: если центр поплывёт, курсор не уедет
// и не помешает перепрошить плату.
#include <Mouse.h>

const byte BTN_LEFT = 4;
const byte BTN_RIGHT = 5;
const byte BTN_ON = 7;
const int DEAD_ZONE = 20;

int centerX, centerY;
bool enabled = false;
bool lastOn = false, lastLeft = false, lastRight = false;

// Чем дальше ручка от центра, тем быстрее курсор: у центра — по пикселю.
int speed(int raw, int center) {
  long d = raw - center;
  if (abs(d) <= DEAD_ZONE) {
    return 0;
  }
  long v = d * abs(d) / 16384;
  if (v == 0) {
    v = (d > 0) ? 1 : -1;
  }
  return constrain(v, -16L, 16L);
}

void setup() {
  pinMode(BTN_LEFT, INPUT_PULLUP);
  pinMode(BTN_RIGHT, INPUT_PULLUP);
  pinMode(BTN_ON, INPUT_PULLUP);
  centerX = analogRead(A0);   // ручку при включении не трогать
  centerY = analogRead(A1);
  Mouse.begin();
}

void loop() {
  bool on = digitalRead(BTN_ON) == LOW;
  if (on && !lastOn) {
    enabled = !enabled;
    Mouse.release(MOUSE_LEFT);   // выключили посреди перетаскивания — отпускаем
    Mouse.release(MOUSE_RIGHT);
    lastLeft = lastRight = false;
  }
  lastOn = on;

  if (enabled) {
    int dx = speed(analogRead(A0), centerX);
    // Курсор вниз — это плюс, а Y у Trema-джойстика растёт вверх: отсюда минус.
    int dy = -speed(analogRead(A1), centerY);
    if (dx != 0 || dy != 0) {
      Mouse.move(dx, dy, 0);
    }
    bool left = digitalRead(BTN_LEFT) == LOW;
    if (left != lastLeft) {
      if (left) {
        Mouse.press(MOUSE_LEFT);     // держите — и можно тащить окно
      } else {
        Mouse.release(MOUSE_LEFT);
      }
      lastLeft = left;
    }
    bool right = digitalRead(BTN_RIGHT) == LOW;
    if (right != lastRight) {
      if (right) {
        Mouse.press(MOUSE_RIGHT);
      } else {
        Mouse.release(MOUSE_RIGHT);
      }
      lastRight = right;
    }
  }
  delay(10);   // 100 раз в секунду; заодно гасит дребезг кнопок
}

Флеша — 5 868 байт. Мышь включается кнопкой на выводе 7, а после включения платы она выключена, и это не прихоть. Джойстик со съехавшим центром тянет курсор в угол, и нажать «Загрузить» становится непросто. Mouse.press() держит кнопку, пока её не отпустят, — так перетаскивают окна, а Mouse.click() щёлкает и сразу отпускает.

Если под рукой только Uno

Как сказано выше, у Uno R3 USB — у отдельного чипа. Варианты, от простого к сложному:

  • Взять плату на 32U4. Leonardo стоит как Uno: 790 ₽ против 640–890 ₽ за разные Uno R3, а скетчи из этой статьи написаны как раз для неё.
  • Оставить клавиши компьютеру. Uno шлёт в COM-порт короткие команды, а небольшая программа на компьютере, например на Python, превращает их в нажатия. Работает с любой платой, но без этой программы ничего не будет.
  • Перепрошить переходник. У оригинальных Uno R3 и Mega R3 это ATmega16U2, и проект HoodLoader2 делает из него вторую программируемую плату, которая умеет быть клавиатурой. Это работа с загрузчиками, и пакета HoodLoader2 в Trema IDE из коробки нет. У копий с CH340 и у Nano путь закрыт: CH340 и FT232RL — готовые микросхемы, их не перепрошить.
  • Программный USB — V-USB. На нём работает Digispark. Для Uno его тоже собирают — резисторы, два стабилитрона на 3,6 В и отдельный разъём USB с линией D+ на выводе 2, — но это эксперимент для вечера, а не способ сделать клавиатуру.

Обратная задача: настоящая клавиатура в Arduino

Бывает и наоборот: нужно, чтобы Arduino читала обычную USB-клавиатуру, мышь или геймпад. Тогда плата должна быть не устройством, а хостом — как компьютер. На Uno и Mega для этого ставят USB Host Shield 2.0 с микросхемой MAX3421E: она ведёт шину USB, а с Arduino общается по SPI.

USB Host Shield: Arduino читает настоящую клавиатуруArduino UnoD10 — выбор (SS)D9 — прерываниеICSP: SCK, MISO, MOSI5V3.3VGNDUSB Host Shield 2.0MAX3421Eкварц 12 МГц74AHC1253.3V5VVBUSна копиях перемычки часто не запаяныUSB-клавиатура5 В — от шилда
Шилд говорит с Arduino по SPI через разъём ICSP — на Uno это выводы 11, 12 и 13 — и занимает ещё два вывода: 10 выбирает микросхему MAX3421E, 9 — её прерывание. Клавиатура получает 5 В с разъёма USB на шилде. На дешёвых копиях перемычки питания у края платы бывают не запаяны: пока их нет, микросхема и клавиатура остаются без напряжения.

Библиотека — USB Host Shield Library 2.0 из каталога. В ней примеры для клавиатур, мышей, геймпадов PS4, PS5, Xbox и Switch Pro, флешек и Bluetooth-адаптеров. Скетч ниже печатает в монитор порта всё, что набирают на клавиатуре:

// Обычная USB-клавиатура подключена к Arduino через USB Host Shield:
// нажатые клавиши появляются в мониторе порта (115200).
// Uno или Mega и библиотека USB Host Shield Library 2.0 из каталога.
// Шилд занимает выводы 9 (INT), 10 (SS) и шину SPI на разъёме ICSP.
#include <hidboot.h>
#include <usbhub.h>
#include <SPI.h>

class KeyPrinter : public KeyboardReportParser {
protected:
  void OnKeyDown(uint8_t mod, uint8_t key) override {
    uint8_t c = OemToAscii(mod, key);   // номер клавиши — в символ латиницы
    if (c == 13) {
      Serial.println();                 // Enter
    } else if (c) {
      Serial.print((char)c);
    } else {
      Serial.print('[');                // F1, стрелки и прочие — номером
      Serial.print(key, HEX);
      Serial.print(']');
    }
  }
};

USB usb;
USBHub hub(&usb);   // клавиатура с хабом внутри или хаб с питанием тоже заработают
HIDBoot<USB_HID_PROTOCOL_KEYBOARD> keyboard(&usb);
KeyPrinter printer;

void setup() {
  Serial.begin(115200);
  if (usb.Init() == -1) {
    Serial.println("Шилд не отвечает: проверьте перемычки питания и разъём ICSP");
    while (true) {
    }
  }
  keyboard.SetReportParser(0, &printer);
  Serial.println("Шилд готов, подключайте клавиатуру");
}

void loop() {
  usb.Task();   // опрос шины: без него клавиатура молчит
}

На Uno скетч берёт 12 596 байт флеша и 641 байт ОЗУ. Строка с USBHub нужна, если клавиатура подключена через хаб или хаб у неё внутри — так бывает у клавиатур со своим разъёмом USB. OemToAscii() переводит номер клавиши в символ английской раскладки, так что и здесь плата видит клавиши, а не буквы: русская «ж» придёт как «;». Caps Lock, Num Lock и Scroll Lock библиотека отрабатывает сама и зажигает их светодиоды на клавиатуре.

Дешёвые копии шилда часто приходят недопаянными: перемычки у края платы, которые подают на неё 3,3 и 5 В с Arduino и 5 В на разъём USB (VBUS), разомкнуты. Пока их нет, микросхема или клавиатура остаются без питания. Перед пайкой посмотрите маркировку маленькой микросхемы на 14 выводов — согласователя уровней: по схеме там 74AHC125. Если стоит 74HC125 или 74HCT125, после пайки перемычек на линии 3,3 В окажется около 4 В — больше, чем рассчитана MAX3421E. Такую микросхему меняют на 74AHC125, а до замены шилд надолго не включают. Клавиатуре хватает питания от USB компьютера, а геймпаду с подсветкой или вибрацией может не хватить — тогда помогает внешний блок питания для Arduino или USB-хаб со своим питанием.

У ESP32-S2 и S3 USB-хост встроен в сам чип: в пакете платы 3.3 есть примеры USBHostKeyboard и USBHostMouse. Проверьте только, подаёт ли ваша плата 5 В на свой разъём USB, — без этого клавиатура не включится. Монитор порта при этом смотрят через второй разъём платы, UART: сочетание USB Mode «USB-OTG (TinyUSB)» с включённым USB CDC On Boot для хоста не годится. А для флешек удобнее модуль на CH376: файловую систему он ведёт сам, библиотека Ch376msc есть в каталоге.

Ошибки и что за ними стоит

Сообщение или симптомЧто случилось
'Keyboard' was not declared in this scopeСкетч собирают для платы без USB в чипе: Uno, Nano, Mega. Переустанавливать библиотеку бесполезно — нужна плата из таблицы выше.
HID.h: No such file or directoryСкетч с Keyboard.h собирают для ESP32. На ESP32-S2 и S3 клавиатуру делают средствами пакета платы — USBHIDKeyboard, а на ESP32, C3 и C6 по USB её не сделать.
#error HID Project can only be used with an USB MCU.HID-Project собирают для платы, которую библиотека не поддерживает: Uno и Nano, а ещё UNO R4 и Pico. На R4 остаются Keyboard и Mouse, на Pico громкость умеет встроенная Keyboard — consumerPress().
expected identifier before numeric constant или redefinition of 'class Keyboard_' — в файле Keyboard.hВ скетче подключены и Keyboard.h, и HID-Project.h. Оставьте одну HID-Project: в ней своя Keyboard, только коды вроде KEY_LEFT_CTRL у неё другого типа — об этом в разделе про громкость.
Вместо «Hello» на экране «Руддщ»На компьютере включена русская раскладка. Плата жмёт клавиши, а буквы выбирает компьютер.
Вместо русских букв мусор, а иногда открывается меню «Пуск»Русский текст передан в Keyboard.print(). Печатайте его функцией printRu() из этой статьи при включённой русской раскладке.
Клавиша «залипла» и повторяетсяПосле press() нет release() или releaseAll(): компьютер считает клавишу зажатой и включает автоповтор.
Плата печатает без остановки, перепрошить не получаетсяПечать без условия. Отключите плату, исправьте скетч и нажмите «Проверить». Потом подключите, нажмите «Загрузить» и сразу зажмите RESET (у Pro Micro — дважды замкните RST на GND), а отпустите, когда начнётся загрузка.
После прошивки Pro Micro пропала из системыПлату на 3,3 В и 8 МГц прошили как Leonardo или наоборот, и USB настроился под чужую частоту. Двойной сброс и прошивка с правильной платой.
UNO R4 WiFi: после скетча с клавиатурой пропал COM-портТак задумано: при запуске такого скетча USB переключается с радиомодуля на основной чип RA4M1. Перед следующей прошивкой дважды нажмите RESET.
В joy.cpl геймпад есть, а игра его не видитСкорее всего, игра понимает только геймпады Xbox (XInput), а геймпад из HID-Project Windows показывает как обычный игровой контроллер. В играх из Steam может выручить Steam Input.
'Joystick_' does not name a typeСкетч из интернета написан под библиотеку-геймпад Joystick, которой в каталоге нет. Под тем же именем в каталоге лежит другая — она читает аналоговый джойстик. Геймпад на Leonardo делает HID-Project.
«OSC did not start» в примерах USB Host Shield, «Шилд не отвечает» в нашем скетчеПлата не достучалась до MAX3421E: на копии шилда не запаяны перемычки питания, SPI не доходит через разъём ICSP или выводы 9 и 10 заняты чем-то ещё.
Шилд отвечает, а клавиатура не светится; пример board_qc застрял на «Waiting for device...»На разъём USB шилда не приходит 5 В: не запаяна перемычка VBUS или не хватает тока. Авторы библиотеки советуют внешний блок питания для Arduino или USB-хаб со своим питанием — строка USBHub для хаба в нашем скетче уже есть.

Что купить

Для всех проектов статьи подойдёт Arduino Leonardo — 790 ₽. К ней — Trema-джойстик за 160 ₽ (оси X и Y, кнопки на нём нет) и Trema-модуль «Энкодер» за 216 ₽ для ручки громкости. Для пульта и геймпада хороши аркадные кнопки Sanwa OBSF-24 за 90 ₽ и OBSF-30 за 120 ₽: у них два вывода, подключаются так же, как на схеме. Самая дешёвая плата-клавиатура — Digispark за 480 ₽, но у неё своя библиотека и только английская раскладка. Цены — на 16.11.2026.

Частые вопросы

Может ли Arduino Uno быть USB-клавиатурой?

Обычным скетчем — нет. На Uno и Nano разъём USB обслуживает отдельный чип-переходник (ATmega16U2, FT232RL или CH340), а сам ATmega328P USB не умеет: скетч с Keyboard.h останавливается на ошибке «'Keyboard' was not declared in this scope». Нужна плата с USB в самом чипе — Leonardo, Micro, Pro Micro, UNO R4, Raspberry Pi Pico или ESP32-S3. Без новой платы можно слать команды в COM-порт, а нажимать клавиши будет программа на компьютере.

Почему Arduino печатает «Руддщ» вместо «Hello»?

Плата-клавиатура передаёт компьютеру номера клавиш, а не буквы. Букву выбирает компьютер по включённой раскладке: в русской клавиши H, E, L, L, O дают «Руддщ». Переключите раскладку на английскую — сама плата её узнать не может.

Как напечатать русский текст через Keyboard.h?

Keyboard.print() русские буквы не понимает: каждая занимает два байта, и библиотека принимает их за служебные клавиши, вплоть до клавиши Windows. Русский текст печатают теми клавишами, на которых нарисованы русские буквы, при включённой русской раскладке: «а» — клавиша F, «б» — запятая. Готовая функция printRu() — в статье.

Какую плату выбрать в Trema IDE для Pro Micro?

Отдельного пункта нет. Pro Micro на 5 В и 16 МГц прошивают как «Arduino Leonardo», на 3,3 В и 8 МГц — как «LilyPad Arduino USB». С неверной частотой USB не заработает, и плата пропадёт из системы; её возвращают двойным замыканием RST на GND и прошивкой с правильной платой.

Как сделать на Arduino регулятор громкости для компьютера?

Нужны плата с USB в чипе, энкодер и библиотека HID-Project из каталога: клавиш громкости в обычной Keyboard нет. На каждый щелчок энкодера — Consumer.write(MEDIA_VOLUME_UP) или MEDIA_VOLUME_DOWN, на нажатие ручки — MEDIA_VOLUME_MUTE. Готовый скетч для Leonardo и Pro Micro — в статье.

Как превратить Arduino в геймпад для компьютера?

На Leonardo, Micro и Pro Micro — библиотекой HID-Project: объект Gamepad даёт 32 кнопки, шесть осей и две крестовины, а отчёт уходит компьютеру по Gamepad.write(). Проверяют геймпад в Windows через joy.cpl. Библиотека с именем Joystick из каталога для этого не подходит — она читает аналоговый джойстик, а не делает из платы геймпад.

Как подключить USB-клавиатуру к Arduino?

Через USB Host Shield 2.0 на микросхеме MAX3421E и библиотеку USB Host Shield Library 2.0 из каталога. Шилд занимает SPI на разъёме ICSP и выводы 9 и 10. У дешёвых копий проверьте перемычки питания: часто они не запаяны. ESP32-S2 и S3 умеют быть USB-хостом сами, без шилда.

Обновлено: 16 ноября 2026