🚶 Датчик движения PIR

👤 Учитель заходит в класс → Светодиод загорается ДО того, как его видят ученики
🚪 Кто-то движется за дверью → Система сразу реагирует
📄 Лист бумаги перед датчиком → Человек за листом все равно обнаруживается!
🪑 Учитель прячется за стул → Датчик "видит" сквозь мебель
❄️ Включаем кондиционер → Система не реагирует на холодный воздух

🐍 ЗМЕЯ-ГАДЮКА              ↔    🔍 PIR ДАТЧИК
Видит тепловое излучение    ↔    Обнаруживает ИК-излучение
Реагирует на теплокровных   ↔    Реагирует на людей/животных
Не видит холодные объекты   ↔    Игнорирует неживые предметы
Охотится в полной темноте   ↔    Работает без освещения
Мгновенная реакция на жертву ↔   Быстрое срабатывание

🌙 УМНЫЙ ДОМ НОЧЬЮ:
- Входите в коридор → Автоматически включается приглушенный свет
- Идете в ванную → Освещение следует за вами
- Покидаете комнату → Через 2 минуты все выключается

🛡️ СИСТЕМА БЕЗОПАСНОСТИ:
- Движение ночью → Сигнал тревоги + фото на телефон
- Долгое отсутствие движения → "Режим охраны" активирован
- Обнаружен злоумышленник → Сирена + уведомление владельцу

🌈 СПЕКТР ЭЛЕКТРОМАГНИТНОГО ИЗЛУЧЕНИЯ:

Видимый свет: 380-780 нм (то что видят наши глаза)
Ближний ИК: 780нм-1.4мкм (пульты ДУ, оптоволокно)  
Средний ИК: 1.4-8мкм (ТЕПЛОВОЕ излучение человека!)
Дальний ИК: 8-15мкм (тепловизоры, астрономия)

🔥 ТЕПЛОВОЕ ИЗЛУЧЕНИЕ ЧЕЛОВЕКА:
- Температура тела: 36.6°C = 309.6K
- Пик излучения: 9.3 мкм (средний ИК)
- Мощность: ~100 Вт тепла с поверхности тела
- Видимость: В полной темноте для ИК-камеры!

❄️ ОКРУЖАЮЩИЕ ОБЪЕКТЫ:
- Комнатная температура: 20°C = 293K  
- Пик излучения: 9.9 мкм
- Контраст: 6.6°C разности = четкое обнаружение!

🔬 АНАТОМИЯ PIR ДАТЧИКА:

1️⃣ ПИРОЭЛЕКТРИЧЕСКИЙ ЭЛЕМЕНТ:
- Материал: Танталат лития (LiTaO3)
- Принцип: Изменение поляризации при нагреве
- Структура: ДВА элемента рядом (дифференциальная схема)
- Чувствительность: Изменения температуры 0.1°C

2️⃣ ЛИНЗА ФРЕНЕЛЯ:
- Материал: Полиэтилен (прозрачен для ИК)
- Функция: Фокусировка ИК-лучей на сенсор
- Зоны: 20-60 фокусных сегментов
- Угол обзора: 90-120 градусов

3️⃣ ЭЛЕКТРОННАЯ ОБРАБОТКА:
- Усилитель: Увеличивает слабый сигнал в 1000+ раз
- Компаратор: Превращает аналоговый сигнал в цифровой
- Таймер: Устанавливает длительность выходного сигнала
- Фильтр: Убирает помехи и ложные срабатывания

🎯 ПРИНЦИП РАБОТЫ:
1. ИК-излучение от человека попадает на ОДИН из двух элементов
2. Возникает РАЗНОСТЬ сигналов между элементами  
3. Разность усиливается и сравнивается с порогом
4. При превышении порога → Выход становится HIGH
5. Таймер удерживает HIGH заданное время

🎯 ЗОНЫ ОБНАРУЖЕНИЯ PIR:

АКТИВНЫЕ ЗОНЫ (высокая чувствительность):
┌─────────────────────────┐
│  \     /\     /\     /  │ ← Лучи линзы Френеля
│   \   /  \   /  \   /   │
│    \ /    \ /    \ /    │
│     X      X      X     │ ← Фокальные точки
│      \    /|\    /      │
│       \  / | \  /       │
│        \/  |  \/        │
│           PIR            │
└─────────────────────────┘

МЕРТВЫЕ ЗОНЫ (слабая чувствительность):
- Прямо перед датчиком (слишком близко)
- Между активными лучами
- Сбоку от датчика (вне угла обзора)
- За препятствиями (стены, мебель)

🚶 ОПТИМАЛЬНОЕ ДВИЖЕНИЕ:
✅ Поперек лучей (слева направо)
✅ На расстоянии 2-7 метров
✅ Средняя скорость (1-2 м/с)

❌ ПЛОХОЕ ОБНАРУЖЕНИЕ:
- Движение прямо на датчик/от датчика
- Очень медленное движение (<0.3 м/с)
- Очень быстрое движение (>5 м/с)
- В жаркую погоду (малый контраст)

🔬 ЛАБОРАТОРИЯ ДЕТЕКЦИИ ДВИЖЕНИЯ:

Эксперимент 1: Зависимость от расстояния
Методика: Движение на разных расстояниях от датчика

📊 ТАБЛИЦА ДАЛЬНОСТИ:
┌─────────────┬──────────────┬─────────────┬──────────────┐
│ Расстояние  │ Обнаружение  │ Время реакции│ Надежность  │
├─────────────┼──────────────┼─────────────┼──────────────┤
│ 0.5 м       │ ДА/НЕТ       │ _____ мс    │ ____/10      │
│ 1 м         │ ДА/НЕТ       │ _____ мс    │ ____/10      │
│ 2 м         │ ДА/НЕТ       │ _____ мс    │ ____/10      │
│ 3 м         │ ДА/НЕТ       │ _____ мс    │ ____/10      │
│ 5 м         │ ДА/НЕТ       │ _____ мс    │ ____/10      │
│ 7 м         │ ДА/НЕТ       │ _____ мс    │ ____/10      │
└─────────────┴──────────────┴─────────────┴──────────────┘

Эксперимент 2: Направление движения
- Слева направо: Обнаружен на расстоянии _____ м
- Справа налево: Обнаружен на расстоянии _____ м  
- На датчик: Обнаружен на расстоянии _____ м
- От датчика: Обнаружен на расстоянии _____ м
- Вывод: Лучшее направление _____________

Эксперимент 3: Влияние препятствий  
- Прозрачное стекло: БЛОКИРУЕТ/ПРОПУСКАЕТ
- Тонкая ткань: БЛОКИРУЕТ/ПРОПУСКАЕТ
- Лист бумаги: БЛОКИРУЕТ/ПРОПУСКАЕТ
- Пластиковая бутылка: БЛОКИРУЕТ/ПРОПУСКАЕТ
- Вывод: ИК-излучение проходит через ___________

Эксперимент 4: Ложные срабатывания
□ Включение лампы накаливания
□ Горячий чай рядом с датчиком
□ Фен или обогреватель  
□ Домашнее животное (кот/собака)
□ Развевающиеся шторы
□ Автомобиль за окном

🎛️ ОРГАНЫ УПРАВЛЕНИЯ HC-SR501:

1️⃣ ПОТЕНЦИОМЕТР ЧУВСТВИТЕЛЬНОСТИ (Sx):
Положение: Левый потенциометр
Диапазон: 3-7 метров  
Поворот по часовой: УВЕЛИЧИТЬ дальность
Поворот против часовой: УМЕНЬШИТЬ дальность
Рекомендация: Для класса - средняя позиция

2️⃣ ПОТЕНЦИОМЕТР ВРЕМЕНИ (Tx):
Положение: Правый потенциометр
Диапазон: 0.3 - 300 секунд
Поворот по часовой: УВЕЛИЧИТЬ время удержания
Поворот против часовой: УМЕНЬШИТЬ время
Рекомендация: Для тестов - минимум (0.3 сек)

3️⃣ ПЕРЕМЫЧКА РЕЖИМА РАБОТЫ:
Позиция H: Режим "Повтора" (retriggering)
- При новом движении время сбрасывается
- Подходит для освещения

Позиция L: Режим "Однократного срабатывания"  
- Игнорирует движение пока идет отсчет
- Подходит для охранных систем

🔧 РЕКОМЕНДУЕМЫЕ НАСТРОЙКИ:
Для обучения: Sx = мин, Tx = мин, Jumper = L
Для освещения: Sx = сред, Tx = 30сек, Jumper = H  
Для охраны: Sx = макс, Tx = макс, Jumper = L

🛠️ СХЕМА ПОДКЛЮЧЕНИЯ PIR ДАТЧИКА:

       ESP32                    HC-SR501
    ┌─────────┐              ┌─────────────┐
    │   5V    │──────────────│ VCC (красный)│
    │ GPIO 13 │──────────────│ OUT (желтый) │
    │   GND   │──────────────│ GND (черный) │
    └─────────┘              └─────────────┘
                              │ [Sx] [Tx]  │ ← Потенциометры
                              │    [H/L]   │ ← Перемычка
                              └─────────────┘

⚠️ ВАЖНЫЕ МОМЕНТЫ:
1. PIR требует 5V питания (не 3.3V!)
2. Выходной сигнал 3.3V - безопасен для ESP32
3. После включения нужно 60 секунд на стабилизацию
4. Не касаться руками линзы датчика
5. Устанавливать вертикально для лучшей работы

🔧 ДОПОЛНИТЕЛЬНЫЕ КОМПОНЕНТЫ:
- Светодиод + резистор 220Ом (индикация движения)
- Buzzer (звуковая сигнализация)  
- Реле (управление мощными нагрузками)
- LCD дисплей (отображение статуса)

// 🚶 ПРОГРАММА ДАТЧИКА ДВИЖЕНИЯ PIR
// Урок 15: Обнаружение движения и создание охранных систем

// 🔧 Настройки пинов
const int PIR_PIN = 13;              // Пин подключения PIR датчика
const int LED_PIN = 2;               // Встроенный светодиод
const int EXTERNAL_LED_PIN = 5;      // Внешний светодиод
const int BUZZER_PIN = 4;            // Пищалка (опционально)

// 📊 Параметры детекции
const unsigned long STABILIZATION_TIME = 60000;  // 60 сек стабилизации
const unsigned long MOTION_TIMEOUT = 5000;       // 5 сек без движения = "покой"
const int MOTION_COUNTER_THRESHOLD = 3;          // Мин. количество срабатываний

// 📈 Переменные состояния
bool motionDetected = false;          // Текущее состояние движения
bool systemArmed = false;             // Система активирована
unsigned long lastMotionTime = 0;    // Время последнего движения
unsigned long systemStartTime = 0;   // Время запуска системы
int motionCounter = 0;                // Счетчик движений
int totalMotions = 0;                 // Общее количество движений

// 🕐 Временные метки для анализа
unsigned long motionTimes[10];        // История последних движений
int motionIndex = 0;                  // Индекс в массиве истории

void setup() {
  Serial.begin(9600);
  Serial.println("🚶 Система детекции движения PIR v2.0");
  
  // 🔧 Настройка пинов
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  pinMode(EXTERNAL_LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  
  systemStartTime = millis();
  
  Serial.println("⏳ Ожидание стабилизации PIR датчика...");
  Serial.println("   (НЕ ДВИГАЙТЕСЬ 60 секунд!)");
  
  // 🎯 Период стабилизации с индикацией
  stabilizationPeriod();
  
  Serial.println("✅ PIR датчик готов к работе!");
  Serial.println("📊 Формат: Движение | Счетчик | Время | Статус");
  Serial.println("─────────────────────────────────────────────────");
}

void loop() {
  // 📖 Читаем состояние PIR датчика
  bool currentMotion = digitalRead(PIR_PIN);
  
  // 🔍 Обрабатываем изменения состояния
  if (currentMotion != motionDetected) {
    handleMotionChange(currentMotion);
  }
  
  // ⏰ Проверяем таймаут отсутствия движения
  checkMotionTimeout();
  
  // 💡 Обновляем индикацию
  updateIndicators();
  
  // 📊 Анализируем паттерны движения
  analyzeMotionPatterns();
  
  // 🎮 Обрабатываем команды пользователя
  handleSerialCommands();
  
  delay(100);  // Опрос 10 раз в секунду
}

// ⏳ Функция стабилизации PIR датчика
void stabilizationPeriod() {
  unsigned long startTime = millis();
  
  while (millis() - startTime < STABILIZATION_TIME) {
    unsigned long elapsed = millis() - startTime;
    int progress = (elapsed * 100) / STABILIZATION_TIME;
    
    // 📈 Показываем прогресс каждые 10 секунд
    if (elapsed % 10000 == 0 && elapsed > 0) {
      Serial.printf("⏳ Стабилизация: %d%% (%lu сек)\n", 
                    progress, elapsed / 1000);
    }
    
    // 💡 Мигание светодиода во время стабилизации
    bool blinkState = (millis() / 500) % 2;
    digitalWrite(LED_PIN, blinkState);
    
    delay(100);
  }
  
  digitalWrite(LED_PIN, LOW);
}

// 🔄 Функция обработки изменения состояния движения
void handleMotionChange(bool newState) {
  motionDetected = newState;
  unsigned long currentTime = millis();
  
  if (newState) {
    // 🚶 ДВИЖЕНИЕ ОБНАРУЖЕНО
    lastMotionTime = currentTime;
    motionCounter++;
    totalMotions++;
    
    // 📝 Записываем время в историю
    motionTimes[motionIndex] = currentTime;
    motionIndex = (motionIndex + 1) % 10;
    
    Serial.printf("🚶 ДВИЖЕНИЕ! Счетчик: %d | Общий: %d | Время: %lu\n",
                  motionCounter, totalMotions, currentTime / 1000);
    
    // 🎯 Реакция на движение
    onMotionDetected();
    
  } else {
    // 🛑 ДВИЖЕНИЕ ПРЕКРАТИЛОСЬ
    Serial.printf("🛑 Движение прекратилось | Длительность: %lu мс\n",
                  currentTime - lastMotionTime);
  }
}

// 🎯 Функция реакции на обнаруженное движение
void onMotionDetected() {
  // 💡 Включаем освещение
  digitalWrite(EXTERNAL_LED_PIN, HIGH);
  
  // 🔊 Звуковой сигнал при активированной системе
  if (systemArmed) {
    tone(BUZZER_PIN, 1000, 200);  // 200мс сигнал 1кГц
    Serial.println("🚨 ТРЕВОГА! Движение при активированной охране!");
  }
  
  // 📊 Анализ активности
  analyzeActivity();
}

// ⏰ Функция проверки таймаута движения
void checkMotionTimeout() {
  if (motionDetected && (millis() - lastMotionTime > MOTION_TIMEOUT)) {
    Serial.printf("😴 Период покоя начался (>%d сек без движения)\n", 
                  MOTION_TIMEOUT / 1000);
    
    // 🔄 Сбрасываем счетчик движений
    motionCounter = 0;
    
    // 💡 Выключаем освещение
    digitalWrite(EXTERNAL_LED_PIN, LOW);
  }
}

// 💡 Функция обновления индикаторов
void updateIndicators() {
  // 🔴 Встроенный светодиод = текущее движение
  digitalWrite(LED_PIN, motionDetected);
  
  // 🟢 Внешний светодиод = недавняя активность
  bool recentActivity = (millis() - lastMotionTime) < MOTION_TIMEOUT;
  digitalWrite(EXTERNAL_LED_PIN, recentActivity);
}

// 📊 Функция анализа паттернов движения
void analyzeMotionPatterns() {
  static unsigned long lastAnalysis = 0;
  
  // 📈 Анализируем каждые 30 секунд
  if (millis() - lastAnalysis >= 30000) {
    lastAnalysis = millis();
    
    // 🔍 Анализируем историю движений
    int recentMotions = countRecentMotions(30000);  // За последние 30 сек
    
    Serial.printf("📊 Анализ активности: %d движений за 30 сек\n", recentMotions);
    
    // 🎯 Классификация активности
    if (recentMotions == 0) {
      Serial.println("😴 Статус: ПОКОЙ");
    } else if (recentMotions <= 2) {
      Serial.println("🚶 Статус: НИЗКАЯ АКТИВНОСТЬ");
    } else if (recentMotions <= 5) {
      Serial.println("🏃 Статус: СРЕДНЯЯ АКТИВНОСТЬ");
    } else {
      Serial.println("💃 Статус: ВЫСОКАЯ АКТИВНОСТЬ");
    }
  }
}

// 📈 Функция подсчета недавних движений
int countRecentMotions(unsigned long timeWindow) {
  unsigned long currentTime = millis();
  int count = 0;
  
  for (int i = 0; i < 10; i++) {
    if (motionTimes[i] != 0 && 
        (currentTime - motionTimes[i]) <= timeWindow) {
      count++;
    }
  }
  
  return count;
}

// 🔍 Функция анализа активности
void analyzeActivity() {
  // 📊 Частота движений
  int recentMotions = countRecentMotions(60000);  // За минуту
  
  if (recentMotions > 10) {
    Serial.println("🎪 Обнаружена высокая активность (возможно праздник)");
  } else if (recentMotions > 5) {
    Serial.println("👥 Обнаружена групповая активность");
  } else {
    Serial.println("👤 Обнаружена одиночная активность");
  }
}

// 🎮 Функция обработки команд через Serial
void handleSerialCommands() {
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    command.toLowerCase();
    
    if (command == "arm") {
      systemArmed = true;
      Serial.println("🛡️ Система охраны АКТИВИРОВАНА");
      tone(BUZZER_PIN, 800, 100);
      
    } else if (command == "disarm") {
      systemArmed = false;
      Serial.println("✅ Система охраны ДЕАКТИВИРОВАНА");
      tone(BUZZER_PIN, 400, 100);
      
    } else if (command == "status") {
      printSystemStatus();
      
    } else if (command == "reset") {
      resetStatistics();
      
    } else if (command == "help") {
      printHelp();
      
    } else {
      Serial.println("❌ Неизвестная команда. Введите 'help'");
    }
  }
}

// 📊 Функция вывода статуса системы
void printSystemStatus() {
  unsigned long uptime = millis() / 1000;
  
  Serial.println("📊 СТАТУС СИСТЕМЫ ДВИЖЕНИЯ:");
  Serial.printf("├ Время работы: %lu сек (%lu мин)\n", uptime, uptime / 60);
  Serial.printf("├ Система охраны: %s\n", systemArmed ? "ВКЛ" : "ВЫКЛ");
  Serial.printf("├ Текущее движение: %s\n", motionDetected ? "ДА" : "НЕТ");
  Serial.printf("├ Последнее движение: %lu сек назад\n", 
                (millis() - lastMotionTime) / 1000);
  Serial.printf("├ Движений в текущем периоде: %d\n", motionCounter);
  Serial.printf("├ Всего движений: %d\n", totalMotions);
  Serial.printf("├ Активность за минуту: %d движений\n", 
                countRecentMotions(60000));
  Serial.printf("└ Средняя частота: %.1f движений/мин\n", 
                (float)totalMotions / (uptime / 60.0));
}

// 🔄 Сброс статистики
void resetStatistics() {
  totalMotions = 0;
  motionCounter = 0;
  systemStartTime = millis();
  
  // 🔄 Очищаем историю
  for (int i = 0; i < 10; i++) {
    motionTimes[i] = 0;
  }
  motionIndex = 0;
  
  Serial.println("🔄 Статистика движений сброшена");
}

// 📋 Справка по командам
void printHelp() {
  Serial.println("📋 ДОСТУПНЫЕ КОМАНДЫ:");
  Serial.println("├ arm - активировать охранную систему");
  Serial.println("├ disarm - деактивировать охрану");
  Serial.println("├ status - показать статус системы");
  Serial.println("├ reset - сбросить статистику");
  Serial.println("└ help - эта справка");
}

// 🧠 УМНАЯ ОБРАБОТКА СИГНАЛОВ PIR

// 📊 Структура для адаптивных настроек
struct PIRSettings {
  int minMotionDuration;     // Мин. длительность движения (мс)
  int maxMotionGap;          // Макс. промежуток в движении (мс)
  int falseAlarmThreshold;   // Порог ложных срабатываний
  bool adaptiveMode;         // Режим адаптации
  unsigned long learningTime; // Время обучения (мс)
};

PIRSettings settings = {200, 2000, 5, true, 300000}; // 5 мин обучения

// 🎯 Функция умной фильтрации движений
bool smartMotionFilter(bool rawMotion) {
  static bool lastState = false;
  static unsigned long stateChangeTime = 0;
  static int shortPulseCount = 0;
  static unsigned long lastShortPulse = 0;
  
  unsigned long currentTime = millis();
  
  // 🔄 Обнаружение изменения состояния
  if (rawMotion != lastState) {
    unsigned long stateDuration = currentTime - stateChangeTime;
    
    // 🔍 Анализ предыдущего состояния
    if (lastState == true) {
      // Завершилось движение
      if (stateDuration < settings.minMotionDuration) {
        // 📊 Слишком короткое движение - возможно помеха
        shortPulseCount++;
        lastShortPulse = currentTime;
        
        Serial.printf("⚠️ Короткий импульс: %lu мс (помеха?)\n", stateDuration);
        
        // 🚨 Много коротких импульсов = проблема
        if (shortPulseCount > settings.falseAlarmThreshold && 
            (currentTime - lastShortPulse) < 10000) {
          Serial.println("🚨 Обнаружены помехи! Увеличиваю фильтрацию");
          settings.minMotionDuration += 50;  // Увеличиваем порог
        }
      }
    }
    
    stateChangeTime = currentTime;
    lastState = rawMotion;
  }
  
  // 🎯 Сброс счетчика коротких импульсов
  if (currentTime - lastShortPulse > 60000) {  // Через минуту
    shortPulseCount = 0;
  }
  
  return rawMotion;
}

// 🤖 Функция машинного обучения паттернов
void learnMotionPatterns() {
  static unsigned long learningStart = 0;
  static int normalMotions = 0;
  static int falseAlarms = 0;
  
  if (learningStart == 0) {
    learningStart = millis();
    Serial.println("🎓 Начинаю обучение распознаванию движений...");
  }
  
  unsigned long learningElapsed = millis() - learningStart;
  
  if (learningElapsed < settings.learningTime) {
    // 📚 Период обучения - собираем статистику
    // (в реальности здесь был бы более сложный алгоритм)
    
    if (learningElapsed % 60000 == 0) {  // Каждую минуту
      int progress = (learningElapsed * 100) / settings.learningTime;
      Serial.printf("🎓 Обучение: %d%% | Движений: %d | Помех: %d\n",
                    progress, normalMotions, falseAlarms);
    }
  } else {
    // ✅ Обучение завершено
    settings.adaptiveMode = false;
    
    float accuracy = (float)normalMotions / (normalMotions + falseAlarms) * 100;
    Serial.printf("🎯 Обучение завершено! Точность: %.1f%%\n", accuracy);
    
    // 🔧 Оптимизируем настройки на основе обучения
    if (accuracy < 90) {
      settings.minMotionDuration += 100;
      Serial.println("🔧 Увеличил фильтрацию для повышения точности");
    }
  }
}

// 📊 Функция анализа качества сигнала
void analyzeSignalQuality() {
  static int signalChanges = 0;
  static unsigned long analysisStart = millis();
  static bool lastSignal = false;
  
  bool currentSignal = digitalRead(PIR_PIN);
  
  if (currentSignal != lastSignal) {
    signalChanges++;
    lastSignal = currentSignal;
  }
  
  // 📈 Анализируем каждые 30 секунд
  if (millis() - analysisStart >= 30000) {
    float changesPerSecond = (float)signalChanges / 30.0;
    
    Serial.printf("📊 Качество сигнала: %.1f изм/сек", changesPerSecond);
    
    if (changesPerSecond > 2.0) {
      Serial.println(" (ШУМНЫЙ - возможны помехи)");
    } else if (changesPerSecond > 0.5) {
      Serial.println(" (АКТИВНЫЙ - норма)");
    } else {
      Serial.println(" (СТАБИЛЬНЫЙ - отлично)");
    }
    
    // 🔄 Сброс для следующего периода
    signalChanges = 0;
    analysisStart = millis();
  }
}

// 🛡️ ОХРАННАЯ СИСТЕМА "УМНЫЙ СТРАЖ" v3.0

// 🎯 Режимы работы системы
enum SecurityMode {
  MODE_DISARMED,    // Выключена
  MODE_HOME,        // Домашний режим
  MODE_AWAY,        // Режим отсутствия
  MODE_NIGHT,       // Ночной режим
  MODE_ALARM        // Тревога
};

// 📊 Структура состояния системы
struct SecuritySystem {
  SecurityMode currentMode;
  bool armed;
  unsigned long armTime;
  unsigned long lastMotion;
  int alarmLevel;        // 0-5 уровень тревоги
  bool sirenActive;
  int motionZones[4];    // 4 зоны контроля
  String lastAlarmReason;
};

SecuritySystem security = {MODE_DISARMED, false, 0, 0, 0, false, {0}, ""};

// ⏰ Временные настройки
const unsigned long ARM_DELAY = 30000;        // 30 сек на выход
const unsigned long ENTRY_DELAY = 15000;      // 15 сек на вход
const unsigned long ALARM_DURATION = 300000;  // 5 мин сирена
const unsigned long MOTION_MEMORY = 60000;    // 1 мин память движения

void securitySystemLoop() {
  // 📖 Читаем датчики
  bool motionDetected = readAllMotionSensors();
  
  // 🧠 Обрабатываем состояние системы
  processSecurityLogic(motionDetected);
  
  // 🚨 Управляем тревогой
  handleAlarmState();
  
  // 💡 Обновляем индикацию
  updateSecurityIndicators();
  
  // 📱 Отправляем уведомления
  sendSecurityNotifications();
}

// 📖 Функция чтения всех датчиков движения
bool readAllMotionSensors() {
  // В реальной системе здесь было бы несколько PIR датчиков
  bool motion = digitalRead(PIR_PIN);
  
  if (motion) {
    security.lastMotion = millis();
    
    // 📍 Определяем зону срабатывания (упрощенно)
    int zone = determineMotionZone();
    security.motionZones[zone]++;
    
    Serial.printf("🚶 Движение в зоне %d (всего: %d)\n", 
                  zone + 1, security.motionZones[zone]);
  }
  
  return motion;
}

// 📍 Функция определения зоны движения
int determineMotionZone() {
  // Упрощенная логика - в реальности анализ нескольких датчиков
  unsigned long time = millis();
  return (time / 10000) % 4;  // Имитация разных зон
}

// 🧠 Основная логика системы безопасности
void processSecurityLogic(bool motionDetected) {
  unsigned long currentTime = millis();
  
  switch (security.currentMode) {
    case MODE_DISARMED:
      // 😴 Система выключена - только мониторинг
      if (motionDetected) {
        Serial.println("👁️ Движение зафиксировано (система выключена)");
      }
      break;
      
    case MODE_HOME:
      // 🏠 Домашний режим - контроль периметра
      if (motionDetected) {
        int zone = determineMotionZone();
        if (zone == 0) {  // Входная зона
          triggerAlarm("Движение во входной зоне (домашний режим)");
        } else {
          Serial.printf("🏠 Нормальное движение дома (зона %d)\n", zone + 1);
        }
      }
      break;
      
    case MODE_AWAY:
      // 🚶 Режим отсутствия - любое движение = тревога
      if (motionDetected) {
        if (currentTime - security.armTime > ARM_DELAY) {
          startEntryDelay("Движение при отсутствии");
        } else {
          Serial.println("⏰ Движение в период выхода (игнорируется)");
        }
      }
      break;
      
    case MODE_NIGHT:
      // 🌙 Ночной режим - контроль первого этажа
      if (motionDetected) {
        int zone = determineMotionZone();
        if (zone <= 1) {  // Первый этаж
          startEntryDelay("Движение на первом этаже ночью");
        }
      }
      break;
      
    case MODE_ALARM:
      // 🚨 Режим тревоги - продолжаем сирену
      handleActiveAlarm();
      break;
  }
}

// ⏰ Функция запуска задержки входа
void startEntryDelay(String reason) {
  static unsigned long entryDelayStart = 0;
  
  if (entryDelayStart == 0) {
    entryDelayStart = millis();
    security.lastAlarmReason = reason;
    
    Serial.printf("⏰ ЗАДЕРЖКА ВХОДА: %s\n", reason.c_str());
    Serial.printf("   У вас %d секунд для отключения\n", ENTRY_DELAY / 1000);
    
    // 🔊 Предупредительные сигналы
    for (int i = 0; i < 3; i++) {
      tone(BUZZER_PIN, 800, 200);
      delay(300);
    }
  }
  
  // ⏱️ Проверяем истечение времени
  if (millis() - entryDelayStart >= ENTRY_DELAY) {
    triggerAlarm(security.lastAlarmReason);
    entryDelayStart = 0;
  }
}

// 🚨 Функция активации тревоги
void triggerAlarm(String reason) {
  security.currentMode = MODE_ALARM;
  security.sirenActive = true;
  security.alarmLevel = 5;
  security.lastAlarmReason = reason;
  
  Serial.printf("🚨 ТРЕВОГА АКТИВИРОВАНА: %s\n", reason.c_str());
  Serial.println("📱 Отправляется уведомление владельцу");
  
  // 🔊 Включаем сирену
  startSiren();
  
  // 📸 Делаем "фото" (имитация)
  takeSecurityPhoto();
  
  // 📱 Отправляем уведомление
  sendAlarmNotification(reason);
}

// 📯 Функция управления сиреной
void startSiren() {
  // 🔊 Паттерн европейской сирены
  static unsigned long sirenStart = 0;
  static bool sirenPhase = false;
  
  if (sirenStart == 0) {
    sirenStart = millis();
  }
  
  if (security.sirenActive) {
    unsigned long elapsed = millis() - sirenStart;
    
    // 🔄 Меняем тон каждые 500мс
    if (elapsed % 1000 < 500) {
      tone(BUZZER_PIN, 800);  // Высокий тон
    } else {
      tone(BUZZER_PIN, 400);  // Низкий тон
    }
    
    // ⏰ Автоматическое отключение через 5 минут
    if (elapsed >= ALARM_DURATION) {
      stopSiren();
      Serial.println("⏰ Сирена автоматически отключена через 5 минут");
    }
  }
}

// 🔇 Функция остановки сирены
void stopSiren() {
  security.sirenActive = false;
  noTone(BUZZER_PIN);
  
  if (security.currentMode == MODE_ALARM) {
    Serial.println("🔇 Сирена остановлена");
  }
}

// 📸 Функция "фотографирования" нарушителя
void takeSecurityPhoto() {
  Serial.println("📸 Делаю фото нарушителя...");
  Serial.println("   [В реальной системе здесь подключение камеры]");
  Serial.println("   Фото сохранено: intruder_2025-05-27_15-46.jpg");
}

// 📱 Функция отправки уведомлений
void sendAlarmNotification(String reason) {
  Serial.println("📱 ОТПРАВКА УВЕДОМЛЕНИЯ:");
  Serial.printf("   Кому: Владелец дома (+7-XXX-XXX-XXXX)\n");
  Serial.printf("   Текст: ТРЕВОГА! %s\n", reason.c_str());
  Serial.printf("   Время: %s\n", getCurrentTime().c_str());
  Serial.printf("   Фото: attached\n");
  Serial.printf("   Управление: http://home-security.local/alarm\n");
}

// 🕐 Функция получения текущего времени
String getCurrentTime() {
  unsigned long uptime = millis() / 1000;
  int hours = (uptime / 3600) % 24;
  int minutes = (uptime / 60) % 60;
  int seconds = uptime % 60;
  
  char timeStr[20];
  sprintf(timeStr, "%02d:%02d:%02d", hours, minutes, seconds);
  return String(timeStr);
}

// 🎮 Функция управления системой
void handleSecurityCommands(String command) {
  if (command == "arm home") {
    armSystem(MODE_HOME);
  } else if (command == "arm away") {
    armSystem(MODE_AWAY);
  } else if (command == "arm night") {
    armSystem(MODE_NIGHT);
  } else if (command == "disarm") {
    disarmSystem();
  } else if (command == "panic") {
    triggerAlarm("Кнопка паники нажата");
  } else if (command == "test") {
    testAllSensors();
  } else if (command == "zones") {
    printZoneStatus();
  }
}

// 🛡️ Функция постановки на охрану
void armSystem(SecurityMode mode) {
  security.currentMode = mode;
  security.armed = true;
  security.armTime = millis();
  
  String modeNames[] = {"", "ДОМАШНИЙ", "ОТСУТСТВИЕ", "НОЧНОЙ", ""};
  Serial.printf("🛡️ Система поставлена на охрану: %s\n", 
                modeNames[mode].c_str());
  Serial.printf("⏰ Задержка выхода: %d секунд\n", ARM_DELAY / 1000);
  
  // 🔊 Подтверждающие сигналы
  for (int i = 0; i < mode; i++) {
    tone(BUZZER_PIN, 1000, 100);
    delay(200);
  }
}

// ✅ Функция снятия с охраны
void disarmSystem() {
  SecurityMode oldMode = security.currentMode;
  
  security.currentMode = MODE_DISARMED;
  security.armed = false;
  stopSiren();
  
  Serial.println("✅ Система снята с охраны");
  
  if (oldMode == MODE_ALARM) {
    Serial.println("🔇 Тревога отменена");
  }
  
  // 🔊 Подтверждение отключения
  tone(BUZZER_PIN, 400, 500);
}

// 🔧 Функция тестирования датчиков
void testAllSensors() {
  Serial.println("🔧 ТЕСТИРОВАНИЕ СИСТЕМЫ БЕЗОПАСНОСТИ:");
  
  // 🚶 Тест PIR датчика
  Serial.print("🚶 PIR датчик: ");
  bool motion = digitalRead(PIR_PIN);
  Serial.println(motion ? "✅ РАБОТАЕТ" : "❌ НЕТ ДВИЖЕНИЯ");
  
  // 🔊 Тест сирены
  Serial.println("🔊 Тест сирены...");
  tone(BUZZER_PIN, 1000, 1000);
  delay(1100);
  
  // 💡 Тест индикации
  Serial.println("💡 Тест светодиодов...");
  for (int i = 0; i < 3; i++) {
    digitalWrite(LED_PIN, HIGH);
    digitalWrite(EXTERNAL_LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
    digitalWrite(EXTERNAL_LED_PIN, LOW);
    delay(200);
  }
  
  Serial.println("✅ Тестирование завершено");
}

// 📊 Функция вывода статуса зон
void printZoneStatus() {
  Serial.println("📊 СТАТУС ЗОН БЕЗОПАСНОСТИ:");
  
  String zoneNames[] = {"Входная группа", "Гостиная", "Кухня", "Коридор"};
  
  for (int i = 0; i < 4; i++) {
    Serial.printf("├ Зона %d (%s): %d срабатываний\n", 
                  i + 1, zoneNames[i].c_str(), security.motionZones[i]);
  }
  
  unsigned long timeSinceMotion = millis() - security.lastMotion;
  Serial.printf("└ Последнее движение: %lu сек назад\n", 
                timeSinceMotion / 1000);
}

// 💡 СИСТЕМА УМНОГО ОСВЕЩЕНИЯ "СВЕТОВОД"

// 🌟 Режимы освещения
enum LightMode {
  LIGHT_OFF,         // Выключено
  LIGHT_AUTO,        // Автоматический режим
  LIGHT_MANUAL,      // Ручное управление
  LIGHT_ECONOMY,     // Экономичный режим
  LIGHT_PARTY,       // Праздничный режим
  LIGHT_NIGHT        // Ночной режим
};

// 📊 Структура системы освещения
struct SmartLighting {
  LightMode currentMode;
  int brightness;              // 0-255
  bool motionActivated;        // Включено движением
  unsigned long lightOnTime;   // Время включения
  int autoOffDelay;           // Задержка автоотключения (сек)
  bool presenceDetected;       // Присутствие человека
  int lightSensorValue;        // Значение датчика света
};

SmartLighting lighting = {LIGHT_AUTO, 128, false, 0, 300, false, 0};

void smartLightingLoop() {
  // 📖 Читаем датчики
  bool motion = digitalRead(PIR_PIN);
  int lightLevel = analogRead(LIGHT_SENSOR_PIN);  // Если есть датчик света
  
  lighting.lightSensorValue = lightLevel;
  
  // 🧠 Определяем присутствие
  updatePresenceDetection(motion);
  
  // 💡 Управляем освещением
  controlAutoLighting();
  
  // 📊 Обновляем статистику
  updateLightingStats();
}

// 👁️ Функция определения присутствия
void updatePresenceDetection(bool motion) {
  static unsigned long lastMotionTime = 0;
  static int motionCount = 0;
  static unsigned long presenceStart = 0;
  
  if (motion) {
    lastMotionTime = millis();
    motionCount++;
    
    if (!lighting.presenceDetected) {
      lighting.presenceDetected = true;
      presenceStart = millis();
      Serial.println("👤 Присутствие ОБНАРУЖЕНО");
    }
  }
  
  // 📊 Анализ отсутствия движения
  unsigned long timeSinceMotion = millis() - lastMotionTime;
  
  if (lighting.presenceDetected && timeSinceMotion > lighting.autoOffDelay * 1000) {
    lighting.presenceDetected = false;
    unsigned long presenceDuration = (millis() - presenceStart) / 1000;
    
    Serial.printf("👻 Присутствие ЗАВЕРШЕНО (длительность: %lu сек)\n", 
                  presenceDuration);
    
    // 📊 Анализ поведения
    analyzeUserBehavior(presenceDuration, motionCount);
    motionCount = 0;
  }
}

// 💡 Функция автоматического управления освещением
void controlAutoLighting() {
  if (lighting.currentMode != LIGHT_AUTO) return;
  
  // 🌅 Определяем нужность освещения по датчику света
  bool needLight = lighting.lightSensorValue < 500;  // Темно
  
  // 🎯 Логика включения/выключения
  if (lighting.presenceDetected && needLight) {
    // 💡 Включаем свет
    if (!lighting.motionActivated) {
      turnOnLight();
    }
  } else {
    // 💤 Выключаем свет
    if (lighting.motionActivated) {
      turnOffLight();
    }
  }
  
  // 🌈 Адаптивная яркость
  adaptBrightness();
}

// 🔆 Функция включения освещения
void turnOnLight() {
  lighting.motionActivated = true;
  lighting.lightOnTime = millis();
  
  Serial.printf("💡 Свет ВКЛЮЧЕН (режим: %s)\n", getLightModeString().c_str());
  
  // 🌅 Плавное включение
  fadeLight(0, lighting.brightness, 1000);  // 1 секунда на включение
}

// 💤 Функция выключения освещения
void turnOffLight() {
  unsigned long onDuration = (millis() - lighting.lightOnTime) / 1000;
  
  Serial.printf("💤 Свет ВЫКЛЮЧЕН (горел %lu сек)\n", onDuration);
  
  // 🌇 Плавное выключение
  fadeLight(lighting.brightness, 0, 2000);  // 2 секунды на выключение
  
  lighting.motionActivated = false;
}

// 🌈 Функция плавного изменения яркости
void fadeLight(int fromBrightness, int toBrightness, int duration) {
  int steps = 50;
  int stepDelay = duration / steps;
  
  for (int i = 0; i <= steps; i++) {
    int currentBrightness = map(i, 0, steps, fromBrightness, toBrightness);
    analogWrite(EXTERNAL_LED_PIN, currentBrightness);
    delay(stepDelay);
  }
}

// 🎛️ Функция адаптивной яркости
void adaptBrightness() {
  if (!lighting.motionActivated) return;
  
  // 📊 Адаптация к уровню внешнего освещения
  int targetBrightness;
  
  if (lighting.lightSensorValue < 200) {
    targetBrightness = 255;  // Очень темно - максимум
  } else if (lighting.lightSensorValue < 400) {
    targetBrightness = 200;  // Темно - яркий свет
  } else if (lighting.lightSensorValue < 600) {
    targetBrightness = 150;  // Сумерки - средний свет
  } else {
    targetBrightness = 80;   // Светло - приглушенный
  }
  
  // 🌙 Ночной режим - снижаем яркость
  if (lighting.currentMode == LIGHT_NIGHT) {
    targetBrightness /= 3;
  }
  
  // 🔄 Плавная адаптация яркости
  if (abs(lighting.brightness - targetBrightness) > 10) {
    lighting.brightness = targetBrightness;
    analogWrite(EXTERNAL_LED_PIN, lighting.brightness);
    
    Serial.printf("🌈 Яркость адаптирована: %d (освещенность: %d)\n",
                  lighting.brightness, lighting.lightSensorValue);
  }
}

// 🧠 Функция анализа поведения пользователя
void analyzeUserBehavior(unsigned long duration, int motionCount) {
  float motionRate = (float)motionCount / (duration / 60.0);  // движений/мин
  
  Serial.printf("🧠 Анализ поведения: %.1f движений/мин", motionRate);
  
  if (motionRate > 5) {
    Serial.println(" (АКТИВНАЯ работа)");
    lighting.autoOffDelay = 600;  // 10 мин для активной работы
  } else if (motionRate > 2) {
    Serial.println(" (ОБЫЧНАЯ активность)");
    lighting.autoOffDelay = 300;  // 5 мин стандартно
  } else {
    Serial.println(" (НИЗКАЯ активность)");
    lighting.autoOffDelay = 120;  // 2 мин для низкой активности
  }
  
  Serial.printf("🕐 Новая задержка отключения: %d сек\n", lighting.autoOffDelay);
}

// 📊 Функция получения названия режима
String getLightModeString() {
  switch (lighting.currentMode) {
    case LIGHT_OFF: return "ВЫКЛ";
    case LIGHT_AUTO: return "АВТО";
    case LIGHT_MANUAL: return "РУЧНОЙ";
    case LIGHT_ECONOMY: return "ЭКОНОМ";
    case LIGHT_PARTY: return "ПРАЗДНИК";
    case LIGHT_NIGHT: return "НОЧЬ";
    default: return "НЕИЗВЕСТЕН";
  }
}

// 🎮 Функция управления режимами освещения
void handleLightCommands(String command) {
  if (command == "light auto") {
    lighting.currentMode = LIGHT_AUTO;
    Serial.println("💡 Режим: АВТОМАТИЧЕСКИЙ");
  } else if (command == "light manual") {
    lighting.currentMode = LIGHT_MANUAL;
    Serial.println("💡 Режим: РУЧНОЙ");
  } else if (command == "light night") {
    lighting.currentMode = LIGHT_NIGHT;
    Serial.println("💡 Режим: НОЧНОЙ");
  } else if (command == "light on") {
    lighting.currentMode = LIGHT_MANUAL;
    turnOnLight();
  } else if (command == "light off") {
    turnOffLight();
  } else if (command.startsWith("brightness ")) {
    int newBrightness = command.substring(11).toInt();
    setBrightness(newBrightness);
  }
}

// 🔆 Функция установки яркости
void setBrightness(int brightness) {
  lighting.brightness = constrain(brightness, 0, 255);
  
  if (lighting.motionActivated) {
    analogWrite(EXTERNAL_LED_PIN, lighting.brightness);
  }
  
  Serial.printf("🔆 Яркость установлена: %d/255\n", lighting.brightness);
}

### **Блок 4: "Интеграция с IoT системой школы" (10 минут)**

#### **📡 "Отправка данных о движении на сервер"**

**Мониторинг активности в классе:**

Данные о движении, собираемые PIR датчиками, представляют огромную ценность для анализа образовательного процесса. Система отправляет на школьный сервер информацию о:

- **Паттернах активности учеников** - когда класс наиболее и наименее активен
- **Эффективности уроков** - корреляция между движением и вовлеченностью
- **Оптимизации расписания** - определение лучшего времени для разных типов занятий
- **Безопасности** - контроль присутствия и несанкционированного доступа
- **Энергосбережении** - статистика работы автоматического освещения

**Собираемые метрики:**
- Количество движений за урок/день
- Периоды высокой и низкой активности
- Время присутствия каждого ученика
- Эффективность систем автоматизации
- Статистика ложных срабатываний

#### **🖥️ "Веб-дашборд школьной администрации"**

**Административная панель для директора и завучей:**

Школьная IoT платформа предоставляет руководству детальную аналитику по всем классам:

**Панель "Активность по классам":**
- Сравнение активности разных классов в реальном времени
- Графики вовлеченности учеников по времени суток
- Статистика посещаемости на основе датчиков движения
- Анализ эффективности различных форм обучения

**Панель "Безопасность школы":**
- Мониторинг всех помещений в режиме реального времени
- Система оповещений о несанкционированном доступе
- Контроль работы систем автоматического освещения
- Статистика энергопотребления по зданию

**Педагогическая аналитика:**
- Определение оптимального времени для проведения контрольных работ
- Анализ влияния физической активности на успеваемость
- Рекомендации по организации перемен и физкультминуток
- Мониторинг соблюдения санитарно-гигиенических норм

#### **📊 "Большие данные образования"**

**Применение данных PIR в образовательной аналитике:**

Собранные данные используются для:

**Исследований в области педагогики:**
- Изучение биоритмов учащихся и их влияния на обучение
- Анализ эффективности различных методов преподавания
- Исследование влияния физической среды на образовательный процесс

**Оптимизации учебного процесса:**
- Автоматическое формирование расписания с учетом активности классов
- Рекомендации по продолжительности уроков для разных возрастов
- Планирование ремонтов и модернизации аудиторий

**Здоровьесбережения:**
- Контроль соблюдения норм двигательной активности
- Автоматические напоминания о необходимости проветривания
- Мониторинг эргономики учебного пространства

#### **🌐 "Интеграция с городской системой 'Умный город'"**

**Школа как часть цифровой экосистемы:**

Данные школьных PIR датчиков интегрируются с городскими системами:

- **Транспортная система** - прогнозирование загрузки общественного транспорта
- **Энергосети** - оптимизация электроснабжения образовательных учреждений  
- **Система безопасности** - координация с районными службами охраны
- **Экологический мониторинг** - анализ влияния школьной активности на окружающую среду

## 🎨 Творческое задание: "Умная система безопасности и комфорта" (12 минут)

### **🛡️ "Создание интеллектуальной системы контроля класса"**

**Техническое задание для команд:**

Команды получают задание создать комплексную систему, которая не просто реагирует на движение, но анализирует поведение и адаптируется к потребностям класса.

**Базовый функционал:**
- Детекция движения с возможностью различения типов активности
- Автоматическое управление освещением с учетом времени суток
- Система безопасности с градацией уровней тревоги
- Сбор и анализ статистики для оптимизации учебного процесса

**Инновационные возможности:**
- ИИ-анализ поведенческих паттернов учеников
- Интеграция с другими системами умного дома
- Предиктивная аналитика для предотвращения проблем
- Адаптивное обучение алгоритмов под конкретный класс

### **🎪 "Выставка умных решений"**

**Демонстрация проектов:**

Каждая команда представляет свою систему, демонстрируя:

**Техническое совершенство:**
- Надежность работы в различных условиях
- Скорость реакции и точность детекции
- Энергоэффективность решения
- Масштабируемость для всей школы

**Практическую применимость:**
- Решение реальных проблем класса
- Удобство использования для учителей
- Безопасность и конфиденциальность данных
- Экономическую целесообразность внедрения

**Инновационность:**
- Оригинальность технических решений
- Креативность в применении PIR технологий
- Интеграция с современными трендами IoT
- Потенциал для дальнейшего развития

## 📝 Рефлексия и закрепление (5 минут)

### **🚶 "Викторина движения и безопасности"**

**Интерактивное закрепление знаний:**

Ученики демонстрируют понимание материала через практические действия:

**Физические демонстрации:**
- Показывают оптимальные траектории движения для PIR датчика
- Демонстрируют зоны максимальной и минимальной чувствительности
- Объясняют принципы работы через движение и жесты

**Анализ ситуаций:**
- Обсуждают этические аспекты мониторинга движения
- Предлагают решения для повышения конфиденциальности
- Анализируют баланс между безопасностью и приватностью

### **💭 "Размышления о безопасности"**

**Философские аспекты темы:**

Ученики размышляют о роли технологий в современном мире:

- "PIR датчики изменили мое понимание безопасности, потому что..."
- "Самое важное в системах автоматизации это..."
- "В будущем я бы применил эти технологии для..."
- "Баланс между удобством и приватностью должен быть..."

## 🏠 Домашнее задание

### **🚶 "Домашний исследователь движения"**

**Практические исследования:**

**1. Наблюдение и анализ:**
- Изучить системы безопасности в своем доме/подъезде
- Найти PIR датчики в общественных местах (магазины, офисы)
- Проанализировать эффективность автоматического освещения

**2. Эксперименты с системой:**
- Протестировать PIR датчик в различных условиях дома
- Измерить влияние температуры на чувствительность
- Найти оптимальное размещение для домашнего использования

**3. Творческое применение:**
- Придумать новые способы использования PIR датчиков
- Спроектировать систему безопасности для своей комнаты
- Создать план "умного дома" с автоматизацией

### **📔 "Дневник инженера безопасности"**

### **🔬 Исследовательское задание (для увлеченных):**
- Изучить другие типы датчиков движения (ультразвуковые, микроволновые)
- Найти информацию о системах компьютерного зрения
- Исследовать применение PIR в автомобильной промышленности

### **🎨 Творческое задание:**
- Нарисовать план "умной школы" с датчиками движения
- Создать комикс "День из жизни PIR датчика"

## 📊 Критерии оценивания

### **"Отлично" (5):**
- Глубоко понимает принципы работы PIR датчиков и инфракрасного излучения
- Создает многофункциональную систему безопасности с несколькими режимами
- Программирует адаптивные алгоритмы анализа движения
- Реализует инновационные функции интеграции с IoT
- Демонстрирует понимание этических аспектов мониторинга
- Создает практически применимое решение

### **"Хорошо" (4):**
- Понимает основы работы PIR датчиков
- Создает функциональную систему автоматического освещения и охраны
- Программирует базовые алгоритмы детекции движения
- Выполняет настройку и калибровку системы
- Интегрирует систему с внешними сервисами

### **"Удовлетворительно" (3):**
- Имеет общее представление о датчиках движения
- С помощью создает простую систему реакции на движение
- Понимает базовые принципы систем безопасности
- Участвует в групповой работе над проектом

## 🛠️ Материалы и оборудование

### **Для каждой команды (3-4 человека):**
- ESP32 DevKit плата
- PIR датчик движения HC-SR501  
- Светодиоды (белый, красный, зеленый)
- Резисторы 220 Ом (3 шт)
- Пьезобузер для звуковых сигналов
- Макетная плата и провода
- Мультиметр для диагностики

### **Для демонстраций учителем:**
- Инфракрасная камера (или тепловизор) для демонстрации ИК-излучения
- Различные источники тепла для экспериментов
- Препятствия разных материалов для тестирования проникновения ИК
- Профессиональный PIR датчик для сравнения характеристик

### **Программное обеспечение:**
- Arduino IDE с библиотеками для работы с таймерами
- Serial Plotter для визуализации активности датчика
- Веб-интерфейс школьного IoT сервера
- Приложения для анализа данных движения

### **Дополнительные компоненты (для продвинутых проектов):**
- Несколько PIR датчиков для многозонной системы
- Реле для управления мощным освещением
- LCD дисплей для отображения статуса системы
- SD карта для локального хранения логов
- Камера модуль для фото при тревоге
- Датчик освещенности для адаптивного управления

## 🔍 Методические заметки для учителя

### **Подготовка к уроку:**
1. **Стабилизация датчиков:** За час до урока включить все PIR датчики для прогрева
2. **Зонирование класса:** Разметить зоны для тестирования дальности обнаружения
3. **Демонстрационные материалы:** Подготовить источники тепла и препятствия
4. **Безопасность:** Проверить отсутствие острых углов и надежность креплений

### **Возможные сложности:**

**Проблема:** PIR датчик не стабилизируется или дает ложные срабатывания
**Решение:** Обеспечить 60+ секунд на стабилизацию, экранировать от сквозняков и ИК-источников

**Проблема:** Учащиеся не понимают принцип работы инфракрасного излучения
**Решение:** Больше наглядных демонстраций с тепловизором, аналогии с живой природой

**Проблема:** Этические вопросы о приватности и слежке
**Решение:** Обязательно обсудить границы применения, получение согласия, анонимизацию данных

### **Безопасность:**
- Использование только безопасных источников тепла для демонстраций
- Контроль правильности подключения 5V питания PIR датчиков
- Обсуждение этических аспектов использования систем мониторинга
- Информирование о том, что данные используются только в образовательных целях

### **Дифференциация обучения:**
- **Для продвинутых:** изучение профессиональных охранных систем, машинное обучение для анализа паттернов
- **Для начинающих:** готовые алгоритмы, простые схемы подключения
- **Для визуалов:** тепловизионные изображения, схемы зон обнаружения
- **Для кинестетиков:** больше движения для тестирования датчиков

### **Связь с реальным миром:**
- Системы безопасности в банках, музеях, частных домах
- Автоматическое освещение в общественных зданиях
- Системы подсчета посетителей в торговых центрах
- Умные города и IoT инфраструктура

### **Межпредметные связи:**
- **Физика:** инфракрасное излучение, тепло, оптика
- **Биология:** терморегуляция живых организмов, органы чувств змей
- **ОБЖ:** системы безопасности, охрана жилища
- **Обществознание:** приватность, этика слежения, права человека

### **Развитие проекта:**
- Интеграция с камерами для распознавания лиц
- Машинное обучение для классификации типов движения
- Создание мобильного приложения для управления
- Интеграция с голосовыми ассистентами