Управление Arduino из WPF приложения

SerialPort port = new SerialPort();
port.PortName = "COM3"; // Здесь может быть любой доступный порт
port.BaudRate = 9600;   // Скорость должна совпадать с Arduino
port.Open();            // Открываем соединение

foreach (string portName in SerialPort.GetPortNames())
{
    try
    {
        SerialPort testPort = new SerialPort(portName, 9600);
        testPort.Open();
        // Здесь можно отправить какую-то команду и проверить ответ
        testPort.Close();
        // Если мы дошли сюда, значит порт существует и доступен
    }
    catch
    {
        // Этот порт недоступен или занят
        continue;
    }
}

port.DataBits = 8;          // Количество бит данных
port.Parity = Parity.None;  // Проверка четности
port.StopBits = StopBits.One; // Количество стоп-битов
port.Handshake = Handshake.None; // Управление потоком
port.ReadTimeout = 500;     // Таймаут чтения
port.WriteTimeout = 500;    // Таймаут записи

port.DataReceived += Port_DataReceived;
 
private void Port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
    // Чтение данных
    string data = port.ReadLine();
    // Обработка полученных данных
    // ...
}

Dispatcher.Invoke(() => {
    statusTextBlock.Text = data;
});

var arduino = new ArduinoSession(new SerialConnection("COM3", 57600));
arduino.DigitalPinUpdated += (sender, args) => {
    Console.WriteLine($"Pin {args.Pin} changed to {args.Value}");
};
arduino.PinStateReceived += (sender, args) => {
    Console.WriteLine($"Pin {args.Pin} state: {args.Mode}");
};
 
// Включаем режим отчетов для цифровых портов
arduino.ReportDigital(0, true); // порт 0 (пины 0-7)
arduino.ReportDigital(1, true); // порт 1 (пины 8-15)
 
// Управляем пином
arduino.SetDigitalPinMode(13, PinMode.Output);
arduino.SetDigitalPin(13, true); // включаем светодиод

using System.Management;
 
public static List<string> FindArduinoComPorts()
{
    List<string> ports = new List<string>();
    
    try
    {
        ManagementScope scope = new ManagementScope("\\\\.\\root\\cimv2");
        scope.Connect();
        
        // VID и PID для Arduino UNO (могут отличаться для других моделей)
        string arduinoVid = "2341";
        string arduinoPid = "0043";
        
        ObjectQuery query = new ObjectQuery(
            "SELECT * FROM Win32_PnPEntity WHERE DeviceID LIKE '%VID_" + arduinoVid + "%' AND DeviceID LIKE '%PID_" + arduinoPid + "%'"
        );
        
        ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
        ManagementObjectCollection collection = searcher.Get();
        
        foreach (ManagementObject device in collection)
        {
            string caption = device["Caption"].ToString();
            
            // Извлекаем COM-порт из строки вида "Arduino Uno (COM3)"
            int comIndex = caption.LastIndexOf("(COM");
            if (comIndex != -1)
            {
                string comPort = caption.Substring(comIndex + 1);
                comPort = comPort.TrimEnd(')');
                ports.Add(comPort);
            }
        }
    }
    catch (ManagementException ex)
    {
        // Обработка ошибок WMI
        Console.WriteLine("An error occurred: " + ex.Message);
    }
    
    return ports;
}

using RJCP.IO.Ports;
 
SerialPortStream port = new SerialPortStream("COM3", 9600);
port.Open();
port.Write(buffer, 0, buffer.Length);
port.Flush();
int bytesRead = port.Read(readBuffer, 0, readBuffer.Length);
port.Close();

// Bluetooth модуль определяется как COM-порт
SerialPort btPort = new SerialPort("COM5", 9600);
btPort.Open();
btPort.WriteLine("COMMAND"); // отправка команды
string response = btPort.ReadLine(); // чтение ответа
btPort.Close();

using System.Net.Sockets;
 
TcpClient client = new TcpClient();
client.Connect("192.168.1.100", 80); // IP-адрес и порт Arduino с WiFi
NetworkStream stream = client.GetStream();
 
byte[] data = Encoding.ASCII.GetBytes("COMMAND");
stream.Write(data, 0, data.Length);
 
byte[] buffer = new byte[1024];
int bytesRead = stream.Read(buffer, 0, buffer.Length);
string response = Encoding.ASCII.GetString(buffer, 0, bytesRead);
 
client.Close();

CMD:MOTOR:ON\n
CMD:LED:OFF\n

private void LogData(string direction, byte[] data)
{
    string hexData = BitConverter.ToString(data);
    string asciiData = Encoding.ASCII.GetString(data);
    
    File.AppendAllText("communication.log", 
        $"{DateTime.Now} {direction}: HEX={hexData}, ASCII={asciiData}\r\n");
}
 
// Использование
byte[] sendData = Encoding.ASCII.GetBytes("COMMAND");
LogData("SEND", sendData);
port.Write(sendData, 0, sendData.Length);
 
byte[] receiveBuffer = new byte[1024];
int bytesRead = port.Read(receiveBuffer, 0, receiveBuffer.Length);
byte[] receiveData = new byte[bytesRead];
Array.Copy(receiveBuffer, receiveData, bytesRead);
LogData("RECV", receiveData);

MyArduinoApp/
├─ Models/
│  ├─ ArduinoDevice.cs       // Представление Arduino устройства
│  ├─ SensorData.cs          // Данные с датчиков
│  └─ CommandResult.cs       // Результаты выполнения команд
├─ ViewModels/
│  ├─ MainViewModel.cs       // Основная VM приложения
│  ├─ DeviceViewModel.cs     // VM для Arduino устройства
│  └─ SensorViewModel.cs     // VM для отображения данных сенсоров
├─ Views/
│  ├─ MainWindow.xaml        // Главное окно
│  └─ DeviceControl.xaml     // Пользовательский контрол
├─ Services/
│  ├─ ArduinoService.cs      // Сервис для работы с Arduino
│  ├─ SerialPortService.cs   // Обертка над SerialPort
│  └─ LoggingService.cs      // Сервис логирования
└─ Helpers/
   ├─ AsyncRelayCommand.cs   // Асинхронная реализация ICommand
   └─ Extensions.cs          // Методы-расширения

public class ArduinoService : IDisposable
{
    private SerialPort _port;
    private readonly ILoggingService _logger;
    private CancellationTokenSource _cts;
    private Task _listeningTask;
    
    public event EventHandler<SensorDataReceivedEventArgs> DataReceived;
    public event EventHandler<ConnectionStatusChangedEventArgs> ConnectionStatusChanged;
    
    public bool IsConnected => _port?.IsOpen ?? false;
    
    public ArduinoService(ILoggingService logger)
    {
        _logger = logger;
    }
    
    public async Task<bool> ConnectAsync(string portName, int baudRate)
    {
        try
        {
            _port = new SerialPort(portName, baudRate)
            {
                DataBits = 8,
                Parity = Parity.None,
                StopBits = StopBits.One,
                ReadTimeout = 500,
                WriteTimeout = 500
            };
            
            _port.Open();
            
            _cts = new CancellationTokenSource();
            _listeningTask = StartListeningAsync(_cts.Token);
            
            OnConnectionStatusChanged(true);
            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError($"Failed to connect: {ex.Message}");
            return false;
        }
    }
    
    private async Task StartListeningAsync(CancellationToken token)
    {
        await Task.Run(async () =>
        {
            byte[] buffer = new byte[4096];
            
            while (!token.IsCancellationRequested)
            {
                try
                {
                    if (_port.BytesToRead > 0)
                    {
                        int bytesRead = _port.Read(buffer, 0, buffer.Length);
                        
                        if (bytesRead > 0)
                        {
                            byte[] data = new byte[bytesRead];
                            Array.Copy(buffer, data, bytesRead);
                            
                            // Парсинг данных и вызов события
                            var parsedData = ParseData(data);
                            OnDataReceived(parsedData);
                        }
                    }
                    
                    await Task.Delay(10, token); // Небольшая пауза, чтобы не загружать процессор
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception ex)
                {
                    _logger.LogError($"Error reading data: {ex.Message}");
                    
                    // Попытка переподключения при ошибке
                    if (_port.IsOpen)
                    {
                        try { _port.Close(); } catch { }
                        OnConnectionStatusChanged(false);
                        
                        await Task.Delay(1000, token);
                        
                        try
                        {
                            _port.Open();
                            OnConnectionStatusChanged(true);
                        }
                        catch
                        {
                            // Не удалось переподключиться
                        }
                    }
                }
            }
        }, token);
    }
    
    // Другие методы...
}

public class AsyncRelayCommand : ICommand
{
    private readonly Func<Task> _execute;
    private readonly Func<bool> _canExecute;
    private bool _isExecuting;
    
    public AsyncRelayCommand(Func<Task> execute, Func<bool> canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }
    
    public event EventHandler CanExecuteChanged;
    
    public bool CanExecute(object parameter)
    {
        return !_isExecuting && (_canExecute?.Invoke() ?? true);
    }
    
    public async void Execute(object parameter)
    {
        if (!CanExecute(parameter))
            return;
        
        try
        {
            _isExecuting = true;
            RaiseCanExecuteChanged();
            
            await _execute();
        }
        finally
        {
            _isExecuting = false;
            RaiseCanExecuteChanged();
        }
    }
    
    public void RaiseCanExecuteChanged()
    {
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }
}

public class MainViewModel : INotifyPropertyChanged
{
    private readonly ArduinoService _arduinoService;
    private string _status;
    private bool _isConnected;
    private string _selectedPort;
    private ObservableCollection<string> _availablePorts;
    private ObservableCollection<SensorViewModel> _sensors;
    
    public ICommand ConnectCommand { get; }
    public ICommand DisconnectCommand { get; }
    public ICommand SendCommandCommand { get; }
    public ICommand RefreshPortsCommand { get; }
    
    public string Status
    {
        get => _status;
        set
        {
            if (_status != value)
            {
                _status = value;
                OnPropertyChanged();
            }
        }
    }
    
    public bool IsConnected
    {
        get => _isConnected;
        set
        {
            if (_isConnected != value)
            {
                _isConnected = value;
                OnPropertyChanged();
            }
        }
    }
    
    // Другие свойства...
    
    public MainViewModel(ArduinoService arduinoService)
    {
        _arduinoService = arduinoService;
        _sensors = new ObservableCollection<SensorViewModel>();
        _availablePorts = new ObservableCollection<string>();
        
        ConnectCommand = new AsyncRelayCommand(ConnectAsync, () => !IsConnected && !string.IsNullOrEmpty(SelectedPort));
        DisconnectCommand = new AsyncRelayCommand(DisconnectAsync, () => IsConnected);
        SendCommandCommand = new AsyncRelayCommand(SendCommandAsync, () => IsConnected);
        RefreshPortsCommand = new AsyncRelayCommand(RefreshPortsAsync);
        
        _arduinoService.DataReceived += ArduinoService_DataReceived;
        _arduinoService.ConnectionStatusChanged += ArduinoService_ConnectionStatusChanged;
        
        // Инициализация
        RefreshPortsCommand.Execute(null);
    }
    
    private async Task ConnectAsync()
    {
        Status = "Connecting...";
        IsConnected = await _arduinoService.ConnectAsync(SelectedPort, 9600);
        Status = IsConnected ? "Connected" : "Connection failed";
    }
    
    // Обработчик события от сервиса
    private void ArduinoService_DataReceived(object sender, SensorDataReceivedEventArgs e)
    {
        // Важно! Это событие происходит в фоновом потоке
        App.Current.Dispatcher.Invoke(() =>
        {
            // Обновление данных в UI потоке
            foreach (var data in e.Data)
            {
                var sensor = _sensors.FirstOrDefault(s => s.SensorId == data.SensorId);
                if (sensor != null)
                {
                    sensor.UpdateValue(data.Value);
                }
                else
                {
                    _sensors.Add(new SensorViewModel(data.SensorId, data.Value));
                }
            }
        });
    }
    
    // Другие методы...
    
    public event PropertyChangedEventHandler PropertyChanged;
    
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

private async Task AutoReconnectAsync(CancellationToken token)
{
    int attempt = 0;
    int delayMs = 100;
    
    while (!token.IsCancellationRequested)
    {
        try
        {
            _port.Open();
            OnConnectionStatusChanged(true);
            return; // Успешное подключение
        }
        catch
        {
            // Увеличиваем задержку экспоненциально, но не более 30 секунд
            attempt++;
            delayMs = Math.Min(30000, delayMs * 2);
            await Task.Delay(delayMs, token);
        }
    }
}

public void Dispose()
{
    _cts?.Cancel();
    
    if (_listeningTask != null)
    {
        try
        {
            // Ждем завершения задачи прослушивания
            _listeningTask.Wait(1000);
        }
        catch { }
    }
    
    if (_port != null)
    {
        if (_port.IsOpen)
        {
            try
            {
                _port.Close();
            }
            catch { }
        }
        
        _port.Dispose();
        _port = null;
    }
    
    _cts?.Dispose();
    _cts = null;
}

public async Task<CommandResult> SendCommandAsync(string command)
{
    if (!IsConnected)
        return new CommandResult { Success = false, Error = "Not connected" };
 
    try
    {
        // Блокируем одновременную отправку нескольких команд
        using (await _commandLock.LockAsync())
        {
            // Очищаем буфер от старых данных
            _port.DiscardInBuffer();
            
            // Добавляем символ новой строки, если его нет
            if (!command.EndsWith("\n"))
                command += "\n";
            
            // Устанавливаем обработчик для приема ответа
            var responseCompletionSource = new TaskCompletionSource<string>();
            void DataReceivedHandler(object s, SerialDataReceivedEventArgs e)
            {
                try
                {
                    string response = _port.ReadLine();
                    responseCompletionSource.TrySetResult(response);
                }
                catch (Exception ex)
                {
                    responseCompletionSource.TrySetException(ex);
                }
            }
 
            _port.DataReceived += DataReceivedHandler;
            
            try
            {
                // Отправляем команду
                _port.WriteLine(command);
                
                // Ждем ответа с таймаутом
                var response = await Task.WhenAny(
                    responseCompletionSource.Task,
                    Task.Delay(CommandTimeout)
                );
                
                if (response == responseCompletionSource.Task)
                {
                    string result = await responseCompletionSource.Task;
                    return ParseResponse(result);
                }
                else
                {
                    return new CommandResult { Success = false, Error = "Command timeout" };
                }
            }
            finally
            {
                _port.DataReceived -= DataReceivedHandler;
            }
        }
    }
    catch (Exception ex)
    {
        _logger.LogError($"Error sending command: {ex.Message}");
        return new CommandResult { Success = false, Error = ex.Message };
    }
}
 
private CommandResult ParseResponse(string response)
{
    response = response.Trim();
    
    if (response.EndsWith(":OK"))
    {
        return new CommandResult { Success = true };
    }
    else if (response.StartsWith("ERROR:"))
    {
        return new CommandResult 
        { 
            Success = false, 
            Error = response.Substring(6) // Remove "ERROR:" prefix
        };
    }
    else
    {
        // Пытаемся извлечь данные из ответа
        var dataParts = response.Split(':');
        if (dataParts.Length >= 2)
        {
            return new CommandResult 
            { 
                Success = true, 
                Data = string.Join(":", dataParts.Skip(1))
            };
        }
        
        // Если ничего не получилось, просто возвращаем ответ как есть
        return new CommandResult { Success = true, Data = response };
    }
}

private Task ProcessIncomingDataAsync(CancellationToken token)
{
    return Task.Run(async () =>
    {
        try
        {
            while (!token.IsCancellationRequested)
            {
                if (_port.BytesToRead > 0)
                {
                    string line = _port.ReadLine().Trim();
                    
                    if (line.StartsWith("DATA:"))
                    {
                        var sensorData = ParseSensorData(line);
                        if (sensorData.Count > 0)
                        {
                            OnDataReceived(new SensorDataReceivedEventArgs(sensorData));
                        }
                    }
                }
                
                await Task.Delay(10, token);
            }
        }
        catch (OperationCanceledException)
        {
            // Нормальное завершение при отмене
        }
        catch (Exception ex)
        {
            _logger.LogError($"Error processing data: {ex.Message}");
            // Сигнализируем о проблеме
            OnConnectionStatusChanged(false);
        }
    }, token);
}
 
private Dictionary<string, double> ParseSensorData(string dataLine)
{
    var result = new Dictionary<string, double>();
    
    // Формат: DATA:TYPE1:VALUE1;TYPE2:VALUE2;...
    if (dataLine.StartsWith("DATA:"))
    {
        string[] parts = dataLine.Substring(5).Split(';');
        
        foreach (var part in parts)
        {
            string[] keyValue = part.Split(':');
            if (keyValue.Length == 2 && double.TryParse(keyValue[1], out double value))
            {
                result[keyValue[0]] = value;
            }
        }
    }
    
    return result;
}

private bool ValidateSensorData(Dictionary<string, double> data)
{
    if (data.Count == 0)
        return false;
    
    // Проверка допустимых диапазонов для каждого типа датчика
    foreach (var kvp in data)
    {
        switch (kvp.Key)
        {
            case "TEMP":
                if (kvp.Value < -50 || kvp.Value > 150)
                    return false;
                break;
            case "HUM":
                if (kvp.Value < 0 || kvp.Value > 100)
                    return false;
                break;
            // Другие типы датчиков...
        }
    }
    
    // Проверка частоты обновления
    if (_lastDataReceivedTime != DateTime.MinValue)
    {
        TimeSpan timeSinceLastUpdate = DateTime.Now - _lastDataReceivedTime;
        if (timeSinceLastUpdate.TotalMilliseconds < _minUpdateInterval)
            return false;
    }
    
    _lastDataReceivedTime = DateTime.Now;
    return true;
}

public abstract class ArduinoCommand
{
    public byte CommandCode { get; }
    
    protected ArduinoCommand(byte commandCode)
    {
        CommandCode = commandCode;
    }
    
    public abstract byte[] ToByteArray();
    public abstract bool ParseResponse(byte[] response);
}
 
public class SetLedCommand : ArduinoCommand
{
    public byte Red { get; }
    public byte Green { get; }
    public byte Blue { get; }
    public bool Success { get; private set; }
    
    public SetLedCommand(byte red, byte green, byte blue) 
        : base(0x01) // COMMAND_SET_LED
    {
        Red = red;
        Green = green;
        Blue = blue;
    }
    
    public override byte[] ToByteArray()
    {
        return new byte[] { CommandCode, Red, Green, Blue };
    }
    
    public override bool ParseResponse(byte[] response)
    {
        if (response.Length >= 2 && response[0] == CommandCode)
        {
            Success = response[1] == 0x01;
            return true;
        }
        return false;
    }
}

public class BinaryProtocolHandler
{
    private readonly SerialPort _port;
    private readonly byte _startMarker = 0xAA;
    private readonly byte _endMarker = 0x55;
    private readonly object _sendLock = new object();
    
    public BinaryProtocolHandler(SerialPort port)
    {
        _port = port;
    }
    
    public async Task<bool> SendCommandAsync<T>(T command) where T : ArduinoCommand
    {
        byte[] commandData = command.ToByteArray();
        byte[] fullPacket = new byte[commandData.Length + 2];
        
        fullPacket[0] = _startMarker;
        Array.Copy(commandData, 0, fullPacket, 1, commandData.Length);
        fullPacket[fullPacket.Length - 1] = _endMarker;
        
        TaskCompletionSource<byte[]> responseSource = new TaskCompletionSource<byte[]>();
        
        void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                // Чтение и парсинг ответа...
                byte[] response = ReadResponse();
                if (response != null && response.Length > 0 && response[0] == command.CommandCode)
                {
                    responseSource.TrySetResult(response);
                }
            }
            catch (Exception ex)
            {
                responseSource.TrySetException(ex);
            }
        }
        
        lock (_sendLock)
        {
            try
            {
                _port.DataReceived += DataReceivedHandler;
                
                // Очищаем буферы
                _port.DiscardInBuffer();
                _port.DiscardOutBuffer();
                
                // Отправляем команду
                _port.Write(fullPacket, 0, fullPacket.Length);
                
                // Ждем ответа с таймаутом
                var timeoutTask = Task.Delay(1000);
                var responseTask = responseSource.Task;
                
                var completedTask = await Task.WhenAny(responseTask, timeoutTask);
                
                if (completedTask == responseTask)
                {
                    byte[] response = await responseTask;
                    return command.ParseResponse(response);
                }
                
                return false; // Таймаут
            }
            finally
            {
                _port.DataReceived -= DataReceivedHandler;
            }
        }
    }
    
    private byte[] ReadResponse()
    {
        // Реализация чтения ответа с учетом маркеров начала и конца
        // ...
    }
}

public class CommandQueue
{
    private readonly Queue<ArduinoCommand> _queue = new Queue<ArduinoCommand>();
    private readonly BinaryProtocolHandler _protocolHandler;
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    private bool _isProcessing = false;
    
    public CommandQueue(BinaryProtocolHandler protocolHandler)
    {
        _protocolHandler = protocolHandler;
    }
    
    public async Task<bool> EnqueueCommandAsync(ArduinoCommand command)
    {
        await _semaphore.WaitAsync();
        try
        {
            _queue.Enqueue(command);
            
            if (!_isProcessing)
            {
                _isProcessing = true;
                _ = ProcessQueueAsync();
            }
            
            return true;
        }
        finally
        {
            _semaphore.Release();
        }
    }
    
    private async Task ProcessQueueAsync()
    {
        while (true)
        {
            ArduinoCommand command;
            
            await _semaphore.WaitAsync();
            try
            {
                if (_queue.Count == 0)
                {
                    _isProcessing = false;
                    return;
                }
                
                command = _queue.Dequeue();
            }
            finally
            {
                _semaphore.Release();
            }
            
            try
            {
                await _protocolHandler.SendCommandAsync(command);
            }
            catch (Exception ex)
            {
                // Обработка ошибок
                Debug.WriteLine($"Error processing command: {ex.Message}");
            }
        }
    }
}

private enum ReceiveState { WaitingForSTX, ReadingCommand, ReadingLength, ReadingData, ReadingChecksum, Complete }
 
private byte[] ReceivePacket(int timeout = 1000)
{
    ReceiveState state = ReceiveState.WaitingForSTX;
    byte command = 0;
    byte length = 0;
    byte[] data = new byte[256]; // Максимальный размер буфера
    int dataIndex = 0;
    byte checksum = 0;
    byte calculatedChecksum = 0;
    
    DateTime startTime = DateTime.Now;
    
    while (DateTime.Now - startTime < TimeSpan.FromMilliseconds(timeout))
    {
        if (_port.BytesToRead > 0)
        {
            byte b = (byte)_port.ReadByte();
            
            switch (state)
            {
                case ReceiveState.WaitingForSTX:
                    if (b == 0x02) // STX
                        state = ReceiveState.ReadingCommand;
                    break;
                
                case ReceiveState.ReadingCommand:
                    command = b;
                    calculatedChecksum ^= b;
                    state = ReceiveState.ReadingLength;
                    break;
                
                case ReceiveState.ReadingLength:
                    length = b;
                    calculatedChecksum ^= b;
                    if (length > 0)
                        state = ReceiveState.ReadingData;
                    else
                        state = ReceiveState.ReadingChecksum;
                    break;
                
                case ReceiveState.ReadingData:
                    data[dataIndex++] = b;
                    calculatedChecksum ^= b;
                    if (dataIndex >= length)
                        state = ReceiveState.ReadingChecksum;
                    break;
                
                case ReceiveState.ReadingChecksum:
                    checksum = b;
                    state = ReceiveState.Complete;
                    break;
                
                case ReceiveState.Complete:
                    if (b == 0x03) // ETX
                    {
                        // Проверяем контрольную сумму
                        if (checksum == calculatedChecksum)
                        {
                            // Формируем результирующий массив
                            byte[] result = new byte[dataIndex + 1];
                            result[0] = command;
                            Array.Copy(data, 0, result, 1, dataIndex);
                            return result;
                        }
                    }
                    
                    // Если дошли сюда, значит пакет некорректный
                    // Сбрасываем состояние и начинаем заново
                    state = ReceiveState.WaitingForSTX;
                    dataIndex = 0;
                    calculatedChecksum = 0;
                    break;
            }
        }
        else
        {
            Thread.Sleep(1); // Даем другим потокам поработать
        }
    }
    
    // Таймаут
    return null;
}

private async Task<bool> SendCommandWithRetryAsync(ArduinoCommand command, int maxRetries = 3)
{
    for (int attempt = 0; attempt < maxRetries; attempt++)
    {
        if (await SendCommandAsync(command))
            return true;
        
        // Увеличиваем задержку с каждой попыткой
        await Task.Delay(100 * (attempt + 1));
    }
    
    return false;
}

public class ArduinoStateCache
{
    private readonly Dictionary<string, object> _cache = new Dictionary<string, object>();
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    
    public void SetValue(string key, object value)
    {
        _lock.EnterWriteLock();
        try
        {
            _cache[key] = value;
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }
    
    public T GetValue<T>(string key, T defaultValue = default)
    {
        _lock.EnterReadLock();
        try
        {
            if (_cache.TryGetValue(key, out object value) && value is T typedValue)
                return typedValue;
            return defaultValue;
        }
        finally
        {
            _lock.ExitReadLock();
        }
    }
}

public class ArduinoEmulator : IArduinoDevice
{
    private readonly Random _random = new Random();
    private readonly Dictionary<int, bool> _pinStates = new Dictionary<int, bool>();
    private readonly Dictionary<string, double> _sensorValues = new Dictionary<string, double>();
    private readonly Timer _updateTimer;
    
    public event EventHandler<SensorDataReceivedEventArgs> DataReceived;
    
    public ArduinoEmulator()
    {
        // Инициализация виртуальных пинов и датчиков
        for (int i = 0; i < 14; i++)
            _pinStates[i] = false;
        
        _sensorValues["TEMP"] = 25.0;
        _sensorValues["HUM"] = 50.0;
        
        // Таймер для эмуляции периодической отправки данных
        _updateTimer = new Timer(_ => SimulateSensorUpdates(), null, 1000, 1000);
    }
    
    public Task<bool> SetPinStateAsync(int pin, bool state)
    {
        if (pin >= 0 && pin < 14)
        {
            _pinStates[pin] = state;
            return Task.FromResult(true);
        }
        return Task.FromResult(false);
    }
    
    public Task<bool> GetPinStateAsync(int pin)
    {
        if (_pinStates.TryGetValue(pin, out bool state))
            return Task.FromResult(state);
        return Task.FromResult(false);
    }
    
    private void SimulateSensorUpdates()
    {
        // Добавляем небольшие случайные изменения к значениям датчиков
        _sensorValues["TEMP"] += (_random.NextDouble() - 0.5) * 0.1;
        _sensorValues["HUM"] += (_random.NextDouble() - 0.5) * 0.2;
        
        // Ограничиваем значения реалистичными диапазонами
        _sensorValues["TEMP"] = Math.Max(10, Math.Min(40, _sensorValues["TEMP"]));
        _sensorValues["HUM"] = Math.Max(20, Math.Min(80, _sensorValues["HUM"]));
        
        // Уведомляем подписчиков
        DataReceived?.Invoke(this, new SensorDataReceivedEventArgs(_sensorValues));
    }
    
    // Реализация остальных методов интерфейса IArduinoDevice...
}

public class DataBuffer<T>
{
    private readonly Queue<T> _buffer = new Queue<T>();
    private readonly int _maxSize;
    private readonly object _lock = new object();
    
    public DataBuffer(int maxSize = 1000)
    {
        _maxSize = maxSize;
    }
    
    public void Add(T item)
    {
        lock (_lock)
        {
            _buffer.Enqueue(item);
            
            // Если буфер переполнен, удаляем самые старые данные
            while (_buffer.Count > _maxSize)
                _buffer.Dequeue();
        }
    }
    
    public IEnumerable<T> GetAndClear()
    {
        lock (_lock)
        {
            T[] items = _buffer.ToArray();
            _buffer.Clear();
            return items;
        }
    }
}

private async Task StartWatchdogAsync(CancellationToken token)
{
    while (!token.IsCancellationRequested)
    {
        try
        {
            // Проверяем, что последнее обновление было не более 10 секунд назад
            if (DateTime.Now - _lastUpdateTime > TimeSpan.FromSeconds(10))
            {
                // Отправляем пинг-команду
                bool pingResult = await SendCommandAsync(new PingCommand());
                
                if (!pingResult)
                {
                    // Если пинг не прошел, инициируем переподключение
                    await ReconnectAsync();
                }
            }
            
            // Проверяем раз в 5 секунд
            await Task.Delay(5000, token);
        }
        catch (OperationCanceledException)
        {
            // Нормальное завершение при отмене
            break;
        }
        catch (Exception ex)
        {
            _logger.LogError($"Watchdog error: {ex.Message}");
        }
    }
}

public async Task<bool> SendCommandToSleepingDeviceAsync(ArduinoCommand command)
{
    // Сначала отправляем сигнал пробуждения
    await SendWakeupSignalAsync();
    
    // Даем время на "пробуждение"
    await Task.Delay(100);
    
    // Теперь отправляем команду
    return await SendCommandAsync(command);
}

public class PriorityCommandQueue
{
    private class QueueItem
    {
        public ArduinoCommand Command { get; }
        public int Priority { get; }
        public TaskCompletionSource<bool> CompletionSource { get; }
        
        public QueueItem(ArduinoCommand command, int priority, TaskCompletionSource<bool> completionSource)
        {
            Command = command;
            Priority = priority;
            CompletionSource = completionSource;
        }
    }
    
    private readonly List<QueueItem> _queue = new List<QueueItem>();
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    private readonly BinaryProtocolHandler _protocolHandler;
    private bool _isProcessing = false;
    
    public PriorityCommandQueue(BinaryProtocolHandler protocolHandler)
    {
        _protocolHandler = protocolHandler;
    }
    
    public async Task<bool> EnqueueCommandAsync(ArduinoCommand command, int priority = 0)
    {
        var completionSource = new TaskCompletionSource<bool>();
        
        await _semaphore.WaitAsync();
        try
        {
            // Добавляем команду в очередь с сортировкой по приоритету
            _queue.Add(new QueueItem(command, priority, completionSource));
            _queue.Sort((a, b) => b.Priority.CompareTo(a.Priority));
            
            if (!_isProcessing)
            {
                _isProcessing = true;
                _ = ProcessQueueAsync();
            }
        }
        finally
        {
            _semaphore.Release();
        }
        
        // Возвращаем Task, который завершится, когда команда будет выполнена
        return await completionSource.Task;
    }
    
    private async Task ProcessQueueAsync()
    {
        while (true)
        {
            QueueItem item = null;
            
            await _semaphore.WaitAsync();
            try
            {
                if (_queue.Count == 0)
                {
                    _isProcessing = false;
                    return;
                }
                
                item = _queue[0];
                _queue.RemoveAt(0);
            }
            finally
            {
                _semaphore.Release();
            }
            
            try
            {
                bool result = await _protocolHandler.SendCommandAsync(item.Command);
                item.CompletionSource.SetResult(result);
            }
            catch (Exception ex)
            {
                item.CompletionSource.SetException(ex);
            }
        }
    }
}