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 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();
}
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
}
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 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);
}
public void SetBackground(IExternalDevice dev,
Measurement background,
Measurement sampleRate)
{
Background[dev] = new EpochBackground(background, sampleRate);
}
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;
}
protected virtual void WriteStimulusParameter(Epoch e, IExternalDevice ed, IStimulus s, string k, object v)
{
Console.WriteLine("Epoch stimulus parameter {0}={1}", k, v);
}
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();
}
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();
}
public IInputData DataWithExternalDeviceConfiguration(IExternalDevice dev, IDictionary <string, object> config)
{
return(DataWithNodeConfiguration(dev.Name, config));
}
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());
}
