Управление Arduino из Windows Forms приложения C#. Программирование Arduino и отправка команд, датчики

// Отправка строки с добавлением символа новой строки
serialPort.WriteLine("COMMAND");
 
// Отправка строки без символа новой строки
serialPort.Write("COMMAND");
 
// Отправка массива байтов
byte[] data = { 0x01, 0x02, 0x03 };
serialPort.Write(data, 0, data.Length);

public void SendCommand(string command)
{
    if (!serialPort.IsOpen)
        throw new InvalidOperationException("Port is not open");
        
    // Добавляем символ новой строки, если его нет
    if (!command.EndsWith("\n"))
        command += "\n";
        
    serialPort.Write(command);
}

public bool TrySendCommand(string command, out string errorMessage)
{
    errorMessage = null;
    
    try
    {
        // Попытка переоткрыть порт, если он закрыт
        if (!serialPort.IsOpen)
        {
            try
            {
                serialPort.Open();
                // Даем Arduino время на сброс
                Thread.Sleep(1500);
            }
            catch (Exception ex)
            {
                errorMessage = $"Не удалось открыть порт: {ex.Message}";
                return false;
            }
        }
        
        // Установка таймаута для операции записи
        serialPort.WriteTimeout = 1000;
        
        // Отправка команды
        if (!command.EndsWith("\n"))
            command += "\n";
            
        serialPort.Write(command);
        return true;
    }
    catch (TimeoutException)
    {
        errorMessage = "Превышено время ожидания при отправке команды";
        return false;
    }
    catch (InvalidOperationException ex)
    {
        errorMessage = $"Недопустимая операция: {ex.Message}";
        return false;
    }
    catch (Exception ex)
    {
        errorMessage = $"Ошибка при отправке команды: {ex.Message}";
        
        // Если порт в непригодном состоянии, закрываем его
        try
        {
            if (serialPort.IsOpen)
                serialPort.Close();
        }
        catch { /* Игнорируем ошибки закрытия */ }
        
        return false;
    }
}

public string SendCommandAndWaitForResponse(string command, int timeoutMs = 2000)
{
    try
    {
        // Очищаем буфер перед отправкой
        serialPort.DiscardInBuffer();
        
        // Отправляем команду
        if (!command.EndsWith("\n"))
            command += "\n";
            
        serialPort.Write(command);
        
        // Устанавливаем таймаут для чтения
        serialPort.ReadTimeout = timeoutMs;
        
        // Читаем ответ
        return serialPort.ReadLine();
    }
    catch (TimeoutException)
    {
        return "ERROR:TIMEOUT";
    }
    catch (Exception ex)
    {
        return $"ERROR:{ex.Message}";
    }
}

public async Task<string> SendCommandAndWaitForResponseAsync(string command, int timeoutMs = 2000)
{
    TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();
    
    // Обработчик события получения данных
    SerialDataReceivedEventHandler handler = null;
    handler = (s, e) =>
    {
        try
        {
            string response = serialPort.ReadLine();
            // Отписываемся от события
            serialPort.DataReceived -= handler;
            // Устанавливаем результат
            tcs.TrySetResult(response);
        }
        catch (Exception ex)
        {
            // В случае ошибки также отписываемся и устанавливаем исключение
            serialPort.DataReceived -= handler;
            tcs.TrySetException(ex);
        }
    };
    
    try
    {
        // Очищаем буфер
        serialPort.DiscardInBuffer();
        
        // Подписываемся на событие
        serialPort.DataReceived += handler;
        
        // Отправляем команду
        if (!command.EndsWith("\n"))
            command += "\n";
            
        serialPort.Write(command);
        
        // Создаем задачу с таймаутом
        Task<string> resultTask = tcs.Task;
        Task timeoutTask = Task.Delay(timeoutMs);
        
        // Ожидаем либо результат, либо таймаут
        Task completedTask = await Task.WhenAny(resultTask, timeoutTask);
        
        if (completedTask == timeoutTask)
        {
            // Таймаут - отписываемся от события
            serialPort.DataReceived -= handler;
            return "ERROR:TIMEOUT";
        }
        
        // Получен результат
        return await resultTask;
    }
    catch (Exception ex)
    {
        // Обеспечиваем отписку от события в случае ошибки
        serialPort.DataReceived -= handler;
        return $"ERROR:{ex.Message}";
    }
}

public class CommandQueue
{
    // Очередь команд с их приоритетами
    private SortedList<int, Queue<CommandItem>> _priorityQueues = new SortedList<int, Queue<CommandItem>>();
    
    // Блокировка для потокобезопасного доступа
    private object _lock = new object();
    
    // Класс, представляющий команду
    public class CommandItem
    {
        public string Command { get; }
        public TaskCompletionSource<string> ResponseTask { get; }
        
        public CommandItem(string command, TaskCompletionSource<string> responseTask)
        {
            Command = command;
            ResponseTask = responseTask;
        }
    }
    
    // Добавление команды в очередь
    public Task<string> EnqueueCommand(string command, int priority = 0)
    {
        var tcs = new TaskCompletionSource<string>();
        
        lock (_lock)
        {
            // Создаем очередь для приоритета, если её еще нет
            if (!_priorityQueues.ContainsKey(priority))
                _priorityQueues[priority] = new Queue<CommandItem>();
                
            // Добавляем команду в соответствующую очередь
            _priorityQueues[priority].Enqueue(new CommandItem(command, tcs));
        }
        
        // Возвращаем задачу, которая будет завершена, когда придет ответ
        return tcs.Task;
    }
    
    // Получение следующей команды из очереди
    public bool TryDequeueCommand(out CommandItem command)
    {
        lock (_lock)
        {
            command = null;
            
            // Перебираем очереди по приоритетам (от высокого к низкому)
            foreach (var queue in _priorityQueues.Values.Reverse())
            {
                if (queue.Count > 0)
                {
                    command = queue.Dequeue();
                    return true;
                }
            }
            
            return false;
        }
    }
}

public class ArduinoCommunicator : IDisposable
{
    private SerialPort _serialPort;
    private CommandQueue _commandQueue = new CommandQueue();
    private bool _isProcessingQueue = false;
    private object _processingLock = new object();
    
    // Конструктор и методы инициализации порта опущены для краткости
    
    // Метод для отправки команды через очередь
    public Task<string> SendCommandAsync(string command, int priority = 0)
    {
        var resultTask = _commandQueue.EnqueueCommand(command, priority);
        
        // Запускаем обработку очереди, если она еще не запущена
        StartQueueProcessing();
        
        return resultTask;
    }
    
    private void StartQueueProcessing()
    {
        lock (_processingLock)
        {
            if (_isProcessingQueue)
                return;
                
            _isProcessingQueue = true;
            
            // Запускаем обработку в отдельном потоке
            Task.Run(() => ProcessCommandQueue());
        }
    }
    
    private async Task ProcessCommandQueue()
    {
        try
        {
            while (true)
            {
                // Получаем следующую команду из очереди
                if (!_commandQueue.TryDequeueCommand(out var commandItem))
                {
                    // Очередь пуста - завершаем обработку
                    lock (_processingLock)
                    {
                        _isProcessingQueue = false;
                    }
                    break;
                }
                
                try
                {
                    // Отправляем команду и ждем ответа
                    string response = await SendCommandAndWaitForResponseAsync(commandItem.Command);
                    
                    // Устанавливаем результат
                    commandItem.ResponseTask.TrySetResult(response);
                }
                catch (Exception ex)
                {
                    // В случае ошибки устанавливаем исключение
                    commandItem.ResponseTask.TrySetException(ex);
                }
            }
        }
        catch (Exception)
        {
            // Обработка общих ошибок
            lock (_processingLock)
            {
                _isProcessingQueue = false;
            }
        }
    }
    
    // Реализация отправки команды и ожидания ответа
    private async Task<string> SendCommandAndWaitForResponseAsync(string command)
    {
        // Реализация аналогична показанной выше
    }
    
    public void Dispose()
    {
        if (_serialPort != null)
        {
            if (_serialPort.IsOpen)
                _serialPort.Close();
                
            _serialPort.Dispose();
            _serialPort = null;
        }
    }
}

// Базовый интерфейс команды
public interface IArduinoCommand
{
    Task<string> ExecuteAsync(IArduinoController controller);
    string GetCommandString();
    int Priority { get; }
}
 
// Базовая реализация команды
public abstract class ArduinoCommandBase : IArduinoCommand
{
    public virtual int Priority => 0; // Обычный приоритет по умолчанию
    
    public abstract string GetCommandString();
    
    public async Task<string> ExecuteAsync(IArduinoController controller)
    {
        return await controller.SendCommandAsync(GetCommandString(), Priority);
    }
}
 
// Пример конкретной команды - установка состояния светодиода
public class SetLedCommand : ArduinoCommandBase
{
    private readonly int _pin;
    private readonly bool _state;
    
    public SetLedCommand(int pin, bool state)
    {
        _pin = pin;
        _state = state;
    }
    
    public override string GetCommandString()
    {
        return $"LED:{_pin},{(_state ? "1" : "0")};";
    }
}
 
// Команда экстренной остановки с высоким приоритетом
public class EmergencyStopCommand : ArduinoCommandBase
{
    public override int Priority => 10; // Высокий приоритет
    
    public override string GetCommandString()
    {
        return "STOP;";
    }
}

private async void buttonStop_Click(object sender, EventArgs e)
{
    try
    {
        IArduinoCommand command = new EmergencyStopCommand();
        string response = await command.ExecuteAsync(_arduinoController);
        LogResponse(response);
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Ошибка при отправке команды: {ex.Message}");
    }
}

public class CommandExecutionLogger
{
    private readonly string _logPath;
    
    public CommandExecutionLogger(string logPath)
    {
        _logPath = logPath;
        Directory.CreateDirectory(Path.GetDirectoryName(logPath));
    }
    
    public void LogCommand(IArduinoCommand command, string response, bool success)
    {
        try
        {
            string logEntry = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} | " +
                            $"Command: {command.GetCommandString()} | " +
                            $"Response: {response} | " +
                            $"Success: {success}";
            
            File.AppendAllText(_logPath, logEntry + Environment.NewLine);
        }
        catch
        {
            // Логирование не должно прерывать основной процесс
        }
    }
}

public class ArduinoController : IArduinoController
{
    private readonly CommandExecutionLogger _logger;
    
    public ArduinoController()
    {
        _logger = new CommandExecutionLogger("arduino_commands.log");
    }
    
    public async Task<string> ExecuteCommandAsync(IArduinoCommand command)
    {
        string response = string.Empty;
        bool success = false;
        
        try
        {
            response = await command.ExecuteAsync(this);
            success = !response.StartsWith("ERROR:");
        }
        catch (Exception ex)
        {
            response = $"ERROR:{ex.Message}";
        }
        finally
        {
            _logger.LogCommand(command, response, success);
        }
        
        return response;
    }
}

public async Task<string> SendCommandWithCancellationAsync(
    IArduinoCommand command, 
    CancellationToken cancellationToken)
{
    // Регистрируем задачу в очереди
    var resultTask = _commandQueue.EnqueueCommand(command.GetCommandString(), command.Priority);
    
    // Запускаем обработку очереди
    StartQueueProcessing();
    
    // Ожидаем завершения или отмены
    await Task.WhenAny(resultTask, Task.Delay(-1, cancellationToken));
    
    if (cancellationToken.IsCancellationRequested)
    {
        // Можно добавить логику для уведомления Arduino об отмене операции
        return "CANCELLED";
    }
    
    return await resultTask;
}

private CancellationTokenSource _cts;
 
private async void buttonStartOperation_Click(object sender, EventArgs e)
{
    _cts = new CancellationTokenSource();
    buttonCancel.Enabled = true;
    
    try
    {
        var command = new StartOperationCommand();
        string result = await _arduinoController.SendCommandWithCancellationAsync(
            command, _cts.Token);
        
        if (result == "CANCELLED")
            LogMessage("Операция отменена пользователем");
        else
            LogMessage($"Результат: {result}");
    }
    catch (Exception ex)
    {
        LogMessage($"Ошибка: {ex.Message}");
    }
    finally
    {
        buttonCancel.Enabled = false;
    }
}
 
private void buttonCancel_Click(object sender, EventArgs e)
{
    _cts?.Cancel();
}

public class TemperatureSensor
{
  private float _lastValue;
  private DateTime _lastReadTime;
  private List<SensorReading> _readings = new List<SensorReading>();
  
  public float CurrentValue => _lastValue;
  public DateTime LastReadTime => _lastReadTime;
  public IReadOnlyList<SensorReading> Readings => _readings;
  
  // Структура для хранения показания с временной меткой
  public struct SensorReading
  {
      public DateTime Timestamp { get; }
      public float Value { get; }
      
      public SensorReading(DateTime timestamp, float value)
      {
          Timestamp = timestamp;
          Value = value;
      }
  }
  
  // Метод для обработки данных от Arduino
  public bool TryProcessData(string data)
  {
      // Проверяем, что данные предназначены для этого датчика
      if (!data.StartsWith("TEMP:"))
          return false;
          
      // Извлекаем значение
      string valueString = data.Substring(5).TrimEnd(';');
      
      if (!float.TryParse(valueString, out float value))
          return false;
          
      // Обновляем текущее значение и время считывания
      _lastValue = value;
      _lastReadTime = DateTime.Now;
      
      // Добавляем в историю
      _readings.Add(new SensorReading(_lastReadTime, value));
      
      // Ограничиваем размер истории
      if (_readings.Count > 1000)
          _readings.RemoveAt(0);
          
      return true;
  }
}

public class SensorManager
{
  private Dictionary<string, ISensor> _sensors = new Dictionary<string, ISensor>();
  
  public void RegisterSensor(string id, ISensor sensor)
  {
      _sensors[id] = sensor;
  }
  
  public void ProcessData(string data)
  {
      foreach (var sensor in _sensors.Values)
      {
          if (sensor.TryProcessData(data))
              break; // Данные обработаны
      }
  }
  
  public T GetSensor<T>(string id) where T : ISensor
  {
      if (_sensors.TryGetValue(id, out ISensor sensor) && sensor is T typedSensor)
          return typedSensor;
          
      return default;
  }
}

private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
  try
  {
      string data = _serialPort.ReadLine().Trim();
      
      // Обрабатываем данные в менеджере датчиков
      this.Invoke((MethodInvoker)delegate {
          _sensorManager.ProcessData(data);
          UpdateSensorDisplay();
      });
  }
  catch (Exception ex)
  {
      Debug.WriteLine($"Error reading data: {ex.Message}");
  }
}

private void InitializeTemperatureChart()
{
  // Настройка серии данных
  chartTemperature.Series.Clear();
  var series = new Series("Temperature");
  series.ChartType = SeriesChartType.Line;
  series.XValueType = ChartValueType.DateTime;
  chartTemperature.Series.Add(series);
  
  // Настройка осей
  chartTemperature.ChartAreas[0].AxisX.LabelStyle.Format = "HH:mm:ss";
  chartTemperature.ChartAreas[0].AxisX.Title = "Время";
  chartTemperature.ChartAreas[0].AxisY.Title = "Температура (°C)";
  
  // Начальные границы
  chartTemperature.ChartAreas[0].AxisY.Minimum = 0;
  chartTemperature.ChartAreas[0].AxisY.Maximum = 50;
  
  // Авто-масштабирование по оси X
  chartTemperature.ChartAreas[0].AxisX.ScrollBar.Enabled = true;
  chartTemperature.ChartAreas[0].CursorX.AutoScroll = true;
}
 
private void UpdateTemperatureChart()
{
  var tempSensor = _sensorManager.GetSensor<TemperatureSensor>("temp1");
  if (tempSensor == null)
      return;
      
  var series = chartTemperature.Series[0];
  series.Points.Clear();
  
  foreach (var reading in tempSensor.Readings)
  {
      series.Points.AddXY(reading.Timestamp, reading.Value);
  }
  
  // Обновляем границы по Y, если нужно
  double min = tempSensor.Readings.Count > 0 ? 
               tempSensor.Readings.Min(r => r.Value) : 0;
  double max = tempSensor.Readings.Count > 0 ? 
               tempSensor.Readings.Max(r => r.Value) : 50;
  
  // Добавляем небольшой запас к границам
  chartTemperature.ChartAreas[0].AxisY.Minimum = Math.Max(0, min - 5);
  chartTemperature.ChartAreas[0].AxisY.Maximum = max + 5;
  
  // Фокусируемся на последних данных
  if (series.Points.Count > 0)
  {
      chartTemperature.ChartAreas[0].AxisX.ScaleView.Zoom(
          DateTime.Now.AddMinutes(-5), DateTime.Now);
  }
}

public class CalibratableSensor : ISensor
{
  private float _offset = 0.0f;  // Сдвиг (аддитивная составляющая)
  private float _scale = 1.0f;   // Масштаб (мультипликативная составляющая)
  
  public float Offset
  {
      get => _offset;
      set => _offset = value;
  }
  
  public float Scale
  {
      get => _scale;
      set => _scale = value != 0 ? value : 1.0f;  // Предотвращаем деление на 0
  }
  
  // Применяем калибровку к сырому значению
  protected float ApplyCalibration(float rawValue)
  {
      return rawValue * _scale + _offset;
  }
  
  // Сохранение калибровочных коэффициентов
  public void SaveCalibration(string sensorId)
  {
      Properties.Settings.Default[$"{sensorId}_Offset"] = _offset;
      Properties.Settings.Default[$"{sensorId}_Scale"] = _scale;
      Properties.Settings.Default.Save();
  }
  
  // Загрузка калибровочных коэффициентов
  public void LoadCalibration(string sensorId)
  {
      if (Properties.Settings.Default[$"{sensorId}_Offset"] != null)
          _offset = (float)Properties.Settings.Default[$"{sensorId}_Offset"];
          
      if (Properties.Settings.Default[$"{sensorId}_Scale"] != null)
          _scale = (float)Properties.Settings.Default[$"{sensorId}_Scale"];
  }
}

private void buttonCalibrate_Click(object sender, EventArgs e)
{
  var sensor = _sensorManager.GetSensor<TemperatureSensor>("temp1");
  if (sensor == null)
      return;
      
  using (var calibrationForm = new CalibrationForm(sensor))
  {
      if (calibrationForm.ShowDialog() == DialogResult.OK)
      {
          // Калибровка применена в форме
          UpdateSensorDisplay();
      }
  }
}

public class MovingAverageFilter
{
  private Queue<float> _values = new Queue<float>();
  private int _windowSize;
  private float _sum = 0;
  
  public MovingAverageFilter(int windowSize = 10)
  {
      _windowSize = windowSize > 0 ? windowSize : 1;
  }
  
  public float ProcessValue(float newValue)
  {
      // Добавляем новое значение
      _values.Enqueue(newValue);
      _sum += newValue;
      
      // Удаляем старое значение, если превышен размер окна
      if (_values.Count > _windowSize)
      {
          float oldValue = _values.Dequeue();
          _sum -= oldValue;
      }
      
      // Возвращаем среднее
      return _sum / _values.Count;
  }
}

public class KalmanFilter
{
  private float _estimate;   // Текущая оценка
  private float _errorEst;   // Ошибка оценки
  private float _errorMeas;  // Ошибка измерения
  private float _q;          // Шум процесса
  
  public KalmanFilter(float initialValue = 0, float initialErrorEstimate = 1,
                    float measurementError = 1, float processNoise = 0.01f)
  {
      _estimate = initialValue;
      _errorEst = initialErrorEstimate;
      _errorMeas = measurementError;
      _q = processNoise;
  }
  
  public float ProcessValue(float measurement)
  {
      // Предсказание
      float errorPred = _errorEst + _q;
      
      // Обновление
      float gain = errorPred / (errorPred + _errorMeas);
      _estimate += gain * (measurement - _estimate);
      _errorEst = (1 - gain) * errorPred;
      
      return _estimate;
  }
}

// Преобразование аналогового значения в расстояние для Sharp GP2Y0A21YK
private float ConvertToDistance(int adcValue)
{
  // Предотвращение деления на 0
  if (adcValue <= 0)
      return 500; // Максимальное значение в мм
      
  // Эмпирическая формула преобразования
  return 27.86f * (float)Math.Pow(adcValue, -1.15f) * 100;
}

public abstract class SensorBase : ISensor
{
    protected string _id;
    protected string _name;
    protected string _units;
    protected float _warningThresholdLow;
    protected float _warningThresholdHigh;
    protected bool _isWarningActive;
    
    // Обработчик события предупреждений
    public event EventHandler<SensorWarningEventArgs> WarningTriggered;
    
    public string Id => _id;
    public string Name => _name;
    public string Units => _units;
    
    public abstract float CurrentValue { get; }
    
    public bool IsWarningActive => _isWarningActive;
    
    // Метод проверки предупреждений
    protected void CheckWarningThresholds(float value)
    {
        bool wasWarningActive = _isWarningActive;
        _isWarningActive = value < _warningThresholdLow || value > _warningThresholdHigh;
        
        // Если состояние изменилось, генерируем событие
        if (_isWarningActive != wasWarningActive)
        {
            OnWarningTriggered(new SensorWarningEventArgs(
                _id, _name, value, _isWarningActive, 
                value < _warningThresholdLow ? SensorWarningType.Low : SensorWarningType.High));
        }
    }
    
    protected virtual void OnWarningTriggered(SensorWarningEventArgs e)
    {
        WarningTriggered?.Invoke(this, e);
    }
    
    public abstract bool TryProcessData(string data);
}

public class DataLogger
{
    private string _filePath;
    private SensorManager _sensorManager;
    private Timer _loggingTimer;
    private bool _isHeaderWritten = false;
    
    public DataLogger(string filePath, SensorManager sensorManager, int loggingIntervalMs = 5000)
    {
        _filePath = filePath;
        _sensorManager = sensorManager;
        
        _loggingTimer = new Timer(loggingIntervalMs);
        _loggingTimer.Elapsed += LoggingTimer_Elapsed;
    }
    
    public void Start()
    {
        _loggingTimer.Start();
    }
    
    public void Stop()
    {
        _loggingTimer.Stop();
    }
    
    private void LoggingTimer_Elapsed(object sender, ElapsedEventArgs e)
    {
        try
        {
            WriteDataToFile();
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Error writing to log file: {ex.Message}");
        }
    }
    
    private void WriteDataToFile()
    {
        // Получаем данные со всех датчиков
        var sensors = _sensorManager.GetAllSensors();
        
        // Если это первая запись, добавляем заголовок
        if (!_isHeaderWritten || !File.Exists(_filePath))
        {
            string header = "Timestamp," + string.Join(",", sensors.Select(s => $"{s.Name} ({s.Units})"));
            File.WriteAllText(_filePath, header + Environment.NewLine);
            _isHeaderWritten = true;
        }
        
        // Формируем строку с данными
        string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        string dataLine = timestamp + "," + string.Join(",", sensors.Select(s => s.CurrentValue.ToString("F2")));
        
        // Добавляем в файл
        File.AppendAllText(_filePath, dataLine + Environment.NewLine);
    }
}

public enum SensorWarningType
{
    Low,
    High,
    RateOfChange,
    Disconnected
}
 
public class SensorWarningEventArgs : EventArgs
{
    public string SensorId { get; }
    public string SensorName { get; }
    public float Value { get; }
    public bool IsActive { get; }
    public SensorWarningType WarningType { get; }
    
    public SensorWarningEventArgs(string id, string name, float value, 
                                bool isActive, SensorWarningType type)
    {
        SensorId = id;
        SensorName = name;
        Value = value;
        IsActive = isActive;
        WarningType = type;
    }
}

private void InitializeWarningSystem()
{
    foreach (var sensor in _sensorManager.GetAllSensors())
    {
        sensor.WarningTriggered += Sensor_WarningTriggered;
    }
}
 
private void Sensor_WarningTriggered(object sender, SensorWarningEventArgs e)
{
    // Выводим сообщение пользователю
    string message = $"Предупреждение: {e.SensorName} - ";
    
    switch (e.WarningType)
    {
        case SensorWarningType.Low:
            message += $"значение слишком низкое ({e.Value})";
            break;
        case SensorWarningType.High:
            message += $"значение слишком высокое ({e.Value})";
            break;
        case SensorWarningType.RateOfChange:
            message += $"слишком быстрое изменение";
            break;
        case SensorWarningType.Disconnected:
            message += "потеряна связь с датчиком";
            break;
    }
    
    // Обновляем UI в соответствии с состоянием предупреждения
    if (e.IsActive)
    {
        logTextBox.AppendText($"[ПРЕДУПРЕЖДЕНИЕ] {message}{Environment.NewLine}");
        // Находим индикатор датчика и меняем его цвет на красный
        UpdateSensorIndicator(e.SensorId, Color.Red);
        
        // Воспроизводим звуковое оповещение
        SystemSounds.Exclamation.Play();
    }
    else
    {
        logTextBox.AppendText($"[ИНФО] Предупреждение для {e.SensorName} снято{Environment.NewLine}");
        // Возвращаем обычный цвет индикатора
        UpdateSensorIndicator(e.SensorId, Color.Green);
    }
}

public class HeatIndexSensor : SensorBase
{
    private TemperatureSensor _temperatureSensor;
    private HumiditySensor _humiditySensor;
    private float _lastCalculatedValue;
    
    public HeatIndexSensor(string id, TemperatureSensor tempSensor, HumiditySensor humSensor)
    {
        _id = id;
        _name = "Тепловой индекс";
        _units = "°C";
        _temperatureSensor = tempSensor;
        _humiditySensor = humSensor;
        
        // Устанавливаем пороговые значения
        _warningThresholdLow = 0;
        _warningThresholdHigh = 40; // Опасно высокий тепловой индекс
        
        // Рассчитываем начальное значение
        UpdateValue();
    }
    
    public override float CurrentValue => _lastCalculatedValue;
    
    public void UpdateValue()
    {
        float t = _temperatureSensor.CurrentValue;
        float h = _humiditySensor.CurrentValue;
        
        // Формула для расчета теплового индекса
        _lastCalculatedValue = CalculateHeatIndex(t, h);
        
        // Проверяем, не превышены ли пороговые значения
        CheckWarningThresholds(_lastCalculatedValue);
    }
    
    // Не требуется обработка данных напрямую, так как этот датчик виртуальный
    public override bool TryProcessData(string data)
    {
        return false;
    }
    
    private float CalculateHeatIndex(float temperature, float humidity)
    {
        // Упрощенная формула расчета теплового индекса
        if (temperature < 27)
            return temperature; // При низкой температуре индекс равен температуре
            
        // Коэффициенты формулы
        float c1 = -8.784695f;
        float c2 = 1.61139411f;
        float c3 = 2.338549f;
        float c4 = -0.14611605f;
        float c5 = -0.01230809f;
        float c6 = -0.01642482f;
        float c7 = 0.00221173f;
        float c8 = 0.00072546f;
        float c9 = -0.00000358f;
        
        return c1 + c2 * temperature + c3 * humidity +
               c4 * temperature * humidity + c5 * temperature * temperature +
               c6 * humidity * humidity + c7 * temperature * temperature * humidity +
               c8 * temperature * humidity * humidity +
               c9 * temperature * temperature * humidity * humidity;
    }
}