Управление Arduino на C# через последовательный порт

using System.IO.Ports;
 
SerialPort serialPort = new SerialPort();
serialPort.PortName = "COM3";
serialPort.BaudRate = 9600;
serialPort.Parity = Parity.None;
serialPort.DataBits = 8;
serialPort.StopBits = StopBits.One;
serialPort.Handshake = Handshake.None;

private string buffer = string.Empty;
 
private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
    buffer += serialPort.ReadExisting();
    
    while (buffer.Contains("\n"))
    {
        int index = buffer.IndexOf("\n");
        string message = buffer.Substring(0, index).Trim();
        buffer = buffer.Remove(0, index + 1);
        
        ProcessMessage(message);
    }
}

// HID требует специальных библиотек для чтения raw input
protected override void WndProc(ref Message m)
{
    if (m.Msg == WM_INPUT)
    {
        // Обработка сырых данных от HID устройства
        ProcessRawInput(m.LParam);
    }
    base.WndProc(ref m);
}

// Подключение по TCP требует создания сокетов
TcpClient client = new TcpClient();
client.Connect("192.168.1.100", 8080);
NetworkStream stream = client.GetStream();

serialPort.BaudRate = 115200; // Современный стандарт для большинства задач
serialPort.DataBits = 8;      // Количество бит данных в каждом байте
serialPort.Parity = Parity.None;     // Без проверки четности
serialPort.StopBits = StopBits.One;  // Один стоп-бит
serialPort.Handshake = Handshake.None; // Без аппаратного управления потоком

// Расширенная конфигурация для критически важных систем
serialPort.ReadTimeout = 1000;  // Таймаут чтения в миллисекундах
serialPort.WriteTimeout = 1000; // Таймаут записи
serialPort.ReceivedBytesThreshold = 1; // Минимум байтов для срабатывания события
 
// Размеры внутренних буферов
serialPort.ReadBufferSize = 4096;
serialPort.WriteBufferSize = 2048;

// Проверка доступности порта перед подключением
private bool IsPortAvailable(string portName)
{
    try
    {
        using (var port = new SerialPort(portName))
        {
            port.Open();
            return true;
        }
    }
    catch (UnauthorizedAccessException)
    {
        return false; // Порт занят другим приложением
    }
    catch (ArgumentException)
    {
        return false; // Порт не существует
    }
    catch (IOException)
    {
        return false; // Аппаратная проблема
    }
}

private string FindArduinoPort()
{
    using (var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PnPEntity WHERE Caption LIKE '%(COM%'"))
    {
        foreach (ManagementObject obj in searcher.Get())
        {
            string caption = obj["Caption"]?.ToString();
            if (caption != null && caption.Contains("Arduino"))
            {
                var match = Regex.Match(caption, @"COM(\d+)");
                if (match.Success)
                {
                    return "COM" + match.Groups[1].Value;
                }
            }
        }
    }
    return null;
}

// Минимизация буферизации для снижения задержек
serialPort.WriteTimeout = 500;
serialPort.ReadTimeout = 500;
 
// Принудительная отправка данных
serialPort.Write(command);
serialPort.BaseStream.Flush();

// Отключение энергосбережения для COM-порта
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool SetCommTimeouts(IntPtr hFile, ref COMMTIMEOUTS lpCommTimeouts);
 
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool SetCommMask(IntPtr hFile, uint dwEvtMask);

Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;

private SerialPort InitializeSerialPort()
{
    // Получаем список доступных портов
    string[] availablePorts = SerialPort.GetPortNames();
    
    if (availablePorts.Length == 0)
    {
        throw new InvalidOperationException("No COM ports available");
    }
    
    // Попытка найти Arduino автоматически
    string arduinoPort = DetectArduinoPort();
    if (string.IsNullOrEmpty(arduinoPort))
    {
        // Используем первый доступный порт как fallback
        arduinoPort = availablePorts[0];
    }
    
    SerialPort port = new SerialPort(arduinoPort);
    return ConfigureSerialPort(port);
}

private SerialPort ConfigureSerialPort(SerialPort port)
{
    port.BaudRate = 115200;
    port.DataBits = 8;
    port.Parity = Parity.None;
    port.StopBits = StopBits.One;
    port.Handshake = Handshake.None;
    
    // Критические параметры для стабильности
    port.ReadTimeout = 2000;
    port.WriteTimeout = 2000;
    port.ReceivedBytesThreshold = 1;
    
    // Оптимизация буферов
    port.ReadBufferSize = 8192;
    port.WriteBufferSize = 4096;
    
    return port;
}

private bool TryOpenPort(SerialPort port, int maxRetries = 3)
{
    for (int attempt = 0; attempt < maxRetries; attempt++)
    {
        try
        {
            port.Open();
            
            // Проверяем, действительно ли порт открылся
            if (port.IsOpen)
            {
                // Отправляем тестовый пакет
                SendHandshakeRequest(port);
                return true;
            }
        }
        catch (UnauthorizedAccessException)
        {
            // Порт занят - пытаемся найти альтернативу
            Thread.Sleep(1000);
            continue;
        }
        catch (ArgumentException ex)
        {
            // Порт не существует или неверные параметры
            throw new InvalidOperationException($"Invalid port configuration: {ex.Message}");
        }
        catch (IOException ex)
        {
            // Аппаратная проблема
            if (attempt == maxRetries - 1)
            {
                throw new InvalidOperationException($"Hardware error: {ex.Message}");
            }
            Thread.Sleep(2000);
        }
    }
    
    return false;
}

private void SetupEventHandlers(SerialPort port)
{
    port.DataReceived += OnDataReceived;
    port.ErrorReceived += OnErrorReceived;
    port.PinChanged += OnPinChanged;
    
    // Обработка неожиданного закрытия порта
    AppDomain.CurrentDomain.ProcessExit += (sender, e) => {
        if (port.IsOpen)
        {
            port.Close();
        }
    };
}

private bool SendHandshakeRequest(SerialPort port)
{
    const int handshakeTimeout = 5000; // 5 секунд на ответ
    DateTime startTime = DateTime.Now;
    
    port.WriteLine("PING");
    
    while ((DateTime.Now - startTime).TotalMilliseconds < handshakeTimeout)
    {
        if (port.BytesToRead > 0)
        {
            string response = port.ReadLine().Trim();
            if (response == "PONG" || response == "ARDUINO_READY")
            {
                return true;
            }
        }
        Thread.Sleep(100);
    }
    
    return false;
}

public class ArduinoConnection : IDisposable
{
    private SerialPort _serialPort;
    private bool _disposed = false;
    
    public bool Initialize(string portName = null)
    {
        try
        {
            _serialPort = InitializeSerialPort();
            SetupEventHandlers(_serialPort);
            return TryOpenPort(_serialPort);
        }
        catch (Exception ex)
        {
            // Логирование ошибки
            Console.WriteLine($"Failed to initialize Arduino connection: {ex.Message}");
            return false;
        }
    }
    
    public void Dispose()
    {
        if (!_disposed)
        {
            _serialPort?.Close();
            _serialPort?.Dispose();
            _disposed = true;
        }
    }
}

private StringBuilder _dataBuffer = new StringBuilder();
private readonly object _bufferLock = new object();
 
private void OnDataReceived(object sender, SerialDataReceivedEventArgs e)
{
    try
    {
        SerialPort port = (SerialPort)sender;
        
        // Проверяем, есть ли данные для чтения
        if (port.BytesToRead == 0) return;
        
        string newData = port.ReadExisting();
        
        lock (_bufferLock)
        {
            _dataBuffer.Append(newData);
            
            // Обрабатываем все полные сообщения
            ProcessCompleteMessages();
        }
    }
    catch (InvalidOperationException ex)
    {
        // Порт был закрыт во время чтения
        HandlePortDisconnection(ex);
    }
    catch (TimeoutException ex)
    {
        // Превышен таймаут чтения
        HandleReadTimeout(ex);
    }
}

private void ProcessCompleteMessages()
{
    string buffer = _dataBuffer.ToString();
    string[] lines = buffer.Split('\n');
    
    // Последняя строка может быть неполной
    for (int i = 0; i < lines.Length - 1; i++)
    {
        string message = lines[i].Trim();
        if (!string.IsNullOrEmpty(message))
        {
            // Передаем обработку в основной поток UI
            InvokeMessageHandler(message);
        }
    }
    
    // Сохраняем неполную строку в буфере
    _dataBuffer.Clear();
    if (lines.Length > 0 && !buffer.EndsWith("\n"))
    {
        _dataBuffer.Append(lines[lines.Length - 1]);
    }
}

private void InvokeMessageHandler(string message)
{
    // Проверяем, нужно ли переключение контекста
    if (this.InvokeRequired)
    {
        this.BeginInvoke(new Action<string>(ProcessArduinoMessage), message);
    }
    else
    {
        ProcessArduinoMessage(message);
    }
}
 
private void ProcessArduinoMessage(string message)
{
    // Этот метод уже выполняется в UI-потоке
    if (message.StartsWith("SENSOR:"))
    {
        int value = int.Parse(message.Substring(7));
        sensorValueLabel.Text = value.ToString();
        
        // Можем безопасно обновлять график или другие элементы
        UpdateSensorChart(value);
    }
    else if (message.StartsWith("ERROR:"))
    {
        MessageBox.Show($"Arduino error: {message.Substring(6)}");
    }
}

private void OnErrorReceived(object sender, SerialErrorReceivedEventArgs e)
{
    string errorDescription = GetErrorDescription(e.EventType);
    
    // Логируем ошибку с временной меткой
    LogError($"Serial error at {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}: {errorDescription}");
    
    switch (e.EventType)
    {
        case SerialError.Frame:
            // Ошибка кадрирования - возможно неверная скорость передачи
            HandleFrameError();
            break;
            
        case SerialError.Overrun:
            // Переполнение буфера - данные поступают быстрее обработки
            HandleBufferOverrun();
            break;
            
        case SerialError.RXOver:
            // Переполнение приемного буфера
            HandleReceiveOverflow();
            break;
            
        case SerialError.RXParity:
            // Ошибка четности
            HandleParityError();
            break;
    }
}
 
private string GetErrorDescription(SerialError errorType)
{
    return errorType switch
    {
        SerialError.Frame => "Frame error - possible baud rate mismatch",
        SerialError.Overrun => "Character buffer overrun",
        SerialError.RXOver => "Input buffer overflow", 
        SerialError.RXParity => "Parity error",
        SerialError.TXFull => "Output buffer full",
        _ => $"Unknown error: {errorType}"
    };
}

private void HandleBufferOverrun()
{
    // Увеличиваем размер буфера приема
    if (_serialPort.ReadBufferSize < 16384)
    {
        _serialPort.ReadBufferSize *= 2;
        LogInfo($"Increased read buffer size to {_serialPort.ReadBufferSize}");
    }
    
    // Очищаем буферы для восстановления синхронизации
    _serialPort.DiscardInBuffer();
    _serialPort.DiscardOutBuffer();
}
 
private void HandleFrameError()
{
    // Ошибки кадрирования часто указывают на проблемы с baud rate
    _frameErrorCount++;
    
    if (_frameErrorCount > 5)
    {
        // Слишком много ошибок - пытаемся снизить скорость
        if (_serialPort.BaudRate > 9600)
        {
            int newBaudRate = _serialPort.BaudRate / 2;
            LogWarning($"Reducing baud rate from {_serialPort.BaudRate} to {newBaudRate}");
            
            ReconfigureConnection(newBaudRate);
        }
        
        _frameErrorCount = 0;
    }
}

private void ProcessArduinoMessage(string message)
{
    var stopwatch = Stopwatch.StartNew();
    
    try
    {
        // Основная логика обработки сообщения
        HandleMessageByType(message);
    }
    finally
    {
        stopwatch.Stop();
        
        // Предупреждаем о медленной обработке
        if (stopwatch.ElapsedMilliseconds > 50)
        {
            LogWarning($"Slow message processing: {stopwatch.ElapsedMilliseconds}ms for message '{message}'");
        }
    }
}

public string SendCommandSync(string command, int timeoutMs = 2000)
{
    if (!_serialPort.IsOpen)
        throw new InvalidOperationException("Serial port is not open");
    
    // Очищаем входной буфер перед отправкой команды
    _serialPort.DiscardInBuffer();
    
    _serialPort.WriteLine(command);
    
    DateTime startTime = DateTime.Now;
    StringBuilder response = new StringBuilder();
    
    while ((DateTime.Now - startTime).TotalMilliseconds < timeoutMs)
    {
        if (_serialPort.BytesToRead > 0)
        {
            char receivedChar = (char)_serialPort.ReadChar();
            response.Append(receivedChar);
            
            // Проверяем окончание сообщения
            if (receivedChar == '\n')
            {
                return response.ToString().Trim();
            }
        }
        Thread.Sleep(10);
    }
    
    throw new TimeoutException($"No response received for command: {command}");
}

private readonly Dictionary<int, TaskCompletionSource<string>> _pendingCommands = new();
private int _commandIdCounter = 0;
 
public async Task<string> SendCommandAsync(string command)
{
    int commandId = Interlocked.Increment(ref _commandIdCounter);
    var tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
    
    _pendingCommands[commandId] = tcs;
    
    // Отправляем команду с ID
    string commandWithId = $"{commandId}:{command}";
    _serialPort.WriteLine(commandWithId);
    
    // Устанавливаем таймаут
    var timeoutTask = Task.Delay(5000);
    var completedTask = await Task.WhenAny(tcs.Task, timeoutTask);
    
    _pendingCommands.TryRemove(commandId, out _);
    
    if (completedTask == timeoutTask)
    {
        throw new TimeoutException($"Command {command} timed out");
    }
    
    return await tcs.Task;
}

public async Task<List<string>> SendCommandBatchAsync(IEnumerable<string> commands)
{
    var commandArray = commands.ToArray();
    var batchId = Guid.NewGuid().ToString("N")[..8];
    
    var batch = new {
        batchId = batchId,
        commands = commandArray.Select((cmd, index) => new { id = index, command = cmd })
    };
    
    string jsonBatch = JsonConvert.SerializeObject(batch);
    return await SendCommandAsync($"BATCH:{jsonBatch}");
}

public event EventHandler<SensorDataEventArgs> SensorDataReceived;
public event EventHandler<StatusChangeEventArgs> StatusChanged;
 
private void ProcessStreamData(string message)
{
    if (message.StartsWith("SENSOR:"))
    {
        var sensorData = ParseSensorData(message);
        SensorDataReceived?.Invoke(this, new SensorDataEventArgs(sensorData));
    }
    else if (message.StartsWith("STATUS:"))
    {
        var statusData = ParseStatusChange(message);
        StatusChanged?.Invoke(this, new StatusChangeEventArgs(statusData));
    }
}

public async Task<string> SendCommandWithRetry(string command, int maxRetries = 3)
{
    for (int attempt = 0; attempt < maxRetries; attempt++)
    {
        try
        {
            return await SendCommandAsync(command);
        }
        catch (TimeoutException) when (attempt < maxRetries - 1)
        {
            await Task.Delay(1000 * (attempt + 1)); // Экспоненциальная задержка
            continue;
        }
    }
    
    throw new CommunicationException($"Failed to execute command '{command}' after {maxRetries} attempts");
}

private readonly ConcurrentQueue<string> _commandQueue = new();
private volatile bool _isConnected = true;
 
public void EnqueueCommand(string command)
{
    if (_isConnected)
    {
        _serialPort.WriteLine(command);
    }
    else
    {
        _commandQueue.Enqueue(command);
    }
}
 
private void OnConnectionRestored()
{
    _isConnected = true;
    
    // Отправляем накопленные команды
    while (_commandQueue.TryDequeue(out string command))
    {
        _serialPort.WriteLine(command);
        Thread.Sleep(50); // Предотвращаем перегрузку Arduino
    }
}

public class LedController
{
    private SerialPort _serialPort;
    private readonly Dictionary<int, bool> _ledStates = new();
    
    public async Task<bool> SetLedState(int pin, bool isOn)
    {
        string command = $"LED:{pin}:{(isOn ? "ON" : "OFF")}";
        
        try
        {
            string response = await SendCommandAsync(command);
            if (response == "LED_OK")
            {
                _ledStates[pin] = isOn;
                return true;
            }
        }
        catch (TimeoutException)
        {
            // Повторяем команду при таймауте
            return await RetryLedCommand(pin, isOn);
        }
        
        return false;
    }
    
    public async Task SetRgbColor(int redPin, int greenPin, int bluePin, Color color)
    {
        string command = $"RGB:{redPin},{greenPin},{bluePin}:{color.R},{color.G},{color.B}";
        await SendCommandAsync(command);
    }
}

public class SensorReader
{
    private readonly MovingAverageFilter _temperatureFilter = new(10);
    private readonly MovingAverageFilter _lightFilter = new(5);
    
    public event EventHandler<SensorDataEventArgs> SensorDataChanged;
    
    private void ProcessSensorData(string data)
    {
        if (data.StartsWith("TEMP:"))
        {
            float rawValue = float.Parse(data.Substring(5));
            float filteredValue = _temperatureFilter.AddSample(rawValue);
            
            // Преобразуем АЦП в температуру для LM35
            float temperature = (filteredValue * 5.0f / 1024.0f) * 100.0f;
            
            SensorDataChanged?.Invoke(this, new SensorDataEventArgs
            {
                SensorType = "Temperature",
                Value = temperature,
                Unit = "°C",
                Timestamp = DateTime.Now
            });
        }
        else if (data.StartsWith("LIGHT:"))
        {
            float rawValue = float.Parse(data.Substring(6));
            float filteredValue = _lightFilter.AddSample(rawValue);
            
            // Фотодатчик: инвертируем значения (больше света = меньше сопротивление)
            float lightLevel = (1024 - filteredValue) / 1024.0f * 100.0f;
            
            SensorDataChanged?.Invoke(this, new SensorDataEventArgs
            {
                SensorType = "Light",
                Value = lightLevel,
                Unit = "%",
                Timestamp = DateTime.Now
            });
        }
    }
}
 
public class MovingAverageFilter
{
    private readonly float[] _samples;
    private int _index = 0;
    private bool _bufferFull = false;
    
    public MovingAverageFilter(int sampleCount)
    {
        _samples = new float[sampleCount];
    }
    
    public float AddSample(float newSample)
    {
        _samples[_index] = newSample;
        _index = (_index + 1) % _samples.Length;
        
        if (_index == 0) _bufferFull = true;
        
        return CalculateAverage();
    }
    
    private float CalculateAverage()
    {
        int count = _bufferFull ? _samples.Length : _index;
        if (count == 0) return 0;
        
        float sum = 0;
        for (int i = 0; i < count; i++)
        {
            sum += _samples[i];
        }
        
        return sum / count;
    }
}

public async Task<bool> CalibrateSensor(string sensorType, float referenceValue)
{
    // Получаем текущее показание датчика
    string response = await SendCommandAsync($"READ:{sensorType}");
    float currentValue = float.Parse(response);
    
    // Вычисляем калибровочный коэффициент
    float calibrationFactor = referenceValue / currentValue;
    
    // Отправляем коэффициент на Arduino
    await SendCommandAsync($"CALIBRATE:{sensorType}:{calibrationFactor}");
    
    return true;
}

public class AsyncArduinoReader
{
    private readonly SerialPort _serialPort;
    private readonly Channel<string> _messageChannel;
    private CancellationTokenSource _cancellationTokenSource;
    
    public AsyncArduinoReader(SerialPort serialPort)
    {
        _serialPort = serialPort;
        var options = new BoundedChannelOptions(1000)
        {
            FullMode = BoundedChannelFullMode.Wait,
            SingleReader = true,
            SingleWriter = false
        };
        _messageChannel = Channel.CreateBounded<string>(options);
    }
    
    public async Task StartAsync(CancellationToken cancellationToken = default)
    {
        _cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        
        _serialPort.DataReceived += OnDataReceived;
        
        // Запускаем фоновую обработку сообщений
        _ = Task.Run(ProcessMessagesAsync, _cancellationTokenSource.Token);
    }
    
    private void OnDataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        try
        {
            string data = _serialPort.ReadExisting();
            string[] lines = data.Split('\n', StringSplitOptions.RemoveEmptyEntries);
            
            foreach (string line in lines)
            {
                // Неблокирующая отправка в канал
                _messageChannel.Writer.TryWrite(line.Trim());
            }
        }
        catch (InvalidOperationException)
        {
            // Порт закрыт - игнорируем
        }
    }
}

private async Task ProcessMessagesAsync()
{
    await foreach (string message in _messageChannel.Reader.ReadAllAsync(_cancellationTokenSource.Token))
    {
        try
        {
            var parsedMessage = ParseArduinoMessage(message);
            if (parsedMessage != null)
            {
                await ProcessParsedMessage(parsedMessage);
            }
        }
        catch (FormatException ex)
        {
            // Логируем ошибки парсинга без прерывания обработки
            Debug.WriteLine($"Message parsing error: {ex.Message}, Raw: {message}");
        }
        catch (OperationCanceledException)
        {
            break;
        }
    }
}
 
private ArduinoMessage ParseArduinoMessage(string rawMessage)
{
    if (string.IsNullOrWhiteSpace(rawMessage))
        return null;
        
    var parts = rawMessage.Split(':', 3);
    if (parts.Length < 2)
        return null;
    
    return new ArduinoMessage
    {
        Type = parts[0],
        Payload = parts.Length > 2 ? parts[2] : parts[1],
        Timestamp = DateTime.Now,
        RawData = rawMessage
    };
}

public class RobustMessageParser
{
    private readonly StringBuilder _buffer = new StringBuilder();
    private readonly Regex _messagePattern = new Regex(@"^\{.*\}$|^[A-Z_]+:[^:]*$");
    
    public IEnumerable<ArduinoMessage> ParseIncomingData(string newData)
    {
        _buffer.Append(newData);
        var messages = new List<ArduinoMessage>();
        
        string bufferContent = _buffer.ToString();
        string[] potentialMessages = bufferContent.Split('\n');
        
        // Обрабатываем все полные строки кроме последней
        for (int i = 0; i < potentialMessages.Length - 1; i++)
        {
            string candidate = potentialMessages[i].Trim();
            
            if (TryParseMessage(candidate, out ArduinoMessage message))
            {
                messages.Add(message);
            }
        }
        
        // Сохраняем неполную последнюю строку
        _buffer.Clear();
        if (potentialMessages.Length > 0 && !bufferContent.EndsWith('\n'))
        {
            _buffer.Append(potentialMessages[^1]);
        }
        
        return messages;
    }
    
    private bool TryParseMessage(string candidate, out ArduinoMessage message)
    {
        message = null;
        
        if (!_messagePattern.IsMatch(candidate))
            return false;
            
        try
        {
            if (candidate.StartsWith('{') && candidate.EndsWith('}'))
            {
                // JSON сообщение
                var jsonData = JsonConvert.DeserializeObject<dynamic>(candidate);
                message = new ArduinoMessage
                {
                    Type = jsonData.type ?? "JSON",
                    Payload = candidate,
                    JsonData = jsonData,
                    Timestamp = DateTime.Now
                };
            }
            else
            {
                // Простое текстовое сообщение
                var colonIndex = candidate.IndexOf(':');
                message = new ArduinoMessage
                {
                    Type = candidate.Substring(0, colonIndex),
                    Payload = candidate.Substring(colonIndex + 1),
                    Timestamp = DateTime.Now
                };
            }
            
            return true;
        }
        catch (JsonException)
        {
            return false;
        }
    }
}

public interface IMessageProcessor
{
    Task<bool> CanProcess(ArduinoMessage message);
    Task ProcessAsync(ArduinoMessage message);
}
 
public class SensorDataProcessor : IMessageProcessor
{
    public Task<bool> CanProcess(ArduinoMessage message)
    {
        return Task.FromResult(message.Type.StartsWith("SENSOR"));
    }
    
    public async Task ProcessAsync(ArduinoMessage message)
    {
        var sensorData = ParseSensorData(message.Payload);
        
        // Асинхронное сохранение в базу данных
        await SaveSensorDataAsync(sensorData);
        
        // Уведомление подписчиков
        SensorDataReceived?.Invoke(sensorData);
    }
    
    public event Action<SensorData> SensorDataReceived;
}
 
public class MessageDispatcher
{
    private readonly List<IMessageProcessor> _processors = new();
    
    public void RegisterProcessor(IMessageProcessor processor)
    {
        _processors.Add(processor);
    }
    
    public async Task DispatchAsync(ArduinoMessage message)
    {
        var tasks = _processors
            .Where(p => p.CanProcess(message).Result)
            .Select(p => p.ProcessAsync(message));
            
        await Task.WhenAll(tasks);
    }
}

private async Task ProcessParsedMessage(ArduinoMessage message)
{
    try
    {
        await _messageDispatcher.DispatchAsync(message);
    }
    catch (Exception ex) when (!(ex is OperationCanceledException))
    {
        // Логируем исключение и продолжаем работу
        _logger.LogError(ex, $"Error processing message type {message.Type}");
        
        // Можем отправить уведомление о проблеме
        await NotifyErrorAsync(message, ex);
    }
}
 
private async Task NotifyErrorAsync(ArduinoMessage message, Exception ex)
{
    try
    {
        // Отправляем клиентам информацию об ошибке обработки
        await _hubContext.Clients.All.SendAsync("ProcessingError", new 
        {
            MessageType = message.Type,
            Error = ex.Message,
            Timestamp = DateTime.Now
        });
    }
    catch
    {
        // Даже уведомление об ошибке не должно прерывать основной поток
    }
}

public class ProcessingMetrics
{
    private long _processedMessages;
    private long _errorCount;
    private readonly ConcurrentQueue<TimeSpan> _processingTimes = new();
    
    public void RecordProcessingTime(TimeSpan duration)
    {
        Interlocked.Increment(ref _processedMessages);
        _processingTimes.Enqueue(duration);
        
        // Ограничиваем размер очереди
        while (_processingTimes.Count > 1000)
        {
            _processingTimes.TryDequeue(out _);
        }
    }
    
    public void RecordError()
    {
        Interlocked.Increment(ref _errorCount);
    }
    
    public ProcessingStats GetStats()
    {
        var times = _processingTimes.ToArray();
        
        return new ProcessingStats
        {
            TotalProcessed = _processedMessages,
            ErrorCount = _errorCount,
            AverageProcessingTime = times.Length > 0 ? 
                TimeSpan.FromTicks((long)times.Average(t => t.Ticks)) : TimeSpan.Zero,
            MaxProcessingTime = times.Length > 0 ? times.Max() : TimeSpan.Zero
        };
    }
}

public interface IArduinoObserver
{
  Task OnSensorDataChanged(SensorData data);
  Task OnStatusChanged(DeviceStatus status);
  Task OnErrorOccurred(DeviceError error);
  
  // Метаданные для фильтрации
  string[] InterestedSensorTypes { get; }
  bool AcceptsHighFrequencyUpdates { get; }
}
 
public class ArduinoDataSubject
{
  private readonly ConcurrentDictionary<Guid, IArduinoObserver> _observers = new();
  private readonly SemaphoreSlim _notificationSemaphore = new(10); // Ограничение параллельных уведомлений
  
  public Guid Subscribe(IArduinoObserver observer)
  {
      var id = Guid.NewGuid();
      _observers.TryAdd(id, observer);
      return id;
  }
  
  public void Unsubscribe(Guid observerId)
  {
      _observers.TryRemove(observerId, out _);
  }
  
  public async Task NotifySensorDataAsync(SensorData data)
  {
      await _notificationSemaphore.WaitAsync();
      
      try
      {
          var relevantObservers = _observers.Values
              .Where(o => o.InterestedSensorTypes.Contains(data.SensorType) || 
                         o.InterestedSensorTypes.Contains("*"));
          
          var notificationTasks = relevantObservers
              .Select(async observer =>
              {
                  try
                  {
                      await observer.OnSensorDataChanged(data);
                  }
                  catch (Exception ex)
                  {
                      // Ошибка одного observer'а не должна влиять на остальных
                      LogObserverError(observer, ex);
                  }
              });
          
          await Task.WhenAll(notificationTasks);
      }
      finally
      {
          _notificationSemaphore.Release();
      }
  }
}

public class ConditionalObserver : IArduinoObserver
{
  private readonly Func<SensorData, bool> _condition;
  private readonly Action<SensorData> _action;
  
  public ConditionalObserver(Func<SensorData, bool> condition, Action<SensorData> action, params string[] sensorTypes)
  {
      _condition = condition;
      _action = action;
      InterestedSensorTypes = sensorTypes;
  }
  
  public Task OnSensorDataChanged(SensorData data)
  {
      if (_condition(data))
      {
          _action(data);
      }
      
      return Task.CompletedTask;
  }
  
  public string[] InterestedSensorTypes { get; }
  public bool AcceptsHighFrequencyUpdates => false;
}
 
// Использование
var coolingObserver = new ConditionalObserver(
  data => data.Value > 25.0f,
  data => StartCoolingSystem(),
  "TEMPERATURE"
);

public class ArduinoProtocol
{
  private const byte START_MARKER = 0x02;
  private const byte END_MARKER = 0x03;
  private const byte ESCAPE_CHAR = 0x1B;
  
  public byte[] EncodeMessage(string messageType, object payload)
  {
      var message = new ProtocolMessage
      {
          Type = messageType,
          Payload = JsonConvert.SerializeObject(payload),
          Timestamp = DateTime.UtcNow.Ticks,
          Checksum = 0
      };
      
      string json = JsonConvert.SerializeObject(message);
      byte[] jsonBytes = Encoding.UTF8.GetBytes(json);
      
      // Вычисляем CRC16 для контроля целостности
      message.Checksum = CalculateCrc16(jsonBytes);
      json = JsonConvert.SerializeObject(message);
      jsonBytes = Encoding.UTF8.GetBytes(json);
      
      return EncodeWithEscaping(jsonBytes);
  }
  
  private byte[] EncodeWithEscaping(byte[] data)
  {
      var encoded = new List<byte> { START_MARKER };
      
      foreach (byte b in data)
      {
          if (b == START_MARKER || b == END_MARKER || b == ESCAPE_CHAR)
          {
              encoded.Add(ESCAPE_CHAR);
              encoded.Add((byte)(b ^ 0x20)); // XOR с маской
          }
          else
          {
              encoded.Add(b);
          }
      }
      
      encoded.Add(END_MARKER);
      return encoded.ToArray();
  }
  
  public IEnumerable<ProtocolMessage> DecodeMessages(byte[] buffer)
  {
      var messages = new List<ProtocolMessage>();
      int startIndex = 0;
      
      while (startIndex < buffer.Length)
      {
          int messageStart = Array.IndexOf(buffer, START_MARKER, startIndex);
          if (messageStart == -1) break;
          
          int messageEnd = Array.IndexOf(buffer, END_MARKER, messageStart + 1);
          if (messageEnd == -1) break;
          
          try
          {
              byte[] messageBytes = DecodeWithUnescaping(buffer, messageStart + 1, messageEnd - messageStart - 1);
              string json = Encoding.UTF8.GetString(messageBytes);
              
              var message = JsonConvert.DeserializeObject<ProtocolMessage>(json);
              if (VerifyChecksum(message, messageBytes))
              {
                  messages.Add(message);
              }
          }
          catch (JsonException)
          {
              // Поврежденное сообщение - пропускаем
          }
          
          startIndex = messageEnd + 1;
      }
      
      return messages;
  }
  
  private ushort CalculateCrc16(byte[] data)
  {
      ushort crc = 0xFFFF;
      
      foreach (byte b in data)
      {
          crc ^= b;
          for (int i = 0; i < 8; i++)
          {
              if ((crc & 1) != 0)
                  crc = (ushort)((crc >> 1) ^ 0xA001);
              else
                  crc >>= 1;
          }
      }
      
      return crc;
  }
}
 
public class ProtocolMessage
{
  public string Type { get; set; }
  public string Payload { get; set; }
  public long Timestamp { get; set; }
  public ushort Checksum { get; set; }
}

public class ReliableArduinoCommunication
{
  private readonly ConcurrentDictionary<int, TaskCompletionSource<bool>> _pendingAcks = new();
  private int _messageIdCounter = 0;
  
  public async Task<bool> SendReliableCommand(string command, object payload, int timeoutMs = 5000)
  {
      int messageId = Interlocked.Increment(ref _messageIdCounter);
      var tcs = new TaskCompletionSource<bool>();
      
      _pendingAcks[messageId] = tcs;
      
      var message = new 
      {
          id = messageId,
          type = command,
          payload = payload,
          requiresAck = true
      };
      
      byte[] encodedMessage = _protocol.EncodeMessage("COMMAND", message);
      await _serialPort.WriteAsync(encodedMessage, 0, encodedMessage.Length);
      
      using var timeoutCts = new CancellationTokenSource(timeoutMs);
      timeoutCts.Token.Register(() => tcs.TrySetResult(false));
      
      try
      {
          return await tcs.Task;
      }
      finally
      {
          _pendingAcks.TryRemove(messageId, out _);
      }
  }
  
  public void ProcessAcknowledgment(int messageId)
  {
      if (_pendingAcks.TryGetValue(messageId, out var tcs))
      {
          tcs.TrySetResult(true);
      }
  }
}

public enum NotificationPriority
{
    Low = 0,
    Normal = 1,
    High = 2,
    Critical = 3
}
 
public class PriorityArduinoSubject
{
    private readonly PriorityQueue<NotificationTask, NotificationPriority> _notificationQueue = new();
    private readonly SemaphoreSlim _processingLock = new(1);
    private readonly CancellationTokenSource _cancellationTokenSource = new();
    
    public void Subscribe(IArduinoObserver observer, NotificationPriority priority = NotificationPriority.Normal)
    {
        var subscription = new ObserverSubscription(observer, priority);
        _observers.Add(subscription);
        
        // Запускаем обработку очереди если еще не запущена
        _ = ProcessNotificationQueue();
    }
    
    public async Task NotifyAsync<T>(T data, NotificationPriority priority = NotificationPriority.Normal) where T : IArduinoData
    {
        var notification = new NotificationTask(data, GetRelevantObservers<T>(), priority);
        
        lock (_notificationQueue)
        {
            _notificationQueue.Enqueue(notification, priority);
        }
        
        _processingLock.Release(); // Сигнал о новом элементе
    }
    
    private async Task ProcessNotificationQueue()
    {
        while (!_cancellationTokenSource.Token.IsCancellationRequested)
        {
            await _processingLock.WaitAsync(_cancellationTokenSource.Token);
            
            NotificationTask task = null;
            lock (_notificationQueue)
            {
                if (_notificationQueue.Count > 0)
                {
                    task = _notificationQueue.Dequeue();
                }
            }
            
            if (task != null)
            {
                await ExecuteNotificationTask(task);
            }
        }
    }
}

public class MessageBatcher
{
    private readonly List<object> _batchBuffer = new();
    private readonly Timer _flushTimer;
    private readonly object _bufferLock = new object();
    private const int MAX_BATCH_SIZE = 20;
    private const int FLUSH_INTERVAL_MS = 100;
    
    public MessageBatcher()
    {
        _flushTimer = new Timer(FlushBatch, null, FLUSH_INTERVAL_MS, FLUSH_INTERVAL_MS);
    }
    
    public void AddMessage(object message)
    {
        lock (_bufferLock)
        {
            _batchBuffer.Add(message);
            
            if (_batchBuffer.Count >= MAX_BATCH_SIZE)
            {
                FlushBatch(null);
            }
        }
    }
    
    private void FlushBatch(object state)
    {
        List<object> messagesToSend;
        
        lock (_bufferLock)
        {
            if (_batchBuffer.Count == 0) return;
            
            messagesToSend = new List<object>(_batchBuffer);
            _batchBuffer.Clear();
        }
        
        var batchMessage = new
        {
            type = "BATCH",
            count = messagesToSend.Count,
            messages = messagesToSend,
            batchId = Guid.NewGuid().ToString("N")[..8]
        };
        
        byte[] encoded = _protocol.EncodeMessage("BATCH", batchMessage);
        _serialPort.Write(encoded, 0, encoded.Length);
    }
}

public class ConnectionRecoveryManager
{
    private DateTime _lastSuccessfulCommunication = DateTime.Now;
    private readonly TimeSpan _connectionTimeout = TimeSpan.FromSeconds(30);
    
    public async Task<bool> PerformRecoveryHandshake()
    {
        // Запрашиваем текущее состояние Arduino
        var request = new { type = "STATE_SYNC", requestId = Guid.NewGuid() };
        await SendReliableCommand("SYNC", request);
        
        // Ждем ответа с полным состоянием
        var response = await WaitForStateSync(TimeSpan.FromSeconds(10));
        if (response == null) return false;
        
        // Синхронизируем локальное состояние
        await ReconcileStates(response);
        
        _lastSuccessfulCommunication = DateTime.Now;
        return true;
    }
    
    private async Task ReconcileStates(StateSync arduinoState)
    {
        // Сравниваем временные метки последних событий
        if (arduinoState.LastEventTimestamp > _localLastEventTimestamp)
        {
            // Arduino имеет более свежие данные - запрашиваем пропущенные события
            await RequestMissedEvents(_localLastEventTimestamp, arduinoState.LastEventTimestamp);
        }
        else if (_localLastEventTimestamp > arduinoState.LastEventTimestamp)
        {
            // Локальное состояние новее - отправляем обновления на Arduino
            await SendStateDelta(arduinoState.LastEventTimestamp);
        }
        
        // Обновляем кэшированное состояние
        _deviceStates.Merge(arduinoState.DeviceStates);
    }
}

public class CommunicationQualityMonitor
{
    private int _successfulTransmissions;
    private int _totalTransmissions;
    private readonly Queue<bool> _recentResults = new();
    
    public void RecordTransmissionResult(bool success)
    {
        _totalTransmissions++;
        if (success) _successfulTransmissions++;
        
        _recentResults.Enqueue(success);
        if (_recentResults.Count > 100)
        {
            _recentResults.Dequeue();
        }
        
        // Автоматическая адаптация параметров
        if (GetRecentSuccessRate() < 0.95)
        {
            AdaptCommunicationParameters();
        }
    }
    
    private double GetRecentSuccessRate()
    {
        return _recentResults.Count > 0 ? 
            _recentResults.Count(x => x) / (double)_recentResults.Count : 1.0;
    }
    
    private void AdaptCommunicationParameters()
    {
        // Уменьшаем размер пакетов и увеличиваем таймауты
        _protocol.MaxPacketSize = Math.Max(32, _protocol.MaxPacketSize / 2);
        _protocol.AckTimeout = TimeSpan.FromMilliseconds(_protocol.AckTimeout.TotalMilliseconds * 1.5);
    }
}

public class SensorDataRepository
{
  private readonly string _connectionString;
  private readonly SemaphoreSlim _connectionSemaphore = new(10);
  
  public async Task<bool> SaveSensorDataBatchAsync(IEnumerable<SensorReading> readings)
  {
      await _connectionSemaphore.WaitAsync();
      
      try
      {
          using var connection = new SqlConnection(_connectionString);
          await connection.OpenAsync();
          
          using var transaction = await connection.BeginTransactionAsync();
          
          const string sql = @"
              INSERT INTO SensorReadings (DeviceId, SensorType, Value, Unit, Quality, Timestamp, JsonData)
              VALUES (@DeviceId, @SensorType, @Value, @Unit, @Quality, @Timestamp, @JsonData)";
          
          foreach (var reading in readings)
          {
              var parameters = new
              {
                  DeviceId = reading.DeviceId,
                  SensorType = reading.SensorType,
                  Value = reading.Value,
                  Unit = reading.Unit,
                  Quality = reading.Quality,
                  Timestamp = reading.Timestamp,
                  JsonData = JsonConvert.SerializeObject(reading.Metadata)
              };
              
              await connection.ExecuteAsync(sql, parameters, transaction);
          }
          
          await transaction.CommitAsync();
          return true;
      }
      catch (SqlException ex)
      {
          // Логируем ошибку базы данных
          LogDatabaseError(ex, readings.Count());
          return false;
      }
      finally
      {
          _connectionSemaphore.Release();
      }
  }
}

public class ArduinoJsonProcessor
{
  private readonly JsonSerializerSettings _jsonSettings = new JsonSerializerSettings
  {
      DateFormatHandling = DateFormatHandling.UnixTimeStamp,
      NullValueHandling = NullValueHandling.Ignore,
      Error = HandleJsonError
  };
  
  public async Task ProcessJsonMessage(string jsonString)
  {
      try
      {
          var message = JsonConvert.DeserializeObject<ArduinoMessage>(jsonString, _jsonSettings);
          
          switch (message.Type?.ToUpperInvariant())
          {
              case "SENSOR_BATCH":
                  await ProcessSensorBatch(message.Data);
                  break;
              case "DEVICE_STATUS":
                  await ProcessDeviceStatus(message.Data);
                  break;
              case "ERROR_REPORT":
                  await ProcessErrorReport(message.Data);
                  break;
          }
      }
      catch (JsonException ex)
      {
          // Corrupted JSON - attempt partial recovery
          TryPartialJsonRecovery(jsonString, ex);
      }
  }
  
  private async Task ProcessSensorBatch(JToken data)
  {
      var readings = data.ToObject<SensorReading[]>();
      
      // Валидация данных перед сохранением
      var validReadings = readings.Where(r => IsValidSensorReading(r)).ToList();
      
      if (validReadings.Any())
      {
          await _repository.SaveSensorDataBatchAsync(validReadings);
      }
      
      // Уведомляем о количестве обработанных записей
      await SendProcessingConfirmation(readings.Length, validReadings.Count);
  }
}

public class AsyncDatabaseWriter
{
  private readonly Channel<SensorReading> _dataChannel;
  private readonly SensorDataRepository _repository;
  private readonly CancellationTokenSource _cancellationTokenSource = new();
  
  public AsyncDatabaseWriter(SensorDataRepository repository)
  {
      _repository = repository;
      
      var options = new BoundedChannelOptions(10000)
      {
          FullMode = BoundedChannelFullMode.Wait,
          SingleReader = true,
          SingleWriter = false
      };
      _dataChannel = Channel.CreateBounded<SensorReading>(options);
      
      // Запускаем фоновый writer
      _ = Task.Run(ProcessDataQueue);
  }
  
  public async Task<bool> EnqueueSensorData(SensorReading reading)
  {
      return await _dataChannel.Writer.TryWriteAsync(reading);
  }
  
  private async Task ProcessDataQueue()
  {
      var batch = new List<SensorReading>(100);
      
      await foreach (var reading in _dataChannel.Reader.ReadAllAsync(_cancellationTokenSource.Token))
      {
          batch.Add(reading);
          
          // Отправляем batch при достижении лимита или таймаута
          if (batch.Count >= 100 || ShouldFlushBatch())
          {
              await _repository.SaveSensorDataBatchAsync(batch);
              batch.Clear();
              ResetBatchTimer();
          }
      }
      
      // Сохраняем остаток при завершении
      if (batch.Count > 0)
      {
          await _repository.SaveSensorDataBatchAsync(batch);
      }
  }
}

public class CachedSensorService
{
  private readonly IMemoryCache _cache;
  private readonly SensorDataRepository _repository;
  private readonly TimeSpan _cacheExpiration = TimeSpan.FromMinutes(5);
  
  public async Task<SensorReading[]> GetLatestReadings(string deviceId, int count = 10)
  {
      string cacheKey = $"latest_readings_{deviceId}_{count}";
      
      if (_cache.TryGetValue(cacheKey, out SensorReading[] cached))
      {
          return cached;
      }
      
      var readings = await _repository.GetLatestReadingsAsync(deviceId, count);
      
      _cache.Set(cacheKey, readings, _cacheExpiration);
      return readings;
  }
  
  public void InvalidateCache(string deviceId)
  {
      var keysToRemove = _cache.GetKeys().Where(k => k.ToString().StartsWith($"latest_readings_{deviceId}"));
      
      foreach (var key in keysToRemove)
      {
          _cache.Remove(key);
      }
  }
}

public class SensorAnalyticsHub : Hub
{
  public async Task SubscribeToDevice(string deviceId)
  {
      await Groups.AddToGroupAsync(Context.ConnectionId, $"device_{deviceId}");
  }
  
  public async Task BroadcastAnalytics(string deviceId, object analytics)
  {
      await Clients.Group($"device_{deviceId}").SendAsync("AnalyticsUpdate", analytics);
  }
}
 
public class RealTimeAnalytics
{
  private readonly IHubContext<SensorAnalyticsHub> _hubContext;
  private readonly ConcurrentDictionary<string, MovingWindowAggregate> _aggregates = new();
  
  public async Task ProcessNewReading(SensorReading reading)
  {
      var deviceKey = $"{reading.DeviceId}_{reading.SensorType}";
      var aggregate = _aggregates.GetOrAdd(deviceKey, _ => new MovingWindowAggregate(TimeSpan.FromHours(1)));
      
      aggregate.AddValue(reading.Value, reading.Timestamp);
      
      var analytics = new
      {
          DeviceId = reading.DeviceId,
          SensorType = reading.SensorType,
          Current = reading.Value,
          Average = aggregate.Average,
          Min = aggregate.Minimum,
          Max = aggregate.Maximum,
          Trend = aggregate.CalculateTrend(),
          UpdateTime = DateTime.Now
      };
      
      await _hubContext.Clients.Group($"device_{reading.DeviceId}").SendAsync("AnalyticsUpdate", analytics);
  }
}