Как работать с модулем ESP-12E NodeMcu V3 в ArduinoIDE

http://arduino.esp8266.com/stable/package_esp8266com_index.json

// Пример соответствия пинов NodeMcu и GPIO
int ledPin = D1;  // На плате обозначен как D1
// Эквивалентно
int ledPin = 5;   // GPIO5 в системе ESP8266

// Пример перехода в режим глубокого сна на 10 минут
ESP.deepSleep(10 * 60 * 1000000); // Время в микросекундах

// Так делать НЕ надо!
void loop() {
  // Считываем температуру
  float temp = readTemperature();
  // Выводим на дисплей
  displayTemperature(temp);
  // Блокируем выполнение на 2 секунды
  delay(2000);
  // Wi-Fi стек не получает управление и соединение разрывается!
}

unsigned long previousMillis = 0;
const long interval = 2000;
 
void loop() {
  // Текущее время
  unsigned long currentMillis = millis();
  
  // Обновляем показания только через определенный интервал
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    float temp = readTemperature();
    displayTemperature(temp);
  }
  
  // Здесь Wi-Fi стек получает управление и может обрабатывать пакеты
  yield();
}

#include <LittleFS.h>
 
void setup() {
  Serial.begin(115200);
  
  if(!LittleFS.begin()) {
    Serial.println("Ошибка монтирования файловой системы!");
    return;
  }
  
  // Открываем файл для записи
  File configFile = LittleFS.open("/config.json", "w");
  if(!configFile) {
    Serial.println("Не удалось открыть файл для записи!");
    return;
  }
  
  // Записываем данные
  configFile.println("{\"ssid\":\"MyNetwork\",\"password\":\"secret\"}");
  configFile.close();
  
  Serial.println("Файл успешно записан!");
}

#include <ESP8266mDNS.h>
 
void setup() {
  // Инициализация Wi-Fi опущена для краткости
  
  // Запускаем mDNS с именем "myesp8266"
  if (!MDNS.begin("myesp8266")) {
    Serial.println("Ошибка запуска mDNS!");
  } else {
    Serial.println("mDNS запущен, устройство доступно по адресу myesp8266.local");
  }
}

#include <RemoteDebug.h>
 
RemoteDebug Debug;
 
void setup() {
  // Инициализация Wi-Fi опущена для краткости
  
  // Запускаем удалённую отладку
  Debug.begin("ESP8266");
  Debug.setResetCmdEnabled(true);
  
  Debug.println("Отладка запущена!");
}
 
void loop() {
  // Важно: нужно регулярно вызывать handle() для обработки команд
  Debug.handle();
  
  // Разные уровни отладочных сообщений
  Debug.verbose("Это подробное сообщение");
  Debug.debug("Это отладочное сообщение");
  Debug.info("Это информационное сообщение");
  Debug.warning("Это предупреждение");
  Debug.error("Это сообщение об ошибке");
  
  delay(1000);
}

NodeMcu D7 (GPIO13) ---> Резистор 220 Ом ---> LED (+) ---> LED (-) ---> GND

void setup() {
  // Инициализируем цифровой пин 13 (D7) как выход
  pinMode(13, OUTPUT);
}
 
void loop() {
  digitalWrite(13, HIGH);  // Включаем светодиод (HIGH - высокий уровень напряжения)
  delay(1000);            // Ждём 1 секунду
  digitalWrite(13, LOW);   // Выключаем светодиод (LOW - низкий уровень напряжения)
  delay(1000);            // Ждём ещё 1 секунду
}

pinMode(D7, OUTPUT);
digitalWrite(D7, HIGH);
digitalWrite(D7, LOW);

unsigned long previousMillis = 0;
const long interval = 1000;
int ledState = LOW;
const int ledPin = 13;
 
void setup() {
  pinMode(ledPin, OUTPUT);
}
 
void loop() {
  unsigned long currentMillis = millis();
  
  // Проверяем, прошёл ли нужный интервал времени
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    
    // Меняем состояние светодиода на противоположное
    ledState = (ledState == LOW) ? HIGH : LOW;
    digitalWrite(ledPin, ledState);
  }
  
  // Здесь можно выполнять другие задачи без блокировки
  // например, проверять Wi-Fi соединение или считывать датчики
}

const int ledPin = 13;
 
void setup() {
  pinMode(ledPin, OUTPUT);
}
 
void loop() {
  // Плавное увеличение яркости
  for (int brightness = 0; brightness <= 255; brightness++) {
    analogWrite(ledPin, brightness);
    delay(10);
  }
  
  // Плавное уменьшение яркости
  for (int brightness = 255; brightness >= 0; brightness--) {
    analogWrite(ledPin, brightness);
    delay(10);
  }
}

const int ledPin = 13;
 
void setup() {
  pinMode(ledPin, OUTPUT);
  // Инициализируем генератор случайных чисел
  randomSeed(analogRead(A0));
}
 
void loop() {
  int brightness = random(100, 255);  // Случайная яркость
  analogWrite(ledPin, brightness);
  
  int flickerTime = random(50, 150);  // Случайная продолжительность
  delay(flickerTime);
}

// Код для мигания встроенным светодиодом на NodeMcu
void setup() {
  pinMode(2, OUTPUT);  // GPIO2 = D4 = встроенный светодиод
}
 
void loop() {
  digitalWrite(2, LOW);   // Включаем светодиод (инверсная логика!)
  delay(1000);
  digitalWrite(2, HIGH);  // Выключаем светодиод
  delay(1000);
}

#include <DHT.h>
 
#define DHTPIN D4     // Пин, к которому подключен датчик
#define DHTTYPE DHT22 // Тип датчика (DHT11 или DHT22)
 
DHT dht(DHTPIN, DHTTYPE);
 
void setup() {
  Serial.begin(115200);
  dht.begin();
}
 
void loop() {
  delay(2000); // Датчику нужно время между измерениями
  
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  if (isnan(h) || isnan(t)) {
    Serial.println("Ошибка чтения с датчика DHT!");
    return;
  }
  
  Serial.print("Влажность: ");
  Serial.print(h);
  Serial.print("%, Температура: ");
  Serial.print(t);
  Serial.println("°C");
}

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <DHT.h>
 
// Конфигурация WiFi
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
 
// Настройка датчика и пина светодиода
#define DHTPIN D4
#define DHTTYPE DHT22
#define LEDPIN D7
 
DHT dht(DHTPIN, DHTTYPE);
ESP8266WebServer server(80);
 
void setup() {
  Serial.begin(115200);
  pinMode(LEDPIN, OUTPUT);
  dht.begin();
  
  // Подключаемся к WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Подключено к WiFi. IP адрес: ");
  Serial.println(WiFi.localIP());
  
  // Настраиваем маршруты сервера
  server.on("/", handleRoot);
  server.on("/led/on", [](){
    digitalWrite(LEDPIN, HIGH);
    server.send(200, "text/plain", "LED ON");
  });
  server.on("/led/off", [](){
    digitalWrite(LEDPIN, LOW);
    server.send(200, "text/plain", "LED OFF");
  });
  
  server.begin();
  Serial.println("HTTP сервер запущен");
}
 
void loop() {
  server.handleClient();
}
 
void handleRoot() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  String html = "<html><head>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1.0'>";
  html += "<style>body {font-family: Arial; text-align: center;}</style>";
  html += "</head><body>";
  html += "<h1>ESP8266 Веб-сервер</h1>";
  
  if (isnan(h) || isnan(t)) {
    html += "<p>Ошибка чтения с датчика!</p>";
  } else {
    html += "<p>Температура: " + String(t) + " °C</p>";
    html += "<p>Влажность: " + String(h) + " %</p>";
  }
  
  html += "<p><a href='/led/on'><button>Включить LED</button></a>";
  html += "<a href='/led/off'><button>Выключить LED</button></a></p>";
  html += "</body></html>";
  
  server.send(200, "text/html", html);
}

#include <LittleFS.h>
 
void setup() {
  Serial.begin(115200);
  
  if(!LittleFS.begin()) {
    Serial.println("Ошибка монтирования LittleFS");
    return;
  }
  
  // Чтение файла
  File file = LittleFS.open("/config.json", "r");
  if(!file) {
    Serial.println("Не удалось открыть файл");
    return;
  }
  
  while(file.available()) {
    Serial.write(file.read());
  }
  file.close();
}

#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
 
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
 
void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  // Настройка OTA
  ArduinoOTA.setHostname("esp8266-device"); // mDNS имя
  ArduinoOTA.setPassword("admin"); // Пароль для OTA
  
  ArduinoOTA.onStart([]() {
    Serial.println("Начало обновления");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nОбновление завершено");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Прогресс: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Ошибка[%u]: ", error);
    if (error == OTA_AUTH_ERROR) Serial.println("Ошибка аутентификации");
    else if (error == OTA_BEGIN_ERROR) Serial.println("Ошибка начала обновления");
    else if (error == OTA_CONNECT_ERROR) Serial.println("Ошибка соединения");
    else if (error == OTA_RECEIVE_ERROR) Serial.println("Ошибка получения данных");
    else if (error == OTA_END_ERROR) Serial.println("Ошибка завершения обновления");
  });
  
  ArduinoOTA.begin();
  Serial.println("OTA готов");
}
 
void loop() {
  ArduinoOTA.handle();
  // Основной код программы
}

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
 
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
 
// Сертификат сервера (пример)
const char* rootCACertificate = \
"-----BEGIN CERTIFICATE-----\n" \
"MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmVoRLvFzANBgkqhkiG9w0BAQUFADA/\n" \
"MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT\n" \
"DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow\n" \
"PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD\n" \
"Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n" \
"..." \
"-----END CERTIFICATE-----\n";
 
void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  WiFiClientSecure client;
  client.setCACert(rootCACertificate);
  
  if (!client.connect("example.com", 443)) {
    Serial.println("Соединение не удалось!");
    return;
  }
  
  // Отправка HTTPS запроса
  client.println("GET / HTTP/1.1");
  client.println("Host: example.com");
  client.println("Connection: close");
  client.println();
  
  // Чтение ответа
  while (client.connected()) {
    String line = client.readStringUntil('\n');
    Serial.println(line);
  }
}

#include <painlessMesh.h>
 
#define MESH_PREFIX     "MeshNetwork"
#define MESH_PASSWORD   "meshPassword"
#define MESH_PORT       5555
 
painlessMesh mesh;
 
void setup() {
  Serial.begin(115200);
  
  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT);
  mesh.onReceive(&receivedCallback);
  mesh.onNewConnection(&newConnectionCallback);
  mesh.onChangedConnections(&changedConnectionCallback);
}
 
void loop() {
  mesh.update();
  
  // Отправка сообщения каждые 5 секунд
  if(millis() % 5000 == 0) {
    String msg = "Привет из узла #";
    msg += mesh.getNodeId();
    mesh.sendBroadcast(msg);
  }
}
 
void receivedCallback(uint32_t from, String &msg) {
  Serial.printf("Получено от %u: %s\n", from, msg.c_str());
}
 
void newConnectionCallback(uint32_t nodeId) {
  Serial.printf("Новое подключение: %u\n", nodeId);
}
 
void changedConnectionCallback() {
  Serial.println("Изменения в соединениях");
}

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
 
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
const char* mqtt_server = "broker.hivemq.com"; // Публичный MQTT-брокер
 
WiFiClient espClient;
PubSubClient client(espClient);
 
void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}
 
void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  // Публикуем данные каждые 30 секунд
  static unsigned long lastPublish = 0;
  if (millis() - lastPublish > 30000) {
    lastPublish = millis();
    
    String topic = "esp8266/";
    topic += WiFi.macAddress();
    topic += "/temperature";
    
    float temperature = 25.5; // В реальном проекте здесь будут данные с датчика
    client.publish(topic.c_str(), String(temperature).c_str());
  }
}
 
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Получено сообщение [");
  Serial.print(topic);
  Serial.print("] ");
  
  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  
  Serial.println(message);
}
 
void reconnect() {
  while (!client.connected()) {
    Serial.print("Подключение к MQTT...");
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);
    
    if (client.connect(clientId.c_str())) {
      Serial.println("подключено");
      
      // Подписываемся на тему
      client.subscribe("esp8266/command");
    } else {
      Serial.print("ошибка, rc=");
      Serial.print(client.state());
      Serial.println(" повторная попытка через 5 секунд");
      delay(5000);
    }
  }
}

#include <ESP8266WiFi.h>
#include <Adafruit_MQTT.h>
#include <Adafruit_MQTT_Client.h>
 
#define WIFI_SSID "ВашаСеть"
#define WIFI_PASS "ВашПароль"
 
#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "ваше_имя_пользователя"
#define AIO_KEY         "ваш_ключ_api"
 
WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
 
// Каналы для публикации/подписки
Adafruit_MQTT_Publish tempPub = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/temperature");
Adafruit_MQTT_Subscribe ledControl = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/led");
 
void setup() {
  Serial.begin(115200);
  pinMode(BUILTIN_LED, OUTPUT);
  
  // Подключение к WiFi
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  // Настройка подписки
  mqtt.subscribe(&ledControl);
}
 
void loop() {
  // Поддержка соединения с MQTT
  MQTT_connect();
  
  // Проверка входящих сообщений
  Adafruit_MQTT_Subscribe *subscription;
  while ((subscription = mqtt.readSubscription(5000))) {
    if (subscription == &ledControl) {
      Serial.print("Получена команда: ");
      Serial.println((char *)ledControl.lastread);
      
      if (strcmp((char *)ledControl.lastread, "ON") == 0) {
        digitalWrite(BUILTIN_LED, LOW); // Включение (инверсная логика)
      } else {
        digitalWrite(BUILTIN_LED, HIGH); // Выключение
      }
    }
  }
  
  // Публикация данных каждые 30 секунд
  static unsigned long lastPublishTime = 0;
  if (millis() - lastPublishTime > 30000) {
    lastPublishTime = millis();
    
    float temperature = 25.5; // В реальном проекте - показания датчика
    
    if (tempPub.publish(temperature)) {
      Serial.println("Температура отправлена!");
    } else {
      Serial.println("Ошибка отправки!");
    }
  }
  
  // Пинг MQTT-соединения, чтобы избежать таймаутов
  if(millis() - lastPublishTime > 10000) {
    if(! mqtt.ping()) {
      mqtt.disconnect();
    }
  }
}
 
// Функция для подключения и переподключения к MQTT
void MQTT_connect() {
  int8_t ret;
  
  // Если уже подключены
  if (mqtt.connected()) {
    return;
  }
  
  Serial.print("Подключение к MQTT... ");
  
  uint8_t retries = 3;
  while ((ret = mqtt.connect()) != 0) {
    Serial.println(mqtt.connectErrorString(ret));
    Serial.println("Повторная попытка через 5 секунд...");
    mqtt.disconnect();
    delay(5000);
    if (--retries == 0) {
      // Бесконечный цикл ожидания
      while (1);
    }
  }
  
  Serial.println("MQTT подключено!");
}

#include <ESP8266WiFi.h>
#include <WebSocketsServer.h>
#include <ESP8266WebServer.h>
#include <ArduinoJson.h>
 
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
 
ESP8266WebServer server(80);
WebSocketsServer webSocket = WebSocketsServer(81);
 
void setup() {
  Serial.begin(115200);
  
  // Подключение к WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  // Настройка веб-сервера
  server.on("/", HTTP_GET, [](){
    String html = "<html><head>";
    html += "<script>";
    html += "var socket = new WebSocket('ws://' + window.location.hostname + ':81/');";
    html += "socket.onmessage = function(event) {";
    html += "  var data = JSON.parse(event.data);";
    html += "  document.getElementById('temperature').innerText = data.temperature;";
    html += "  document.getElementById('humidity').innerText = data.humidity;";
    html += "};";
    html += "</script></head><body>";
    html += "<h1>Датчики в реальном времени</h1>";
    html += "<p>Температура: <span id='temperature'>--</span> °C</p>";
    html += "<p>Влажность: <span id='humidity'>--</span> %</p>";
    html += "</body></html>";
    server.send(200, "text/html", html);
  });
  
  server.begin();
  
  // Настройка WebSocket
  webSocket.begin();
  webSocket.onEvent(webSocketEvent);
}
 
void loop() {
  webSocket.loop();
  server.handleClient();
  
  // Отправка данных каждую секунду
  static unsigned long lastUpdate = 0;
  if (millis() - lastUpdate > 1000) {
    lastUpdate = millis();
    
    // Формируем JSON с данными
    DynamicJsonDocument doc(256);
    doc["temperature"] = 22.5; // В реальном проекте - показания датчика
    doc["humidity"] = 65.3;    // В реальном проекте - показания датчика
    
    String json;
    serializeJson(doc, json);
    
    // Отправляем всем подключенным клиентам
    webSocket.broadcastTXT(json);
  }
}
 
void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
  switch(type) {
    case WStype_DISCONNECTED:
      Serial.printf("[%u] Отключен!\n", num);
      break;
    case WStype_CONNECTED:
      {
        IPAddress ip = webSocket.remoteIP(num);
        Serial.printf("[%u] Подключен с %d.%d.%d.%d\n", num, ip[0], ip[1], ip[2], ip[3]);
      }
      break;
    case WStype_TEXT:
      Serial.printf("[%u] Получено: %s\n", num, payload);
      // Здесь можно обрабатывать команды от клиента
      break;
  }
}

#include <ESP8266WiFi.h>
#include <Hash.h>
 
const char* secretKey = "superSecretKey123";
 
String generateHMAC(String message) {
  uint8_t* hash = SHA256::hmac(secretKey, strlen(secretKey), message.c_str(), message.length());
  String result = "";
  for (int i = 0; i < 32; i++) {
    char hex[3];
    sprintf(hex, "%02x", hash[i]);
    result += hex;
  }
  return result;
}
 
bool verifyHMAC(String message, String receivedHmac) {
  String calculatedHmac = generateHMAC(message);
  return calculatedHmac.equals(receivedHmac);
}
 
void setup() {
  Serial.begin(115200);
  
  // Пример использования
  String message = "temperature=25.5&humidity=60.3";
  String hmac = generateHMAC(message);
  
  Serial.println("Сообщение: " + message);
  Serial.println("HMAC: " + hmac);
  
  // Проверка подписи
  bool isValid = verifyHMAC(message, hmac);
  Serial.println("Проверка подписи: " + String(isValid ? "успешно" : "ошибка"));
  
  // Проверка с измененным сообщением
  bool isTampered = verifyHMAC(message + "x", hmac);
  Serial.println("Проверка измененного сообщения: " + String(isTampered ? "успешно (подделка не обнаружена)" : "ошибка (подделка обнаружена)"));
}
 
void loop() {
  // Пусто для демонстрации
}

#include <ESP8266WiFi.h>
#include <time.h>
 
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
 
// Настройки NTP
const char* ntpServer = "pool.ntp.org";
const long  gmtOffset_sec = 3600 * 3; // Московское время (UTC+3)
const int   daylightOffset_sec = 0;
 
void setup() {
  Serial.begin(115200);
  
  // Подключение к WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  // Настройка и синхронизация времени
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  
  Serial.println("Ожидание получения времени");
  time_t now = time(nullptr);
  while (now < 24 * 3600) {
    delay(500);
    Serial.print(".");
    now = time(nullptr);
  }
  Serial.println();
  
  // Вывод текущего времени
  struct tm timeinfo;
  localtime_r(&now, &timeinfo);
  Serial.print("Текущее время: ");
  Serial.print(timeinfo.tm_hour);
  Serial.print(":");
  Serial.print(timeinfo.tm_min);
  Serial.print(":");
  Serial.println(timeinfo.tm_sec);
}
 
void loop() {
  delay(1000);
  
  time_t now = time(nullptr);
  struct tm timeinfo;
  localtime_r(&now, &timeinfo);
  
  // Вывод времени каждую секунду
  Serial.printf("%02d:%02d:%02d\n", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
}

#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
 
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
 
AsyncWebServer server(80);
 
void setup() {
  Serial.begin(115200);
  
  // Подключение к WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  // Маршруты для веб-сервера
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send(200, "text/plain", "Hello, World!");
  });
  
  server.on("/sensor", HTTP_GET, [](AsyncWebServerRequest *request){
    String json = "{\"temperature\": 25.5, \"humidity\": 60.3}";
    request->send(200, "application/json", json);
  });
  
  server.on("/led", HTTP_POST, [](AsyncWebServerRequest *request){
    int params = request->params();
    for(int i=0;i<params;i++){
      AsyncWebParameter* p = request->getParam(i);
      if(p->name() == "state"){
        if(p->value() == "on"){
          digitalWrite(LED_BUILTIN, LOW); // Включаем LED (инверсная логика)
        } else {
          digitalWrite(LED_BUILTIN, HIGH); // Выключаем LED
        }
      }
    }
    request->send(200, "text/plain", "OK");
  });
  
  server.begin();
  
  pinMode(LED_BUILTIN, OUTPUT);
}
 
void loop() {
  // Основной код программы может выполняться параллельно
  // с обработкой веб-запросов!
}

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
 
const char* ssid = "ВашаСеть";
const char* password = "ВашПароль";
const char* mqtt_server = "192.168.1.10"; // IP вашего сервера Home Assistant
 
WiFiClient espClient;
PubSubClient client(espClient);
 
// Уникальный идентификатор устройства
String deviceId = "esp_" + String(ESP.getChipId(), HEX);
 
void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  
  // Подключение к WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  // Настройка MQTT
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}
 
void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  // Публикация данных каждые 30 секунд
  static unsigned long lastPublish = 0;
  if (millis() - lastPublish > 30000) {
    lastPublish = millis();
    
    // Чтение температуры
    float temperature = 25.5; // В реальном проекте - показания датчика
    
    // Публикация значения
    client.publish(("homeassistant/sensor/" + deviceId + "/temperature/state").c_str(), 
                  String(temperature).c_str(), true);
  }
}
 
void reconnect() {
  while (!client.connected()) {
    Serial.print("Подключение к MQTT...");
    
    if (client.connect(deviceId.c_str())) {
      Serial.println("подключено");
      
      // Отправка конфигурации для автоматического обнаружения
      DynamicJsonDocument doc(1024);
      
      // Конфигурация датчика температуры
      doc["name"] = "ESP Temperature";
      doc["device_class"] = "temperature";
      doc["state_topic"] = "homeassistant/sensor/" + deviceId + "/temperature/state";
      doc["unit_of_measurement"] = "°C";
      doc["value_template"] = "{{ value }}";
      
      String config;
      serializeJson(doc, config);
      
      client.publish(("homeassistant/sensor/" + deviceId + "/temperature/config").c_str(), 
                    config.c_str(), true);
      
      // Подписка на команды
      client.subscribe(("homeassistant/switch/" + deviceId + "/led/set").c_str());
      
      // Отправка конфигурации переключателя
      doc.clear();
      doc["name"] = "ESP LED";
      doc["command_topic"] = "homeassistant/switch/" + deviceId + "/led/set";
      
      config = "";
      serializeJson(doc, config);
      
      client.publish(("homeassistant/switch/" + deviceId + "/led/config").c_str(), 
                    config.c_str(), true);
    } else {
      Serial.print("ошибка, rc=");
      Serial.print(client.state());
      Serial.println(" повторная попытка через 5 секунд");
      delay(5000);
    }
  }
}
 
void callback(char* topic, byte* payload, unsigned int length) {
  payload[length] = '\0'; // Добавляем нулевой символ для превращения в строку
  String message = String((char*)payload);
  
  String topicStr = String(topic);
  
  if (topicStr == "homeassistant/switch/" + deviceId + "/led/set") {
    if (message == "ON") {
      digitalWrite(LED_BUILTIN, LOW); // Включаем LED (инверсная логика)
    } else {
      digitalWrite(LED_BUILTIN, HIGH); // Выключаем LED
    }
  }
}

// Измеряем, отправляем данные, потом засыпаем на 10 минут
sendData(); // Ваша функция отправки данных
ESP.deepSleep(10 * 60 * 1000000); // 10 минут в микросекундах

// Выключаем все, что можно
WiFi.disconnect(true);
WiFi.mode(WIFI_OFF);
pinMode(LED_BUILTIN, INPUT); // Отключаем встроенный светодиод

// Более быстрое пробуждение, но больше потребление
WiFi.mode(WIFI_NONE_SLEEP);
wifi_light_sleep_open();
wifi_fpm_set_sleep_type(LIGHT_SLEEP_T);
wifi_fpm_open();
wifi_fpm_set_wakeup_cb(wakeupCallback);
wifi_fpm_do_sleep(sleepTimeMilliseconds * 1000);
delay(1); // Нужно для фактического перехода в сон

IPAddress staticIP(192, 168, 1, 200);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
IPAddress dns(8, 8, 8, 8);
WiFi.config(staticIP, gateway, subnet, dns);

void ensureWiFiConnected() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Соединение потеряно, переподключаюсь...");
    WiFi.disconnect();
    delay(100);
    WiFi.begin(ssid, password);
    
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 20) {
      delay(500);
      Serial.print(".");
      attempts++;
    }
  }
}

Serial.println(F("Эта строка хранится во флеш-памяти, а не в RAM"));

Serial.print("Свободная память: ");
Serial.println(ESP.getFreeHeap());

// Плохо:
for(int i = 0; i < 100; i++) {
  String temp = "Датчик " + String(i) + ": " + String(getData(i));
  client.publish(topic, temp.c_str());
}
 
// Хорошо:
char buffer[50];
for(int i = 0; i < 100; i++) {
  snprintf(buffer, sizeof(buffer), "Датчик %d: %f", i, getData(i));
  client.publish(topic, buffer);
}

// Вычисление необходимого размера буфера
const size_t capacity = JSON_OBJECT_SIZE(3) + 70;
DynamicJsonDocument doc(capacity);

#include <WiFiUdp.h>
#include <Syslog.h>
 
WiFiUDP udpClient;
Syslog syslog(udpClient, "192.168.1.100", 514, "esp8266", "app", LOG_KERN);
 
// Теперь можно логировать события
syslog.log(LOG_INFO, "Температура: " + String(temperature));

upload_flags = --silent