Умное освещение на Arduino: пошаговая инструкция для новичков

// Определение пинов
const int pirPin = 2;      // Пин датчика движения
const int relayPin = 3;    // Пин реле
const int ledPin = 13;     // Встроенный светодиод для индикации

// Настройки таймеров
unsigned long timeoutDuration = 30000;  // Время до выключения света (30 сек)
unsigned long lastMotionTime = 0;       // Время последнего обнаружения движения

// Состояние системы
bool lightOn = false;      // Текущее состояние света
bool motionDetected = false; // Обнаружено ли движение

void setup() {
  Serial.begin(9600);  // Инициализация Serial для отладки
  
  pinMode(pirPin, INPUT);     // Настройка пина датчика движения
  pinMode(relayPin, OUTPUT);  // Настройка пина реле
  pinMode(ledPin, OUTPUT);    // Настройка пина светодиода
  
  digitalWrite(relayPin, HIGH);  // Выключаем реле (HIGH = выкл для многих модулей)
  
  Serial.println("Система инициализирована. Ожидание движения...");
  delay(2000);  // Даем время датчику PIR для калибровки
}

void loop() {
  // Считываем состояние датчика движения
  motionDetected = digitalRead(pirPin);
  
  // Если обнаружено движение
  if (motionDetected == HIGH) {
    lastMotionTime = millis();  // Обновляем время последнего движения
    
    // Если свет выключен, включаем его
    if (!lightOn) {
      digitalWrite(relayPin, LOW);  // Включаем реле (LOW = вкл для многих модулей)
      digitalWrite(ledPin, HIGH);   // Включаем светодиод для индикации
      lightOn = true;
      Serial.println("Движение обнаружено! Свет включен.");
    }
  }
  
  // Проверяем, не пора ли выключить свет
  if (lightOn && (millis() – lastMotionTime > timeoutDuration)) {
    digitalWrite(relayPin, HIGH);  // Выключаем реле
    digitalWrite(ledPin, LOW);     // Выключаем светодиод
    lightOn = false;
    Serial.println("Движение не обнаружено в течение заданного времени. Свет выключен.");
  }
  
  delay(100);  // Небольшая задержка для стабильности
}

// Определение пинов
const int pirPin = 2;         // Пин датчика движения
const int relayPin = 3;       // Пин реле
const int photoresistorPin = A0; // Пин фоторезистора

// Настройки таймеров и пороговых значений
unsigned long timeoutDuration = 60000;  // 1 минута
unsigned long lastMotionTime = 0;
int lightThreshold = 500;     // Пороговое значение освещенности (настраивается экспериментально)

// Состояние системы
bool lightOn = false;

void setup() {
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH);  // Выключаем реле при старте
  
  Serial.println("Система с учетом освещенности инициализирована.");
  delay(2000);
}

void loop() {
  // Считываем уровень освещенности и наличие движения
  int lightLevel = analogRead(photoresistorPin);
  bool motionDetected = digitalRead(pirPin);
  
  // Выводим текущие значения для отладки
  Serial.print("Освещенность: ");
  Serial.print(lightLevel);
  Serial.print(" | Движение: ");
  Serial.println(motionDetected ? "ДА" : "НЕТ");
  
  // Если темно и обнаружено движение
  if (lightLevel < lightThreshold && motionDetected) {
    lastMotionTime = millis();
    
    // Включаем свет, если он был выключен
    if (!lightOn) {
      digitalWrite(relayPin, LOW);
      lightOn = true;
      Serial.println("Движение в темноте! Свет включен.");
    }
  }
  
  // Проверяем таймаут для выключения света
  if (lightOn && (millis() – lastMotionTime > timeoutDuration)) {
    digitalWrite(relayPin, HIGH);
    lightOn = false;
    Serial.println("Таймаут. Свет выключен.");
  }
  
  // Если стало светло, выключаем свет независимо от движения
  if (lightOn && lightLevel >= lightThreshold) {
    digitalWrite(relayPin, HIGH);
    lightOn = false;
    Serial.println("Стало достаточно светло. Свет выключен.");
  }
  
  delay(500);  // Проверяем состояние каждые полсекунды
}

#include <Wire.h>
#include <BH1750.h>
#include <RTClib.h>

// Инициализация объектов
BH1750 lightMeter;
RTC_DS3231 rtc;

// Определение пинов
const int mosfetPin = 9;       // PWM пин для управления светодиодами через MOSFET
const int pirPin = 2;          // Датчик движения
const int minBrightness = 10;  // Минимальная яркость (0-255)
const int maxBrightness = 255; // Максимальная яркость

// Переменные состояния
unsigned long lastMotionTime = 0;
unsigned long timeoutDuration = 300000; // 5 минут
bool lightOn = false;
int currentBrightness = 0;
int targetBrightness = 0;

void setup() {
  Serial.begin(9600);
  pinMode(mosfetPin, OUTPUT);
  pinMode(pirPin, INPUT);
  
  // Инициализация датчика освещенности
  Wire.begin();
  lightMeter.begin();
  
  // Инициализация часов реального времени
  if (!rtc.begin()) {
    Serial.println("Не удалось найти RTC модуль!");
    while (1);
  }
  
  if (rtc.lostPower()) {
    Serial.println("RTC потерял питание, установим время!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  
  Serial.println("Система адаптивного освещения инициализирована!");
}

void loop() {
  // Получение текущих данных
  DateTime now = rtc.now();
  float lux = lightMeter.readLightLevel();
  bool motion = digitalRead(pirPin);
  
  // Логика адаптивного освещения
  if (motion) {
    lastMotionTime = millis();
    
    // Определение целевой яркости в зависимости от времени суток и освещенности
    int hour = now.hour();
    
    // Ночной режим (22:00 – 6:00)
    if (hour >= 22 || hour < 6) {
      targetBrightness = map(lux, 0, 50, minBrightness, minBrightness + 30);
    } 
    // Утро/вечер (6:00-8:00, 18:00-22:00)
    else if ((hour >= 6 && hour < 8) || (hour >= 18 && hour < 22)) {
      targetBrightness = map(lux, 0, 200, maxBrightness – 50, minBrightness + 50);
    }
    // День (8:00-18:00)
    else {
      if (lux < 200) {
        targetBrightness = map(lux, 0, 200, maxBrightness, minBrightness + 70);
      } else {
        targetBrightness = 0; // Достаточно естественного освещения
      }
    }
    
    lightOn = (targetBrightness > 0);
  }
  
  // Выключение при таймауте
  if (lightOn && (millis() – lastMotionTime > timeoutDuration)) {
    targetBrightness = 0;
    lightOn = false;
    Serial.println("Таймаут. Выключение света.");
  }
  
  // Плавное изменение яркости
  if (currentBrightness < targetBrightness) {
    currentBrightness++;
  } else if (currentBrightness > targetBrightness) {
    currentBrightness--;
  }
  
  // Установка яркости через PWM
  analogWrite(mosfetPin, currentBrightness);
  
  // Вывод отладочной информации
  Serial.print("Время: ");
  Serial.print(now.hour());
  Serial.print(":");
  Serial.print(now.minute());
  Serial.print(" | Освещенность: ");
  Serial.print(lux);
  Serial.print(" лк | Целевая яркость: ");
  Serial.print(targetBrightness);
  Serial.print(" | Текущая яркость: ");
  Serial.println(currentBrightness);
  
  delay(20); // Задержка для плавного изменения яркости
}

// Добавьте в глобальные переменные:
bool awayMode = false;  // Режим "Имитация присутствия"
unsigned long lastChangeTime = 0;
unsigned long changeInterval = 0;
const int relayPins[] = {3, 4, 5, 6};  // Пины для управления разными светильниками
const int numRelays = 4;  // Количество реле

// Функция для включения режима имитации присутствия
void enableAwayMode() {
  awayMode = true;
  Serial.println("Режим имитации присутствия активирован");
  changeInterval = random(15000, 40000);  // Случайный интервал 15-40 минут
  lastChangeTime = millis();
}

// В функции loop() добавьте:
if (awayMode && (millis() – lastChangeTime > changeInterval)) {
  // Выбираем случайное реле
  int relayToToggle = random(0, numRelays);
  
  // Изменяем его состояние
  if (digitalRead(relayPins[relayToToggle]) == HIGH) {
    digitalWrite(relayPins[relayToToggle], LOW);
    Serial.print("Включаем свет в зоне ");
  } else {
    digitalWrite(relayPins[relayToToggle], HIGH);
    Serial.print("Выключаем свет в зоне ");
  }
  Serial.println(relayToToggle);
  
  // Устанавливаем новый случайный интервал
  changeInterval = random(15000, 40000);
  lastChangeTime = millis();
}

#include <SoftwareSerial.h>
#include <ArduinoJson.h>

// Настройка программного UART для ESP8266
SoftwareSerial esp8266(10, 11); // RX, TX

// Пины для управления освещением
const int relayPin = 3;
const int mosfetPin = 9; // Для управления яркостью

// Состояние системы
bool lightOn = false;
int brightness = 0;
String currentMode = "manual"; // "manual", "auto", "away"

void setup() {
  Serial.begin(9600);
  esp8266.begin(9600);
  
  pinMode(relayPin, OUTPUT);
  pinMode(mosfetPin, OUTPUT);
  
  digitalWrite(relayPin, HIGH); // Выключено при запуске
  
  // Инициализация ESP8266
  initESP8266();
  
  Serial.println("Система с Wi-Fi управлением инициализирована");
}

void loop() {
  // Проверяем наличие команд от ESP8266
  if (esp8266.available()) {
    String message = esp8266.readStringUntil('\n');
    processCommand(message);
  }
  
  // Продолжаем выполнять обычную логику умного освещения...
  
  // Отправляем обновления состояния каждые 5 секунд
  static unsigned long lastUpdate = 0;
  if (millis() – lastUpdate > 5000) {
    sendStatusUpdate();
    lastUpdate = millis();
  }
}

// Инициализация ESP8266
void initESP8266() {
  Serial.println("Инициализация Wi-Fi...");
  
  // Сбрасываем настройки ESP8266
  sendCommand("AT+RST", 2000);
  
  // Устанавливаем режим клиента
  sendCommand("AT+CWMODE=1", 1000);
  
  // Подключаемся к Wi-Fi
  sendCommand("AT+CWJAP=\"YOUR_WIFI_SSID\",\"YOUR_WIFI_PASSWORD\"", 10000);
  
  // Подключаемся к MQTT-брокеру
  sendCommand("AT+CIPSTART=\"TCP\",\"your-mqtt-broker.com\",1883", 5000);
  
  // Подписываемся на топик команд
  sendMQTTSubscribe("home/light/command");
  
  Serial.println("Wi-Fi инициализирован");
}

// Обработка входящих команд
void processCommand(String message) {
  // Разбор JSON-сообщения
  DynamicJsonDocument doc(256);
  DeserializationError error = deserializeJson(doc, message);
  
  if (error) {
    Serial.print("Ошибка разбора JSON: ");
    Serial.println(error.c_str());
    return;
  }
  
  // Обработка команд
  if (doc.containsKey("power")) {
    bool powerState = doc["power"];
    setLight(powerState);
  }
  
  if (doc.containsKey("brightness")) {
    int newBrightness = doc["brightness"];
    setBrightness(newBrightness);
  }
  
  if (doc.containsKey("mode")) {
    String newMode = doc["mode"];
    setMode(newMode);
  }
  
  // Отправляем обновление состояния
  sendStatusUpdate();
}

// Установка состояния освещения
void setLight(bool state) {
  lightOn = state;
  digitalWrite(relayPin, state ? LOW : HIGH);
  Serial.print("Свет: ");
  Serial.println(state ? "ВКЛ" : "ВЫКЛ");
}

// Установка яркости
void setBrightness(int level) {
  brightness = constrain(level, 0, 255);
  analogWrite(mosfetPin, brightness);
  Serial.print("Яркость: ");
  Serial.println(brightness);
}

// Установка режима работы
void setMode(String mode) {
  currentMode = mode;
  Serial.print("Режим: ");
  Serial.println(mode);
  
  if (mode == "away") {
    // Включаем режим имитации присутствия
    // ...
  }
}

// Отправка обновления состояния
void sendStatusUpdate() {
  // Формируем JSON со статусом
  DynamicJsonDocument statusDoc(256);
  statusDoc["power"] = lightOn;
  statusDoc["brightness"] = brightness;
  statusDoc["mode"] = currentMode;
  
  String statusJson;
  serializeJson(statusDoc, statusJson);
  
  // Отправляем в MQTT
  sendMQTTPublish("home/light/status", statusJson);
}

// Отправка команды на ESP8266 с ожиданием ответа
void sendCommand(String command, int timeout) {
  esp8266.println(command);
  delay(timeout);
  while (esp8266.available()) {
    String response = esp8266.readStringUntil('\n');
    Serial.println(response);
  }
}

// Отправка MQTT-сообщения
void sendMQTTPublish(String topic, String message) {
  // Формируем MQTT-пакет
  // (упрощенный пример, в реальном проекте нужна полноценная реализация MQTT)
  String mqttPacket = "PUBLISH " + topic + " " + message;
  sendCommand(mqttPacket, 1000);
}

// Подписка на MQTT-топик
void sendMQTTSubscribe(String topic) {
  // Формируем MQTT-пакет подписки
  String mqttPacket = "SUBSCRIBE " + topic;
  sendCommand(mqttPacket, 1000);
}