Bluetooth и Arduino: модуль HC-05 и управление с телефона

Что такое Bluetooth-модуль и чего он не делает

Проще всего представлять HC-05 как удлинитель для двух проводов. У платы Arduino есть последовательный порт — две линии, по которым она отправляет и принимает байты. Обычно на другом конце этих линий компьютер. Модуль забирает эти же байты и переносит их по воздуху: что плата отправила — то на телефоне появилось, что телефон прислал — то плата прочитала. Больше он не делает ничего.

Из этого следуют три вещи, которые экономят вечер новичку. Первая: никакой особой библиотеки не нужно — работа с модулем это тот же код, что и вывод в монитор порта. Вторая: модуль не даёт плате интернета — Bluetooth и Wi-Fi это разные вещи, и через HC-05 ни сайт открыть, ни данные в облако отправить нельзя. Третья: залить скетч «по воздуху» через него тоже не получится — загрузчику платы нужен сигнал сброса, а этого сигнала в Bluetooth-канале нет.

Последнее стоит пояснить, потому что вопрос задают часто. Когда вы жмёте «Загрузить» при обычном USB-кабеле, плату перезапускает не среда, а переходник: он дёргает линию сброса, и загрузчик успевает поймать программу в свою секундную форточку. По воздуху этой линии нет — модуль переносит только поток данных. Умельцы приспосабливают под сброс вывод STATE с конденсатором, и это иногда работает, но загрузка срывается от любой помехи в эфире: у загрузчика Optiboot это известная и описанная в его багтрекере беда. Так что честный ответ новичку — нет, скетч заливаем кабелем.

Зато то, что он делает, он делает надёжно: команды с телефона, показания датчиков на экран, руль для машинки, связь двух плат между собой. Для школьного проекта этого хватает с запасом.

Главный вопрос: с кем вы собираетесь связываться

Половина неудач случается ещё в магазине. Человек берёт HC-05, потому что он самый дешёвый и самый описанный, а потом выясняется, что телефон у него неподходящий или поделка должна месяц жить от батарейки. Выбор модуля определяется двумя вопросами: кто на другом конце и зачем.

Строка про ведущего важнее, чем кажется. Ведомый модуль умеет только ждать, пока к нему подключатся. Ведущий сам ищет напарника и устанавливает связь — поэтому парой модулей HC-05 можно соединить две платы Arduino без всякого телефона, а парой HC-06 нельзя: они оба будут вечно ждать друг друга.

Почему iPhone не увидит HC-05

Это самый частый вопрос по теме и самый неприятный ответ. Дело не в модуле, не в приложении и не в кривой прошивке. Bluetooth — это не один протокол, а набор «профилей»: наушники, гарнитура, передача файлов, клавиатура, последовательный порт. Устройство и телефон должны поддерживать один и тот же профиль, иначе им не о чем разговаривать.

HC-05 умеет ровно один профиль — последовательный порт. Apple публикует список профилей, которые поддерживает iOS: их меньше десятка — гарнитура, наушники, клавиатура, передача контактов и подобное, — и последовательного порта среди них нет. Стороннему приложению система открывает только Bluetooth Low Energy, то есть новое, экономичное поколение Bluetooth. Классический последовательный канал доступен только аксессуарам, прошедшим фирменную программу сертификации Apple, — а туда принимают компании, и аксессуару нужна отдельная микросхема аутентификации на плате.

Поэтому «поискать подходящее приложение в магазине» бессмысленно: приложения работают на том, что им даёт система, а система такого канала не даёт. Ни новое имя модуля, ни смена кода, ни другая прошивка ничего не изменят.

Что на плате модуля

Ходовая плата HC-05 — это прямоугольник с синей платкой самого радиомодуля, гребёнкой из шести выводов, маленькой кнопкой и светодиодом. Радиомодуль работает от 3,3 вольта, но на плате-носителе стоит собственный стабилизатор, поэтому питание берут с пятивольтового вывода Arduino.

Плата с четырьмя выводами и без кнопки — это почти наверняка не HC-05, а его младший родственник HC-06. Для управления с телефона он тоже годится, но роль ведущего у него не переключается, а команды настройки пишутся иначе.

Светодиод на плате — самый честный диагностический прибор в этой теме. По его ритму видно, что происходит внутри, ещё до того, как вы напишете первую строчку кода.

Подключение: четыре провода, и один — через резисторы

Проводов ровно четыре: питание, земля и две линии данных, перекрещённые между собой. Передача модуля идёт на приём платы, приём модуля — на передачу платы. Земля обязательна: без общего провода два устройства не договорятся о том, что считать нулём.

Единственная тонкость — направление «плата говорит модулю». Arduino выдаёт пять вольт, а вход модуля рассчитан на 1,8–3,6 вольта, и предельным значением в даташите названы 3,7. Пять вольт превышают этот предел почти на полтора, и вход постепенно выходит из строя — обычно тихо, без дыма: модуль просто перестаёт принимать. Лечится двумя резисторами: 1 кОм последовательно и 2 кОм на землю превращают пять вольт в 3,33. В обратную сторону делитель не нужен — пятивольтовая плата считает единицей всё, что выше трёх вольт.

Из этого правила есть одно задокументированное исключение — наш Trema-модуль. В его характеристиках прямо написано, что напряжение на выводах TX и RX не должно превышать напряжение питания модуля, а питание допускается 5 вольт. То есть если вы питаете его пятью вольтами, делитель не нужен. У обычной синей платы такой гарантии в карточке нет, а даташит самой микросхемы говорит про 3,6 вольта — поэтому для неё делитель остаётся обязательным.

Первая проверка: мост в монитор порта

Прежде чем писать что-то умное, полезно убедиться, что байты вообще ходят. Этот скетч соединяет монитор порта компьютера с модулем: что напечатали — улетело в воздух, что прилетело — появилось на экране. Он же понадобится позже, при настройке.

// Мост «монитор порта - Bluetooth-модуль».
// Что напечатали в мониторе - улетело в модуль, что пришло по воздуху -
// появилось в мониторе. С этого скетча начинают проверку связи.
// Схема (Arduino Uno): TXD модуля -> вывод 10, RXD модуля -> делитель -> 11,
// VCC модуля -> 5V, GND -> GND.

#include <SoftwareSerial.h>

SoftwareSerial bt(10, 11);     // 10 - приём (RX), 11 - передача (TX)

// Рабочая скорость модуля. В карточках наших модулей указано 38400.
// У модулей из других магазинов часто 9600: если в мониторе идёт мусор -
// поменяйте число здесь и попробуйте 9600, потом 57600.
const long BT_BAUD = 38400;

void setup() {
  Serial.begin(9600);          // окно монитора порта
  bt.begin(BT_BAUD);
  Serial.println("Мост открыт. Печатайте - уйдёт в модуль.");
}

void loop() {
  if (bt.available()) {        // пришло по воздуху - показываем в мониторе
    Serial.write(bt.read());
  }
  if (Serial.available()) {    // напечатали в мониторе - отправляем в модуль
    bt.write(Serial.read());
  }
}

Обратите внимание на строку со скоростью. Модули приезжают с разными заводскими настройками: у массовых плат это обычно 9600, у Trema-модуля в карточке указано 38400, попадаются экземпляры и на 57600. Если в мониторе вместо букв идёт мусор — скорость не та, переберите эти три значения. Точный ответ даст сам модуль, но чуть позже, в разделе про настройку.

Сопряжение с телефоном шаг за шагом

Здесь спотыкается больше людей, чем на пайке. Причина в том, что «сопряжено» и «подключено» — разные состояния, а телефон показывает только первое.

На практике порядок такой. Включаете плату — светодиод модуля часто мигает. В настройках Bluetooth телефона появляется устройство с именем HC-05 или H-C-2010-06-01. Телефон просит код: сначала пробуйте 1234, если не подошёл — 0000. Телефон пишет «сопряжено» — и на этом системная часть заканчивается. Дальше нужно открыть приложение-терминал, выбрать в нём это устройство и нажать «подключиться». Только теперь байты пойдут, светодиод перейдёт на две вспышки с паузой, а вывод STATE поднимется в единицу.

Пара мелочей, которые экономят нервы. Поиск устройств у телефона занимает около десяти секунд, а не мгновение, — список появляется не сразу. Если модуль в списке есть, но приложение его не показывает, почти всегда дело в разрешениях: начиная с двенадцатой версии Android приложению нужно отдельное разрешение «Устройства поблизости», а на версиях постарше — включённая геолокация. И ещё: модуль подключается только к одному устройству за раз, так что второй телефон в семье придётся отсоединить.

Приложений-терминалов для Android много, и все они делают одно и то же: показывают текст, который прислала плата, и отправляют то, что вы напечатали. Выбирать стоит по трём признакам: свежая дата обновления (иначе приложение может просто не встать на новый телефон), настройка окончания строки — она понадобится, когда команды станут длиннее одного символа, — и честный раздел о данных в магазине приложений. Всем трём условиям отвечает, например, Serial Bluetooth Terminal: он бесплатный, не собирает данные и умеет работать и с классическими модулями, и с BLE. Есть и приложения с готовыми пультами вместо текстового окна — с джойстиком и кнопками для машинки; правда, чаще всего они показывают рекламу.

Первая команда: светодиод с телефона

Самый простой протокол — одна цифра, одно действие. Отправили единицу — загорелось, отправили ноль — погасло. Плата отвечает словами, чтобы на экране телефона было видно, что команда дошла.

// Первое управление с телефона: одна цифра - одно действие.
// Отправьте с телефона 1 - светодиод загорится, 0 - погаснет.
// Модуль отвечает словами, чтобы на телефоне было видно, что команда дошла.

#include <SoftwareSerial.h>

SoftwareSerial bt(10, 11);
const long BT_BAUD = 38400;
const uint8_t PIN_LED = 13;    // светодиод на самой плате

void setup() {
  pinMode(PIN_LED, OUTPUT);
  bt.begin(BT_BAUD);
  bt.println("Плата на связи. 1 - включить, 0 - выключить.");
}

void loop() {
  if (!bt.available()) {
    return;
  }

  char command = bt.read();
  if (command == '1') {
    digitalWrite(PIN_LED, HIGH);
    bt.println("свет включён");
  } else if (command == '0') {
    digitalWrite(PIN_LED, LOW);
    bt.println("свет выключен");
  }
  // Всё остальное - в том числе перевод строки от телефона - пропускаем молча.
}

Если всё собрано верно, это работает с первого раза. Если нет — почти наверняка дело в одной из трёх вещей: не та скорость, не перекрещены провода данных или приложение не подключилось к устройству, а только сопряглось.

Команды длиннее одного символа

Как только вы захотите передавать не «включи», а «поставь яркость 120», простая схема ломается. Байты приходят по одному, а главный цикл программы успевает прокрутиться сотни раз между ними — поэтому проверка «а не букву ли L мы получили» срабатывает на первом символе, а число уходит в никуда.

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

// Команды из нескольких символов: буква и число.
// L120 - яркость 120, L0 - погасить, S - спросить состояние.
// Главное правило: по одному байту команду разбирать нельзя, её собирают
// в буфер до перевода строки. В приложении-терминале включите отправку \n.

#include <SoftwareSerial.h>

SoftwareSerial bt(10, 11);
const long BT_BAUD = 38400;
const uint8_t PIN_LED = 9;     // светодиод через резистор на ШИМ-выводе

char line[24];                 // буфер одной команды
uint8_t filled = 0;            // сколько символов уже собрано
unsigned long lastByte = 0;    // когда пришёл последний символ
int brightness = 0;            // текущая яркость, 0...255

void setup() {
  pinMode(PIN_LED, OUTPUT);
  analogWrite(PIN_LED, brightness);
  bt.begin(BT_BAUD);
  bt.println("Готов. L120 - яркость, L0 - погасить, S - состояние.");
}

void loop() {
  while (bt.available()) {
    char symbol = bt.read();
    lastByte = millis();

    if (symbol == '\r') {
      continue;                // возврат каретки не нужен
    }
    if (symbol == '\n') {     // строка кончилась - команда собрана
      line[filled] = '\0';
      if (filled > 0) {
        run(line);
      }
      filled = 0;
      continue;
    }
    if (filled < sizeof(line) - 1) {
      line[filled] = symbol;
      filled++;
    } else {
      filled = 0;              // слишком длинная строка - выбрасываем целиком
      bt.println("команда слишком длинная");
    }
  }

  // Связь пропала на середине строки - выбрасываем огрызок, иначе
  // следующая команда склеится с ним в одну бессмыслицу.
  if (filled > 0 && millis() - lastByte > 200) {
    filled = 0;
  }
}

void run(const char *command) {
  if (command[0] == 'L' || command[0] == 'l') {
    brightness = constrain(atoi(command + 1), 0, 255);
    analogWrite(PIN_LED, brightness);
    bt.print("яркость ");
    bt.println(brightness);
  } else if (command[0] == 'S' || command[0] == 's') {
    bt.print("сейчас яркость ");
    bt.println(brightness);
  } else {
    bt.print("не понял: ");
    bt.println(command);
  }
}

Тот же самый разбор строк уже разобран у нас по шагам в уроке «Пульт из клавиатуры» — там команды приходят по проводу с компьютера. Протокол не меняется от того, что провод заменили воздухом: это и есть главная мысль всей страницы.

Плата отвечает: показания на экран телефона

Связь двусторонняя, и обычно хочется не только командовать, но и видеть, что происходит. Здесь появляется вопрос меры: канал не резиновый. На скорости 9600 через него проходит 960 байт в секунду, и если сыпать показания двадцать раз в секунду, плата будет занята болтовнёй, а команды начнут опаздывать.

Второй момент — время. Задержки в главном цикле недопустимы: приёмный буфер всего 64 байта, и всё, что пришло сверх него, теряется молча. Поэтому телеметрию отправляют по часам, а не через delay().

// Плата сама рассказывает телефону, что у неё происходит.
// Раз в полсекунды уходит значение с датчика - и при этом плата
// продолжает слушать команды: никаких delay() в цикле нет.
// Вывод STATE модуля показывает, есть ли связь: пока никто не подключился,
// говорить в пустоту незачем.

#include <SoftwareSerial.h>

SoftwareSerial bt(10, 11);
const long BT_BAUD = 38400;

const uint8_t PIN_STATE = 8;   // вывод STATE модуля
const uint8_t PIN_SENSOR = A0; // датчик или потенциометр
const unsigned long PERIOD = 500;   // как часто отправлять, мс

unsigned long lastSent = 0;
bool wasLinked = false;

void setup() {
  pinMode(PIN_STATE, INPUT);
  bt.begin(BT_BAUD);
}

void loop() {
  bool linked = digitalRead(PIN_STATE) == HIGH;

  if (linked && !wasLinked) {
    bt.println("телефон подключился");
  }
  wasLinked = linked;

  if (linked && millis() - lastSent >= PERIOD) {
    lastSent = millis();
    bt.print("A0=");
    bt.println(analogRead(PIN_SENSOR));
  }

  while (bt.available()) {     // команды продолжают приниматься между отправками
    char symbol = bt.read();
    if (symbol == 'P' || symbol == 'p') {
      bt.print("сейчас A0=");
      bt.println(analogRead(PIN_SENSOR));
    }
  }
}

Вывод STATE здесь работает выключателем: пока телефон не подключился, говорить не с кем. Заодно это защита для подвижных поделок — по пропаже связи можно остановить моторы.

Этот вывод есть не у всех модулей: на синей плате он выведен на гребёнку, а у Trema-модуля вместо него светодиод «соединён» и вывод K для настройки. Если STATE нет, связь определяют по молчанию: пусть телефон раз в полсекунды присылает любой символ, и если его не было дольше полутора секунд — считаем, что связь потеряна.

Настройка модуля: режим AT-команд

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

В этом режиме порт открывается на скорости 38400 независимо от того, что настроено для передачи данных. Именно отсюда растёт путаница «а какая же у HC-05 скорость»: скоростей две, у разных режимов.

// Разговор с модулем на его языке: режим AT-команд.
// Модуль должен быть ВКЛЮЧЁН в этот режим до подачи питания:
// удерживайте кнопку на плате модуля, пока подаёте на него питание,
// либо держите вывод EN (KEY) в HIGH. Светодиод начнёт мигать редко.
// В мониторе порта выберите окончание строки «NL и CR» - без него
// HC-05 не ответит ни на одну команду.

#include <SoftwareSerial.h>

SoftwareSerial bt(10, 11);     // 10 - приём (RX), 11 - передача (TX)

// В режиме AT-команд у HC-05 своя скорость, и она НЕ равна рабочей.
const long AT_BAUD = 38400;

void setup() {
  Serial.begin(9600);
  bt.begin(AT_BAUD);
  Serial.println("Режим настройки. Проверка: наберите AT и нажмите Enter.");
  Serial.println("Ответ OK означает, что модуль слышит команды.");
}

void loop() {
  if (bt.available()) {
    Serial.write(bt.read());
  }
  if (Serial.available()) {
    bt.write(Serial.read());
  }
}

Две команды заслуживают предупреждения. Смена скорости меняет её только для режима данных — режим настройки всё равно останется на 38400, поэтому «потерять» модуль нельзя, что бы вы ни поставили. А сброс к заводским настройкам заодно переименовывает модуль: в списке телефона он появится как H-C-2010-06-01, и старую пару придётся удалить.

Машинка, которой рулят с телефона

Это самый частый школьный проект по теме, и он собирается из уже разобранного: команды из предыдущего раздела плюс драйвер моторов. Буквы задают направление, число — скорость. Единственное, что добавлено сверх очевидного, — защита: если команд не было дольше секунды, машинка тормозит сама. Иначе при выходе из зоны связи она уедет в стену на полном ходу.

// Машинка на драйвере L298N, которой рулят с телефона.
// Команды: F - вперёд, B - назад, L - влево, R - вправо, S - стоп,
// V80 - скорость 80 процентов. Разбор строк - как в скетче с командами.
// У робота выводы 9 и 10 заняты драйвером, поэтому модуль переехал на 11 и 12.

#include <SoftwareSerial.h>

SoftwareSerial bt(11, 12);     // 11 - приём (RX), 12 - передача (TX)
const long BT_BAUD = 38400;

const uint8_t L_IN1 = 8;
const uint8_t L_IN2 = 7;
const uint8_t L_EN = 9;        // ШИМ

const uint8_t R_IN1 = 4;
const uint8_t R_IN2 = 2;
const uint8_t R_EN = 10;       // ШИМ

const int MIN_PWM = 60;        // ниже этого моторы только гудят
const unsigned long TIMEOUT = 1000;  // молчит дольше секунды - тормозим

char line[16];
uint8_t filled = 0;
unsigned long lastByte = 0;
int speedPercent = 70;
unsigned long lastCommand = 0;

void setup() {
  const uint8_t pins[] = {L_IN1, L_IN2, L_EN, R_IN1, R_IN2, R_EN};
  for (uint8_t i = 0; i < sizeof(pins); i++) {
    pinMode(pins[i], OUTPUT);
  }
  drive(0, 0);
  bt.begin(BT_BAUD);
  bt.println("Машинка готова. F B L R S, скорость V80.");
}

void loop() {
  while (bt.available()) {
    char symbol = bt.read();
    lastByte = millis();
    if (symbol == '\r') {
      continue;
    }
    if (symbol == '\n') {
      line[filled] = '\0';
      if (filled > 0) {
        run(line);
        lastCommand = millis();
      }
      filled = 0;
      continue;
    }
    if (filled < sizeof(line) - 1) {
      line[filled] = symbol;
      filled++;
    } else {
      filled = 0;
    }
  }

  if (filled > 0 && millis() - lastByte > 200) {
    filled = 0;              // огрызок строки не должен ждать следующей команды
  }

  // Связь оборвалась на ходу - машинка не должна уехать в стену.
  if (lastCommand > 0 && millis() - lastCommand > TIMEOUT) {
    drive(0, 0);
  }
}

void run(const char *command) {
  int power = speedPercent;

  switch (command[0]) {
    case 'F': case 'f': drive(power, power); break;
    case 'B': case 'b': drive(-power, -power); break;
    case 'L': case 'l': drive(-power, power); break;
    case 'R': case 'r': drive(power, -power); break;
    case 'S': case 's': drive(0, 0); break;
    case 'V': case 'v':
      speedPercent = constrain(atoi(command + 1), 0, 100);
      bt.print("скорость ");
      bt.println(speedPercent);
      break;
    default:
      bt.println("не понял команду");
      break;
  }
}

void wheel(uint8_t in1, uint8_t in2, uint8_t en, int percent) {
  percent = constrain(percent, -100, 100);
  digitalWrite(in1, percent >= 0 ? HIGH : LOW);
  digitalWrite(in2, percent >= 0 ? LOW : HIGH);

  int power = abs(percent);
  if (power == 0) {
    analogWrite(en, 0);
  } else {
    analogWrite(en, map(power, 1, 100, MIN_PWM, 255));
  }
}

void drive(int left, int right) {
  wheel(L_IN1, L_IN2, L_EN, left);
  wheel(R_IN1, R_IN2, R_EN, right);
}

Обратите внимание на выводы: модуль здесь переехал на другую пару, потому что привычные заняты драйвером. Это обычная история в реальном проекте — выводы кончаются раньше, чем идеи.

Когда не работает

Ниже — то, с чем сталкиваются чаще всего, в порядке от самого частого. Почти всё диагностируется без приборов: хватает светодиода на модуле и монитора порта.

Честно про защиту

Код сопряжения из четырёх цифр — это не пароль от вашего проекта, а формальность двадцатилетней давности. Он защищает ровно от случайного подключения соседа, и ничего больше. Кто сопрягся с модулем — тот и командует платой: никакой проверки «а ты имеешь право» в самом Bluetooth-канале нет.

Практический вывод простой. Управлять с телефона светом в комнате, машинкой, поливалкой для цветов — нормально. Делать на HC-05 замок входной двери или что-то, где ошибка стоит дорого, — не стоит. Если очень хочется, защиту делают не в модуле, а в своей программе: свой код в команде, подтверждение действия, ограничение по времени. И обязательно поменяйте имя и код сопряжения — заводские знают все.

И ещё одно, про энергию: модуль не умеет спать. В паре он потребляет около 8 миллиампер круглосуточно, независимо от того, передаётся что-нибудь или нет. Для поделки, которая должна месяц жить от батарейки, нужен BLE — он для того и придуман.

Что купить

Всё проверено 24 августа 2026 года: каждая карточка открыта отдельно, цена и артикул взяты с самой страницы товара. Того, чего нет в наличии, в подборке нет.

Дальше по теме

• Последовательный порт и SoftwareSerial — что происходит в проводе, который заменяет Bluetooth.
• Скетч не загружается — разбор ошибки, которая появляется, если модуль занял выводы 0 и 1.
• Мотор и драйвер L298N — вторая половина проекта «машинка с телефона».
• Плата ESP32 — когда радио уже внутри платы и внешний модуль не нужен.
• Все модули к Arduino — обзорная таблица с библиотеками и разборами.

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