public DataSender(ConnectionBase interf, IDispatchData data)
        {
            _sendState.In(SendState.Idle).ExecuteOnEntry(() => Debug.WriteLine("DataSender: idle"))
                .On(SendEvent.Send).Goto(SendState.Wait1).Execute(SendData);

            _sendState.In(SendState.Wait1).ExecuteOnEntry(() => Debug.WriteLine("DataSender: Wait1"))
                .On(SendEvent.Retry).Goto(SendState.Wait2).Execute(SendData)
                .On(SendEvent.Succes).Goto(SendState.Finished).Execute(Succeed);

            _sendState.In(SendState.Wait2).ExecuteOnEntry(() => Debug.WriteLine("DataSender: Wait2"))
                .On(SendEvent.Retry).Goto(SendState.Wait3).Execute(SendData)
                .On(SendEvent.Succes).Goto(SendState.Finished).Execute(Succeed);

            _sendState.In(SendState.Wait3).ExecuteOnEntry(() => Debug.WriteLine("DataSender: Wait3"))
                .On(SendEvent.Retry).Goto(SendState.Wait4).Execute(SendData)
                .On(SendEvent.Succes).Goto(SendState.Finished).Execute(Succeed);

            _sendState.In(SendState.Wait4).ExecuteOnEntry(() => Debug.WriteLine("DataSender: Erronuous"))
               .On(SendEvent.Retry).Goto(SendState.Finished).Execute(Retry3)
               .On(SendEvent.Succes).Goto(SendState.Finished).Execute(Succeed);

            _sendState.In(SendState.Finished).ExecuteOnEntry(() =>
            {
                Dispose();
                Debug.WriteLine("DataSender: Finished");
            });

            _interface = interf;
            _data = data;

            _interface.DataReceived += InterfaceOnDataReceived;

            _sendState.Initialize(SendState.Idle);
            _sendState.Start();
        }
        public DataQueue(ConnectionBase interf)
        {
            _interf = interf;

            _queueState.In(QueueState.Empty).ExecuteOnEntry(() => Debug.WriteLine("DataQueue: empty"))

                .On(QueueEvent.Push).If(QueueHasData).Goto(QueueState.Waiting).Execute(SendNext)
                .Otherwise().Execute(OnQueueEmpty);

            _queueState.In(QueueState.Waiting).ExecuteOnEntry(() => Debug.WriteLine("DataQueue: waiting"))

                .On(QueueEvent.DataSend)
                .If(QueueHasData).Execute(SendNext)
                .Otherwise().Goto(QueueState.Empty).Execute(OnQueueEmpty);
        }
        private void Connect(Tuple<string, ConnectType> specs)
        {
            try
            {
                _interface = ConnectionFactory(specs.Item2);

                _interface.DataReceived += (sender, bytes) => _mcucomm.Fire(Cevts.ReceiveCompleted, bytes);
                _interface.ErrorOccured += (sender, s) => _mcucomm.Fire(Cevts.Error, s.Exception.ToString());
                _interface.ModeChanged += (sender, b) => _mcucomm.Fire(b.Connected ? Cevts.Connected : Cevts.Disconnect);
                _interface.Connect(specs.Item1);

                _dataQueue = new DataQueue(_interface);

                _dataQueue.Error += (sender, exception) => _mcucomm.Fire(Cevts.Error, exception.Exception.Message);
                _dataQueue.QueueEmpty += (sender, args) => _mcucomm.Fire(Cevts.QueueEmtpy);

                _dataQueue.Run();
            }
            catch (Exception e)
            {
                _mcucomm.Fire(Cevts.Error, e.Message);
            }
        }