public void ChangeChannelTest() { bool waiting = true; const string channel1 = "channel1"; const string channel2 = "channel2"; const string channel3 = "channel3"; const string message = "message"; ITransmitter <string> stringTransmitter = StringChannel.CreateTransmitter(channel1); IReceiver <string> stringReceiver = StringChannel.CreateReceiver(channel2); stringReceiver.Received += (sender, args) => { waiting = false; }; stringTransmitter.Send(message); Thread.Sleep(200); Assert.IsNull(stringReceiver.LastMessage); stringTransmitter.SetChannel(channel3); stringReceiver.SetChannel(channel3); stringTransmitter.Send(message); while (waiting) { Thread.Sleep(200); } Assert.IsNotNull(stringReceiver.LastMessage); }
internal AzureMonitorLogExporter(AzureMonitorExporterOptions options, ITransmitter transmitter) { _options = options ?? throw new ArgumentNullException(nameof(options)); ConnectionString.ConnectionStringParser.GetValues(_options.ConnectionString, out _instrumentationKey, out _); _transmitter = transmitter; _resourceParser = new ResourceParser(); }
public void TransmitterCreationTest() { const string channelName = "channel"; ITransmitter <string> stringTransmitter = StringChannel.CreateTransmitter(channelName); Assert.AreEqual(channelName, stringTransmitter.Channel.ChannelName); }
private ITransmitter GetLoggableTransmitter() { ILogger logger = GetLogger(); ITransmitter transmitter = GetTransmitter(); return(new LoggableTransmitter(logger, transmitter)); }
private static void RunMPC(ITransmitter transmitter, IGoalUtilizer utilizer) { utilizer.Reset(); var generator = new GoalGenerator(); IList <Producer> producers = new List <Producer>() { new Producer(generator, transmitter) }; IList <Consumer> consumers = new List <Consumer>(); consumers.Add(new Consumer(utilizer, transmitter)); consumers.Add(new Consumer(utilizer, transmitter)); consumers.Add(new Consumer(utilizer, transmitter)); GoalManager manager = new GoalManager(producers, consumers); Stopwatch stopWatchBody = new Stopwatch(); stopWatchBody.Start(); manager.Run(); Thread.Sleep(5000);//22 000 000 manager.Stop(); stopWatchBody.Stop(); string elapsedTimeBody = ConvertTSToString(stopWatchBody.Elapsed); Stopwatch stopWatchFinish = new Stopwatch(); stopWatchFinish.Start(); var isOk = utilizer.WasUtilizeSuccessful(); stopWatchFinish.Stop(); string elapsedTimeFinish = ConvertTSToString(stopWatchFinish.Elapsed); Console.WriteLine($"{transmitter.GetType().Name.PadRight(30)} isOk {isOk} nGoals: {generator.Counter} BodyTime: {elapsedTimeBody} FinishTime: {elapsedTimeFinish}"); }
public Producer(ITransmitter transmitter, long maxValue, int nConsumer) { _transmitter = transmitter; _maxValue = maxValue; _nConsumer = nConsumer; _thread = new Thread(GenerateGoals); }
public aHandControllerForm() { InitializeComponent(); this.CommandEncoder = new Encoder(); this.CommandTransmitter = new SerialTransmitter(); this.ContinuousRotationCommandFrequency = 500; }
public StockProcessor() { this._container = UnityHelper.GetContainer(); this._receiver = this._container.Resolve <IReceiver <Stock> >(); this._transmitter = this._container.Resolve <ITransmitter <Stock> >(); }
internal AzureMonitorTraceExporter(AzureMonitorExporterOptions options, ITransmitter transmitter) { this.options = options ?? throw new ArgumentNullException(nameof(options)); ConnectionString.ConnectionStringParser.GetValues(this.options.ConnectionString, out this.instrumentationKey, out _); this.Transmitter = transmitter; }
public void TransmitMessageToMultipleReceiverTest() { bool rcv1Waiting = true; bool rcv2Waiting = true; const string channel = "channel"; const string message = "message"; ITransmitter <string> stringTransmitter = StringChannel.CreateTransmitter(channel); IReceiver <string> receiver1 = StringChannel.CreateReceiver(channel); IReceiver <string> receiver2 = StringChannel.CreateReceiver(channel); receiver1.Received += (sender, args) => { Assert.AreEqual(channel, args.Channel.ChannelName); rcv1Waiting = false; }; receiver2.Received += (sender, args) => { Assert.AreEqual(channel, args.Channel.ChannelName); rcv2Waiting = false; }; stringTransmitter.Send(message); while (rcv1Waiting && rcv2Waiting) { Thread.Sleep(200); } Assert.AreEqual(message, receiver1.LastMessage); Assert.AreEqual(message, receiver2.LastMessage); }
public Consumer(ITransmitter transmitter, AutoResetEvent waitHandle) { Goals = new List <long>(); _transmitter = transmitter; _waitHandle = waitHandle; _thread = new Thread(ProcessGoals); }
private void Connect(Neuron n, ITransmitter input) { n.AddInput(input, rnd.NextDouble()); if (input is Neuron) { ((Neuron)input).AddOutput(n); } }
public override void Run() { base.Run(); Message message = GetMessage(); ITransmitter transmitter = GetLoggableTransmitter(); transmitter.Send(message.GetStream()); var stream = transmitter.Recieve(); }
public bool UpdateWeight(ITransmitter input, double newWeight) { if (!InputExists(input)) { return(false); } Weights[input.ID] = newWeight; return(true); }
public bool AddInput(ITransmitter input, double weight) { if (InputExists(input)) { return(false); } Inputs.Add(input); return(UpdateWeight(input, weight)); }
public DefaultTransmissionService( TransmissionRequestFactory transmissionRequestFactory, ITransmitter transmitter, Trace tracer) : base(tracer) { this.transmissionRequestFactory = transmissionRequestFactory; this.transmitter = transmitter; }
internal void TransmitPermanentAppearance(ITransmitter <IEnumerable <Packet> > transmitter, long oldPAVersion) { if (Station.paEnumerable == null) { Station.paEnumerable = new Station.PAEnumerable(); } Station.paEnumerable.Reset(this.paHistory, oldPAVersion); transmitter.Transmit(Station.paEnumerable); }
public void Receive(ITransmitter t) { RecieveCounter++; Value += t.Value * Weights[t.ID]; if (RecieveCounter >= Inputs.Count) { Transmit(); } }
internal void TransmitInstantDisappearance(ITransmitter <IEnumerable <Packet> > transmitter) { if (Station.paListEnumerable == null) { Station.paListEnumerable = new Station.PAListEnumerable(); } Station.paListEnumerable.Reset(this.firstElement, false); transmitter.Transmit(Station.paListEnumerable); }
public ApiController(ITransmitter transmitter, IAppSetting appSetting, IAuthenticateUtil authenticateUtil, ICacheMemory cacheMemory, IAuthenticateUser authenticateService) { _transmitter = transmitter; _appSetting = appSetting; _authenticateUtil = authenticateUtil; _cacheMemory = cacheMemory; _authenticateService = authenticateService; }
internal AzureMonitorTraceExporter(AzureMonitorExporterOptions options, ITransmitter transmitter) { _options = options ?? throw new ArgumentNullException(nameof(options)); ConnectionString.ConnectionStringParser.GetValues(_options.ConnectionString, out _instrumentationKey, out _); _transmitter = transmitter; _resourceParser = new ResourceParser(); // Todo: Add check if offline storage is enabled by user via options _storageTransmissionEvaluator = new StorageTransmissionEvaluator(StorageTransmissionEvaluatorSampleSize); }
public PayloadProcessorBase(IRadioObject payload, IEnvironment env, ILog log, IEnumerable <MototrboRadio> radios, ITransmitter transmitter, IUIDispatcher uiDispatcher) { _env = env; _log = log; _radios = radios; _transmitter = transmitter; _uiDispatcher = uiDispatcher; rxObject = payload; _radio = GetRadio(payload.Ip); }
internal AzureMonitorLogExporter(ITransmitter transmitter) { _transmitter = transmitter; _instrumentationKey = transmitter.InstrumentationKey; _resourceParser = new ResourceParser(); if (transmitter is AzureMonitorTransmitter _azureMonitorTransmitter && _azureMonitorTransmitter._storage != null) { _persistentStorage = new AzureMonitorPersistentStorage(transmitter); } }
public IDisposable Subscribe(IObserver <Thermometer> transmitter) { ITransmitter <Thermometer> thermoObserver = transmitter as ITransmitter <Thermometer>; if (!transmitters.Contains(thermoObserver)) { transmitters.Add(thermoObserver); } return(new Unsubscriber(transmitters, thermoObserver)); }
public RxProcessor(IEnvironment env, ILog log, IEventAggregator aggregator, IEnumerable <MototrboRadio> radios, ITransmitter transmitter, IUIDispatcher uiDispatcher) { _env = env; _log = log; _aggregator = aggregator; _radios = radios; _transmitter = transmitter; _uiDispatcher = uiDispatcher; _receiverQueue = new ConcurrentQueue <RxObject>(); _rxPoolThread = new Thread(new ThreadStart(Process)); }
public Station( Constants.StationId stationType, ITransmitter transmitter, int bufferSize, int timeoutInMs, bool detectionOnly, FileStream inputFileStream, FileStream outputFileStream, Constants.ShowFrameDelegate sendFrame) { this.StationId = stationType; this.transmitter = transmitter; this.BufferSize = bufferSize; InputBuffer = new Dictionary <int, Frame>(); OutputBuffer = new Dictionary <int, Frame>(); this.TimeoutInMs = timeoutInMs; this.CorrectionMode = detectionOnly ? HammingHelper.Mode.DETECT : HammingHelper.Mode.CORRECT; this.inputFileStream = inputFileStream; this.outputFileStream = outputFileStream; this.sendFrameDelegate = sendFrame; StopExecution = false; ExecutionStopped = new ManualResetEvent(false); // Initialize constants int frameSizeBeforeHamming = HammingHelper.GetDataSize(Constants.FrameSize * 8) / 8; int realBitCount = HammingHelper.GetTotalSize(frameSizeBeforeHamming * 8); EncodedFramePadding = Constants.FrameSize * 8 - realBitCount; int frameHeaderSize = Frame.HeaderSize(); DataSizeInFrame = frameSizeBeforeHamming - frameHeaderSize; MaxSequence = (UInt16)(bufferSize * 2 - 1); // Initialize fields FirstFrameSent = 0; NextFrameToSendSequenceNumber = 0; NextFrameToReceive = 0; // Since frames cannot use MaxSequence as a sequence number, we use it for LastFrameSequenceNumberForNak. // This is meant to ensure that no Frame matches this field if there was no Nak sent. LastFrameSequenceNumberForNak = MaxSequence; // Initialise ack timer logic AckTimer = new System.Timers.Timer(AckTimeout); // When the timer ends, we need to inform the program that we need to send an Ack now. Also stop the timer. AckTimer.Elapsed += (sender, e) => { sendAck = true; AckTimer.Stop(); Console.WriteLine("ack timer elapsed"); }; sendAck = false; HighPriorityFrames = new Queue <Frame>(); TimeoutTimers = new ConcurrentDictionary <UInt16, System.Timers.Timer>(); }
/// <summary> /// The main program /// </summary> /// <param name="argv">The command line arguments</param> static async Task Run(Service service) { Console.WriteLine("Login as " + SdkHelper.Splunk.Username); await service.LogOnAsync(SdkHelper.Splunk.Username, SdkHelper.Splunk.Password); Console.WriteLine("Create an index"); string indexName = "user-index"; Index index = await service.Indexes.GetOrNullAsync(indexName); if (index != null) { await index.RemoveAsync(); } index = await service.Indexes.CreateAsync(indexName); Exception exception = null; try { await index.EnableAsync(); ITransmitter transmitter = service.Transmitter; SearchResult result; result = await transmitter.SendAsync("Hello World.", indexName); result = await transmitter.SendAsync("Goodbye world.", indexName); using (var results = await service.SearchOneShotAsync(string.Format("search index={0}", indexName))) { foreach (SearchResult task in results) { Console.WriteLine(task); } } } catch (Exception e) { exception = e; } await index.RemoveAsync(); if (exception != null) { throw exception; } }
public ServerManager(IEnvironment env, ILog logger, IEventAggregator aggregator, IEnumerable<MototrboRadio> radios, ILog consoleLog) { _env = env; _log = logger; _aggregator = aggregator; _radios = radios; _consoleLog = consoleLog; _transmitter = new Transmiter(_env, _log, _aggregator, _consoleLog); _uiDispatcher = new UIDispatcher(_env, _log, _aggregator); _rxProcessor = new RxProcessor(_env, _log, _aggregator, _radios, _transmitter, _uiDispatcher); _serviceList = new Dictionary<int, IReceiver>(); }
public void Dispose() { try { this.Transmitter.Dispose(); } catch { } finally { this.Transmitter = null; } }
public static void SetupCancelHandler(ImuseEngine engine, ITransmitter transmitter) { // Clean up, even with Ctrl+C cancelHandler = new ConsoleCancelEventHandler((sender, e) => { logger.Warning("Abrupt exit - trying to clean up..."); engine.Dispose(); if (transmitter is IDisposable disposableTransmitter) { disposableTransmitter.Dispose(); } }); Console.CancelKeyPress += cancelHandler; }
public void disconnectFromTransmitter() { try { if (null == getMyDriver()) return; } catch (cantOpenPortException) { return; } _mydriver.Dispose(); _mydriver = null; _nodes.Clear(); lstNodes.Clear(); clearNodeInfoPanel(); MessageBox.Show("Port closed."); generalToolStripMenuItem.Enabled = true; }
public Node(ITransmitter driver, Int16 newid) { id = newid; Mydriver = driver; fillProperties(); }
//Start OSC transmitter private void btnStartOSCTrans_Click(object sender, RoutedEventArgs e) { //Get the transport type if ((string)cmbbOSCTransType.SelectedItem == UDP_STRING) { transmitter_ipendpoint = new IPEndPoint(IPAddress.Parse(txtOSCTransIP.Text), Convert.ToInt32(txtOSCTransPort.Text)); osc_transmitter = new UdpTransmitter(transmitter_ipendpoint); } else if ((string)cmbbOSCTransType.SelectedItem == TCP_STRING) { transmitter_ipendpoint = new IPEndPoint(IPAddress.Parse(txtOSCTransIP.Text), Convert.ToInt32(txtOSCTransPort.Text)); osc_transmitter = new TcpTransmitter(transmitter_ipendpoint); } else { //Do nothing Debug.WriteLine("Transmitter transport type not recognized."); return; } //osc_transmitter.Start(bundle); btnStartOSCTrans.IsEnabled = false; cmbbOSCTransType.IsEnabled = false; txtOSCTransIP.IsEnabled = false; txtOSCTransPort.IsEnabled = false; }
public void setMyDriver(ITransmitter toThis) { _mydriver = toThis; }
public ITransmitter getMyDriver() { if ( (null == _mydriver) || (!_mydriver.portOpen()) ) { DialogResult response = MessageBox.Show("To do this, the transmitter must be connected. Connect to transmitter now?", "Connect to transmitter?", MessageBoxButtons.YesNo); if ((response == DialogResult.No) || (response == DialogResult.None)) throw new cantOpenPortException(); _mydriver = new _transmitter(_myOptions.portname, _myOptions.useEncryption, _myOptions.myKey.keyArray); generalToolStripMenuItem.Enabled = false; } return _mydriver; }