protected virtual void WriteStimulus(Epoch e, IExternalDevice ed, IStimulus s) { // write s.StimulusID Console.WriteLine("Epoch stimulus id {0} for device {1}", s.StimulusID, ed.Name); WriteStimulusParameters(e, ed, s, s.Parameters); }
/// <summary> /// Inform this Controller that the output pipeline send output data "to the wire". /// </summary> /// <param name="device">ExternalDevice that output the data</param> /// <param name="outputTime">Approximate time the data was sent to the wire</param> /// <param name="duration">Duration of the data block send to the wire</param> /// <param name="configuration">Pipeline node configuration(s) for the output pipeline that processed the outgoing data</param> public virtual void DidOutputData(IExternalDevice device, DateTimeOffset outputTime, TimeSpan duration, IEnumerable <IPipelineNodeConfiguration> configuration) { //virtual for Moq if (CurrentEpoch != null && !CurrentEpoch.IsComplete) { CurrentEpoch.DidOutputData(device, outputTime, duration, configuration); } }
/// <summary> /// Removes the given ExternalDevice from this stream. /// </summary> /// <param name="device">Device to remove</param> public void RemoveDevice(ExternalDeviceBase device) { if (Device == device) { Device.UnbindStream(Name); Device = null; } }
protected virtual void WriteStimulusParameters(Epoch e, IExternalDevice ed, IStimulus s, IDictionary <string, object> p) { foreach (var k in s.Parameters.Keys) { var v = s.Parameters[k]; WriteStimulusParameter(e, ed, s, k, v); } }
/// <summary> /// Pulls IOutputData from the current Epoch destined for a given external deivce. /// Result will have duration greater than zero, but may not equal the requested duration. /// </summary> /// <param name="device">ExternalDevice for this outputdata</param> /// <param name="duration">Duration of the data requested</param> /// <returns>Output data for the requested device</returns> public virtual IOutputData PullOutputData(IExternalDevice device, TimeSpan duration) { if (CurrentEpoch == null) { return(null); } return(CurrentEpoch.PullOutputData(device, duration)); }
/// <summary> /// Add an ExternalDevice to the Controller; take care of performing /// whatever wiring up between the Controller and the ExternalDevice /// needs to be done, as well. /// </summary> /// <param name="dev">The ExternalDevice to wire up</param> /// <exception cref="InvalidOperationException">This controller already has a device with the same name.</exception> /// <returns>This instance, for fluent-style API calls</returns> public Controller AddDevice(IExternalDevice dev) { if (Devices.Where(d => d.Name == dev.Name).Any()) { throw new InvalidOperationException("Device with name " + dev.Name + " already exists."); } Devices.Add(dev); dev.Controller = this; return(this); }
public void SetUp() { device = new UnitConvertingExternalDevice("dev", "man", new Measurement(1, "V")) { OutputSampleRate = new Measurement(10000, "Hz") }; stream = new DeviceBackgroundOutputDataStream(device, Option<TimeSpan>.Some(TimeSpan.FromSeconds(0.97))); indefiniteStream = new DeviceBackgroundOutputDataStream(device); }
protected override void WriteStimulus(Epoch e, IExternalDevice ed, IStimulus s) { writer.WriteStartElement("stimulus"); writer.WriteAttributeString("device", ed.Name); writer.WriteAttributeString("stimulusID", s.StimulusID); writer.WriteAttributeString("stimulusUnits", s.Units); WriteDictionary("parameters", s.Parameters); WriteStimulusConfigurationSpans(s); writer.WriteEndElement(); }
protected override void WriteBackgroundElement(Epoch e, IExternalDevice ed, Epoch.EpochBackground bg) { writer.WriteStartElement(ed.Name); writer.WriteStartElement("backgroundMeasurement"); WriteMeasurement(bg.Background); writer.WriteEndElement(); writer.WriteStartElement("sampleRate"); WriteMeasurement(bg.SampleRate); writer.WriteEndElement(); writer.WriteEndElement(); }
/// <summary> /// Informs this Epoch that stimulus data was output by the Symphony.Core output pipeline. /// </summary> /// <param name="device">ExternalDevice that was the target of the output data</param> /// <param name="outputTime">Approximate time the data was written "to the wire"</param> /// <param name="duration">Duration of the output data segment</param> /// <param name="configuration">Pipeline node configuration(s) for nodes that processed the outgoing data</param> public virtual void DidOutputData(IExternalDevice device, DateTimeOffset outputTime, TimeSpan duration, IEnumerable <IPipelineNodeConfiguration> configuration) { //virtual so that we can mock it if (outputTime < StartTime) { throw new ArgumentException("Data output time must be after Epoch start time", "outputTime"); } if (Stimuli.ContainsKey(device)) { Stimuli[device].DidOutputData(duration, configuration); } }
protected override void WriteResponse(Epoch e, IExternalDevice ed, Response r) { writer.WriteStartElement("response"); writer.WriteAttributeString("device", ed.Name); writer.WriteElementString("inputTime", r.DataSegments.First().InputTime.ToUniversalTime().ToString()); writer.WriteStartElement("sampleRate"); WriteMeasurement(r.SampleRate); writer.WriteEndElement(); WriteResponseConfigurationSpans(r); WriteResponseData(r); writer.WriteEndElement(); }
private IOutputData BackgroundDataForDevice(IExternalDevice dev, TimeSpan blockDuration) { //log.DebugFormat("Presenting Epoch background for {0}.", dev.Name); if (!Background.ContainsKey(dev)) { throw new ArgumentException("Epoch does not have a stimulus or background for " + dev.Name); } //Calculate background var srate = Background[dev].SampleRate; var value = Background[dev].Background; IOutputData result = new OutputData(ConstantMeasurementList(blockDuration, srate, value), srate, false); return(result); }
private ExtdevMeasurementT Convert(IExternalDevice ed, IMeasurement m) { ExtdevMeasurementT emt = new ExtdevMeasurementT(); byte[] edNameData = System.Text.Encoding.UTF8.GetBytes(ed.Name); if (edNameData.Length > FIXED_STRING_LENGTH) { throw new InvalidOperationException("External device name is longer than 40 characters."); } unsafe { for (int i = 0; i < Math.Min(edNameData.Length, FIXED_STRING_LENGTH); i++) { emt.extDeviceName[i] = edNameData[i]; } } emt.measurement = Convert(m); return(emt); }
/// <summary> /// Pulls output data from the given device of the given duration. /// <para>If the given device has an associated Stimulus in this.Stimuli, /// the data is pulled from that Stimulus. If there is no associated Stimulus, /// data is generated according to this.Background[dev].</para> /// </summary> /// <param name="dev">Output device requesting data</param> /// <param name="blockDuration">Requested duration of the IOutputData</param> /// <returns>IOutputData intsance with duration less than or equal to blockDuration</returns> public IOutputData PullOutputData(IExternalDevice dev, TimeSpan blockDuration) { if (Stimuli.ContainsKey(dev)) { var blockIter = StimulusDataEnumerators.GetOrAdd(dev, (d) => Stimuli[d].DataBlocks(blockDuration).GetEnumerator() ); IOutputData stimData = null; while (stimData == null || stimData.Duration < blockDuration) { if (!blockIter.MoveNext()) { break; } stimData = stimData == null ? blockIter.Current : stimData.Concat(blockIter.Current); } if (stimData == null) { return(BackgroundDataForDevice(dev, blockDuration)); } if (stimData.Duration < blockDuration) { var remainingDuration = blockDuration - stimData.Duration; stimData = stimData.Concat(BackgroundDataForDevice(dev, remainingDuration)); } return(stimData); } log.DebugFormat("Will send background for device {0} ({1})", dev.Name, blockDuration); return(BackgroundDataForDevice(dev, blockDuration)); }
private ExtdevBackgroundMeasurementT Convert(IExternalDevice ed, IMeasurement bg, IMeasurement sampleRate) { var result = new ExtdevBackgroundMeasurementT(); byte[] edNameData = System.Text.Encoding.UTF8.GetBytes(ed.Name); if (edNameData.Length > FIXED_STRING_LENGTH) { throw new InvalidOperationException("External device name is longer than 40 characters."); } unsafe { for (int i = 0; i < Math.Min(edNameData.Length, FIXED_STRING_LENGTH); i++) { result.extDeviceName[i] = edNameData[i]; } } result.measurement = Convert(bg); result.sampleRate = Convert(sampleRate); return(result); }
private ExtdevMeasurementT Convert(IExternalDevice ed, IMeasurement m) { ExtdevMeasurementT emt = new ExtdevMeasurementT(); byte[] edNameData = System.Text.Encoding.UTF8.GetBytes(ed.Name); if (edNameData.Length > FIXED_STRING_LENGTH) throw new InvalidOperationException("External device name is longer than 40 characters."); unsafe { for (int i = 0; i < Math.Min(edNameData.Length, FIXED_STRING_LENGTH); i++) emt.extDeviceName[i] = edNameData[i]; } emt.measurement = Convert(m); return emt; }
private IOutputData BackgroundDataForDevice(IExternalDevice dev, TimeSpan blockDuration) { //log.DebugFormat("Presenting Epoch background for {0}.", dev.Name); if (!Background.ContainsKey(dev)) throw new ArgumentException("Epoch does not have a stimulus or background for " + dev.Name); //Calculate background var srate = Background[dev].SampleRate; var value = Background[dev].Background; IOutputData result = new OutputData(ConstantMeasurementList(blockDuration, srate, value), srate, false); return result; }
public void SetBackground(IExternalDevice dev, Measurement background, Measurement sampleRate) { Background[dev] = new EpochBackground(background, sampleRate); }
/// <summary> /// Pulls output data from the given device of the given duration. /// <para>If the given device has an associated Stimulus in this.Stimuli, /// the data is pulled from that Stimulus. If there is no associated Stimulus, /// data is generated according to this.Background[dev].</para> /// </summary> /// <param name="dev">Output device requesting data</param> /// <param name="blockDuration">Requested duration of the IOutputData</param> /// <returns>IOutputData intsance with duration less than or equal to blockDuration</returns> public IOutputData PullOutputData(IExternalDevice dev, TimeSpan blockDuration) { if (Stimuli.ContainsKey(dev)) { var blockIter = StimulusDataEnumerators.GetOrAdd(dev, (d) => Stimuli[d].DataBlocks(blockDuration).GetEnumerator() ); IOutputData stimData = null; while (stimData == null || stimData.Duration < blockDuration) { if (!blockIter.MoveNext()) { break; } stimData = stimData == null ? blockIter.Current : stimData.Concat(blockIter.Current); } if (stimData == null) { return BackgroundDataForDevice(dev, blockDuration); } if (stimData.Duration < blockDuration) { var remainingDuration = blockDuration - stimData.Duration; stimData = stimData.Concat(BackgroundDataForDevice(dev, remainingDuration)); } return stimData; } log.DebugFormat("Will send background for device {0} ({1})", dev.Name, blockDuration); return BackgroundDataForDevice(dev, blockDuration); }
protected virtual void WriteStimulusParameters(Epoch e, IExternalDevice ed, IStimulus s, IDictionary<string, object> p) { foreach (var k in s.Parameters.Keys) { var v = s.Parameters[k]; WriteStimulusParameter(e, ed, s, k, v); } }
private void CheckTemperature(IExternalDevice device, float temperature) { if (temperatureController.ShouldEnableCooling(temperature)) { EnableCooling(); } else { DisableCooling(); } }
/// <summary> /// Constructs an output data stream with the given Device, of a given duration. /// </summary> /// <param name="device"></param> /// <param name="duration">Duration of stream</param> public DeviceBackgroundOutputDataStream(IExternalDevice device, Option<TimeSpan> duration) { if (device == null) throw new ArgumentNullException("device"); if (duration == null) throw new ArgumentNullException("duration"); Device = device; Duration = duration; Position = TimeSpan.Zero; OutputPosition = TimeSpan.Zero; }
protected virtual void WriteResponse(Epoch e, IExternalDevice ed, Response r) { // write r.Data }
public void AddExternalDevice(IExternalDevice externalDevice) { lock (syncObject) { externalDevice.DataReceived += new EventHandler(device_DataReceived); externalDevices.Add(externalDevice); } }
protected virtual void WriteStimulusParameter(Epoch e, IExternalDevice ed, IStimulus s, string k, object v) { Console.WriteLine("Epoch stimulus parameter {0}={1}", k, v); }
private ExtdevBackgroundMeasurementT Convert(IExternalDevice ed, IMeasurement bg, IMeasurement sampleRate) { var result = new ExtdevBackgroundMeasurementT(); byte[] edNameData = System.Text.Encoding.UTF8.GetBytes(ed.Name); if (edNameData.Length > FIXED_STRING_LENGTH) throw new InvalidOperationException("External device name is longer than 40 characters."); unsafe { for (int i = 0; i < Math.Min(edNameData.Length, FIXED_STRING_LENGTH); i++) result.extDeviceName[i] = edNameData[i]; } result.measurement = Convert(bg); result.sampleRate = Convert(sampleRate); return result; }
/// <summary> /// Constructs an output data stream with the given Device, of indefinite duration. /// </summary> /// <param name="device"></param> public DeviceBackgroundOutputDataStream(IExternalDevice device) : this(device, Option<TimeSpan>.None()) { }
protected virtual void WriteBackgroundElement(Epoch e, IExternalDevice ed, Epoch.EpochBackground bg) { Console.WriteLine("Epoch background element for device {0} for measurement {1}, samplerate {2}", ed.Name, bg.Background.ToString(), bg.SampleRate.ToString()); }
public void SetBackground(IExternalDevice dev, IMeasurement background, IMeasurement sampleRate) { Backgrounds[dev] = new Background(background, sampleRate); }
private static Controller SetupController(double sampleRate, out Epoch e, out IExternalDevice dev0, out RenderedStimulus stim1, out IExternalDevice dev1, out RenderedStimulus stim2, out IList <IMeasurement> stimData, int nChannels) { Converters.Clear(); Converters.Register("V", "V", // just an identity conversion for now, to pass Validate() (IMeasurement m) => m); var streamNameMap = new Dictionary <string, string>(); streamNameMap["Out0"] = "In0"; if (nChannels > 1) { streamNameMap["Out1"] = "In1"; } Controller controller = new Parser().ParseConfiguration(Resources.LowGainConfig); var daq = (SimulationDAQController)controller.DAQController; daq.Clock = daq; foreach (var stream in daq.Streams) { stream.SampleRate = new Measurement((decimal)sampleRate, "Hz"); } daq.SimulationRunner += (output, timestep) => { var input = new ConcurrentDictionary <IDAQInputStream, IInputData>(); Parallel.ForEach(output, (kv) => { var outData = kv.Value; var outStream = kv.Key; var inStream = daq.InputStreams.Where((s) => s.Name == streamNameMap[outStream.Name]).First(); var data = outData.DataWithUnits("V").Data; var inData = new InputData(data, outData.SampleRate, DateTimeOffset.Now) .DataWithNodeConfiguration("SimulationController", daq.Configuration); input[inStream] = inData; } ); return(input); }; var protocolParams = new Dictionary <string, object>(1); protocolParams["key1"] = "value1"; e = new Epoch("LowGainSimulation", protocolParams); dev0 = controller.GetDevice("Device0"); dev1 = controller.GetDevice("Device1"); if (nChannels == 1) { dev1.UnbindStream(dev1.Streams.Values.First().Name); } stimData = Enumerable.Range(0, (int)(10 * sampleRate)) .Select(i => new Measurement(i, -3, "V") as IMeasurement) .ToList(); var srate = new Measurement((decimal)sampleRate, "Hz"); stim1 = new RenderedStimulus((string)"RenderedStimulus", (IDictionary <string, object>) new Dictionary <string, object>(), (IOutputData) new OutputData(stimData, srate, false)); stim2 = new RenderedStimulus((string)"RenderedStimulus", (IDictionary <string, object>) new Dictionary <string, object>(), (IOutputData) new OutputData(stimData, srate, false)); e.Stimuli[dev0] = stim1; if (nChannels > 1) { e.Stimuli[dev1] = stim2; } e.Responses[dev0] = new Response(); if (nChannels > 1) { e.Responses[dev1] = new Response(); } e.Background[dev1] = new Epoch.EpochBackground(new Measurement(0, "V"), srate); e.Background[dev0] = new Epoch.EpochBackground(new Measurement(0, "V"), srate); return(controller); }
private void GetTemperature(IExternalDevice device) { float temperature = device.ReadTemperature(); CurrentTemperature = temperature; temperatures.Add(temperature); }
/// <summary> /// Informs this Epoch that stimulus data was output by the Symphony.Core output pipeline. /// </summary> /// <param name="device">ExternalDevice that was the target of the output data</param> /// <param name="outputTime">Approximate time the data was written "to the wire"</param> /// <param name="duration">Duration of the output data segment</param> /// <param name="configuration">Pipeline node configuration(s) for nodes that processed the outgoing data</param> public virtual void DidOutputData(IExternalDevice device, DateTimeOffset outputTime, TimeSpan duration, IEnumerable<IPipelineNodeConfiguration> configuration) { //virtual so that we can mock it if (outputTime < StartTime) throw new ArgumentException("Data output time must be after Epoch start time", "outputTime"); if (Stimuli.ContainsKey(device)) Stimuli[device].DidOutputData(duration, configuration); }
public TimeStampedDeviceDataStreamEventArgs(IClock clock, IExternalDevice device, IIODataStream stream) : base(clock) { Device = device; Stream = stream; }
private static Controller SetupController(double sampleRate, out Epoch e, out IExternalDevice dev0, out RenderedStimulus stim1, out IExternalDevice dev1, out RenderedStimulus stim2, out IList<IMeasurement> stimData, int nChannels) { Converters.Clear(); Converters.Register("V", "V", // just an identity conversion for now, to pass Validate() (IMeasurement m) => m); var streamNameMap = new Dictionary<string, string>(); streamNameMap["Out0"] = "In0"; if (nChannels > 1) streamNameMap["Out1"] = "In1"; Controller controller = new Parser().ParseConfiguration(Resources.LowGainConfig); var daq = (SimulationDAQController)controller.DAQController; daq.Clock = daq; foreach (var stream in daq.Streams) { stream.SampleRate = new Measurement((decimal) sampleRate, "Hz"); } daq.SimulationRunner += (output, timestep) => { var input = new ConcurrentDictionary<IDAQInputStream, IInputData>(); Parallel.ForEach(output, (kv) => { var outData = kv.Value; var outStream = kv.Key; var inStream = daq.InputStreams.Where((s) => s.Name == streamNameMap[outStream.Name]).First(); var data = outData.DataWithUnits("V").Data; var inData = new InputData(data, outData.SampleRate, DateTimeOffset.Now) .DataWithNodeConfiguration("SimulationController",daq.Configuration); input[inStream] = inData; } ); return input; }; var protocolParams = new Dictionary<string, object>(1); protocolParams["key1"] = "value1"; e = new Epoch("LowGainSimulation", protocolParams); dev0 = controller.GetDevice("Device0"); dev1 = controller.GetDevice("Device1"); if (nChannels == 1) { dev1.UnbindStream(dev1.Streams.Values.First().Name); } stimData = Enumerable.Range(0, (int)(10 * sampleRate)) .Select(i => new Measurement(i, -3, "V") as IMeasurement) .ToList(); var srate = new Measurement((decimal) sampleRate, "Hz"); stim1 = new RenderedStimulus((string) "RenderedStimulus", (IDictionary<string, object>) new Dictionary<string, object>(), (IOutputData) new OutputData(stimData, srate, false)); stim2 = new RenderedStimulus((string) "RenderedStimulus", (IDictionary<string, object>) new Dictionary<string, object>(), (IOutputData) new OutputData(stimData, srate, false)); e.Stimuli[dev0] = stim1; if (nChannels > 1) e.Stimuli[dev1] = stim2; e.Responses[dev0] = new Response(); if (nChannels > 1) e.Responses[dev1] = new Response(); e.Background[dev1] = new Epoch.EpochBackground(new Measurement(0, "V"), srate); e.Background[dev0] = new Epoch.EpochBackground(new Measurement(0, "V"), srate); return controller; }
public TimeStampedDeviceDataEventArgs(IClock clock, IExternalDevice device, IIOData data) : base(clock) { Device = device; Data = data; }
public IInputData DataWithExternalDeviceConfiguration(IExternalDevice dev, IDictionary <string, object> config) { return(DataWithNodeConfiguration(dev.Name, config)); }