Как использовать Bluetooth-модуль HC-05 с Arduino

Arduino TX ---> [1 кОм] ---> HC-05 RX
                    |
                [2 кОм]
                    |
                   GND

HC-05      Arduino Uno
-----      -----------
VCC   ---> 5V
GND   ---> GND
TX    ---> Pin 10 (через SoftwareSerial)
RX    ---> Pin 11 (через делитель напряжения)
STATE ---> не подключен (опционально)
EN    ---> не подключен (пока что)

#include <SoftwareSerial.h>
 
// Создаем объект SoftwareSerial для работы с HC-05
SoftwareSerial btSerial(10, 11); // RX, TX
 
const int LED_PIN = 12;
char btInput;
 
void setup() {
  // Инициализируем последовательный порт для отладки
  Serial.begin(9600);
  
  // Инициализируем последовательный порт для Bluetooth
  btSerial.begin(9600);
  
  // Настраиваем пин светодиода на выход
  pinMode(LED_PIN, OUTPUT);
  
  Serial.println(">>СТАРТ<<");
}
 
void loop() {
  // Проверяем, есть ли данные от Bluetooth
  if(btSerial.available() > 0) {
    btInput = btSerial.read();
    
    // Обрабатываем полученную команду
    if(btInput == '1') {
      Serial.println("ВКЛ");
      digitalWrite(LED_PIN, HIGH);
    }
    else if(btInput == '0') {
      Serial.println("ВЫКЛ");
      digitalWrite(LED_PIN, LOW);
    }
    else {
      Serial.println("НЕВЕРНАЯ КОМАНДА");
      Serial.println(btInput);
    }
  }
}

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
 
const int LED_PIN = 12; // должен поддерживать ШИМ!
String btBuffer = ""; // Буфер для накопления входящих данных
boolean stringComplete = false;
 
void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  Serial.println(">>СТАРТ<<");
}
 
void loop() {
  // Читаем данные от Bluetooth
  while(btSerial.available()) {
    char inChar = (char)btSerial.read();
    
    // Если получен символ новой строки, завершаем строку
    if (inChar == '\n') {
      stringComplete = true;
    } else {
      // Иначе добавляем символ в буфер
      btBuffer += inChar;
    }
  }
  
  // Если строка завершена, обрабатываем команду
  if (stringComplete) {
    // Преобразуем строку в число
    int brightness = btBuffer.toInt();
    
    // Ограничиваем значение диапазоном 0-255
    brightness = constrain(brightness, 0, 255);
    
    // Устанавливаем яркость светодиода
    analogWrite(LED_PIN, brightness);
    
    // Отправляем подтверждение
    Serial.print("Яркость установлена: ");
    Serial.println(brightness);
    btSerial.print("OK: ");
    btSerial.println(brightness);
    
    // Очищаем буфер для следующей команды
    btBuffer = "";
    stringComplete = false;
  }
}

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
 
const int LED_PIN = 12;
String btBuffer = "";
boolean stringComplete = false;
 
void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  Serial.println(">>СТАРТ<<");
}
 
void loop() {
  readBtData();
  processBtCommand();
}
 
// Функция для чтения данных от Bluetooth
void readBtData() {
  while(btSerial.available()) {
    char inChar = (char)btSerial.read();
    
    if (inChar == '\n') {
      stringComplete = true;
    } else {
      btBuffer += inChar;
    }
  }
}
 
// Функция для обработки команд
void processBtCommand() {
  if (stringComplete) {
    // Разбиваем команду на части (команда:параметр)
    int separatorIndex = btBuffer.indexOf(':');
    
    if (separatorIndex != -1) {
      String command = btBuffer.substring(0, separatorIndex);
      String parameter = btBuffer.substring(separatorIndex + 1);
      
      executeCommand(command, parameter);
    } else {
      // Если команда простая, без параметров
      executeCommand(btBuffer, "");
    }
    
    // Очищаем буфер
    btBuffer = "";
    stringComplete = false;
  }
}
 
// Функция выполнения конкретных команд
void executeCommand(String command, String parameter) {
  if (command == "LED") {
    // Управление светодиодом
    int value = parameter.toInt();
    analogWrite(LED_PIN, value);
    sendResponse("OK", String(value));
  } 
  else if (command == "STATUS") {
    // Запрос статуса
    int ledStatus = digitalRead(LED_PIN);
    sendResponse("STATUS", String(ledStatus));
  }
  else {
    // Неизвестная команда
    sendResponse("ERROR", "Unknown command");
  }
}
 
// Функция отправки ответа
void sendResponse(String status, String message) {
  String response = status + ":" + message;
  btSerial.println(response);
  Serial.println("Отправлено: " + response);
}

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial1(10, 11); // RX, TX для первого модуля
SoftwareSerial btSerial2(8, 9);   // RX, TX для второго модуля
 
void setup() {
  Serial.begin(9600);
  btSerial1.begin(9600);
  btSerial2.begin(9600);
  
  // Изначально слушаем первый модуль
  btSerial1.listen();
  
  Serial.println("Система с двумя Bluetooth-модулями запущена");
}
 
void loop() {
  // Проверяем первый модуль
  if (btSerial1.available()) {
    Serial.print("Модуль 1: ");
    while (btSerial1.available()) {
      char c = btSerial1.read();
      Serial.write(c);
    }
    Serial.println();
    
    // Отвечаем на первый модуль
    btSerial1.println("Получено модулем 1");
    
    // Переключаемся на второй модуль
    btSerial2.listen();
  }
  
  // Проверяем второй модуль
  if (btSerial2.available()) {
    Serial.print("Модуль 2: ");
    while (btSerial2.available()) {
      char c = btSerial2.read();
      Serial.write(c);
    }
    Serial.println();
    
    // Отвечаем на второй модуль
    btSerial2.println("Получено модулем 2");
    
    // Переключаемся обратно на первый модуль
    btSerial1.listen();
  }
  
  // Даем немного времени между проверками
  delay(100);
}

unsigned long lastPingTime = 0;
const unsigned long pingInterval = 5000; // 5 секунд
boolean connectionAlive = false;
 
void loop() {
  // Остальной код...
  
  // Периодически проверяем связь
  unsigned long currentMillis = millis();
  if (currentMillis - lastPingTime > pingInterval) {
    sendPing();
    lastPingTime = currentMillis;
  }
}
 
void sendPing() {
  btSerial.println("PING");
  Serial.println("Отправлен PING");
  connectionAlive = false;
  
  // Ждем ответа в течение 1 секунды
  unsigned long pingStartTime = millis();
  while (millis() - pingStartTime < 1000) {
    if (btSerial.available()) {
      String response = btSerial.readString();
      if (response.indexOf("PONG") != -1) {
        connectionAlive = true;
        Serial.println("Соединение активно");
        break;
      }
    }
  }
  
  if (!connectionAlive) {
    Serial.println("Потеряна связь с устройством!");
  }
}

HC-05      Arduino
-----      -------
EN/KEY ---> Pin 9

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
 
const int keyPin = 9; // Пин для управления KEY/EN
 
void setup() {
  Serial.begin(9600);
  
  // Настраиваем пин KEY
  pinMode(keyPin, OUTPUT);
  digitalWrite(keyPin, HIGH); // Удерживаем HIGH для входа в командный режим
  
  // Важно! В командном режиме HC-05 работает на скорости 38400
  btSerial.begin(38400);
  
  Serial.println("Модуль в режиме AT-команд");
  Serial.println("Введите команду для отправки:");
}
 
void loop() {
  // Перенаправляем данные от Serial на btSerial
  if (Serial.available()) {
    btSerial.write(Serial.read());
  }
  
  // Перенаправляем данные от btSerial на Serial
  if (btSerial.available()) {
    Serial.write(btSerial.read());
  }
}

AT

AT+VERSION     // Запрос версии прошивки
AT+NAME        // Запрос текущего имени
AT+NAME=MyBot  // Установка нового имени "MyBot"
AT+PSWD        // Запрос текущего пароля
AT+PSWD=4321   // Установка нового пароля "4321"
AT+UART        // Запрос параметров UART
AT+UART=9600,0,0  // Установка скорости 9600, 1 стоп-бит, без контроля четности
AT+ROLE        // Запрос текущей роли (0=Slave, 1=Master)
AT+ROLE=1      // Установка роли Master

AT+ROLE=1          // Установка роли Master
AT+CMODE=0         // Подключаться только к заданному адресу (не к любому устройству)
AT+BIND=1234,56,789012  // MAC-адрес устройства, к которому нужно подключиться

AT+ROLE=1
AT+CMODE=0
AT+BIND=98d3,32,123456  // MAC-адрес модуля 2
AT+UART=9600,0,0

AT+ROLE=0
AT+UART=9600,0,0

AT+ORGL

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
const int keyPin = 9;
const int ledPin = 13;
 
void setup() {
  Serial.begin(9600);
  pinMode(keyPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  
  // Входим в командный режим
  digitalWrite(keyPin, HIGH);
  digitalWrite(ledPin, HIGH); // Индикатор командного режима
  
  btSerial.begin(38400);
  delay(1000);
  
  // Отправляем команды настройки
  sendATCommand("AT");
  sendATCommand("AT+NAME=RoboControl");
  sendATCommand("AT+PSWD=5678");
  sendATCommand("AT+UART=57600,0,0");
  
  // Выходим из командного режима
  digitalWrite(keyPin, LOW);
  digitalWrite(ledPin, LOW);
  
  // Перезапускаем последовательный порт на новой скорости
  btSerial.end();
  btSerial.begin(57600);
  
  Serial.println("Настройка завершена!");
}
 
void loop() {
  // Тут может быть ваш код для обычного режима работы
}
 
// Функция для отправки AT-команды и ожидания ответа
void sendATCommand(String command) {
  Serial.print("Отправка: ");
  Serial.println(command);
  
  btSerial.println(command);
  delay(1000);
  
  // Читаем ответ
  String response = "";
  while (btSerial.available()) {
    response += (char)btSerial.read();
  }
  
  Serial.print("Ответ: ");
  Serial.println(response);
}

Вывод R светодиода -> Сток MOSFET 1 -> Исток MOSFET 1 -> GND
Вывод G светодиода -> Сток MOSFET 2 -> Исток MOSFET 2 -> GND
Вывод B светодиода -> Сток MOSFET 3 -> Исток MOSFET 3 -> GND
 
Затвор MOSFET 1 -> 10 кОм резистор -> GND
Затвор MOSFET 1 -> Пин 3 Arduino (ШИМ)
 
Затвор MOSFET 2 -> 10 кОм резистор -> GND
Затвор MOSFET 2 -> Пин 5 Arduino (ШИМ)
 
Затвор MOSFET 3 -> 10 кОм резистор -> GND
Затвор MOSFET 3 -> Пин 6 Arduino (ШИМ)

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
 
const int RED_PIN = 3;
const int GREEN_PIN = 5;
const int BLUE_PIN = 6;
 
String btBuffer = "";
boolean stringComplete = false;
 
void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
  
  // Начальный цвет - белый
  analogWrite(RED_PIN, 255);
  analogWrite(GREEN_PIN, 255);
  analogWrite(BLUE_PIN, 255);
  
  Serial.println("RGB-контроллер запущен");
}
 
void loop() {
  // Чтение данных от Bluetooth
  while(btSerial.available()) {
    char inChar = (char)btSerial.read();
    if (inChar == '\n') {
      stringComplete = true;
    } else {
      btBuffer += inChar;
    }
  }
  
  // Обработка команды
  if (stringComplete) {
    processCommand(btBuffer);
    btBuffer = "";
    stringComplete = false;
  }
}
 
void processCommand(String command) {
  if (command.startsWith("RGB:")) {
    // Формат команды: RGB:R,G,B
    // Например: RGB:255,0,128
    
    command = command.substring(4); // Убираем "RGB:"
    
    int firstComma = command.indexOf(',');
    int secondComma = command.indexOf(',', firstComma + 1);
    
    if (firstComma != -1 && secondComma != -1) {
      int red = command.substring(0, firstComma).toInt();
      int green = command.substring(firstComma + 1, secondComma).toInt();
      int blue = command.substring(secondComma + 1).toInt();
      
      // Ограничиваем значения
      red = constrain(red, 0, 255);
      green = constrain(green, 0, 255);
      blue = constrain(blue, 0, 255);
      
      // Устанавливаем цвет
      analogWrite(RED_PIN, red);
      analogWrite(GREEN_PIN, green);
      analogWrite(BLUE_PIN, blue);
      
      // Отправляем подтверждение
      btSerial.print("OK:RGB=");
      btSerial.print(red);
      btSerial.print(",");
      btSerial.print(green);
      btSerial.print(",");
      btSerial.println(blue);
    }
  }
  else if (command == "STATUS") {
    // Запрос текущего состояния
    int red = analogRead(RED_PIN) / 4; // Преобразуем из 10-бит в 8-бит
    int green = analogRead(GREEN_PIN) / 4;
    int blue = analogRead(BLUE_PIN) / 4;
    
    btSerial.print("STATUS:RGB=");
    btSerial.print(red);
    btSerial.print(",");
    btSerial.print(green);
    btSerial.print(",");
    btSerial.println(blue);
  }
}

#include <SoftwareSerial.h>
#include <DHT.h>
#include <Wire.h>
#include <Adafruit_BMP085.h>
 
#define DHTPIN 7      // Пин для DHT22
#define DHTTYPE DHT22 // Тип датчика DHT
#define LDR_PIN A0    // Пин для фоторезистора
 
SoftwareSerial btSerial(10, 11); // RX, TX
DHT dht(DHTPIN, DHTTYPE);
Adafruit_BMP085 bmp;
 
unsigned long lastSendTime = 0;
const long sendInterval = 10000; // Интервал отправки данных (10 секунд)
 
void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  dht.begin();
  
  if (!bmp.begin()) {
    Serial.println("Не найден датчик BMP180!");
    while (1) {}
  }
  
  Serial.println("Метеостанция запущена");
}
 
void loop() {
  // Проверяем входящие команды
  if (btSerial.available()) {
    String command = btSerial.readStringUntil('\n');
    if (command == "GET_DATA") {
      sendSensorData();
    }
  }
  
  // Периодически отправляем данные
  unsigned long currentMillis = millis();
  if (currentMillis - lastSendTime >= sendInterval) {
    lastSendTime = currentMillis;
    sendSensorData();
  }
}
 
void sendSensorData() {
  // Чтение данных с датчиков
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();
  float pressure = bmp.readPressure() / 100.0F; // в гПа
  int light = analogRead(LDR_PIN);
  
  // Проверка на ошибки чтения
  if (isnan(humidity) || isnan(temperature)) {
    btSerial.println("ERROR:DHT_READ_FAILED");
    return;
  }
  
  // Отправка данных в JSON-подобном формате
  btSerial.print("{");
  btSerial.print("\"temp\":");
  btSerial.print(temperature);
  btSerial.print(",\"hum\":");
  btSerial.print(humidity);
  btSerial.print(",\"press\":");
  btSerial.print(pressure);
  btSerial.print(",\"light\":");
  btSerial.print(light);
  btSerial.println("}");
  
  // Дублируем в последовательный порт для отладки
  Serial.print("Темп: ");
  Serial.print(temperature);
  Serial.print("°C, Влаж: ");
  Serial.print(humidity);
  Serial.print("%, Давл: ");
  Serial.print(pressure);
  Serial.print("гПа, Свет: ");
  Serial.println(light);
}

#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <Servo.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
Servo lockServo;
 
const int SERVO_PIN = 9;
const int LED_RED = 7;
const int LED_GREEN = 6;
const int BUZZER_PIN = 5;
 
String password = "1234"; // Начальный пароль
int failedAttempts = 0;
unsigned long lockoutTime = 0;
boolean isLocked = true;
 
void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  
  // Инициализация сервопривода и светодиодов
  lockServo.attach(SERVO_PIN);
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  
  // Начальное состояние - заперто
  lockServo.write(0);
  digitalWrite(LED_RED, HIGH);
  digitalWrite(LED_GREEN, LOW);
  
  // Загрузка пароля из EEPROM
  if (EEPROM.read(0) == 123) { // Маркер валидности
    String storedPass = "";
    for (int i = 1; i <= 4; i++) {
      char c = EEPROM.read(i);
      if (c != 0) storedPass += c;
    }
    if (storedPass.length() > 0) {
      password = storedPass;
    }
  }
  
  Serial.println("Система контроля доступа запущена");
  Serial.println("Текущий пароль: " + password);
}
 
void loop() {
  // Проверка периода блокировки
  if (millis() < lockoutTime) {
    return; // Еще в периоде блокировки
  }
  
  // Чтение команд от Bluetooth
  if (btSerial.available()) {
    String command = btSerial.readStringUntil('\n');
    processCommand(command);
  }
}
 
void processCommand(String command) {
  if (command.startsWith("UNLOCK:")) {
    // Команда разблокировки с паролем
    String inputPass = command.substring(7);
    
    if (password == inputPass) {
      // Пароль верный
      failedAttempts = 0;
      unlockDoor();
      btSerial.println("SUCCESS:DOOR_UNLOCKED");
    } else {
      // Пароль неверный
      failedAttempts++;
      
      if (failedAttempts >= 3) {
        // Слишком много неудачных попыток
        lockoutTime = millis() + 30000; // Блокировка на 30 секунд
        btSerial.println("ERROR:TOO_MANY_ATTEMPTS");
        alertSound();
      } else {
        btSerial.println("ERROR:WRONG_PASSWORD");
        errorSound();
      }
    }
  }
  else if (command.startsWith("CHANGE_PASS:")) {
    // Изменение пароля (формат: CHANGE_PASS:старый:новый)
    int colonPos = command.indexOf(':', 12);
    if (colonPos != -1) {
      String oldPass = command.substring(12, colonPos);
      String newPass = command.substring(colonPos + 1);
      
      if (password == oldPass) {
        // Сохраняем новый пароль
        password = newPass;
        savePasswordToEEPROM(newPass);
        btSerial.println("SUCCESS:PASSWORD_CHANGED");
      } else {
        btSerial.println("ERROR:WRONG_PASSWORD");
      }
    }
  }
  else if (command == "LOCK") {
    // Закрыть дверь
    lockDoor();
    btSerial.println("SUCCESS:DOOR_LOCKED");
  }
}
 
void unlockDoor() {
  lockServo.write(90); // Поворот сервопривода
  digitalWrite(LED_RED, LOW);
  digitalWrite(LED_GREEN, HIGH);
  isLocked = false;
  successSound();
}
 
void lockDoor() {
  lockServo.write(0); // Возврат сервопривода
  digitalWrite(LED_RED, HIGH);
  digitalWrite(LED_GREEN, LOW);
  isLocked = true;
}
 
void savePasswordToEEPROM(String pass) {
  EEPROM.write(0, 123); // Маркер валидности
  for (int i = 0; i < pass.length(); i++) {
    EEPROM.write(i + 1, pass.charAt(i));
  }
  // Очищаем оставшиеся байты, если новый пароль короче старого
  for (int i = pass.length() + 1; i <= 4; i++) {
    EEPROM.write(i, 0);
  }
}
 
void errorSound() {
  tone(BUZZER_PIN, 400, 200);
  delay(300);
}
 
void successSound() {
  tone(BUZZER_PIN, 1000, 100);
  delay(150);
  tone(BUZZER_PIN, 1500, 100);
}
 
void alertSound() {
  for (int i = 0; i < 3; i++) {
    tone(BUZZER_PIN, 800, 200);
    delay(300);
  }
}

#include <SoftwareSerial.h>
#include <DHT.h>
#include <ArduinoJson.h>
 
#define DHTPIN 7
#define DHTTYPE DHT22
 
SoftwareSerial btSerial(10, 11); // RX, TX
DHT dht(DHTPIN, DHTTYPE);
 
unsigned long lastSendTime = 0;
const long sendInterval = 60000; // Отправка раз в минуту для экономии трафика
 
void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  dht.begin();
  
  Serial.println("Bluetooth Cloud Bridge запущен");
}
 
void loop() {
  unsigned long currentMillis = millis();
  
  // Периодическая отправка данных
  if (currentMillis - lastSendTime >= sendInterval) {
    lastSendTime = currentMillis;
    sendDataToCloud();
  }
  
  // Обработка команд от смартфона
  if (btSerial.available()) {
    String command = btSerial.readStringUntil('\n');
    if (command == "GET_DATA") {
      sendDataToCloud();
    }
  }
}
 
void sendDataToCloud() {
  // Создаем JSON-документ
  StaticJsonDocument<200> doc;
  
  // Читаем данные с датчиков
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();
  
  // Добавляем таймстамп (в секундах с запуска Arduino)
  doc["timestamp"] = millis() / 1000;
  doc["device_id"] = "arduino_01";
  
  // Проверяем ошибки чтения
  if (isnan(humidity) || isnan(temperature)) {
    doc["error"] = "Failed to read from DHT sensor!";
  } else {
    doc["temperature"] = temperature;
    doc["humidity"] = humidity;
    doc["battery"] = readBatteryLevel();
  }
  
  // Сериализуем JSON в строку
  String jsonString;
  serializeJson(doc, jsonString);
  
  // Отправляем через Bluetooth
  btSerial.println(jsonString);
  Serial.println("Отправлено: " + jsonString);
}
 
float readBatteryLevel() {
  // Простая имитация чтения уровня батареи
  // В реальном проекте здесь был бы код для считывания напряжения
  return random(30, 100) / 100.0;
}

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
 
// Идентификатор этого узла
const char NODE_ID = 'B';
 
// Буфер для сообщений
char msgBuffer[64];
int bufferIndex = 0;
 
// Таблица маршрутизации (очень упрощенная)
// Для каждого узла указываем, через кого к нему можно достучаться
char routingTable[3][2] = {
  {'A', 'A'}, // Для отправки на узел A нужно отправить на A
  {'B', 'B'}, // Это мы сами
  {'C', 'C'}  // Для отправки на C нужно отправить на C
};
 
void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  
  Serial.println("Mesh Node " + String(NODE_ID) + " запущен");
}
 
void loop() {
  // Читаем сообщения от Bluetooth
  while (btSerial.available()) {
    char c = btSerial.read();
    
    // Если получен конец сообщения - обрабатываем его
    if (c == '\n') {
      msgBuffer[bufferIndex] = '\0'; // Завершаем строку
      processMessage(msgBuffer);
      bufferIndex = 0; // Сбрасываем буфер
    } else if (bufferIndex < sizeof(msgBuffer) - 1) {
      // Иначе добавляем символ в буфер
      msgBuffer[bufferIndex++] = c;
    }
  }
  
  // Читаем сообщения от последовательного порта (для отладки)
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    
    if (command.startsWith("SEND:")) {
      // Формат: SEND:узел:сообщение
      char targetNode = command.charAt(5);
      String message = command.substring(7);
      
      sendMessageToNode(targetNode, message);
    }
  }
}
 
void processMessage(char* message) {
  // Формат сообщения: FROM:TO:MESSAGE
  // Например: A:C:Hello from A
  
  Serial.print("Получено: ");
  Serial.println(message);
  
  char fromNode = message[0];
  char toNode = message[2];
  
  // Если сообщение для нас, выводим его
  if (toNode == NODE_ID) {
    Serial.print("Сообщение от ");
    Serial.print(fromNode);
    Serial.print(": ");
    Serial.println(message + 4); // Пропускаем FROM:TO:
  } 
  // Иначе, если это не для нас - перенаправляем
  else {
    forwardMessage(message);
  }
}
 
void forwardMessage(char* message) {
  char toNode = message[2];
  
  // Находим следующий узел для перенаправления
  char nextHop = findNextHop(toNode);
  
  if (nextHop != '0') {
    Serial.print("Перенаправляем сообщение для ");
    Serial.print(toNode);
    Serial.print(" через ");
    Serial.println(nextHop);
    
    // Отправляем сообщение без изменений
    btSerial.println(message);
  } else {
    Serial.print("Не знаю, как доставить сообщение для ");
    Serial.println(toNode);
  }
}
 
char findNextHop(char targetNode) {
  // Поиск в таблице маршрутизации
  for (int i = 0; i < 3; i++) {
    if (routingTable[i][0] == targetNode) {
      return routingTable[i][1];
    }
  }
  
  return '0'; // Маршрут не найден
}
 
void sendMessageToNode(char targetNode, String message) {
  String fullMessage = String(NODE_ID) + ":" + targetNode + ":" + message;
  
  // Находим следующий узел для перенаправления
  char nextHop = findNextHop(targetNode);
  
  if (nextHop != '0') {
    Serial.print("Отправляем сообщение для ");
    Serial.println(targetNode);
    
    btSerial.println(fullMessage);
  } else {
    Serial.print("Не знаю, как доставить сообщение для ");
    Serial.println(targetNode);
  }
}

#include <SoftwareSerial.h>
 
SoftwareSerial btSerial(10, 11); // RX, TX
 
// Буфер для хранения изображения или других бинарных данных
byte dataBuffer[1024];
int dataSize = 0;
 
// Временный буфер для приема
byte tempBuffer[64];
int tempSize = 0;
 
// Признаки начала и конца бинарного пакета
const byte START_MARKER = 0xAA;
const byte END_MARKER = 0x55;
boolean receivingData = false;
 
void setup() {
  Serial.begin(115200); // Используем более высокую скорость для отладки
  btSerial.begin(115200); // И для Bluetooth тоже
  
  Serial.println("Система передачи бинарных данных запущена");
}
 
void loop() {
  // Проверяем, есть ли команды от компьютера
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    
    if (command == "SEND_TEST") {
      sendTestData();
    }
  }
  
  // Читаем данные от Bluetooth
  while (btSerial.available()) {
    byte inByte = btSerial.read();
    
    // Если получен маркер начала и мы еще не принимаем данные
    if (inByte == START_MARKER && !receivingData) {
      receivingData = true;
      dataSize = 0; // Сбрасываем счетчик данных
      Serial.println("Начало приема данных");
    }
    // Если получен маркер конца и мы принимаем данные
    else if (inByte == END_MARKER && receivingData) {
      receivingData = false;
      Serial.print("Данные получены, размер: ");
      Serial.println(dataSize);
      
      // Здесь можно обработать полученные данные
      processReceivedData();
    }
    // Если мы в процессе приема данных
    else if (receivingData) {
      if (dataSize < sizeof(dataBuffer)) {
        dataBuffer[dataSize++] = inByte;
      } else {
        // Буфер переполнен
        receivingData = false;
        Serial.println("Ошибка: буфер переполнен!");
      }
    }
  }
}
 
void sendTestData() {
  // Генерируем тестовые данные
  for (int i = 0; i < 512; i++) {
    dataBuffer[i] = i % 256;
  }
  
  // Отправляем данные
  sendBinaryData(dataBuffer, 512);
}
 
void sendBinaryData(byte* data, int size) {
  Serial.print("Отправка бинарных данных, размер: ");
  Serial.println(size);
  
  // Отправляем маркер начала
  btSerial.write(START_MARKER);
  
  // Отправляем данные блоками для надежности
  for (int i = 0; i < size; i++) {
    btSerial.write(data[i]);
    
    // Небольшая задержка каждые 64 байта для предотвращения переполнения буфера
    if (i % 64 == 63) {
      delay(10);
    }
  }
  
  // Отправляем маркер конца
  btSerial.write(END_MARKER);
}
 
void processReceivedData() {
  // Здесь можно обработать полученные данные
  // Например, сохранить их, отобразить или передать дальше
  
  Serial.println("Первые 10 байт полученных данных:");
  for (int i = 0; i < 10 && i < dataSize; i++) {
    Serial.print(dataBuffer[i], HEX);
    Serial.print(" ");
  }
  Serial.println();
}

#include <SoftwareSerial.h>
#include <DHT.h>
#include <Wire.h>
#include <Adafruit_BMP085.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <ArduinoJson.h>
#include <EEPROM.h>
 
// Пины для устройств
#define BT_RX_PIN 10
#define BT_TX_PIN 11
#define DHT_PIN 7
#define ONE_WIRE_BUS 8
#define PIR_PIN 4
#define LDR_PIN A0
#define RELAY1_PIN 22
#define RELAY2_PIN 24
#define RELAY3_PIN 26
#define RELAY4_PIN 28
#define RGB_R_PIN 3
#define RGB_G_PIN 5
#define RGB_B_PIN 6
 
// Типы датчиков
#define DHTTYPE DHT22
 
// Настройки
#define SECURITY_ENABLED true
#define AUTO_LIGHT_ENABLED true
#define TEMP_CHECK_INTERVAL 30000
#define SECURITY_CHECK_INTERVAL 1000
#define LIGHT_CHECK_INTERVAL 5000
 
// Объекты для работы с устройствами
SoftwareSerial btSerial(BT_RX_PIN, BT_TX_PIN);
DHT dht(DHT_PIN, DHTTYPE);
Adafruit_BMP085 bmp;
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature tempSensors(&oneWire);
 
// Структура для хранения состояния
struct SystemState {
  bool relay[4] = {false, false, false, false};
  byte rgbColor[3] = {0, 0, 0}; // R, G, B
  bool securityActive = false;
  bool motionDetected = false;
  bool autoLightMode = AUTO_LIGHT_ENABLED;
  float tempThreshold = 25.0;
  int lightThreshold = 500;
  char password[10] = "1234"; // Пароль для управления системой
  bool isAuthenticated = false;
  unsigned long authTimeout = 0;
} state;
 
// Таймеры для периодических задач
unsigned long lastTempCheck = 0;
unsigned long lastSecurityCheck = 0;
unsigned long lastLightCheck = 0;
 
// Буфер для Bluetooth-команд
String btBuffer = "";
boolean stringComplete = false;
 
void setup() {
  // Инициализация последовательных портов
  Serial.begin(9600);
  btSerial.begin(9600);
  
  // Инициализация датчиков
  dht.begin();
  bmp.begin();
  tempSensors.begin();
  
  // Настройка пинов
  pinMode(RELAY1_PIN, OUTPUT);
  pinMode(RELAY2_PIN, OUTPUT);
  pinMode(RELAY3_PIN, OUTPUT);
  pinMode(RELAY4_PIN, OUTPUT);
  pinMode(RGB_R_PIN, OUTPUT);
  pinMode(RGB_G_PIN, OUTPUT);
  pinMode(RGB_B_PIN, OUTPUT);
  pinMode(PIR_PIN, INPUT);
  
  // Загрузка настроек из EEPROM
  loadSettings();
  
  // Применение начальных состояний
  updateOutputs();
  
  Serial.println("Система умного дома запущена");
  btSerial.println("SmartHome system ready");
}
 
void loop() {
  // Чтение данных от Bluetooth
  while(btSerial.available()) {
    char inChar = (char)btSerial.read();
    if (inChar == '\n') {
      stringComplete = true;
    } else {
      btBuffer += inChar;
    }
  }
  
  // Обработка полученной команды
  if (stringComplete) {
    processCommand(btBuffer);
    btBuffer = "";
    stringComplete = false;
  }
  
  // Периодические задачи
  unsigned long currentMillis = millis();
  
  // Проверка температуры и управление отоплением
  if (currentMillis - lastTempCheck >= TEMP_CHECK_INTERVAL) {
    lastTempCheck = currentMillis;
    checkTemperature();
  }
  
  // Проверка системы безопасности
  if (currentMillis - lastSecurityCheck >= SECURITY_CHECK_INTERVAL) {
    lastSecurityCheck = currentMillis;
    checkSecurity();
  }
  
  // Проверка освещенности и автоматическое управление светом
  if (currentMillis - lastLightCheck >= LIGHT_CHECK_INTERVAL) {
    lastLightCheck = currentMillis;
    checkLightLevel();
  }
  
  // Проверка таймаута аутентификации
  if (state.isAuthenticated && currentMillis > state.authTimeout) {
    state.isAuthenticated = false;
    btSerial.println("AUTH:TIMEOUT");
  }
}
 
// Обработка команд от Bluetooth
void processCommand(String command) {
  Serial.print("Получена команда: ");
  Serial.println(command);
  
  // Разбираем команду на части (команда:параметр)
  int separatorIndex = command.indexOf(':');
  
  if (separatorIndex != -1) {
    String cmd = command.substring(0, separatorIndex);
    String param = command.substring(separatorIndex + 1);
    
    // Команды, не требующие аутентификации
    if (cmd == "AUTH") {
      // Проверка пароля
      if (param == String(state.password)) {
        state.isAuthenticated = true;
        state.authTimeout = millis() + 300000; // 5 минут таймаут
        btSerial.println("AUTH:OK");
      } else {
        btSerial.println("AUTH:FAIL");
      }
      return;
    } else if (cmd == "GET_STATUS") {
      sendStatusUpdate();
      return;
    }
    
    // Проверка аутентификации для остальных команд
    if (!state.isAuthenticated) {
      btSerial.println("ERROR:NOT_AUTHENTICATED");
      return;
    }
    
    // Команды, требующие аутентификации
    if (cmd == "RELAY") {
      // Формат: RELAY:номер,состояние
      int comma = param.indexOf(',');
      if (comma != -1) {
        int relay = param.substring(0, comma).toInt();
        int value = param.substring(comma + 1).toInt();
        
        if (relay >= 1 && relay <= 4) {
          state.relay[relay-1] = (value == 1);
          updateOutputs();
          btSerial.print("RELAY:");
          btSerial.print(relay);
          btSerial.print(",");
          btSerial.println(value);
        }
      }
    } 
    else if (cmd == "RGB") {
      // Формат: RGB:R,G,B
      int firstComma = param.indexOf(',');
      int secondComma = param.indexOf(',', firstComma + 1);
      
      if (firstComma != -1 && secondComma != -1) {
        int r = param.substring(0, firstComma).toInt();
        int g = param.substring(firstComma + 1, secondComma).toInt();
        int b = param.substring(secondComma + 1).toInt();
        
        state.rgbColor[0] = constrain(r, 0, 255);
        state.rgbColor[1] = constrain(g, 0, 255);
        state.rgbColor[2] = constrain(b, 0, 255);
        updateOutputs();
        btSerial.print("RGB:");
        btSerial.print(state.rgbColor[0]);
        btSerial.print(",");
        btSerial.print(state.rgbColor[1]);
        btSerial.print(",");
        btSerial.println(state.rgbColor[2]);
      }
    }
    else if (cmd == "SECURITY") {
      // Включение/выключение охранной системы
      state.securityActive = (param == "1");
      btSerial.print("SECURITY:");
      btSerial.println(state.securityActive ? "1" : "0");
    }
    else if (cmd == "AUTO_LIGHT") {
      // Включение/выключение автоматического освещения
      state.autoLightMode = (param == "1");
      btSerial.print("AUTO_LIGHT:");
      btSerial.println(state.autoLightMode ? "1" : "0");
    }
    else if (cmd == "SET_TEMP") {
      // Установка порога температуры
      state.tempThreshold = param.toFloat();
      saveSettings();
      btSerial.print("TEMP_THRESHOLD:");
      btSerial.println(state.tempThreshold);
    }
    else if (cmd == "SET_LIGHT") {
      // Установка порога освещенности
      state.lightThreshold = param.toInt();
      saveSettings();
      btSerial.print("LIGHT_THRESHOLD:");
      btSerial.println(state.lightThreshold);
    }
    else if (cmd == "CHANGE_PASS") {
      // Смена пароля
      if (param.length() >= 4 && param.length() <= 9) {
        param.toCharArray(state.password, 10);
        saveSettings();
        btSerial.println("PASSWORD:CHANGED");
      } else {
        btSerial.println("ERROR:INVALID_PASSWORD");
      }
    }
  }
}
 
// Обновление выходов в соответствии с текущим состоянием
void updateOutputs() {
  digitalWrite(RELAY1_PIN, state.relay[0] ? HIGH : LOW);
  digitalWrite(RELAY2_PIN, state.relay[1] ? HIGH : LOW);
  digitalWrite(RELAY3_PIN, state.relay[2] ? HIGH : LOW);
  digitalWrite(RELAY4_PIN, state.relay[3] ? HIGH : LOW);
  
  analogWrite(RGB_R_PIN, state.rgbColor[0]);
  analogWrite(RGB_G_PIN, state.rgbColor[1]);
  analogWrite(RGB_B_PIN, state.rgbColor[2]);
}
 
// Проверка температуры и управление отоплением (реле 4)
void checkTemperature() {
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();
  float pressure = bmp.readPressure() / 100.0F;
  
  tempSensors.requestTemperatures();
  float floorTemp = tempSensors.getTempCByIndex(0);
  
  // Автоматическое управление отоплением
  if (!isnan(temperature) && temperature < state.tempThreshold && !state.relay[3]) {
    state.relay[3] = true;
    updateOutputs();
    btSerial.println("HEAT:ON");
  } else if (!isnan(temperature) && temperature > state.tempThreshold + 1.0 && state.relay[3]) {
    state.relay[3] = false;
    updateOutputs();
    btSerial.println("HEAT:OFF");
  }
  
  // Отправка информации о температуре
  btSerial.print("TEMP:");
  btSerial.println(temperature);
  btSerial.print("HUMIDITY:");
  btSerial.println(humidity);
  btSerial.print("PRESSURE:");
  btSerial.println(pressure);
  btSerial.print("FLOOR_TEMP:");
  btSerial.println(floorTemp);
}
 
// Проверка системы безопасности
void checkSecurity() {
  if (state.securityActive) {
    bool motion = digitalRead(PIR_PIN) == HIGH;
    
    if (motion && !state.motionDetected) {
      // Обнаружено движение
      state.motionDetected = true;
      btSerial.println("ALERT:MOTION_DETECTED");
      
      // Включаем свет в качестве реакции
      state.relay[0] = true;
      updateOutputs();
    } else if (!motion) {
      state.motionDetected = false;
    }
  }
}
 
// Проверка уровня освещенности и автоматическое управление светом
void checkLightLevel() {
  if (state.autoLightMode) {
    int lightLevel = analogRead(LDR_PIN);
    
    if (lightLevel < state.lightThreshold && !state.relay[0]) {
      // Темно, включаем свет
      state.relay[0] = true;
      updateOutputs();
      btSerial.println("LIGHT:AUTO_ON");
    } else if (lightLevel > state.lightThreshold + 100 && state.relay[0]) {
      // Светло, выключаем свет
      state.relay[0] = false;
      updateOutputs();
      btSerial.println("LIGHT:AUTO_OFF");
    }
    
    btSerial.print("LIGHT_LEVEL:");
    btSerial.println(lightLevel);
  }
}
 
// Отправка полного статуса системы
void sendStatusUpdate() {
  StaticJsonDocument<256> doc;
  
  doc["relay1"] = state.relay[0];
  doc["relay2"] = state.relay[1];
  doc["relay3"] = state.relay[2];
  doc["relay4"] = state.relay[3];
  doc["rgb_r"] = state.rgbColor[0];
  doc["rgb_g"] = state.rgbColor[1];
  doc["rgb_b"] = state.rgbColor[2];
  doc["security"] = state.securityActive;
  doc["auto_light"] = state.autoLightMode;
  doc["temp_threshold"] = state.tempThreshold;
  doc["light_threshold"] = state.lightThreshold;
  
  String jsonString;
  serializeJson(doc, jsonString);
  
  btSerial.println(jsonString);
}
 
// Сохранение настроек в EEPROM
void saveSettings() {
  EEPROM.put(0, state.tempThreshold);
  EEPROM.put(4, state.lightThreshold);
  EEPROM.put(8, state.password);
}
 
// Загрузка настроек из EEPROM
void loadSettings() {
  // Проверяем, инициализирован ли EEPROM
  float testValue;
  EEPROM.get(0, testValue);
  
  if (isnan(testValue) || testValue < -50 || testValue > 100) {
    // EEPROM не инициализирован, используем значения по умолчанию
    saveSettings();
  } else {
    EEPROM.get(0, state.tempThreshold);
    EEPROM.get(4, state.lightThreshold);
    EEPROM.get(8, state.password);
  }
}

VerticalArrangement (вертикальное расположение)
  - Label ("Умный дом")
  - Пустое пространство (маленький Label без текста)
  - HorizontalArrangement (горизонтальное расположение)
    - Label ("Пароль:")
    - PasswordTextBox
  - Button ("Войти")
  - Label ("Статус: Отключено") с Id="StatusLabel"

when Button1.Click
do
  call BluetoothClient1.Connect
  address "XX:XX:XX:XX:XX:XX" // MAC-адрес вашего HC-05

when LightButton.Click
do
  if LightButton.Text = "ВКЛ"
  then
    call BluetoothClient1.SendText
      text "RELAY:1,1
"
    set LightButton.Text to "ВЫКЛ"
  else
    call BluetoothClient1.SendText
      text "RELAY:1,0
"
    set LightButton.Text to "ВКЛ"

when BluetoothClient1.BytesReceived
do
  set global message to call BluetoothClient1.ReceiveText
  number -1
  call ProcessMessage
    message global message

to ProcessMessage message
  if message starts with "TEMP:"
  then
    set TempLabel.Text to join "Температура: " (select text from position 6 to end of message) "°C"
  else if message starts with "HUMIDITY:"
  then
    set HumidityLabel.Text to join "Влажность: " (select text from position 10 to end of message) "%"
  // Другие обработчики

when LoginButton.Click
do
  call BluetoothClient1.SendText
    text join "AUTH:" PasswordTextBox1.Text "
"

if message = "AUTH:OK"
then
  set global authenticated to true
  call TinyDB1.StoreValue
    tag "last_auth_time"
    valueToStore call Clock1.Now
  open another screen
    screenName "ControlPanel"
else if message = "AUTH:FAIL"
then
  set StatusLabel.Text to "Статус: Неверный пароль"

when Screen1.Initialize
do
  set global last_auth to call TinyDB1.GetValue
    tag "last_auth_time"
    valueIfTagNotThere 0
  if Clock1.Now - global last_auth < 86400000 // 24 часа в миллисекундах
  then
    set global authenticated to true
    open another screen
      screenName "ControlPanel"

// Глобальные переменные для хранения истории показаний
initialize global tempHistory to create empty list
initialize global timeHistory to create empty list
 
// Функция для добавления новой точки на график
to AddTempPoint temp
  if length of global tempHistory > 24
  then
    remove list item
      list global tempHistory
      index 1
    remove list item
      list global timeHistory
      index 1
  add items to list
    list global tempHistory
    item temp
  add items to list
    list global timeHistory
    item Clock1.Now
  call DrawTempGraph

to DrawTempGraph
  call Canvas1.Clear
  set local minTemp to min of list global tempHistory
  set local maxTemp to max of list global tempHistory
  set local range to maxTemp - minTemp + 2 // +2 для отступов
  set local width to Canvas1.Width
  set local height to Canvas1.Height
  
  // Рисуем оси
  call Canvas1.DrawLine
    x1 10
    y1 height - 10
    x2 width - 10
    y2 height - 10
    color #000000
    lineWidth 2
  call Canvas1.DrawLine
    x1 10
    y1 10
    x2 10
    y2 height - 10
    color #000000
    lineWidth 2
    
  // Рисуем точки и соединяем их линиями
  for each item temp in global tempHistory with index i
    set local x to 10 + (i * (width - 20) / length of global tempHistory)
    set local y to height - 10 - ((temp - minTemp + 1) * (height - 20) / range)
    call Canvas1.DrawCircle
      x x
      y y
      r 3
      fill #FF0000
      stroke #FF0000
    if i > 1
    then
      set local prevX to 10 + ((i - 1) * (width - 20) / length of global tempHistory)
      set local prevY to height - 10 - ((select list item from global tempHistory at position (i - 1)) - minTemp + 1) * (height - 20) / range
      call Canvas1.DrawLine
        x1 prevX
        y1 prevY
        x2 x
        y2 y
        color #FF0000
        lineWidth 2

when BluetoothClient1.BytesReceived
do
  set local message to call BluetoothClient1.ReceiveText
    number -1
  call ProcessMessage
    message local message
  // Добавляем отладочную информацию
  set DebugText.Text to join DebugText.Text "RX: " local message "
"

when TestButton.Click
do
  call ProcessMessage
    message "TEMP:23.5"
  call Clock1.Timer
    call ProcessMessage
      message "HUMIDITY:45.2"
  call Clock1.Timer
    call ProcessMessage
      message "PRESSURE:748.3"

const int BT_POWER_PIN = 8; // Пин для управления питанием HC-05
 
void setup() {
  pinMode(BT_POWER_PIN, OUTPUT);
  digitalWrite(BT_POWER_PIN, LOW); // Изначально модуль выключен
}
 
void wakeUpBluetooth() {
  digitalWrite(BT_POWER_PIN, HIGH);
  delay(1000); // Даем время на инициализацию
}
 
void sleepBluetooth() {
  digitalWrite(BT_POWER_PIN, LOW);
}

// Функция шифрования/дешифрования
String encryptDecrypt(String data, String key) {
  String result = "";
  for (int i = 0; i < data.length(); i++) {
    result += (char)(data[i] ^ key[i % key.length()]);
  }
  return result;
}
 
// Использование
String message = "TEMP:25.5";
String key = "SECRET_KEY";
String encrypted = encryptDecrypt(message, key);
btSerial.println(encrypted);
 
// На стороне приемника
String received = btSerial.readStringUntil('
');
String decrypted = encryptDecrypt(received, key);

// Отправка данных в бинарном формате
void sendBinaryData(byte paramCode, float value) {
  byte data[2];
  data[0] = paramCode;
  data[1] = (byte)(value * 10); // Преобразуем в fixed-point
  btSerial.write(data, 2);
}
 
// Использование
sendBinaryData(0x01, 25.5); // Отправка температуры