private async void buttonConnect_Click(object sender, EventArgs e) { this.buttonConnect.Enabled = false; var connectionType = (CommunicationType)this.comboBoxCommunicationType.SelectedItem; try { switch (connectionType) { case CommunicationType.SerialPort: this.Communication = new SerialPortCommunication(this.textBoxValue.Text); break; case CommunicationType.NetworkTcp: this.Communication = new TcpNetworkCommunication(new IPEndPoint(IPAddress.Parse(this.textBoxValue.Text), 4003)); break; case CommunicationType.NetworkUdp: this.Communication = new UdpNetworkCommunication(IPAddress.Parse(this.textBoxValue.Text)); break; default: break; } this.DialogResult = DialogResult.OK; } catch (Exception exception) { MessageBox.Show($"Cannot connect {exception}", "Connection Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } this.buttonConnect.Enabled = true; }
public async void TestSetup() { m_loggingContext = new LoggingContext(Guid.NewGuid()); var data = TestHelper.CreateApplicationEndpoint(); m_mockEventChannel = data.EventChannel; m_restfulClient = data.RestfulClient; m_applicationEndpoint = data.ApplicationEndpoint; await m_applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false); await m_applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false); ICommunication communication = m_applicationEndpoint.Application.Communication; m_restfulClient.HandleRequestProcessed += (sender, args) => { TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.MessagingInvitations, HttpMethod.Post, "Event_MessagingInvitationStarted.json", m_mockEventChannel); TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.EstablishMessagingCall, HttpMethod.Post, "Event_MessagingInvitationStarted.json", m_mockEventChannel); }; // Start a messaging invitation m_messagingInvitation = await communication.StartMessagingWithIdentityAsync( "Test subject", "sip:[email protected]", "https://example.com/callback", "Local user", "sip:[email protected]", m_loggingContext); }
public CommunicationPackage(ICommunication _communication, DataPackage _data) { Id = s_idCounter; s_idCounter++; Communication = _communication; Data = _data; }
//TODO: move to separate class {READY} public UserData GetInfoFromUser(TagType tag, Diff diff, IMp3File file, ICommunication communication) { communication.SendMessage($"File: {file.FilePath}"); communication.SendMessage($"There is a problem with tag \"{tag}\". "); communication.SendMessage( $"You can enter tag from: \n\t1) File name (Data: \"{diff.FileNameValue}\"), \n\t2) Mp3 Tags (Data: \"{diff.TagValue}\"), \n\t3) Manual"); while (true) { communication.SendMessage("Your choise (number): "); SyncActions inputData; var choiseCorrect = Enum.TryParse(communication.GetResponse(), out inputData); if (!choiseCorrect) { communication.SendMessage("Wrong input!"); communication.SendMessage("You sholud enter number with action!"); continue; } switch (inputData) { case SyncActions.FromFileName: return new UserData(inputData, diff.FileNameValue); case SyncActions.FromTags: return new UserData(inputData, diff.TagValue); case SyncActions.Manual: communication.SendMessage("Enter text for tag \"" + tag + "\""); return new UserData(inputData, communication.GetResponse()); } } }
public void OnStartGameAction(ICommunication communication, DataPackage data) { if (communication.IsMaster) { if (_serverInfo._lobbylist[0].IsLobbyComplete()) { _gameStarted = true; Core.State = StateEnum.GameRunningState; for (int i = 0; i < _serverInfo._communications.Count; i++) { if (!(_serverInfo._communications[i] == communication)) { _serverInfo._communications[i].Send(_dataPackageProvider.GetPackage("PlayerData")); } } communication.Send(_dataPackageProvider.GetPackage("ServerStartingGame")); } else { communication.Send(_dataPackageProvider.GetPackage("NotEnoughInfo")); } } else { communication.Send(_dataPackageProvider.GetPackage("OnlyMasterStartInfo")); } }
/// <summary> /// Constructor /// </summary> /// <param name="comm">Object implementing the <see cref="ICommunication"/> interface for talking to the brick</param> /// <param name="alwaysSendEvents">Send events when data changes, or at every poll</param> public Brick(ICommunication comm, bool alwaysSendEvents) { DirectCommand = new DirectCommand(this); SystemCommand = new SystemCommand(this); BatchCommand = new Command(this); Buttons = new BrickButtons(); _alwaysSendEvents = alwaysSendEvents; var index = 0; _comm = comm; _comm.ReportReceived += ReportReceived; Ports = new Dictionary <InputPort, Port>(); foreach (InputPort i in Enum.GetValues(typeof(InputPort))) { Ports[i] = new Port { InputPort = i, Index = index++, Name = i.ToString(), }; } }
public PermissionSystem( ICommunication communication, IServiceScopeFactory scopeFactory) { this.communication = communication; this.scopeFactory = scopeFactory; }
public VcselDriverViewModel(ICommunication communication, IRegionManager regionManager, IEventAggregator eventAggregator) : base(regionManager, eventAggregator) { this.comm = communication; this.vcselDriver = new ConfigVcselDriver(); ConfigVcselDriverCmd = new DelegateCommand(ConfigVcselDriver); eventAggregator.GetEvent <ConfigVcselDriverReplyEvent>().Subscribe(reply => { if (reply.Ack == 0) { this.PrintWatchLog("ConfigVcselDriver Success", LogLevel.Warning); } else { this.PrintWatchLog("ConfigVcselDriver Fail", LogLevel.Error); } MaxIBias = (UInt32)(Math.Round(reply.MaxIBiasMicroAmp / 1000.0 / TickFrequency) * TickFrequency); MaxISw = (UInt32)(Math.Round(reply.MaxISwitchMicroAmp / 1000.0 / TickFrequency) * TickFrequency); IBias = (UInt32)(Math.Round(reply.IBiasMicroAmp / 1000.0 / TickFrequency) * TickFrequency); ISw = (UInt32)(Math.Round(reply.ISwitchMicroAmp / 1000.0 / TickFrequency) * TickFrequency); }, true); }
private void btnStart_Click(object sender, EventArgs e) { // While this example uses the SerialCommunication class, any of the communication classes could be used... they all implement ICommunication. // For simplicity we will use 8N1 and not ask on the form. _comm = new SerialCommunication(txtSerialPort.Text, 9600, System.IO.Ports.Parity.None, 8, System.IO.Ports.StopBits.One); _comm.Logger = new Prophecy.Logger.TraceLogger(Prophecy.Logger.LoggerVerbosity.Normal); // assign the built-in TraceLogger just as an example. You could create your own logger class. //_comm.Delimiter = "\r"; // change the delimiter since it defaults to "\r\n". //_comm.CurrentEncoding = System.Text.ASCIIEncoding.ASCII; // this is unnecessary since it defaults to ASCII //_comm.ReceivedDelimitedString += new EventHandler<ReceivedDelimitedStringEventArgs>(_comm_ReceivedDelimitedString); // Since our pretend protocol uses \r as the delimiter let's make life easy and subscribe to the ReceivedDelimitedString event. We could also subscribe to ReceivedString and ReceivedBytes. //_comm.IncludeDelimiterInRawResponse = false; // this is unnecessary since it defaults to false //_comm.ReadBufferEnabled = false; // this is unnecessary since it defaults to false and it since we are using the ReceivedDelimitedString event there would be no need to use a buffer. _comm.Delimiter = null; // set to null to disable the ReceivedDelimitedString _comm.CurrentEncoding = null; // do not decode strings //_comm.ReceivedBytes += new EventHandler<ReceivedBytesEventArgs>(_serial_DataReceived); _comm.ReadBufferEnabled = true; // If the ReadBufferEnabled property is true, you may _comm.DefaultSendDelayInterval = 0; // this is unnecessary since it defaults to 0 _comm.DefaultSendDelayInterval = 0; // this is unnecessary since it defaults to 0 // Start connection monitor. _comm.ConnectionMonitorTimeout = 60000; //_comm.ConnectionMonitorTestRequest = "HELLO\r"; // a pretend message to send when no data has been received for a while (note that serial connections can not detect physical disconnections so we count on this). _comm.ConnectionEstablished += new EventHandler<EventArgs>(_comm_ConnectionEstablished); _comm.ConnectionLost += new EventHandler<EventArgs>(_comm_ConnectionLost); _comm.StartConnectionMonitor(); // if we were not using connection monitoring we could call _comm.Open(). txtSerialPort.Enabled = false; btnStart.Enabled = false; }
public CommunicationAcceptEventArgs(ICommunication communication, byte[] head, Credential credential) : base(communication) { Head = head; Handled = false; Credential = credential; }
/// <summary> /// Constructor /// </summary> /// <param name="comm">Object implementing the <see cref="ICommunication"/> interface for talking to the brick</param> /// <param name="responseManager">The response manager used to get sequence numbers and create reports</param> /// <param name="alwaysSendEvents">Send events when data changes, or at every poll</param> public Brick(ICommunication comm, ResponseManager responseManager, bool alwaysSendEvents) { _subject = new BehaviorSubject <Response>(null); _directCommand = new DirectCommand(this); _systemCommand = new SystemCommand(this); Buttons = new BrickButtons(); _comm = comm ?? throw new ArgumentNullException(nameof(comm)); _responseManager = responseManager ?? throw new ArgumentNullException(nameof(comm)); _alwaysSendEvents = alwaysSendEvents; Ports = new Dictionary <InputPort, Port>(); int index = 0; foreach (InputPort i in Enum.GetValues(typeof(InputPort))) { Ports[i] = new Port { InputPort = i, Index = index++, Name = i.ToString(), }; } }
public MicrophoneHandler( Config.BotConfiguration botConfig, ICommunication communication) { this.communication = communication; this.botConfig = botConfig; }
private static void CircleMovementWithAbsolutePosition(ICommunication communication, bool debug) { var panTiltControl = new EneoPanTiltControl(communication, debug); panTiltControl.Start(); panTiltControl.DisableLimit(); //var random = new Random(); for (var i = 0; i < 50; i++) { var positions = CalculatePolygon(i, new PointF(0, 0), 7); foreach (var position in positions) { panTiltControl.MovePanAbsolute(position.X); panTiltControl.MoveTiltAbsolute(position.Y); Thread.Sleep(40); } //panTiltControl.PanTiltAbsolute(0, 0); //panTiltControl.ComparePosition(new PanTiltPosition(0, 0), 0.5, 20, 200); } panTiltControl.EnableLimit(); panTiltControl.Dispose(); }
private static void TestPanMovementWithStartBeforeEndReached(ICommunication communication) { Console.WriteLine("Start"); var panTiltControl = new EneoPanTiltControl(communication); var positionChecker = new PositionChecker(panTiltControl); panTiltControl.PositionChanged += PanTiltControl_OnPositionChanged; while (true) { panTiltControl.PanAbsolute(0); positionChecker.ComparePosition(new PanTiltPosition(0, 0), 0.5, 20, 100); panTiltControl.PanAbsolute(40); positionChecker.ComparePosition(new PanTiltPosition(40, 0), 0.5, 20, 100); panTiltControl.PanRelative(-40); Thread.Sleep(500); panTiltControl.PanRelative(40); Thread.Sleep(500); panTiltControl.PanAbsolute(0); Console.WriteLine("Loop done"); } }
public static void Invoke(Command CommandType, ICommunication InvokeObject) { Type cmdResolveType = InvokeObject.GetType(); MethodInfo[] methods = cmdResolveType.GetMethods(); foreach (MethodInfo method in methods) { InvokeCommandAttribute attribute = null; object[] customAttributes = method.GetCustomAttributes(typeof(InvokeCommandAttribute), false); if (customAttributes != null && customAttributes.Length == 0) { continue; } attribute = customAttributes.First() as InvokeCommandAttribute; if (attribute != null && attribute.CommandType.Equals(CommandType)) { method.Invoke(InvokeObject, null); //CommandResolve cmdResolveObj = (CommandResolve)Activator.CreateInstance(typeof(CommandResolve), null); //method.Invoke(cmdResolveObj, null); break; } } }
private static byte[] SecureSendReceive(ICommunication com, byte[] sndBuffer, int expectedReceiveBytes) { try { return(SendReceive(com, sndBuffer, expectedReceiveBytes)); } catch (DeviceNotInitializedException) { if (TryWakeupToRetryCommand(com)) { return(SendReceive(com, sndBuffer, expectedReceiveBytes)); } throw; } catch (TimeoutException) { if (TryWakeupToRetryCommand(com)) { return(SendReceive(com, sndBuffer, expectedReceiveBytes)); } throw; } }
public CommunicationReceiveEventArgs(ICommunication communication, Guid dataID, int dataLength, byte[] head) : base(communication) { this.DataID = dataID; this.DataLength = dataLength; this.Head = head; Handled = false; }
public CaptureDataViewModel(ICommunication communication, IRegionManager regionManager, IEventAggregator eventAggregator) : base(regionManager, eventAggregator) { this.comm = communication; foreach (CaptureDataTypeE item in Enum.GetValues(typeof(CaptureDataTypeE))) { CaptureDataTypes.Add(new ComboBoxViewMode <CaptureDataTypeE> { Description = item.ToString(), SelectedModel = item, IsShow = Visibility.Visible }); } foreach (UInt32 item in new UInt32[] { 1, 5, 10, 20, 30, 50, 100, 200, 300, 1000 }) { if (item == 1000) { CaptureDataNums.Add(new ComboBoxViewMode <UInt32> { Description = "continue", SelectedModel = item, IsShow = Visibility.Visible }); } else { CaptureDataNums.Add(new ComboBoxViewMode <UInt32> { Description = item.ToString(), SelectedModel = item, IsShow = Visibility.Visible }); } } CaptureOkCmd = new DelegateCommand(CaptureOK); CaptureCancelCmd = new DelegateCommand(CaptureCancel); }
private void OnSearchAction(string obj, ICommunication communication) { if (isConnected) { _errorMsg = "Error: " + "This command does not exist or isn't enabled at this time"; return; } _OutputWrapper.WriteOutput(0, 1, "Searching...", ConsoleColor.DarkGray); if (isConnected) { return; } Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); _UdpListener.StartListening(); while (stopwatch.ElapsedMilliseconds < 10000) { if (_UdpListener._DataList.Count > 0) { communication.AddPackage(_UdpListener._DataList.First()); _UdpListener._DataList.RemoveAt(0); } } stopwatch.Stop(); _UdpListener.StopListening(); Searched = true; }
public CommunicationSendEventArgs(ICommunication communication, byte[] data, byte[] head) : base(communication) { DataID = Guid.NewGuid(); Data = data; Head = head; }
public static SubscriptionSetup <TMessage> SetupSubscription <TMessage>(ICommunication <TMessage> communication, IEnumerable <string> topics) where TMessage : IMessage { Enforce.NotNull(communication, nameof(communication)); return(new SubscriptionSetup <TMessage>(communication, topics)); }
public IndexModel(ICommunication communication, ICommonResource commonResource, IUserService userService) { /* For Profile */ _commonResource = commonResource; _communication = communication; _userService = userService; }
public void OnAcceptInfoAction(DataPackage data, ICommunication communication) { var accept = MapProtocolToDto <AcceptDTO>(data); _infoOutputView.ViewEnabled = true; _infoOutputView.SetUpdateContent(accept._smallUpdate); }
private async Task StartAgentCallAndTransferFlowAsync(ICommunication communication, string agent, string callContext) { IAudioVideoInvitation invite = await EstablishCallWithAgentAsync(communication, agent).ConfigureAwait(false); lock (m_syncRoot) { m_outboundAVConversations.Add(invite.RelatedConversation); } int result = Interlocked.Exchange(ref m_outboundCallTransferLock, 1); if (result == 0) { //Step 4: do transfer Logger.Instance.Information("[HuntGroupJob] Transferring call to " + agent); IAudioVideoCall av = invite.RelatedConversation.AudioVideoCall; ITransfer t = await av.TransferAsync(null, callContext, LoggingContext).ConfigureAwait(false); await t.WaitForTransferCompleteAsync().TimeoutAfterAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false); Logger.Instance.Information("[HuntGroupJob] Transfer completed successfully!"); } else { // The call is already accepted and transfered by some one else Logger.Instance.Information("[HuntGroupJob] The call is already accepted and transfered by some one else; cancelling the transfer for " + agent); await invite.RelatedConversation.DeleteAsync(LoggingContext).ConfigureAwait(false); } }
public AudioPlayer( Config.BotConfiguration botConfig, ICommunication communication) { this.communication = communication; defaultAudioDevice = botConfig.EffectOutputDevice; }
public ChatHub(ILogger <ChatHub> logger, IMessage messageService, ICommunication communicationService, ICommonResource commonResource) { _logger = logger; _messageService = messageService; _communicationService = communicationService; _commonResource = commonResource; }
public CustomSimpleCommands( ICommunication communication, IServiceScopeFactory scopeFactory) { this.communication = communication; this.scopeFactory = scopeFactory; }
/// <summary> /// Constructor for the Twitch_Helix api helper /// </summary> public HelixHelper( Config.IBotConfigContainer botConfigContainer, ICommunication communication) { this.communication = communication; botConfig = botConfigContainer.BotConfig; }
private static IChannel <StringMessage> Subscribe(ICommunication <StringMessage> communication, string clientName) { return(Scenarios.PubSub.SetupSubscription(communication, new[] { "topic" }) .UsingMessageReceivedHandler((sender, a) => { Console.WriteLine($"{clientName} received message: {a.Message}"); }) .UsingChannelClosedHandler((sender, args) => { Interlocked.Increment(ref _closedChannels); }) .Go()); }
//TODO: move to separate class {READY} public UserData GetInfoFromUser(TagType tag, Diff diff, IMp3File file, ICommunication communication) { communication.SendMessage($"File: {file.FilePath}"); communication.SendMessage($"There is a problem with tag \"{tag}\". "); communication.SendMessage( $"You can enter tag from: \n\t1) File name (Data: \"{diff.FileNameValue}\"), \n\t2) Mp3 Tags (Data: \"{diff.TagValue}\"), \n\t3) Manual"); while (true) { communication.SendMessage("Your choise (number): "); SyncActions inputData; var choiseCorrect = Enum.TryParse(communication.GetResponse(), out inputData); if (!choiseCorrect) { communication.SendMessage("Wrong input!"); communication.SendMessage("You sholud enter number with action!"); continue; } switch (inputData) { case SyncActions.FromFileName: return(new UserData(inputData, diff.FileNameValue)); case SyncActions.FromTags: return(new UserData(inputData, diff.TagValue)); case SyncActions.Manual: communication.SendMessage("Enter text for tag \"" + tag + "\""); return(new UserData(inputData, communication.GetResponse())); } } }
/// <summary> /// Constructor /// </summary> /// <param name="comm">Object implementing the <see cref="ICommunication"/> interface for talking to the brick</param> /// <param name="alwaysSendEvents">Send events when data changes, or at every poll</param> public Brick(ICommunication comm, bool alwaysSendEvents) { _directCommand = new DirectCommand(this); _systemCommand = new SystemCommand(this); _batchCommand = new Command(this); Buttons = new BrickButtons(); _alwaysSendEvents = alwaysSendEvents; int index = 0; _comm = comm; _comm.ReportReceived += ReportReceived; Ports = new Dictionary<InputPort,Port>(); foreach(InputPort i in Enum.GetValues(typeof(InputPort))) { Ports[i] = new Port { InputPort = i, Index = index++, Name = i.ToString(), }; } }
public void Initialize(ICommunication comm, IDictionary config) { _configuration = new CapiDeviceConfiguration(config); try { _capiApplication = new CapiApplication(); _capiApplication.IncomingPhysicalConnection += new EventHandler<IncomingPhysicalConnectionEventArgs>(_capiApplication_IncomingPhysicalConnection); foreach (Controller ctrl in _capiApplication.Controllers) { try { ctrl.Listen(CIPMask.Telephony | CIPMask.Telephony7KHZ | CIPMask.Audio7KHZ | CIPMask.Audio31KHZ); LogInfoEntry("Listening on '{0}'", ctrl); } catch (Exception ex) { LogErrorEntry("Error listening on '{0}': {1}", ctrl, ex); } } } catch (Exception ex) { _capiApplication = null; LogErrorEntry("Error on initializing: {0}", ex); } }
/// <summary> /// 创建通讯模块 /// </summary> /// <param name="communicationType">通讯方式</param> /// <returns></returns> public static ICommunication CreateCommunication(CommunicationType communicationType) { ICommunication communication = null; switch (communicationType) { case CommunicationType.C8962: communication = new C8962Communication(); break; case CommunicationType.socketClient: communication = new SocketTcpClientCommunication(); break; case CommunicationType.Http: communication = new HttpCommunication(); break; case CommunicationType.HongDian: throw new NotImplementedException("CommunicationType.HongDian 通讯方式暂时未实现"); //break; case CommunicationType.MAS: throw new NotImplementedException("CommunicationType.MAS 通讯方式暂时未实现"); //break; default: throw new NotImplementedException("未知通讯方式"); //break; } return(communication); }
//<Constructors> public Client(ICommunication communication) { _communication = communication; _ActionHanlder = new ProtocolAction(); _InputHandler = new InputAction(_ActionHanlder); _OutputWrapper = new OutputWrapper(); }
public Zone(ICommunication comm, int zoneNumber, ILogger logger) { this._comm = comm; this.Number = zoneNumber; this._logger = logger; this._comm.ReceivedDelimitedString += new EventHandler<ReceivedDelimitedStringEventArgs>(ReceivedDelimitedString); }
public PolishLinePlcLog(ICommunication client, ILogger logger) : base(client) { if (logger == null) throw new ArgumentNullException(string.Format("{0} wasn't initialized in class {1}.", typeof(ILogger).FullName, this.GetType().FullName)); _logger = logger; }
// //Constructors // /// <summary> /// Sets up a new client object communicating using the specified interface /// </summary> /// <param name="comms">The interface (implementing ICommunication) that will handle sending and recieving messages</param> public Client(ICommunication comms) { Logger.Log("New Client starting up."); Communications = comms; comms.Parent = this; comms.Recieved += RecieveMessage; comms.Failed += FailedMessage; }
public Mp3Syncing(IEnumerable<IMp3File> files, string mask, ICommunication communication, ISaver saver) { _files = files.ToArray(); _communication = communication; _mask = mask; _data = new List<KeyValuePair<string, KeyValuePair<string, Dictionary<TagType, string>>>>(); _saver = saver; }
private void OnTest(object sender, EventArgs e) { _comm = GetCommunication(_config.Node); _test = new LEDTest(2*_config.LEDsHeight + 2*_config.LEDsWidth); _timer.Elapsed += TimerOnElapsedTest; _timer.Start(); }
/// <summary> /// Constructor for Client UI object /// </summary> /// <param name="comms">The interface to bind communications to</param> public ClientUI(ICommunication comms) { InitializeComponent(); _client = new Client(comms); _client.ActionableMessageRecieved += MessageRecieved; _client.Communications.Failed += MessageSendFailed; _client.Communications.CharacterRecieved += Communications_CharacterRecieved; SendMessage += _client.SendMessage; }
/// <summary> /// Initializes a new instance of <see cref="Workspace"/> for a given <see cref="Token"/> with a given <see cref="ICommunication"/> /// </summary> /// <param name="token"><see cref="Token">Access token to use</see></param> /// <param name="communication"><see cref="ICommunication"/> to use</param> public Workspace(Token token, ICommunication communication) { _communication = communication; Groups = new Groups(token, communication); Datasets = new Datasets(token, communication); Tables = new Tables(token, communication); Rows = new Rows(token, communication); Dashboards = new Dashboards(token, communication); Reports = new Reports(token, communication); Tiles = new Tiles(token, communication); }
private void StartService() { host = new ServiceHost(this); host.Open(); channelFactory = new ChannelFactory<ICommunication>("ChatEndpoint"); _channel = channelFactory.CreateChannel(); //// Information to send to the channel //_channel.DisplayMessage(new SendEntity("Event", _myUserName + " has entered the conversation.")); //// Information to display locally //_displayMessageDelegate(new SendEntity("Info", "To change your name, type setname: NEW_NAME")); }
/// <summary> /// Initializes the modem /// </summary> /// <param name="comm"></param> /// <param name="config"></param> public void Initialize(ICommunication comm, IDictionary config) { _comm = comm; _config = config; _modemConfiguration = new AnalogATZModemConfiguration(config); _comm.OnDataReceived += new OnDataReceivedDelegate(_comm_OnDataReceived); if (TransmitCommand("ATZ") == false || TransmitCommand(_modemConfiguration.CommandInitializeCallerId) == false) { throw new Exception("Initialization of Telecom Device failed!"); } }
public NxtBrick(ICommunication channel) { this.channel = channel; this.channel.ResponseReceived += Channel_ResponseReceived; this.context = SynchronizationContext.Current; this.tokenSource = new CancellationTokenSource(); this.dataReceivedEvent = new ManualResetEvent(false); this.responses = new Queue<ResponseTelegram>(); this.channelMonitor = new SemaphoreSlim(1); this.connectionCommands = new ConnectionCommands(this); this.directCommands = new DirectCommands(this); this.systemCommands = new SystemCommands(this); this.sensors = new Dictionary<SensorPort, SensorBase>(); }
/// <summary> /// Initializes an instance of <see cref="Groups"/> /// </summary> /// <param name="token"><see cref="Token">Access token</see></param> /// <param name="communication"><see cref="ICommunication"/> for communicating with Power BI</param> public Groups(Token token, ICommunication communication) { _token = token; _communication = communication; }
private void OnStartStop(object sender, EventArgs e) { if (_timer.Enabled) { _timer.Stop(); List<Color> black = new List<Color>(_config.LEDsHeight*2 + _config.LEDsWidth*2); black.ForEach(x => x = Color.Black); _comm.Write(black, 0); } else { _capture = new Capture(_config); _comm = GetCommunication(_config.Node); if (_comm == null) { MessageBox.Show("Can't connect to AmbiBeam: " + _config.Node, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } _timer.Elapsed += timer_Tick;; _timer.Start(); } }
/// <summary> /// Initializes a new instance of <see cref="Reports"/> /// </summary> /// <param name="token"><see cref="Token">Access token</see></param> /// <param name="communication"><see cref="ICommunication"/> for communicating with Power BI</param> public Reports(Token token, ICommunication communication) { _token = token; _communication = communication; }
/// <summary> /// Initializes a new instance of <see cref="Tiles"/> /// </summary> /// <param name="token"><see cref="Token">Access token</see></param> /// <param name="communication"><see cref="ICommunication"/> for communicating with Power BI</param> public Tiles(Token token, ICommunication communication) { _token = token; _communication = communication; }
internal ControlAE6MC(ICommunication communication) { var enumerable = Enumerable.Range(1, AE6MC.NumberOfZones); this.communication = communication; }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> /// <param name="disposing"> /// <c>True</c>, if the method is called directly from user code or /// <c>false</c>, if the method is called from inside the finalizer. /// </param> /// <remarks> /// This method executes in two distinct scenarios. /// If <paramref name="disposing"/> equals <c>true</c>, the method has been called /// directly or indirectly by a user's code. /// Managed and unmanaged resources can be disposed. /// If <paramref name="disposing"/> equals <c>false</c>, the method has been called /// by the runtime from inside the finalizer and you should not reference other objects. /// Only unmanaged resources can be disposed. /// </remarks> private void Dispose(bool disposing) { if( !this.disposed ) { if( disposing ) { // Dispose managed resources. if (null != this.channel) { Task.Run(() => this.channel.DisconnectAsync()); this.channel = null; } if(null != this.tokenSource) { this.tokenSource.Cancel(); this.tokenSource.Dispose(); } if (null != this.channelMonitor) this.channelMonitor.Dispose(); if(null != this.dataReceivedEvent) { this.dataReceivedEvent.Dispose(); } } // Free native resources here if necessary. // Disposing has been done. this.disposed = true; } }
public ReadUntillEndRecieved(ICommunication lineReader) { _lineReader = lineReader; }
/// <summary> /// Constructor /// </summary> /// <param name="comm">Object implementing the <see cref="ICommunication"/> interface for talking to the brick</param> public Brick(ICommunication comm) : this(comm, false) { }
public StockerPlc(ICommunication client) : base(client) { }
public WyzComm(ICommunication comm, IAnalyzerCollection result) { }
public PolishLinePlc(ICommunication client) : base(client) { }
public void SaveClient() { //communication.username communication = new MysqlCommunication(); communication.Connect("dsafdsa"); }
/// <summary> /// Initializes an instance of <see cref="Dashboards"/> /// </summary> /// <param name="token"><see cref="Token">Access token</see></param> /// <param name="communication"><see cref="ICommunication"/> for communicating with Power BI</param> public Dashboards(Token token, ICommunication communication) { _token = token; _communication = communication; }
private void Form1_FormClosed(object sender, FormClosedEventArgs e) { if (_comm != null) { _comm.Dispose(); _comm = null; } }
public MountPlc(ICommunication client) : base(client) { }
private void SimpleComm_Transfer(ICommunication source, ICommunication sink, string identifier) { AutoResetEvent syncSrc = new AutoResetEvent(false); AutoResetEvent syncSink = new AutoResetEvent(false); source.OnDataReceived += (OnDataReceivedDelegate)delegate(byte[] data, int length) { Console.WriteLine("{0} SOURCE received: {1}", identifier, Encoding.Default.GetString(data, 0, length)); }; sink.OnDataReceived += (OnDataReceivedDelegate)delegate(byte[] data, int length) { Console.WriteLine("{0} SINK received: {1}", identifier, Encoding.Default.GetString(data, 0, length)); }; //Src thread ThreadPool.QueueUserWorkItem( (WaitCallback)delegate(object state) { for (int i = 0; i < 1000; i++) { byte[] b = Encoding.ASCII.GetBytes(string.Format("Hello from source: {0}", i)); source.SendData(b, 0, b.Length); Thread.Sleep(20); } syncSrc.Set(); }); //Sink thread ThreadPool.QueueUserWorkItem( (WaitCallback)delegate(object state) { for (int i = 0; i < 1000; i++) { byte[] b = Encoding.ASCII.GetBytes(string.Format("Hello from sink: {0}", i)); sink.SendData(b, 0, b.Length); Thread.Sleep(30); } syncSink.Set(); }); syncSrc.WaitOne(); syncSink.WaitOne(); }