Ошибка чтения / записи данных с COM порта

using System;
using System.IO.Ports;
using Modbus.Device;
 
namespace ModbusConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Подключаемся к устройству
            var serialPort = new SerialPort("COM3")
            {
                BaudRate = 4800,
                Parity = Parity.Even,
                DataBits = 8,
                StopBits = StopBits.One,
                ReadTimeout = 1000
            };
 
            try
            {
                serialPort.Open();
                Console.WriteLine("Device connected");
 
                // Создаем Modbus RTU мастер
                var modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
                modbusMaster.Transport.Retries = 3;
 
                // чтение из slave 1 
                ReadSlave(modbusMaster, 2, 1300);
 
                // запись в регистр slave 1
                Console.Write("Введите значение для записи в slave 1 (регистр 1000): ");
                if (int.TryParse(Console.ReadLine(), out int valueToWrite))
                {
                    WriteToSlave(modbusMaster, 2, 1300, valueToWrite);
                    serialPort.Close();
                }
                else
                {
                    Console.WriteLine("Неверное значение для записи.");
                }
 
                // Закрываем порт
                serialPort.Close();
                Console.WriteLine("Соединение закрыто.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Ошибка: {ex.Message}");
            }
        }
 
        static void ReadSlave(IModbusSerialMaster master, byte slaveId, ushort startAddress)
        {
            try
            {
                ushort numOfPoints = 1;
                ushort[] result = master.ReadHoldingRegisters(slaveId, startAddress, numOfPoints);
                Console.WriteLine($"Slave {slaveId} register value at address {startAddress}: {result[0]}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Read error from slave {slaveId}: {ex.Message}");
            }
        }
 
        static void WriteToSlave(IModbusSerialMaster master, byte slaveId, ushort startAddress, int valueToWrite)
        {
            try
            {
                ushort[] values = { (ushort)valueToWrite };
                master.WriteMultipleRegisters(slaveId, startAddress, values);
                Console.WriteLine("Write successful");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Write error to slave {slaveId}: {ex.Message}");
            }
        }
    }
}

using System;
using System.IO.Ports;
using System.Windows.Input;
using Modbus.Device;
using System.ComponentModel;
 
namespace RPStesting
{
    public class MainViewModel : INotifyPropertyChanged
    {
 
        private IModbusSerialMaster _modbusMaster;
        private SerialPort _serialPort;
        private bool _isConnected; // текущее состояние подключен или нет
        private ushort _currentRegisterValue; 
 
        // Команда для переключения значения регистра
        public ICommand ToggleRegisterCommand { get; }
 
        // Сообщение о состоянии
        public string StatusMessage { get; private set; }
 
        // Конструктор ViewModel, где инициализируется команда и соединение с устройством
        public MainViewModel()
        {
            ToggleRegisterCommand = new RelayCommand(ToggleRegister, CanToggleRegister);
            _isConnected = false; // По умолчанию соединение закрыто
            InitializeModbusConnection(); // Инициализация соединения Modbus
        }
 
        //соединения с устройством
        public void InitializeModbusConnection()
        {
            _serialPort = new SerialPort("COM3")
            {
                BaudRate = 4800,
                Parity = Parity.Even,
                DataBits = 8,
                StopBits = StopBits.One,
                ReadTimeout = 1000
            };
 
            try
            {
                // Открываем COM-порт
                _serialPort.Open();
                StatusMessage = "Device connected";
                // Создаем ModbusRTU мастер
                _modbusMaster = ModbusSerialMaster.CreateRtu(_serialPort);
                _modbusMaster.Transport.Retries = 3; // Устанавливаем количество попыток на 3
 
                _isConnected = true; // Обновляем состояние подключения
                StatusMessage = "Device connected"; // Устанавливаем сообщение о состоянии
            }
            catch (Exception ex)
            {
                // Если возникает ошибка, выводим сообщение об ошибке
                StatusMessage = $"Failed to connect: {ex.Message}";
            }
 
            // Уведомляем UI об изменении StatusMessage
            OnPropertyChanged(nameof(StatusMessage));
        }
 
        // Метод для проверки возможности переключения значения регистра
        private bool CanToggleRegister(object parameter)
        {
            return _isConnected; // Можно переключать, только если соединение установлено
        }
 
        // Метод для переключения значения регистра
        private void ToggleRegister(object parameter)
        {
            if (_modbusMaster == null || !_isConnected) return; // Если соединение не установлено, выходим
 
            try
            {
                // Переключаем значение регистра (если 0, то ставим 1 и наоборот)
                _currentRegisterValue = _currentRegisterValue == 0 ? (ushort)1 : (ushort)0;
 
                // Записываем значение в Modbus-устройство
                WriteToSlave(2, 1300, _currentRegisterValue);
 
                // Обновляем статусное сообщение
                StatusMessage = $"Register value toggled to {_currentRegisterValue}";
            }
            catch (Exception ex)
            {
                // Если возникает ошибка, выводим сообщение об ошибке
                StatusMessage = $"Error toggling register: {ex.Message}";
            }
 
            // Уведомляем UI об изменении StatusMessage
            OnPropertyChanged(nameof(StatusMessage));
        }
 
        // Метод для записи значения в Modbus-устройство
        private void WriteToSlave(byte slaveId, ushort startAddress, ushort valueToWrite)
        {
            try
            {
                // Создаем массив значений и записываем в устройство
                ushort[] values = { valueToWrite };
                _modbusMaster.WriteMultipleRegisters(slaveId, startAddress, values);
            }
            catch (Exception ex)
            {
                // Если возникает ошибка, выбрасываем исключение с описанием ошибки
                throw new Exception($"Write error: {ex.Message}");
            }
        }
 
        // Реализация интерфейса INotifyPropertyChanged для уведомления UI об изменениях
        public event PropertyChangedEventHandler PropertyChanged;
 
        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
 
        // Деструктор для закрытия и освобождения ресурсов SerialPort
        ~MainViewModel()
        {
            _serialPort?.Close();
            _serialPort?.Dispose();
        }
    }
 
    // Реализация RelayCommand для команд
    public class RelayCommand : ICommand
    {
        private readonly Action<object> _execute; // для выполнения команды
        private readonly Predicate<object> _canExecute; // для проверки возможности выполнения команды
 
        public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }
 
        public bool CanExecute(object parameter)
        {
            return _canExecute == null || _canExecute(parameter);
        }
 
        public void Execute(object parameter)
        {
            _execute(parameter);
        }
 
        // Событие для уведомления об изменении состояния возможности выполнения команды
        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }
    }
}