示例#1
0
 public Task DisconnectAsync()
 {
     IsConnected = false;
     _workerController.CloseWorker(_worker);
     return(Task.Delay(_config.DisconnectDelay));
 }
示例#2
0
 /// <summary>
 /// Остановливает контроллер
 /// </summary>
 public void Stop()
 {
     IsPaused      = false;
     _isProcessing = false;
     _workerController.CloseWorker(_worker);
 }
        public async Task ConnectAsync()
        {
            AssertInitParams();

            if (IsConnected)
            {
                throw new InvalidOperationException($"{GetType().Name} уже подключен к устройству");
            }

            try
            {
                // очистим перед подключением все накопленные ошибки
                while (_lastExceptions.TryDequeue(out _))
                {
                }

                var monitorIpAddress = await DiscoverMonitorIpAddressAsync()
                                       .ConfigureAwait(false);

                _tcpClient = new TcpClient();

                await _tcpClient.ConnectAsync(monitorIpAddress, _initParams.MonitorTcpPort)
                .ConfigureAwait(false);

                _stream = _tcpClient.GetStream();
                _mitar  = new MitarMonitorDataReceiver(_stream);
                _mitar.Start();
                // ReSharper disable once HeapView.CanAvoidClosure
                _syncWorker = _workerController.StartWorker(_initParams.UpdateDataPeriod, async() =>
                {
                    try
                    {
                        //todo сюды бы токен отмены
                        await UpdateDataAsync()
                        .ConfigureAwait(false);
                    }
                    catch (Exception ex)
                    {
                        IsConnected = false;
                        _workerController.CloseWorker(_syncWorker);
                        _lastExceptions.Enqueue(ex);
                    }
                });
                IsConnected = true;
            }
            catch (SocketException e)
            {
                IsConnected = false;
                throw new DeviceConnectionException("Ошибка подключения к кардиомонитору", e);
            }
            catch (ObjectDisposedException e)
            {
                IsConnected = false;
                throw new DeviceConnectionException("Ошибка подключения к кардиомонитору", e);
            }
            catch (Exception e)
            {
                IsConnected = false;
                throw new DeviceProcessingException("Ошибка подключения к кардиомонитору", e);
            }
        }
示例#4
0
        public async Task ConnectAsync()
        {
            AssertInitParams();
            if (IsConnected)
            {
                throw new InvalidOperationException($"{GetType().Name} уже подключен к устройству");
            }
            if (!IpEndPointParser.TryParse(_config.BedIpEndpoint, out _bedIpEndPoint))
            {
                throw new ArgumentException("Не верно указан адрес подключения к кровати. Требуемый формат - ip:port");
            }

            try
            {
                // очистим перед подключением все накопленные ошибки
                while (_lastExceptions.TryDequeue(out _))
                {
                }

                await InternalDisconectAsync().ConfigureAwait(false);

                _udpSendingClient = new UdpClient
                {
                    Client =
                    {
                        ReceiveTimeout = (int)_config.Timeout.TotalMilliseconds,
                        SendTimeout    = (int)_config.Timeout.TotalMilliseconds
                    }
                };

                _udpReceivingClient = new UdpClient(_bedIpEndPoint.Port)
                {
                    Client =
                    {
                        ReceiveTimeout = (int)_config.Timeout.TotalMilliseconds,
                        SendTimeout    = (int)_config.Timeout.TotalMilliseconds
                    }
                };
                _udpSendingClient.Connect(_bedIpEndPoint);
                _udpReceivingClient.Connect(_bedIpEndPoint);

                IsConnected = true;
                await UpdateRegistersValueAsync()
                .ConfigureAwait(false);

                _syncWorker = _workerController.StartWorker(_config.UpdateDataPeriod, async() =>
                {
                    if (_initialisingStatus == DeviceIsInitialising)
                    {
                        return;
                    }

                    try
                    {
                        //todo сюды бы токен отмены
                        await UpdateRegistersValueAsync()
                        .ConfigureAwait(false);
                    }
                    catch (Exception e)
                    {
                        IsConnected = false;
                        _workerController.CloseWorker(_syncWorker);
                        _lastExceptions.Enqueue(e);
                    }
                });
            }
            catch (DeviceConnectionException)
            {
                IsConnected = false;
                throw;
            }
            catch (SocketException e)
            {
                IsConnected = false;
                throw new DeviceConnectionException("Ошибка подключения к инверсионному столу", e);
            }
            catch (ObjectDisposedException e)
            {
                IsConnected = false;
                throw new DeviceConnectionException("Ошибка подключения к инверсионному столу", e);
            }
            catch (Exception e)
            {
                IsConnected = false;
                throw new DeviceProcessingException("Ошибка в ходе обработки данных от инверсионного стола", e);
            }
        }