public void EnsureIDidNotMessUpTasks()
{
var task = new Task("do stuff");
task.Start();
task.Stop();
task.Start();
task.Stop();
var description = task.Description;
// just make sure it doesn't blow up
}
public void RepositoryWorks()
{
var taskRepository = new TaskRepository() { Configuration = new CoreConfiguration(".", ".") };
var task = new Task("do stuff");
task.Start();
task.Stop();
task.Start();
task.Stop();
taskRepository.CreateTask(task);
var loadedTask = taskRepository.FromFileName(task.FileName);
Assert.Equal(task.Durations.Count, loadedTask.Durations.Count);
Assert.Equal(task.Name, loadedTask.Name);
}
public void CanStartSaveGetAndStop()
{
var taskRepository = new TaskRepository() { Configuration = new CoreConfiguration(".",".") };
var task = new Task("do stuff");
task.Start();
taskRepository.CreateTask(task);
Thread.Sleep(TimeSpan.FromSeconds(1)); // TODO: remove this sleep
var loadedTask = taskRepository.FromFileName(task.FileName);
loadedTask.Stop();
Assert.Equal(1, loadedTask.Durations.Count);
}
//This takes in a voltage. A bit cheezy, but I needed the laser
// voltage to be set as soon value as soon as it gets configured.
public void ConfigureSetLaserVoltage(double voltage)
{
outputLaserTask = new Task("FeedbackToLaser");
laserChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[laserChannelName];
laserChannel.AddToTask(outputLaserTask, -10, 10);
outputLaserTask.Control(TaskAction.Verify);
laserWriter = new AnalogSingleChannelWriter(outputLaserTask.Stream);
laserWriter.WriteSingleSample(true, voltage);
outputLaserTask.Start();
}
public void TestReservedToInProgressActualOwner()
{
IdentityId actualId = new IdentityId();
ILoggingService loggingService = SetupLoggerMock(new List<TaskHistoryEvent>());
Task task = new Task(
new TaskId(), TaskStatus.Reserved, string.Empty,
string.Empty, Priority.Normal, false,
DateTime.UtcNow, new IdentityId().GetIdentity(),
DateTime.UtcNow, null, actualId.GetIdentity())
{
LoggingService = loggingService
};
Assert.IsNotNull(task);
IPrincipal actualOwner = new ClaimsPrincipal(actualId.GetIdentity());
Thread.CurrentPrincipal = actualOwner;
task.Start();
Assert.AreEqual(TaskStatus.InProgress, task.Status);
Assert.AreEqual(actualId.GetIdentity(), task.ActualOwner);
Assert.IsNotNull(task.History);
Assert.AreEqual(1, task.History.Count());
TaskHistoryEvent history = task.History.ElementAt(0);
Assert.IsNotNull(history);
Assert.AreEqual(TaskStatus.Reserved, history.OldStatus);
Assert.AreEqual(TaskStatus.InProgress, history.NewStatus);
Assert.AreEqual(actualId, history.UserId);
}
private static void startButton_Click()
{
try
{
continuousTask = DaqSystem.Local.LoadTask(taskName);
runningTask = continuousTask;
continuousTask.Start();
reader = new AnalogMultiChannelReader(continuousTask.Stream);
callBack = new AsyncCallback(ReadCallBack);
reader.SynchronizeCallbacks = true;
reader.BeginReadWaveform(Convert.ToInt32(continuousTask.Timing.SamplesPerChannel), callBack, continuousTask);
while (true)
{
}
}
catch (DaqException ex)
{
continuousTask.Dispose();
}
}
public void TestTaskReady()
{
TaskEntity entity = new TaskEntity
{
TaskId = new TaskId(),
Initiator = new IdentityId().GetIdentity(),
Priority = Priority.Normal,
Status = TaskStatus.Created,
Created = DateTime.UtcNow,
Name = "Name",
Subject = "Subject"
};
Task task = new Task(entity)
{
LoggingService = new Mock<ILoggingService>().Object,
Priority = Priority.High
};
TaskDao dao = new TaskDao(SessionFactory);
task.Accept(dao);
Task loaded;
using (ISession session = SessionFactory.OpenSession())
{
TaskEntity te = session.Query<TaskEntity>().Where(t => t.TaskId == entity.TaskId).FirstOrDefault();
loaded=new Task(te);
}
Thread.GetDomain().SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
IPrincipal p = Thread.CurrentPrincipal;
loaded.Start();
task.Accept(dao);
loaded.Claim();
task.Accept(dao);
}
public void ConfigureScanTrigger()
{
sendScanTriggerTask = new Task("Send Cavity UnlockCavity Trigger");
sendTriggerChannel = (DigitalOutputChannel)Environs.Hardware.DigitalOutputChannels[triggerOutput];
sendTriggerChannel.AddToTask(sendScanTriggerTask);
sendScanTriggerTask.Control(TaskAction.Verify);
triggerWriter = new DigitalSingleChannelWriter(sendScanTriggerTask.Stream);
triggerWriter.WriteSingleSampleSingleLine(true, false);
sendScanTriggerTask.Start();
}
/// <summary>
/// Perform IV cycles while standing in place
/// </summary>
/// <param name="settings"></param>
/// <param name="worker"></param>
/// <param name="e"></param>
public void IV_AcquireDataWithoutMoving(IVSettings settings, BackgroundWorker worker, DoWorkEventArgs e)
{
int finalFileNumber = settings.IVGeneralSettings.CurrentFileNumber;
double[,] dataAcquired;
List<IDataChannel> physicalChannels = new List<IDataChannel>();
//
// Save this run settings if desired
//
SaveSettingsIfNeeded(settings, settings.IVGeneralSettings.IsFileSavingRequired, settings.IVGeneralSettings.Path);
//
// apply initial voltage on the EM if needed
//
ApplyVoltageOnElectroMagnetIfNeeded(settings.IVSteppingMethodSettings.SteppingDevice == SteppingDevice.ElectroMagnet);
//
// create the input and output tasks
//
m_ivInputTask = GetContinuousAITask(settings.IVGeneralSettings.SampleRate, settings.ChannelsSettings.ActiveChannels, null);
m_ivInputTask.Stream.ReadRelativeTo = ReadRelativeTo.FirstSample;
m_outputTask = GetContinuousAOTask(settings);
//
// initiate writer for the output and set initial bias
//
InitiateOutputWriter(m_outputTask, settings);
//
// Main loop for data aquisition
//
for (int i = 0; i < settings.IVGeneralSettings.TotalNumberOfCycles; i++)
{
//
// Cancel the operatin if user asked for
//
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
m_quitRealTimeOperation = false;
//
// we set the votlage to triangle wave and then open the junction by the EM
//
writer.BeginWriteMultiSample(false, m_functionGenerator.TriangleWave, null, null);
//
// Start the input task.
//
try
{
m_ivInputTask.Start();
}
catch (DaqException ex)
{
throw new SBJException("Error occured when tryin to start DAQ input task", ex);
}
//
// start reading continuously.
// when the junction is opened, the opening thread will change m_quitJuncctionOpeningOperation to true.
// set dataAquired to null otherwise it saves last cycle's data.
//
reader = new AnalogMultiChannelReader(m_ivInputTask.Stream);
dataAcquired = null;
try
{
while (!m_quitRealTimeOperation)
{
try
{
dataAcquired = reader.ReadMultiSample(-1);
}
catch (DaqException)
{
continue;
}
}
if (dataAcquired != null)
{
if (settings.ChannelsSettings.ActiveChannels.Count != dataAcquired.GetLength(0))
{
throw new SBJException("Number of data channels doesn't fit the recieved data.");
}
}
}
catch (DaqException ex)
{
//
// Probably timeout.
// Ignore this cycle and rerun.
//
m_ivInputTask.Stop();
continue;
}
//
// At this point the reader has returned with all the data and we can stop the input task.
//
m_ivInputTask.Stop();
//
// if we didn't acquire any data, there's no need to save anything.
//
if (dataAcquired == null)
{
continue;
}
//
// Assign the aquired data for each channel.
// First clear all data from previous interation.
//
ClearRawData(settings.ChannelsSettings.ActiveChannels);
AssignRawDataToChannels(settings.ChannelsSettings.ActiveChannels, dataAcquired);
//
// physical channel will include both simple and complex channels.
//
physicalChannels = GetChannelsForDisplay(settings.ChannelsSettings.ActiveChannels);
//
// calculate the physical data for each channel
//
GetPhysicalData(physicalChannels);
//
// the IV acquisition is done, we need to return the output to constant voltage for the next cycle
//
writer.BeginWriteMultiSample(false, m_functionGenerator.ConstWave, null, null);
//
// Increase file number by one
// Save data if needed
//
finalFileNumber++;
if (settings.IVGeneralSettings.IsFileSavingRequired)
{
finalFileNumber = SaveData(settings.IVGeneralSettings.Path, settings.ChannelsSettings.ActiveChannels, physicalChannels, finalFileNumber);
}
//
// Signal UI we have the data
//
if (DataAquired != null)
{
DataAquired(this, new DataAquiredEventArgs(physicalChannels, finalFileNumber));
}
}
//
// Finish the measurement properly
//
if (settings.IVSteppingMethodSettings.SteppingDevice == SteppingDevice.ElectroMagnet)
{
m_electroMagnet.Shutdown();
}
m_ivInputTask.Dispose();
m_ivInputTask = null;
m_outputTask.Dispose();
m_outputTask = null;
m_stepperMotor.Shutdown();
}
/// <summary>
/// Do Cycles of closing and opening the junction, while measuring IVs
/// </summary>
/// <param name="settings"></param>
/// <param name="worker"></param>
/// <param name="e"></param>
public void IV_AcquireData(IVSettings settings,BackgroundWorker worker, DoWorkEventArgs e)
{
bool isCancelled = false;
int finalFileNumber = settings.IVGeneralSettings.CurrentFileNumber;
double[,] dataAcquired;
List<IDataChannel> physicalChannels = new List<IDataChannel>();
//
// Save this run settings if desired
//
SaveSettingsIfNeeded(settings, settings.IVGeneralSettings.IsFileSavingRequired, settings.IVGeneralSettings.Path);
//
// apply initial voltage on the EM if needed
//
ApplyVoltageOnElectroMagnetIfNeeded(settings.IVSteppingMethodSettings.SteppingDevice == SteppingDevice.ElectroMagnet);
//
// create the input and output tasks
//
m_ivInputTask = GetContinuousAITask(settings.IVGeneralSettings.SampleRate, settings.ChannelsSettings.ActiveChannels, null);
m_ivInputTask.Stream.ReadRelativeTo = ReadRelativeTo.FirstSample;
m_outputTask = GetContinuousAOTask(settings);
//
// initiate writer for the output and set initial bias
//
InitiateOutputWriter(m_outputTask, settings);
//
// Main loop for data aquisition
//
for (int i = 0; i < settings.IVGeneralSettings.TotalNumberOfCycles; i++)
{
//
// Cancel the operatin if user asked for
//
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
//
// if we use EM, and we are asked to skip the first cycle (that is done by the stepper motor),
// move on to the next cycle.
//
if (i == 0 && settings.IVSteppingMethodSettings.SteppingDevice == SteppingDevice.ElectroMagnet
&& settings.IVSteppingMethodSettings.IsEMSkipFirstCycleEnable)
{
m_stepperMotor.Shutdown();
continue;
}
//
// Change the gain power to 5 before reaching contact
// to ensure full contact current
//
m_amplifier.ChangeGain(5);
//
// Reach to contact before we start openning the junction
// If we use EM and we're after the first cycle, use the EM.
// If user asked to stop than exit
//
isCancelled = (settings.IVSteppingMethodSettings.SteppingDevice == SteppingDevice.ElectroMagnet && i > 0) ?
EMTryObtainShortCircuit(settings.IVSteppingMethodSettings.EMShortCircuitDelayTime, settings.IVGeneralSettings.ShortCircuitVoltage, worker, e) :
TryObtainShortCircuit(settings.IVGeneralSettings.ShortCircuitVoltage,settings.IVGeneralSettings.UseShortCircuitDelayTime,settings.IVGeneralSettings.ShortCircuitDelayTime,worker, e);
if (isCancelled)
{
break;
}
//
// Configure the gain to the desired one before strating the measurement.
// And also this is the time to switch the laser on.
//
int gainPower;
Int32.TryParse(settings.IVGeneralSettings.Gain, out gainPower);
m_amplifier.ChangeGain(gainPower);
//
// Start openning the junction.
// If EM is enabled and we're after the first cycle, use the EM.
//
if (settings.IVSteppingMethodSettings.SteppingDevice == SteppingDevice.ElectroMagnet)
{
if (i == 0)
{
//
// we are on the first cycle and wish to open the junction by the stepper motor.
//
ObtainOpenJunctionByStepperMotor(settings.IVGeneralSettings.TriggerVoltage, worker, e);
//
// from now on we will be using the electroMagnet, so lets turn the stepper motor off and move to the next cycle
//
m_stepperMotor.Shutdown();
continue;
}
else
{
//
// we set the votlage to triangle wave and then open the junction by the EM
//
writer.BeginWriteMultiSample(false, m_functionGenerator.TriangleWave, null, null);
IV_EMBeginOpenJunction(settings);
}
}
else
{
//
// we set the voltage to triangle wave and then open the junction by stepper motor
//
writer.BeginWriteMultiSample(false, m_functionGenerator.TriangleWave, null, null);
IV_StepperMotorBeginOpenJunction(settings);
}
//
// Start the input task.
//
try
{
m_ivInputTask.Start();
}
catch (DaqException ex)
{
throw new SBJException("Error occured when tryin to start DAQ input task", ex);
}
//
// start reading continuously.
// when the junction is opened, the opening thread will change m_quitJuncctionOpeningOperation to true.
// set dataAquired to null otherwise it saves last cycle's data.
//
reader = new AnalogMultiChannelReader(m_ivInputTask.Stream);
dataAcquired = null;
try
{
while (!m_quitJunctionOpenningOperation)
{
dataAcquired = reader.ReadMultiSample(-1);
}
if (dataAcquired != null)
{
if (settings.ChannelsSettings.ActiveChannels.Count != dataAcquired.GetLength(0))
{
throw new SBJException("Number of data channels doesn't fit the recieved data.");
}
}
}
catch (DaqException)
{
//
// Probably timeout.
// Ignore this cycle and rerun.
//
m_ivInputTask.Stop();
continue;
}
//
// At this point the reader has returned with all the data and we can stop the input task.
//
m_ivInputTask.Stop();
//
// if we didn't acquire any data, there's no need to save anything.
//
if (dataAcquired == null)
{
continue;
}
//
// Assign the aquired data for each channel.
// First clear all data from previous interation.
//
ClearRawData(settings.ChannelsSettings.ActiveChannels);
AssignRawDataToChannels(settings.ChannelsSettings.ActiveChannels, dataAcquired);
//
// physical channel will include both simple and complex channels.
//
physicalChannels = GetChannelsForDisplay(settings.ChannelsSettings.ActiveChannels);
//
// calculate the physical data for each channel
//
GetPhysicalData(physicalChannels);
//
// the IV acquisition is done, we need to return the output to constant voltage for the next cycle
//
writer.BeginWriteMultiSample(false, m_functionGenerator.ConstWave, null, null);
//
// Increase file number by one
// Save data if needed
//
finalFileNumber++;
if (settings.IVGeneralSettings.IsFileSavingRequired)
{
finalFileNumber = SaveData(settings.IVGeneralSettings.Path, settings.ChannelsSettings.ActiveChannels, physicalChannels, finalFileNumber);
}
//
// Signal UI we have the data
//
if (DataAquired != null)
{
DataAquired(this, new DataAquiredEventArgs(physicalChannels, finalFileNumber));
}
}
//
// Finish the measurement properly
//
if (settings.IVSteppingMethodSettings.SteppingDevice == SteppingDevice.ElectroMagnet)
{
m_electroMagnet.Shutdown();
}
m_ivInputTask.Dispose();
m_ivInputTask = null;
m_outputTask.Dispose();
m_outputTask = null;
m_stepperMotor.Shutdown();
}
/// <summary>
/// Manually aquire data
/// This method continuously poll the buffer for data until it is stopped by the user.
/// </summary>
/// <param name="settings">The settings for running the aquisition</param>
/// <returns>True whether the operation was cacled by the user. False otherwise.</returns>
public bool AquireDataContinuously(SBJControllerSettings settings, BackgroundWorker worker, DoWorkEventArgs e)
{
//
// Apply voltage with desired tool: Task or Keithley
//
ApplyVoltageIfNeeded(settings.GeneralSettings.UseKeithley,
settings.GeneralSettings.Bias,
settings.GeneralSettings.BiasError,
settings.GeneralSettings.Range,
settings.GeneralSettings.AutoRange);
bool isCancelled = false;
int finalFileNumber = settings.GeneralSettings.CurrentFileNumber;
//
// The array is intialized with size for 1 minute sampling.
//
double[,] dataAquired = new double[1000, 1000];
List<IDataChannel> physicalChannels = new List<IDataChannel>();
//
// Configure the laser if needed for this run
//
ConfigureLaserIfNeeded(settings);
//
// Save this run settings if desired
//
SaveSettingsIfNeeded(settings, settings.GeneralSettings.IsFileSavingRequired, settings.GeneralSettings.Path);
//
//apply initial voltage on the EM
//
ApplyVoltageOnElectroMagnetIfNeeded(settings.ElectromagnetSettings.IsEMEnable);
//
// Create the task
//
m_activeTriggeredTask = GetContinuousAITask(settings.GeneralSettings.SampleRate, settings.ChannelsSettings.ActiveChannels, null);
//
// If EM is enabled, and we are asked to skip the first cycle (that is done by the stepper motor),
// then return.
//
if (settings.ElectromagnetSettings.IsEMEnable && settings.ElectromagnetSettings.IsEMSkipFirstCycleEnable)
{
m_stepperMotor.Shutdown();
return false;
}
if (settings.LaserSettings.IsLaserOn)
{
m_LaserController.TurnOn();
}
//
// Start the task and wait for the data
//
try
{
m_activeTriggeredTask.Start();
}
catch (DaqException ex)
{
throw new SBJException("Error occured when tryin to start DAQ task", ex);
}
AnalogMultiChannelReader reader = new AnalogMultiChannelReader(m_activeTriggeredTask.Stream);
List<List<double>> fullData = new List<List<double>>(settings.ChannelsSettings.ActiveChannels.Count);
for (int i = 0; i < fullData.Capacity; i++)
{
fullData.Add(new List<double>());
}
try
{
//
// Before getting all the data clear the lists.
//
ClearRawData(settings.ChannelsSettings.ActiveChannels);
//
// As long as the user didn't ask to stop the acquisition
// (which is signaled by the stop of the stepper motion)
// we coninue sampling.
//
while (!worker.CancellationPending)
{
//
// Read all available data points in the buffer that
// were not read so far.
//
dataAquired = reader.ReadMultiSample(-1);
fullData = AccumulateData(fullData, dataAquired);
dataAquired = null;
}
}
catch (DaqException)
{
//
// In case of an error just return
//
m_activeTriggeredTask.Stop();
m_activeTriggeredTask.Dispose();
if (m_LaserController != null)
{
m_LaserController.TurnOff();
}
if (m_taborFirstEOMController != null)
{
m_taborFirstEOMController.TurnOff();
}
if (m_taborSecondEOMController != null)
{
m_taborSecondEOMController.TurnOff();
}
return false;
}
//
// At this point the user had requested to stop the data aquisition.
// By signaling "stop". We can stop the task.
//
m_activeTriggeredTask.Stop();
//
// Assign the aquired data for each channel after an average process
//
AssignRawDataToChannels(settings.ChannelsSettings.ActiveChannels, ConvertDataToMatrix(fullData));
//
// physical channel will include both simple and complex channels.
//
physicalChannels = GetChannelsForDisplay(settings.ChannelsSettings.ActiveChannels);
//
// calculate the physical data for each channel
//
GetPhysicalData(physicalChannels);
//
// Increase file number by one
// Save data if needed
//
finalFileNumber++;
if (settings.GeneralSettings.IsFileSavingRequired)
{
finalFileNumber = SaveData(settings.GeneralSettings.Path, settings.ChannelsSettings.ActiveChannels, physicalChannels, finalFileNumber);
}
//
// Signal UI we have the data
//
if (DataAquired != null)
{
DataAquired(this, new DataAquiredEventArgs(physicalChannels, finalFileNumber));
}
//
// Finish the measurement properly
//
if (settings.LaserSettings.IsLaserOn)
{
m_LaserController.TurnOff();
}
if (settings.ElectromagnetSettings.IsEMEnable)
{
m_electroMagnet.Shutdown();
}
if (settings.LaserSettings.IsFirstEOMOn)
{
m_taborFirstEOMController.TurnOff();
}
if (settings.LaserSettings.IsSecondEOMOn)
{
m_taborSecondEOMController.TurnOff();
}
m_activeTriggeredTask.Dispose();
m_stepperMotor.Shutdown();
return (isCancelled || e.Cancel);
}
/// <summary>
/// Manually aquire data
/// This method continuously poll the buffer for data until it is stopped by the user.
/// </summary>
/// <param name="settings">The settings for running the aquisition</param>
/// <returns>True whether the operation was cacled by the user. False otherwise.</returns>
public bool AquireDataManually(SBJControllerSettings settings, BackgroundWorker worker, DoWorkEventArgs e)
{
//
// Apply voltage with desired tool: Task or Keithley
//
ApplyVoltageIfNeeded(settings.GeneralSettings.UseKeithley,
settings.GeneralSettings.Bias,
settings.GeneralSettings.BiasError,
settings.GeneralSettings.Range,
settings.GeneralSettings.AutoRange);
bool isCancelled = false;
int finalFileNumber = settings.GeneralSettings.CurrentFileNumber;
//
// The array is intialized with size for 1 minute sampling.
//
double[,] dataAquired = new double[1000, 1000];
List<IDataChannel> physicalChannels = new List<IDataChannel>();
//
// Configure the laser if needed for this run
//
ConfigureLaserIfNeeded(settings);
//
// Save this run settings if desired
//
SaveSettingsIfNeeded(settings, settings.GeneralSettings.IsFileSavingRequired, settings.GeneralSettings.Path);
//
//apply initial voltage on the EM
//
ApplyVoltageOnElectroMagnetIfNeeded(settings.ElectromagnetSettings.IsEMEnable);
//
// Create the task
//
m_activeTriggeredTask = GetContinuousAITask(settings.GeneralSettings.SampleRate, settings.ChannelsSettings.ActiveChannels, null);
//
// If EM is enabled, and we are asked to skip the first cycle (that is done by the stepper motor),
// then return.
//
if (settings.ElectromagnetSettings.IsEMEnable && settings.ElectromagnetSettings.IsEMSkipFirstCycleEnable)
{
m_stepperMotor.Shutdown();
return false;
}
//
// Turn off the laser before we reach contact
//
if (settings.LaserSettings.IsLaserOn)
{
m_LaserController.TurnOff();
Thread.Sleep(5000);
}
//
// Change the gain power to 5 before reaching contact
// to ensure full contact current
//
if (settings.GeneralSettings.UseDefaultGain)
{
m_amplifier.ChangeGain(5);
}
//
// Reach to contact before we start openning the junction
// If EM is enabled and we're after the first cycle, use the EM.
// If user asked to stop than exit
//
isCancelled = (settings.ElectromagnetSettings.IsEMEnable) ?
EMTryObtainShortCircuit(settings.ElectromagnetSettings.EMShortCircuitDelayTime,
settings.GeneralSettings.ShortCircuitVoltage, worker, e) :
TryObtainShortCircuit(settings.GeneralSettings.ShortCircuitVoltage, settings.GeneralSettings.UseShortCircuitDelayTime,settings.GeneralSettings.ShortCircuitDelayTime, worker, e);
if (isCancelled)
{
return false;
}
//
// Configure the gain to the desired one before strating the measurement.
// And also this is the time to switch the laser on.
//
if (settings.GeneralSettings.UseDefaultGain)
{
int gainPower;
Int32.TryParse(settings.GeneralSettings.Gain, out gainPower);
m_amplifier.ChangeGain(gainPower);
}
if (settings.LaserSettings.IsLaserOn)
{
m_LaserController.TurnOn();
}
//
// Start openning the junction.
// If EM is enabled then use it.
//
if (settings.ElectromagnetSettings.IsEMEnable)
{
m_stepperMotor.Shutdown();
EMBeginOpenJunction(settings, worker, e);
}
else
{
BeginOpenJunction(settings, worker, e);
}
//
// Start the task and wait for the data
//
try
{
m_activeTriggeredTask.Start();
}
catch (DaqException ex)
{
throw new SBJException("Error occured when tryin to start DAQ task", ex);
}
AnalogMultiChannelReader reader = new AnalogMultiChannelReader(m_activeTriggeredTask.Stream);
List<List<double>> averagedData = new List<List<double>>(settings.ChannelsSettings.ActiveChannels.Count);
for (int i = 0; i < averagedData.Capacity; i++)
{
averagedData.Add(new List<double>());
}
try
{
//
// Before getting all the data clear the lists.
//
ClearRawData(settings.ChannelsSettings.ActiveChannels);
//
// As long as the user didn't ask to stop the acquisition
// (which is signaled by the stop of the stepper motion)
// we coninue sampling.
//
while (!m_quitJunctionOpenningOperation)
{
//
// Read all available data points in the buffer that
// were not read so far.
//
dataAquired = reader.ReadMultiSample(-1);
//
// Get average for the acquired the data and assign to variable
//
List<double> averageDataValues = GetAverageDataValue(dataAquired);
for (int i = 0; i < averageDataValues.Count; i++)
{
averagedData[i].Add(averageDataValues[i]);
}
dataAquired = null;
//
// Cancel the operatin if user asked for
// We do it at the end of the loop to make sure we
// saved all the data we have available.
//
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
}
}
catch (DaqException)
{
//
// In case of an error just return
//
m_activeTriggeredTask.Stop();
m_activeTriggeredTask.Dispose();
if (m_LaserController != null)
{
m_LaserController.TurnOff();
}
if (m_taborFirstEOMController != null)
{
m_taborFirstEOMController.TurnOff();
}
if (m_taborSecondEOMController != null)
{
m_taborSecondEOMController.TurnOff();
}
return false;
}
//
// At this point the user had requested to stop the data aquisition.
// By signaling "stop". We can stop the task.
//
m_activeTriggeredTask.Stop();
//
// Assign the aquired data for each channel after an average process
//
AssignRawDataToChannels(settings.ChannelsSettings.ActiveChannels, ConvertDataToMatrix(GetAveragedData(averagedData, 5000)));
//
// physical channel will include both simple and complex channels.
//
physicalChannels = GetChannelsForDisplay(settings.ChannelsSettings.ActiveChannels);
//
// calculate the physical data for each channel
//
GetPhysicalData(physicalChannels);
//
// Increase file number by one
// Save data if needed
//
finalFileNumber++;
if (settings.GeneralSettings.IsFileSavingRequired)
{
finalFileNumber = SaveData(settings.GeneralSettings.Path, settings.ChannelsSettings.ActiveChannels, physicalChannels, finalFileNumber);
}
//
// Signal UI we have the data
//
if (DataAquired != null)
{
DataAquired(this, new DataAquiredEventArgs(physicalChannels, finalFileNumber));
}
//
// Finish the measurement properly
//
if (settings.LaserSettings.IsLaserOn)
{
m_LaserController.TurnOff();
}
if (settings.ElectromagnetSettings.IsEMEnable)
{
m_electroMagnet.Shutdown();
}
if (settings.LaserSettings.IsFirstEOMOn)
{
m_taborFirstEOMController.TurnOff();
}
if (settings.LaserSettings.IsSecondEOMOn)
{
m_taborSecondEOMController.TurnOff();
}
m_activeTriggeredTask.Dispose();
m_stepperMotor.Shutdown();
return (isCancelled || e.Cancel);
}
/// <summary>
/// Reach to position specified by conductance value and then stop and aqcuire data until asked to stop.
/// </summary>
/// <param name="settings"></param>
/// <param name="worker"></param>
/// <param name="e"></param>
/// <returns></returns>
private bool ReachToPositionByMovingUp(SBJControllerSettings settings, BackgroundWorker worker, DoWorkEventArgs e)
{
double[,] dataAcquired = new double[1000, 1000];
int finalFileNumber = settings.GeneralSettings.CurrentFileNumber;
List<IDataChannel> physicalChannels = new List<IDataChannel>();
for (int i = 0; i < settings.GeneralSettings.TotalNumberOfCycles; i++)
{
//
// Cancel the operatin if user asked for
//
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
//
// This flag is used to signal us when the user asked to stop the real time data acquisition
//
m_quitRealTimeOperation = false;
m_activeTriggeredTask = GetMultipleChannelsTriggeredTask(settings, null, RunDirection.Break, m_triggerSlope, m_triggerVoltage, worker, e);
m_activeTriggeredTask.EveryNSamplesReadEventInterval = settings.GeneralSettings.TotalSamples;
m_activeTriggeredTask.Done += new TaskDoneEventHandler(OnTaskDoneOpenning);
m_activeTriggeredTask.Control(TaskAction.Verify);
m_triggerSlope = m_activeTriggeredTask.Triggers.ReferenceTrigger.AnalogEdge.Slope;
m_triggerVoltage = m_activeTriggeredTask.Triggers.ReferenceTrigger.AnalogEdge.Level;
//
// physical channel will include both simple and complex channels.
//
physicalChannels = GetChannelsForDisplay(settings.ChannelsSettings.ActiveChannels);
//
// Assign the aquired data for each channel.
// First clear all data from previous interation.
//
ClearRawData(settings.ChannelsSettings.ActiveChannels);
//
// Create the tasks: One for triggering us to stop and the other for start monitoring the data
//
m_realTimeTask = GetContinuousAITask(settings.GeneralSettings.SampleRate, settings.ChannelsSettings.ActiveChannels, null);
AnalogMultiChannelReader realTimeReader = new AnalogMultiChannelReader(m_realTimeTask.Stream);
//
// Start closing the junction.
// If EM is enabled use the EM.
//
if (settings.ElectromagnetSettings.IsEMEnable)
{
EMTryObtainShortCircuit(settings.ElectromagnetSettings.EMShortCircuitDelayTime, settings.GeneralSettings.ShortCircuitVoltage, worker, e);
}
else
{
TryObtainShortCircuit(settings.GeneralSettings.ShortCircuitVoltage, settings.GeneralSettings.UseShortCircuitDelayTime,settings.GeneralSettings.ShortCircuitDelayTime, worker, e);
}
//
// Start openning the junction. ASync operation.
// If EM is enabled use the EM.
//
if (settings.ElectromagnetSettings.IsEMEnable)
{
EMBeginOpenJunction(settings, worker, e);
}
else
{
BeginOpenJunction(settings, worker, e);
}
//
// Cancel the operatin if user asked for
//
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
//
// Start the triggered task.
//
m_activeTriggeredTask.Start();
//
// If the user asked to stop the operation on the external thread then
// WaitUntilDone will throw an expection. We can ignore that and return.
//
try
{
m_activeTriggeredTask.WaitUntilDone();
}
catch (DaqException)
{
//
// We got here if the user asked to stop the operation
//
break;
}
//
// We reach this point only after we reached the desired conductance value.
// As long as the user didn't ask to stop the operation continue recording the data.
//
while (!m_quitRealTimeOperation)
{
//
// Read operation implicity start the task without the need to call Start() method.
//
try
{
dataAcquired = realTimeReader.ReadMultiSample(-1);
}
catch (DaqException)
{
continue;
}
if (dataAcquired.Length == 0)
{
continue;
}
//
// Assign the aquired data for each channel.
//
AssignRawDataToChannels(settings.ChannelsSettings.ActiveChannels, dataAcquired);
//
// calculate the physical data for each channel
//
GetPhysicalData(physicalChannels);
//
// Signal UI we have the data
//
if (DataAquired != null)
{
DataAquired(this, new DataAquiredEventArgs(physicalChannels, finalFileNumber));
}
}
if (DoneReadingData != null)
{
DoneReadingData(this, null);
}
m_realTimeTask.Stop();
m_realTimeTask.Dispose();
//
// Increase file number by one
// Save data if needed
//
finalFileNumber++;
if (settings.GeneralSettings.IsFileSavingRequired)
{
finalFileNumber = SaveData(settings.GeneralSettings.Path, settings.ChannelsSettings.ActiveChannels, physicalChannels, finalFileNumber);
}
}
m_activeTriggeredTask.Dispose();
m_realTimeTask.Dispose();
m_triggerSlope = 0;
m_triggerVoltage = 0;
return e.Cancel;
}
// Look at the recording hardware settings and create NI Tasks that reflect the user's choices
private void UpdateRecordingSettings()
{
//resets channel counts for input streams
updateChannelCount();
// update the recordingSettings object
recordingSettings.RefreshForm();
// Set spike buffer lengths
spikeBufferLength = Convert.ToInt32(Properties.Settings.Default.ADCPollingPeriodSec * Properties.Settings.Default.RawSampleFrequency);
lfpBufferLength = Convert.ToInt32(Properties.Settings.Default.ADCPollingPeriodSec * Properties.Settings.Default.LFPSampleFrequency);
eegBufferLength = Convert.ToInt32(Properties.Settings.Default.ADCPollingPeriodSec * Properties.Settings.Default.EEGSamplingRate);
// Enable spike detector saving while stopped
spikeDet.EnableFileMenu();
// update recording type to nominal
isNormalRecording = true;
// Refresh all the NI Tasks
try
{
if (spikeTask != null)
{
bool cantReset = true;
//Hack to prevent lock up
DateTime startTime = DateTime.Now;
while (cantReset)
{
cantReset = false;
for (int i = 0; i < spikeTask.Count; i++)
cantReset = cantReset || bwIsRunning[i];
System.Threading.Thread.Sleep(100);
// Exit the loop if we are waiting for more than a second
if ((DateTime.Now - startTime).TotalSeconds > 0.5)
break;
}
for (int i = 0; i < spikeTask.Count; ++i)
spikeTask[i].Dispose();
spikeTask.Clear(); spikeTask = null;
}
if (stimTimeTask != null) { stimTimeTask.Dispose(); stimTimeTask = null; }
if (stimIvsVTask != null) { stimIvsVTask.Dispose(); stimIvsVTask = null; }
if (serialOut != null) { serialOut.Close(); serialOut.Dispose(); }
if (Properties.Settings.Default.UseCineplex)
{
if (videoTask == null)
{
videoTask = new Task("videoTask");
videoTask.COChannels.CreatePulseChannelFrequency(Properties.Settings.Default.CineplexDevice + "/ctr0", "",
COPulseFrequencyUnits.Hertz, COPulseIdleState.Low, 0, 1000, 0.5);
videoTask.Control(TaskAction.Verify);
videoTask.Timing.ReferenceClockSource = "OnboardClock";
videoTask.Timing.ConfigureImplicit(SampleQuantityMode.ContinuousSamples, 10);
videoTask.Start();
}
checkBox_video.Enabled = true;
}
else
checkBox_video.Enabled = false;
try
{
if (Properties.Settings.Default.UseProgRef)
{
string serialOutPort = Properties.Settings.Default.SerialPortDevice;
serialOut = new SerialPort(serialOutPort, 38400, Parity.None, 8, StopBits.One);
serialOut.Open();
serialOut.Write("#0140/0\r"); //Reset everything to power-up state
groupBox_plexonProgRef.Visible = true;
}
else
{
groupBox_plexonProgRef.Visible = false;
}
}
catch (Exception ex)
{
MessageBox.Show("There was a problem when setting up the serial communicaiton port to the Plexon device:\r\n\r\n" + ex.Message);
groupBox_plexonProgRef.Visible = false;
}
this.drawOpenLoopStimPulse();
//Add LFP tab, if applicable
if (Properties.Settings.Default.UseLFPs && !tabControl.TabPages.Contains(tabPage_LFPs))
{
tabPage_LFPs = new TabPage("LFPs");
tabControl.TabPages.Insert(2, tabPage_LFPs);
}
else if (!Properties.Settings.Default.UseLFPs && tabControl.TabPages.Contains(tabPage_LFPs))
tabControl.TabPages.Remove(tabPage_LFPs);
//Add MUA tab, if applicable
if (Properties.Settings.Default.ProcessMUA && !tabControl.TabPages.Contains(tabPage_MUA))
{
tabPage_MUA = new TabPage("MUA");
tabControl.TabPages.Insert((Properties.Settings.Default.UseLFPs ? 3 : 2), tabPage_MUA);
}
else if (!Properties.Settings.Default.ProcessMUA && tabControl.TabPages.Contains(tabPage_MUA))
tabControl.TabPages.Remove(tabPage_MUA);
//Add EEG tab, if applicable
if (Properties.Settings.Default.UseEEG && !tabControl.TabPages.Contains(tabPage_EEG))
{
tabPage_EEG = new TabPage("EEG");
int pageNum = 2;
if (Properties.Settings.Default.UseLFPs)
pageNum++;
if (Properties.Settings.Default.ProcessMUA)
pageNum++;
tabControl.TabPages.Insert(pageNum, tabPage_EEG);
}
else if (!Properties.Settings.Default.UseEEG && tabControl.TabPages.Contains(tabPage_EEG))
tabControl.TabPages.Remove(tabPage_EEG);
////Add Aux tab, if applicable
//if ((Properties.Settings.Default.useAuxAnalogInput || Properties.Settings.Default.useAuxDigitalInput)
// && !tabControl.TabPages.Contains(tabPage_AuxInput))
//{
// int pageNum = 2;
// if (Properties.Settings.Default.UseLFPs)
// pageNum++;
// if (Properties.Settings.Default.ProcessMUA)
// pageNum++;
// if (Properties.Settings.Default.UseEEG)
// pageNum++;
// tabControl.TabPages.Insert(pageNum, tabPage_AuxInput);
//}
//else if (!(Properties.Settings.Default.useAuxAnalogInput || Properties.Settings.Default.useAuxDigitalInput)
// && tabControl.TabPages.Contains(tabPage_AuxInput))
// tabControl.TabPages.Remove(tabPage_AuxInput);
if (tabControl.TabPages.Contains(tabPage_AuxInput))
tabControl.TabPages.Remove(tabPage_AuxInput);
//Add Referencing tab, if applicable
if ((Properties.Settings.Default.UseProgRef || Properties.Settings.Default.UseFloatingRef)
&& !tabControl.TabPages.Contains(tabPage_ProgRef))
{
int pageNum = 2;
if (Properties.Settings.Default.UseLFPs)
pageNum++;
if (Properties.Settings.Default.ProcessMUA)
pageNum++;
if (Properties.Settings.Default.UseEEG)
pageNum++;
if (Properties.Settings.Default.useAuxAnalogInput || Properties.Settings.Default.useAuxDigitalInput)
pageNum++;
pageNum++; // Account for stimulation page
tabControl.TabPages.Insert(pageNum, tabPage_ProgRef);
}
else if (!(Properties.Settings.Default.UseProgRef || Properties.Settings.Default.UseFloatingRef)
&& tabControl.TabPages.Contains(tabPage_ProgRef))
tabControl.TabPages.Remove(tabPage_ProgRef);
//Add Impedance tab, if applicable
if (Properties.Settings.Default.useImpedanceMeasurer && !tabControl.TabPages.Contains(tabPage_impedance))
{
tabPage_MUA = new TabPage("Impedance Measurement");
tabControl.TabPages.Insert(tabControl.TabPages.Count, tabPage_impedance);
}
else if (!Properties.Settings.Default.useImpedanceMeasurer && tabControl.TabPages.Contains(tabPage_impedance))
tabControl.TabPages.Remove(tabPage_impedance);
// Remove the Referencing and Diagnostics tabs since they are currently non functional
//if (tabControl.TabPages.Contains(tabPage_ProgRef))
//{
// tabControl.TabPages.Remove(tabPage_ProgRef);
//}
if (tabControl.TabPages.Contains(tabPage_diagnostics))
{
tabControl.TabPages.Remove(tabPage_diagnostics);
}
Console.WriteLine("UpdateRecordingSettings finished");
}
catch (DaqException exception)
{
MessageBox.Show(exception.Message); //Display Errors
reset();
}
}
public void Configure( double clockFrequency, bool loop, bool fullWidth,
bool lowGroup, int length, bool internalClock, bool triggered)
{
this.clockFrequency = clockFrequency;
this.length = length;
pgTask = new Task("pgTask");
/**** Configure the output lines ****/
// The underscore notation is the way to address more than 8 of the PatternList generator
// lines at once. This is really buried in the NI-DAQ documentation !
String chanString = "";
if ((string)Environs.Hardware.GetInfo("PGType") == "dedicated")
{
if (fullWidth) chanString = device + "/port0_32";
else
{
if (lowGroup) chanString = device + "/port0_16";
else chanString = device + "/port3_16";
}
}
// as far as I know you can only address the whole 32-bit port on the 6229 type integrated PatternList generators
if ((string)Environs.Hardware.GetInfo("PGType") == "integrated")
{
chanString = device + "/port0";
}
DOChannel doChan = pgTask.DOChannels.CreateChannel(
chanString,
"pg",
ChannelLineGrouping.OneChannelForAllLines
);
/**** Configure the clock ****/
String clockSource = "";
if ((string)Environs.Hardware.GetInfo("PGType") == "dedicated")
{
if (!internalClock) clockSource = (string)Environment.Environs.Hardware.GetInfo("PGClockLine");
else clockSource = "";
}
if ((string)Environs.Hardware.GetInfo("PGType") == "integrated")
{
// clocking is more complicated for the 6229 style PG boards as they don't have their own internal clock.
// if external clocking is required it's easy:
if (!internalClock) clockSource = (string)Environment.Environs.Hardware.GetInfo("PGClockLine");
else
{
// if an internal clock is requested we generate it using the card's timer/counters.
counterTask = new Task();
counterTask.COChannels.CreatePulseChannelFrequency(
device + (string)Environs.Hardware.GetInfo("PGClockCounter"),
"PG Clock",
COPulseFrequencyUnits.Hertz,
COPulseIdleState.Low,
0.0,
clockFrequency,
0.5
);
counterTask.Timing.SampleQuantityMode = SampleQuantityMode.ContinuousSamples;
counterTask.Start();
clockSource = device + (string)Environs.Hardware.GetInfo("PGClockCounter") + "InternalOutput";
}
}
/**** Configure regeneration ****/
SampleQuantityMode sqm;
if (loop)
{
sqm = SampleQuantityMode.ContinuousSamples;
pgTask.Stream.WriteRegenerationMode = WriteRegenerationMode.AllowRegeneration;
}
else
{
sqm = SampleQuantityMode.FiniteSamples;
pgTask.Stream.WriteRegenerationMode = WriteRegenerationMode.DoNotAllowRegeneration;
}
pgTask.Timing.ConfigureSampleClock(
clockSource,
clockFrequency,
SampleClockActiveEdge.Rising,
sqm,
length
);
/**** Configure buffering ****/
if ((string)Environs.Hardware.GetInfo("PGType") == "dedicated")
{
// these lines are critical - without them DAQMx copies the data you provide
// as many times as it can into the on board FIFO (the cited reason being stability).
// This has the annoying side effect that you have to wait for the on board buffer
// to stream out before you can update the patterns - this takes ~6 seconds at 1MHz.
// These lines tell the board and the software to use buffers as close to the size of
// the PatternList as possible (on board buffer size is coerced to be related to a power of
// two, so you don't quite get what you ask for).
// note that 6229 type integrated PGs only have 2kB buffer, so this isn't needed for them (or allowed, in fact)
pgTask.Stream.Buffer.OutputBufferSize = length;
pgTask.Stream.Buffer.OutputOnBoardBufferSize = length;
}
/**** Configure triggering ****/
if (triggered)
{
pgTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(
(string)Environs.Hardware.GetInfo("PGTrigger"),
DigitalEdgeStartTriggerEdge.Rising);
}
/**** Write configuration to board ****/
pgTask.Control(TaskAction.Commit);
writer = new DigitalSingleChannelWriter(pgTask.Stream);
}
