👏 Звуковой датчик

// 🎤 ПРОГРАММА ЗВУКОВОГО ДАТЧИКА
// Урок 14: Измерение уровня звука и звуковая активация

// 🔧 Настройки пинов
const int SOUND_ANALOG_PIN = 34;    // Аналоговый вход (AO)
const int SOUND_DIGITAL_PIN = 35;   // Цифровой вход (DO)
const int LED_PIN = 2;              // Светодиод для индикации
const int EXTERNAL_LED_PIN = 5;     // Внешний светодиод

// 📊 Параметры измерения
const int SAMPLES_COUNT = 50;       // Количество измерений для усреднения
const int SAMPLE_DELAY = 2;         // Задержка между измерениями (мс)
const int NOISE_THRESHOLD = 100;    // Порог обнаружения звука
const int CLAP_THRESHOLD = 300;     // Порог обнаружения хлопка

// 📈 Переменные для анализа
int baselineNoise = 0;              // Уровень фонового шума
int maxSoundLevel = 0;              // Максимальный уровень за период
int avgSoundLevel = 0;              // Средний уровень звука
bool soundDetected = false;         // Флаг обнаружения звука
unsigned long lastSoundTime = 0;    // Время последнего звука

void setup() {
  Serial.begin(9600);
  Serial.println("🎤 Инициализация звукового датчика");
  
  // 🔧 Настройка пинов
  pinMode(LED_PIN, OUTPUT);
  pinMode(EXTERNAL_LED_PIN, OUTPUT);
  pinMode(SOUND_DIGITAL_PIN, INPUT);
  
  Serial.println("🔇 Калибровка фонового шума...");
  Serial.println("   (Соблюдайте тишину 5 секунд)");
  
  // 🎯 Калибровка фонового шума
  calibrateBaseline();
  
  Serial.printf("✅ Калибровка завершена! Фон: %d\n", baselineNoise);
  Serial.println("📊 Формат: Сырой | Уровень | Состояние | Тип");
  Serial.println("─────────────────────────────────────────────");
}

void loop() {
  // 📖 Читаем текущий уровень звука
  int currentLevel = readSoundLevel();
  
  // 📊 Анализируем звуковой сигнал
  String soundAnalysis = analyzeSoundLevel(currentLevel);
  
  // 🎵 Обнаружение специальных звуков
  detectSpecialSounds(currentLevel);
  
  // 💡 Управление светодиодами
  updateLEDs(currentLevel);
  
  // 📊 Вывод данных
  printSoundStatus(currentLevel, soundAnalysis);
  
  delay(100);  // Обновление 10 раз в секунду
}

// 🎯 Функция калибровки фонового шума
void calibrateBaseline() {
  long sum = 0;
  int measurements = 100;
  
  for (int i = 0; i < measurements; i++) {
    sum += analogRead(SOUND_ANALOG_PIN);
    delay(50);
    
    // 📈 Показываем прогресс
    if (i % 20 == 0) {
      Serial.printf("🔇 Калибровка: %d%%\n", (i * 100) / measurements);
    }
  }
  
  baselineNoise = sum / measurements;
}

// 📖 Функция чтения уровня звука с усреднением
int readSoundLevel() {
  long sum = 0;
  int maxVal = 0;
  int minVal = 4095;
  
  // 📊 Собираем выборку измерений
  for (int i = 0; i < SAMPLES_COUNT; i++) {
    int reading = analogRead(SOUND_ANALOG_PIN);
    sum += reading;
    
    if (reading > maxVal) maxVal = reading;
    if (reading < minVal) minVal = reading;
    
    delay(SAMPLE_DELAY);
  }
  
  // 📈 Вычисляем среднее и размах
  avgSoundLevel = sum / SAMPLES_COUNT;
  int range = maxVal - minVal;  // Размах = показатель активности
  
  // 🔊 Возвращаем размах как меру громкости
  return range;
}

// 🔍 Функция анализа уровня звука
String analyzeSoundLevel(int level) {
  // 📊 Вычисляем уровень относительно фона
  int relativeLevel = level;
  
  if (relativeLevel < NOISE_THRESHOLD) {
    soundDetected = false;
    return "🔇 Тишина";
  } else if (relativeLevel < NOISE_THRESHOLD * 2) {
    soundDetected = true;
    return "🔉 Тихий звук";
  } else if (relativeLevel < NOISE_THRESHOLD * 4) {
    soundDetected = true;
    return "🔊 Громкий звук";
  } else {
    soundDetected = true;
    return "📢 Очень громко!";
  }
}

// 👏 Функция обнаружения специальных звуков
void detectSpecialSounds(int level) {
  static int previousLevel = 0;
  static unsigned long lastClapTime = 0;
  static int clapCount = 0;
  
  // 👏 Обнаружение хлопка (резкий скачок громкости)
  if (level > CLAP_THRESHOLD && previousLevel < NOISE_THRESHOLD) {
    unsigned long currentTime = millis();
    
    // 🕐 Проверяем, не слишком ли быстро повторяется
    if (currentTime - lastClapTime > 200) {  // Минимум 200мс между хлопками
      clapCount++;
      lastClapTime = currentTime;
      
      Serial.printf("👏 ХЛОПОК обнаружен! (№%d) Уровень: %d\n", clapCount, level);
      
      // 🎯 Реакция на хлопок
      onClapDetected(clapCount);
    }
  }
  
  // 🕐 Сброс счетчика хлопков через 3 секунды
  if (millis() - lastClapTime > 3000) {
    if (clapCount > 0) {
      Serial.printf("🏁 Серия из %d хлопков завершена\n", clapCount);
      clapCount = 0;
    }
  }
  
  previousLevel = level;
}

// 🎯 Функция реакции на хлопок
void onClapDetected(int clapNumber) {
  // 💡 Мигаем светодиодом количество раз = номер хлопка
  for (int i = 0; i < clapNumber; i++) {
    digitalWrite(EXTERNAL_LED_PIN, HIGH);
    delay(100);
    digitalWrite(EXTERNAL_LED_PIN, LOW);
    delay(100);
  }
  
  // 🎵 Различные реакции на количество хлопков
  switch (clapNumber) {
    case 1:
      Serial.println("💡 Одиночный хлопок - переключение основного света");
      break;
    case 2:
      Serial.println("🌙 Двойной хлопок - режим ночника");
      break;
    case 3:
      Serial.println("🚨 Тройной хлопок - режим тревоги");
      break;
    default:
      Serial.println("🎉 Много хлопков - праздничный режим!");
      break;
  }
}

// 💡 Функция управления светодиодами
void updateLEDs(int soundLevel) {
  // 📊 Встроенный светодиод показывает наличие звука
  digitalWrite(LED_PIN, soundDetected);
  
  // 🌈 Внешний светодиод показывает громкость
  int brightness = map(soundLevel, 0, 1000, 0, 255);
  brightness = constrain(brightness, 0, 255);
  analogWrite(EXTERNAL_LED_PIN, brightness);
  
  // 🔊 Цифровой выход для сравнения
  bool digitalSound = digitalRead(SOUND_DIGITAL_PIN);
  if (digitalSound != soundDetected) {
    Serial.printf("⚠️ Расхождение: Аналог=%s, Цифра=%s\n", 
                  soundDetected ? "ДА" : "НЕТ",
                  digitalSound ? "ДА" : "НЕТ");
  }
}

// 📊 Функция вывода статуса звука
void printSoundStatus(int level, String analysis) {
  static unsigned long lastPrint = 0;
  
  if (millis() - lastPrint >= 500) {  // Каждые 0.5 секунды
    Serial.printf("🎤 Сырой: %4d | Уровень: %3d | %s\n", 
                  avgSoundLevel, level, analysis.c_str());
    lastPrint = millis();
  }
}

// 🧠 ПРОДВИНУТАЯ ОБРАБОТКА ЗВУКА

// 📊 Структура для хранения статистики
struct SoundStatistics {
  int minLevel;
  int maxLevel;
  float avgLevel;
  int peakCount;
  unsigned long analysisStartTime;
};

SoundStatistics stats = {4095, 0, 0, 0, 0};

// 📈 Функция адаптивного порога
int calculateAdaptiveThreshold() {
  static unsigned long lastUpdate = 0;
  static int adaptiveThreshold = NOISE_THRESHOLD;
  
  // 🕐 Обновляем порог каждые 10 секунд
  if (millis() - lastUpdate > 10000) {
    // 📊 Анализируем последнюю статистику
    float backgroundLevel = stats.avgLevel;
    float dynamicRange = stats.maxLevel - stats.minLevel;
    
    // 🎯 Вычисляем новый порог
    adaptiveThreshold = backgroundLevel + (dynamicRange * 0.3);
    
    // 🔒 Ограничиваем разумными пределами
    adaptiveThreshold = constrain(adaptiveThreshold, 50, 500);
    
    Serial.printf("🎯 Адаптивный порог обновлен: %d\n", adaptiveThreshold);
    
    // 🔄 Сбрасываем статистику
    resetStatistics();
    lastUpdate = millis();
  }
  
  return adaptiveThreshold;
}

// 🌊 Функция цифрового фильтра (простой FIR)
int applyDigitalFilter(int newSample) {
  static int buffer[5] = {0};  // Буфер для 5 последних значений
  static int index = 0;
  
  // 📝 Добавляем новое значение в буфер
  buffer[index] = newSample;
  index = (index + 1) % 5;
  
  // 📊 Вычисляем взвешенное среднее
  int filtered = (buffer[0] + buffer[1]*2 + buffer[2]*3 + buffer[3]*2 + buffer[4]) / 9;
  
  return filtered;
}

// 🔍 Функция обнаружения речи
bool detectSpeech(int soundLevel) {
  static int speechPattern[10];
  static int patternIndex = 0;
  static bool inSpeech = false;
  
  // 📝 Записываем паттерн активности
  speechPattern[patternIndex] = (soundLevel > NOISE_THRESHOLD) ? 1 : 0;
  patternIndex = (patternIndex + 1) % 10;
  
  // 📊 Анализируем паттерн (речь = ритмичные изменения)
  int transitions = 0;
  for (int i = 0; i < 9; i++) {
    if (speechPattern[i] != speechPattern[i+1]) {
      transitions++;
    }
  }
  
  // 🗣️ Речь характеризуется 3-7 переходами в окне
  bool speechDetected = (transitions >= 3 && transitions <= 7);
  
  if (speechDetected != inSpeech) {
    inSpeech = speechDetected;
    Serial.printf("🗣️ Речь: %s (переходов: %d)\n", 
                  speechDetected ? "ОБНАРУЖЕНА" : "ЗАВЕРШЕНА", transitions);
  }
  
  return speechDetected;
}

// 📊 Функция сбора статистики
void updateStatistics(int level) {
  if (level < stats.minLevel) stats.minLevel = level;
  if (level > stats.maxLevel) stats.maxLevel = level;
  
  // 📈 Скользящее среднее
  static float alpha = 0.1;  // Коэффициент сглаживания
  stats.avgLevel = alpha * level + (1 - alpha) * stats.avgLevel;
  
  // 🔊 Подсчет пиков
  static int lastLevel = 0;
  if (level > lastLevel + 100) {  // Резкий рост = пик
    stats.peakCount++;
  }
  lastLevel = level;
}

// 🔄 Сброс статистики
void resetStatistics() {
  stats.minLevel = 4095;
  stats.maxLevel = 0;
  stats.avgLevel = 0;
  stats.peakCount = 0;
  stats.analysisStartTime = millis();
}

// 👏 СИСТЕМА УПРАВЛЕНИЯ ХЛОПКАМИ v2.0

// 🎯 Команды и их паттерны хлопков
enum ClapCommand {
  CMD_NONE,
  CMD_LIGHT_TOGGLE,     // 1 хлопок
  CMD_NIGHT_MODE,       // 2 хлопка
  CMD_ALARM_MODE,       // 3 хлопка
  CMD_MUSIC_MODE,       // 4 хлопка
  CMD_SYSTEM_RESET      // 5 хлопков
};

// 🕐 Параметры распознавания
const unsigned long CLAP_TIMEOUT = 3000;        // 3 сек на серию хлопков
const unsigned long MIN_CLAP_INTERVAL = 150;    // Мин. интервал между хлопками
const unsigned long MAX_CLAP_INTERVAL = 800;    // Макс. интервал в серии
const int CLAP_SENSITIVITY = 300;               // Чувствительность

// 📊 Переменные состояния системы
struct SystemState {
  bool mainLight;
  bool nightMode;
  bool alarmMode;
  bool musicMode;
  int brightness;
  unsigned long lastCommandTime;
};

SystemState system = {false, false, false, false, 128, 0};

void setup() {
  Serial.begin(9600);
  Serial.println("👏 Система управления хлопками v2.0");
  
  // 🔧 Инициализация
  pinMode(LED_PIN, OUTPUT);
  pinMode(EXTERNAL_LED_PIN, OUTPUT);
  
  calibrateBaseline();
  
  Serial.println("✅ Система готова к управлению хлопками!");
  printCommands();
}

void loop() {
  // 🎤 Обработка звука
  int soundLevel = readSoundLevel();
  
  // 👏 Обнаружение и обработка команд
  ClapCommand command = detectClapCommand(soundLevel);
  
  if (command != CMD_NONE) {
    executeCommand(command);
  }
  
  // 💡 Обновление состояния системы
  updateSystemOutputs();
  
  delay(50);  // 20 FPS для точного распознавания
}

// 👏 Функция распознавания команд по хлопкам
ClapCommand detectClapCommand(int soundLevel) {
  static unsigned long clapTimes[10];  // Времена хлопков
  static int clapCount = 0;
  static unsigned long lastClapTime = 0;
  static bool waitingForSeries = false;
  
  unsigned long currentTime = millis();
  
  // 🔍 Обнаружение хлопка
  bool clapDetected = detectClap(soundLevel);
  
  if (clapDetected) {
    // ⏱️ Проверяем интервал с предыдущим хлопком
    unsigned long interval = currentTime - lastClapTime;
    
    if (interval >= MIN_CLAP_INTERVAL) {
      // 📝 Записываем время хлопка
      clapTimes[clapCount] = currentTime;
      clapCount++;
      lastClapTime = currentTime;
      waitingForSeries = true;
      
      Serial.printf("👏 Хлопок #%d (интервал: %lums)\n", clapCount, interval);
      
      // 🚫 Защита от переполнения
      if (clapCount >= 10) clapCount = 10;
    }
  }
  
  // 🕐 Проверяем таймаут серии хлопков
  if (waitingForSeries && (currentTime - lastClapTime > CLAP_TIMEOUT)) {
    ClapCommand command = analyzeClaps(clapTimes, clapCount);
    
    // 🔄 Сбрасываем состояние
    clapCount = 0;
    waitingForSeries = false;
    
    return command;
  }
  
  return CMD_NONE;
}

// 🔍 Функция обнаружения одиночного хлопка
bool detectClap(int soundLevel) {
  static int previousLevel = 0;
  static bool clapInProgress = false;
  
  // 📈 Резкий скачок громкости = начало хлопка
  if (!clapInProgress && soundLevel > CLAP_SENSITIVITY && 
      previousLevel < NOISE_THRESHOLD) {
    clapInProgress = true;
    return true;
  }
  
  // 📉 Падение ниже порога = конец хлопка
  if (clapInProgress && soundLevel < NOISE_THRESHOLD) {
    clapInProgress = false;
  }
  
  previousLevel = soundLevel;
  return false;
}

// 🧠 Функция анализа паттерна хлопков
ClapCommand analyzeClaps(unsigned long* times, int count) {
  if (count == 0) return CMD_NONE;
  
  Serial.printf("🧠 Анализ серии из %d хлопков:\n", count);
  
  // 📊 Анализируем интервалы между хлопками
  bool validSeries = true;
  for (int i = 1; i < count; i++) {
    unsigned long interval = times[i] - times[i-1];
    Serial.printf("   Интервал %d: %lums\n", i, interval);
    
    // ⏱️ Слишком большой интервал = разные серии
    if (interval > MAX_CLAP_INTERVAL) {
      validSeries = false;
      break;
    }
  }
  
  if (!validSeries) {
    Serial.println("❌ Серия невалидна (слишком большие интервалы)");
    return CMD_NONE;
  }
  
  // 🎯 Определяем команду по количеству хлопков
  switch (count) {
    case 1: return CMD_LIGHT_TOGGLE;
    case 2: return CMD_NIGHT_MODE;
    case 3: return CMD_ALARM_MODE;
    case 4: return CMD_MUSIC_MODE;
    case 5: return CMD_SYSTEM_RESET;
    default:
      Serial.printf("❓ Неизвестная команда (%d хлопков)\n", count);
      return CMD_NONE;
  }
}

// ⚡ Функция выполнения команд
void executeCommand(ClapCommand command) {
  system.lastCommandTime = millis();
  
  switch (command) {
    case CMD_LIGHT_TOGGLE:
      system.mainLight = !system.mainLight;
      Serial.printf("💡 Основное освещение: %s\n", 
                    system.mainLight ? "ВКЛ" : "ВЫКЛ");
      break;
      
    case CMD_NIGHT_MODE:
      system.nightMode = !system.nightMode;
      system.brightness = system.nightMode ? 50 : 128;
      Serial.printf("🌙 Ночной режим: %s (яркость: %d)\n", 
                    system.nightMode ? "ВКЛ" : "ВЫКЛ", system.brightness);
      break;
      
    case CMD_ALARM_MODE:
      system.alarmMode = !system.alarmMode;
      Serial.printf("🚨 Режим тревоги: %s\n", 
                    system.alarmMode ? "ВКЛ" : "ВЫКЛ");
      break;
      
    case CMD_MUSIC_MODE:
      system.musicMode = !system.musicMode;
      Serial.printf("🎵 Музыкальный режим: %s\n", 
                    system.musicMode ? "ВКЛ" : "ВЫКЛ");
      break;
      
    case CMD_SYSTEM_RESET:
      Serial.println("🔄 Сброс системы...");
      resetSystemState();
      break;
  }
  
  // 🎉 Подтверждение выполнения команды
  confirmCommand(command);
}

// ✅ Функция подтверждения команды
void confirmCommand(ClapCommand command) {
  // 💡 Световое подтверждение
  for (int i = 0; i < (int)command; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
    delay(200);
  }
  
  // 🔊 Звуковое подтверждение (если есть buzzer)
  // tone(BUZZER_PIN, 1000, 100);
}

// 🔄 Сброс состояния системы
void resetSystemState() {
  system.mainLight = false;
  system.nightMode = false;
  system.alarmMode = false;
  system.musicMode = false;
  system.brightness = 128;
  
  Serial.println("✅ Система сброшена в исходное состояние");
}

// 💡 Обновление выходов системы
void updateSystemOutputs() {
  // 🌙 Ночной режим имеет приоритет
  if (system.nightMode) {
    analogWrite(EXTERNAL_LED_PIN, system.brightness);
    digitalWrite(LED_PIN, false);
    return;
  }
  
  // 🚨 Режим тревоги
  if (system.alarmMode) {
    // Мигающий красный свет
    bool blinkState = (millis() / 250) % 2;
    digitalWrite(EXTERNAL_LED_PIN, blinkState);
    digitalWrite(LED_PIN, blinkState);
    return;
  }
  
  // 🎵 Музыкальный режим
  if (system.musicMode) {
    // Реакция на текущий уровень звука
    int currentSound = readSoundLevel();
    int musicBrightness = map(currentSound, 0, 500, 0, 255);
    analogWrite(EXTERNAL_LED_PIN, musicBrightness);
    return;
  }
  
  // 💡 Обычное освещение
  if (system.mainLight) {
    analogWrite(EXTERNAL_LED_PIN, system.brightness);
  } else {
    analogWrite(EXTERNAL_LED_PIN, 0);
  }
  
  digitalWrite(LED_PIN, system.mainLight);
}

// 📋 Вывод доступных команд
void printCommands() {
  Serial.println("📋 ДОСТУПНЫЕ КОМАНДЫ:");
  Serial.println("├ 👏      = Переключить основное освещение");
  Serial.println("├ 👏👏    = Ночной режим вкл/выкл");
  Serial.println("├ 👏👏👏  = Режим тревоги вкл/выкл");
  Serial.println("├ 👏👏👏👏 = Музыкальный режим вкл/выкл");
  Serial.println("└ 👏👏👏👏👏 = Сброс системы");
  Serial.println("⏱️ Интервал между хлопками: 150-800мс");
  Serial.println("🕐 Таймаут серии: 3 секунды");
}

// 🎵 СВЕТОМУЗЫКАЛЬНАЯ УСТАНОВКА

// 🌈 RGB светодиод для цветомузыки
const int RED_PIN = 25;
const int GREEN_PIN = 26;
const int BLUE_PIN = 27;

// 📊 Параметры анализа музыки
const int FREQ_BANDS = 3;               // Низкие, средние, высокие частоты
const int HISTORY_SIZE = 20;            // Размер истории для анализа
const int BEAT_THRESHOLD = 150;         // Порог обнаружения ритма

// 📈 Структура для анализа частот
struct FrequencyAnalysis {
  int lowFreq;      // Низкие частоты (бас)
  int midFreq;      // Средние частоты (вокал)
  int highFreq;     // Высокие частоты (тарелки)
  int total;        // Общая энергия
  bool beatDetected; // Обнаружен ритм
};

// 🎨 Режимы светомузыки
enum LightMusicMode {
  MODE_SPECTRUM,    // Спектральный анализ
  MODE_BEAT,        // Реакция на ритм
  MODE_ENERGY,      // По общей энергии
  MODE_DISCO        // Дискотечный режим
};

LightMusicMode currentMode = MODE_SPECTRUM;

void musicAnalyzerLoop() {
  // 🎤 Анализируем звук
  FrequencyAnalysis analysis = analyzeFrequencies();
  
  // 🎵 Обновляем светомузыку
  updateLightMusic(analysis);
  
  // 📊 Выводим анализ
  printMusicAnalysis(analysis);
}

// 📊 Функция анализа частот (упрощенная)
FrequencyAnalysis analyzeFrequencies() {
  FrequencyAnalysis result = {0, 0, 0, 0, false};
  
  // 📈 Собираем данные за короткий период
  int samples[50];
  for (int i = 0; i < 50; i++) {
    samples[i] = analogRead(SOUND_ANALOG_PIN);
    delayMicroseconds(500);  // 1kHz sampling
  }
  
  // 🔍 Простой анализ энергии в разных диапазонах
  // (в реальности нужна FFT для точного частотного анализа)
  
  int totalEnergy = 0;
  int highEnergyCount = 0;
  
  for (int i = 1; i < 49; i++) {
    int energy = abs(samples[i] - samples[i-1]);
    totalEnergy += energy;
    
    // 🎵 Высокие частоты = резкие изменения
    if (energy > 50) highEnergyCount++;
  }
  
  result.total = totalEnergy;
  result.lowFreq = totalEnergy * 0.6;    // Примерное распределение
  result.midFreq = totalEnergy * 0.3;
  result.highFreq = highEnergyCount * 10;
  
  // 🥁 Обнаружение ритма (резкий скачок энергии)
  static int lastTotalEnergy = 0;
  result.beatDetected = (result.total > lastTotalEnergy + BEAT_THRESHOLD);
  lastTotalEnergy = result.total;
  
  return result;
}

// 🌈 Функция управления светомузыкой
void updateLightMusic(FrequencyAnalysis analysis) {
  switch (currentMode) {
    case MODE_SPECTRUM:
      // 🌈 Каждый цвет = своя частота
      analogWrite(RED_PIN, map(analysis.lowFreq, 0, 500, 0, 255));
      analogWrite(GREEN_PIN, map(analysis.midFreq, 0, 300, 0, 255));
      analogWrite(BLUE_PIN, map(analysis.highFreq, 0, 200, 0, 255));
      break;
      
    case MODE_BEAT:
      // 🥁 Вспышка на каждый ритм
      if (analysis.beatDetected) {
        // Белая вспышка
        analogWrite(RED_PIN, 255);
        analogWrite(GREEN_PIN, 255);
        analogWrite(BLUE_PIN, 255);
        delay(50);
      }
      // Затухание
      fadeToBlack(0.9);
      break;
      
    case MODE_ENERGY:
      // ⚡ Яркость по общей энергии
      int brightness = map(analysis.total, 0, 1000, 0, 255);
      // Циклические цвета
      setHSV((millis() / 50) % 360, 255, brightness);
      break;
      
    case MODE_DISCO:
      // 🕺 Случайные цвета на ритм
      if (analysis.beatDetected) {
        int r = random(256);
        int g = random(256);
        int b = random(256);
        analogWrite(RED_PIN, r);
        analogWrite(GREEN_PIN, g);
        analogWrite(BLUE_PIN, b);
      }
      break;
  }
}

// 🌈 Функция установки цвета по HSV
void setHSV(int hue, int saturation, int value) {
  // Упрощенное преобразование HSV в RGB
  int r, g, b;
  
  int sector = hue / 60;
  int remainder = hue % 60;
  
  int p = (value * (255 - saturation)) / 255;
  int q = (value * (255 - (saturation * remainder) / 60)) / 255;
  int t = (value * (255 - (saturation * (60 - remainder)) / 60)) / 255;
  
  switch (sector) {
    case 0: r = value; g = t; b = p; break;
    case 1: r = q; g = value; b = p; break;
    case 2: r = p; g = value; b = t; break;
    case 3: r = p; g = q; b = value; break;
    case 4: r = t; g = p; b = value; break;
    default: r = value; g = p; b = q; break;
  }
  
  analogWrite(RED_PIN, r);
  analogWrite(GREEN_PIN, g);
  analogWrite(BLUE_PIN, b);
}

// 🌑 Функция затухания к черному
void fadeToBlack(float factor) {
  static int lastR = 0, lastG = 0, lastB = 0;
  
  lastR *= factor;
  lastG *= factor;
  lastB *= factor;
  
  analogWrite(RED_PIN, lastR);
  analogWrite(GREEN_PIN, lastG);
  analogWrite(BLUE_PIN, lastB);
}

// 📊 СИСТЕМА МОНИТОРИНГА ШУМА

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>

// 🌐 Настройки сервера
const char* soundDataURL = "http://192.168.1.100/api/sound-data";

// 📊 Структура данных о шуме
struct NoiseData {
  String deviceName;
  String location;
  int averageLevel;      // Средний уровень за период
  int peakLevel;         // Пиковый уровень
  int noiseEvents;       // Количество превышений порога
  float noisePercentage; // Процент времени с шумом
  bool speechDetected;   // Обнаружена речь
  int clapCommands;      // Количество команд хлопками
};

NoiseData currentData;

// 📤 Функция отправки данных о шуме
void sendNoiseDataToServer() {
  if (WiFi.status() != WL_CONNECTED) return;
  
  // 📋 Формируем JSON с данными о шуме
  String jsonData = createNoiseJSON();
  
  HTTPClient http;
  http.begin(soundDataURL);
  http.addHeader("Content-Type", "application/json");
  
  int responseCode = http.POST(jsonData);
  
  if (responseCode == 200) {
    Serial.println("📤 Данные о шуме отправлены на сервер");
  } else {
    Serial.printf("❌ Ошибка отправки шума: %d\n", responseCode);
  }
  
  http.end();
}

// 📋 Создание JSON с данными о шуме
String createNoiseJSON() {
  StaticJsonDocument<512> doc;
  
  doc["device"] = "ESP32_5А_SoundSensor_" + String(ESP.getChipId());
  doc["student"] = "Команда_1"; // Заменить на реальное имя
  doc["sensor_type"] = "sound";
  doc["location"] = "Кабинет информатики";
  doc["average_level"] = currentData.averageLevel;
  doc["peak_level"] = currentData.peakLevel;
  doc["noise_events"] = currentData.noiseEvents;
  doc["noise_percentage"] = currentData.noisePercentage;
  doc["speech_detected"] = currentData.speechDetected;
  doc["clap_commands"] = currentData.clapCommands;
  doc["timestamp"] = millis();
  
  String jsonString;
  serializeJson(doc, jsonString);
  return jsonString;
}

// 📊 Сбор статистики шума
void collectNoiseStatistics(int soundLevel) {
  static unsigned long periodStart = millis();
  static int measurementCount = 0;
  static long levelSum = 0;
  static int noisyMeasurements = 0;
  
  measurementCount++;
  levelSum += soundLevel;
  
  // 📈 Обновляем пиковый уровень
  if (soundLevel > currentData.peakLevel) {
    currentData.peakLevel = soundLevel;
  }
  
  // 🔊 Подсчитываем шумные измерения
  if (soundLevel > NOISE_THRESHOLD) {
    noisyMeasurements++;
    currentData.noiseEvents++;
  }
  
  // 📊 Каждые 30 секунд обновляем статистику
  if (millis() - periodStart >= 30000) {
    currentData.averageLevel = levelSum / measurementCount;
    currentData.noisePercentage = (float)noisyMeasurements / measurementCount * 100;
    
    // 📤 Отправляем данные каждые 5 минут
    static int periodCount = 0;
    periodCount++;
    if (periodCount >= 10) {  // 10 периодов по 30 сек = 5 минут
      sendNoiseDataToServer();
      
      // 🔄 Сбрасываем долгосрочную статистику
      currentData.peakLevel = 0;
      currentData.noiseEvents = 0;
      currentData.clapCommands = 0;
      periodCount = 0;
    }
    
    // 🔄 Сбрасываем текущий период
    measurementCount = 0;
    levelSum = 0;
    noisyMeasurements = 0;
    periodStart = millis();
  }
}