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); }
private void button_electrolesioningStart_Click(object sender, EventArgs e) { //Change mouse cursor to waiting cursor this.Cursor = Cursors.WaitCursor; //Grab values from UI double voltage = Convert.ToDouble(numericUpDown_electrolesioningVoltage.Value); double duration = Convert.ToDouble(numericUpDown_electrolesioningDuration.Value); List<Int32> chList = new List<int>(listBox_electrolesioningChannels.SelectedIndices.Count); for (int i = 0; i < listBox_electrolesioningChannels.SelectedIndices.Count; ++i) chList.Add(listBox_electrolesioningChannels.SelectedIndices[i] + 1); //+1 since indices are 0-based but channels are 1-base //Disable buttons, so users don't try running two experiments at once button_electrolesioningStart.Enabled = false; button_electrolesioningSelectAll.Enabled = false; button_electrolesioningSelectNone.Enabled = false; button_electrolesioningStart.Refresh(); //Refresh stim task stimDigitalTask.Dispose(); stimDigitalTask = new Task("stimDigitalTask_Electrolesioning"); if (Properties.Settings.Default.StimPortBandwidth == 32) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:31", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes else if (Properties.Settings.Default.StimPortBandwidth == 8) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:7", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes stimDigitalWriter = new DigitalSingleChannelWriter(stimDigitalTask.Stream); //Refresh pulse task stimPulseTask.Dispose(); stimPulseTask = new Task("stimPulseTask"); if (Properties.Settings.Default.StimPortBandwidth == 32) { stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao0", "", -10.0, 10.0, AOVoltageUnits.Volts); //Triggers stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao1", "", -10.0, 10.0, AOVoltageUnits.Volts); //Triggers stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao2", "", -10.0, 10.0, AOVoltageUnits.Volts); //Actual Pulse stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao3", "", -10.0, 10.0, AOVoltageUnits.Volts); //Timing } else if (Properties.Settings.Default.StimPortBandwidth == 8) { stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao0", "", -10.0, 10.0, AOVoltageUnits.Volts); stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao1", "", -10.0, 10.0, AOVoltageUnits.Volts); } stimPulseWriter = new AnalogMultiChannelWriter(stimPulseTask.Stream); stimPulseTask.Timing.ConfigureSampleClock("", StimPulse.STIM_SAMPLING_FREQ, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples); stimPulseTask.Timing.SamplesPerChannel = 2; stimDigitalTask.Control(TaskAction.Verify); stimPulseTask.Control(TaskAction.Verify); //For each channel, deliver lesioning pulse for (int i = 0; i < chList.Count; ++i) { int channel = chList[i]; UInt32 data = StimPulse.channel2MUX((double)channel); //Setup digital waveform, open MUX channel stimDigitalWriter.WriteSingleSamplePort(true, data); stimDigitalTask.WaitUntilDone(); stimDigitalTask.Stop(); //Write voltage to channel, wait duration, stop stimPulseWriter.WriteMultiSample(true, new double[,] { { 0, 0 }, { 0, 0 }, { voltage, voltage }, { 0, 0 } }); stimPulseTask.WaitUntilDone(); stimPulseTask.Stop(); Thread.Sleep((int)(Math.Round(duration * 1000))); //Convert to ms stimPulseWriter.WriteMultiSample(true, new double[,] { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }); stimPulseTask.WaitUntilDone(); stimPulseTask.Stop(); //Close MUX stimDigitalWriter.WriteSingleSamplePort(true, 0); stimDigitalTask.WaitUntilDone(); stimDigitalTask.Stop(); } bool[] fData = new bool[Properties.Settings.Default.StimPortBandwidth]; stimDigitalWriter.WriteSingleSampleMultiLine(true, fData); stimDigitalTask.WaitUntilDone(); stimDigitalTask.Stop(); button_electrolesioningSelectAll.Enabled = true; button_electrolesioningSelectNone.Enabled = true; button_electrolesioningStart.Enabled = true; //Now, destroy the objects we made updateSettings(); this.Cursor = Cursors.Default; }
private void radioButton_stimVoltageControlled_Click(object sender, EventArgs e) { if (radioButton_stimVoltageControlled.Checked) { Properties.Settings.Default.StimVoltageControlled = true; if (Properties.Settings.Default.UseStimulator) { //this line goes high (TTL-wise) when we're doing current-controlled stim, low for voltage-controlled stimIvsVTask = new Task("stimIvsV"); stimIvsVTask.DOChannels.CreateChannel(Properties.Settings.Default.StimIvsVDevice + "/Port1/line0", "", ChannelLineGrouping.OneChannelForAllLines); stimIvsVWriter = new DigitalSingleChannelWriter(stimIvsVTask.Stream); stimIvsVTask.Control(TaskAction.Verify); stimIvsVWriter.WriteSingleSampleSingleLine(true, false); stimIvsVTask.WaitUntilDone(); stimIvsVTask.Stop(); stimIvsVTask.Dispose(); } radioButton_impVoltage.Checked = true; } }
public void TestStopActualOwner() { IdentityId actualId = new IdentityId(); ILoggingService loggingService = SetupLoggerMock(new List<TaskHistoryEvent>()); Task task = new Task( new TaskId(), TaskStatus.InProgress, string.Empty, string.Empty, Priority.Normal, false, DateTime.UtcNow, new IdentityId().GetIdentity(), DateTime.UtcNow, null, actualId.GetIdentity()) { LoggingService = loggingService }; IPrincipal actualOwner = new ClaimsPrincipal(actualId.GetIdentity()); Thread.CurrentPrincipal = actualOwner; task.Stop(); Assert.AreEqual(TaskStatus.Reserved, 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.InProgress, history.OldStatus); Assert.AreEqual(TaskStatus.Reserved, history.NewStatus); Assert.AreEqual(actualId, history.UserId); }
/// <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(); }
private void radioButton_stimCurrentControlled_Click(object sender, EventArgs e) { if (radioButton_stimCurrentControlled.Checked) { Properties.Settings.Default.StimVoltageControlled = false; if (Properties.Settings.Default.UseStimulator) { stimIvsVTask = new Task("stimIvsV"); //stimIvsVTask.DOChannels.CreateChannel(Properties.Settings.Default.StimIvsVDevice + "/Port0/line8:15", "", // ChannelLineGrouping.OneChannelForAllLines); stimIvsVTask.DOChannels.CreateChannel(Properties.Settings.Default.StimIvsVDevice + "/Port1/line0", "", ChannelLineGrouping.OneChannelForAllLines); stimIvsVWriter = new DigitalSingleChannelWriter(stimIvsVTask.Stream); //stimIvsVTask.Timing.ConfigureSampleClock("100kHztimebase", 100000, // SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples); stimIvsVTask.Control(TaskAction.Verify); //byte[] b_array = new byte[5] { 255, 255, 255, 255, 255 }; //DigitalWaveform wfm = new DigitalWaveform(5, 8, DigitalState.ForceDown); //wfm = NationalInstruments.DigitalWaveform.FromPort(b_array); //stimIvsVWriter.WriteWaveform(true, wfm); stimIvsVWriter.WriteSingleSampleSingleLine(true, true); stimIvsVTask.WaitUntilDone(); stimIvsVTask.Stop(); stimIvsVTask.Dispose(); } radioButton_impCurrent.Checked = true; } }
/// <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> /// 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> /// 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; }
//call this method after changing stimulation settings, or finishing a stimulation experiment //includes code to set dc offsets back to zero private void updateStim() { lock (this) { bool placedzeros = false; if (stimPulseTask != null || stimDigitalTask != null) { try { // If we were ruuning a closed loop or open-loop protocol, this will zero the outputs double[,] AnalogBuffer = new double[stimPulseTask.AOChannels.Count, STIMBUFFSIZE]; // buffer for analog channels UInt32[] DigitalBuffer = new UInt32[STIMBUFFSIZE]; stimPulseTask.Stop(); stimDigitalTask.Stop(); stimPulseWriter.WriteMultiSample(true, AnalogBuffer); stimDigitalWriter.WriteMultiSamplePort(true, DigitalBuffer); stimPulseTask.WaitUntilDone(20); stimDigitalTask.WaitUntilDone(20); stimPulseTask.Stop(); stimDigitalTask.Stop(); placedzeros = true; } catch (Exception ex) { placedzeros = false; } } if (stimDigitalTask != null) { stimDigitalTask.Dispose(); stimDigitalTask = null; } if (stimPulseTask != null) { stimPulseTask.Dispose(); stimPulseTask = null; } if (Properties.Settings.Default.UseStimulator) { stimPulseTask = new Task("stimPulseTask"); stimDigitalTask = new Task("stimDigitalTask"); if (Properties.Settings.Default.StimPortBandwidth == 32) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:31", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes else if (Properties.Settings.Default.StimPortBandwidth == 8) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:7", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes if (Properties.Settings.Default.StimPortBandwidth == 32) { stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao0", "", -10.0, 10.0, AOVoltageUnits.Volts); //Triggers stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao1", "", -10.0, 10.0, AOVoltageUnits.Volts); //Triggers stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao2", "", -10.0, 10.0, AOVoltageUnits.Volts); //Actual Pulse stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao3", "", -10.0, 10.0, AOVoltageUnits.Volts); //Timing } else if (Properties.Settings.Default.StimPortBandwidth == 8) { stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao0", "", -10.0, 10.0, AOVoltageUnits.Volts); stimPulseTask.AOChannels.CreateVoltageChannel(Properties.Settings.Default.StimulatorDevice + "/ao1", "", -10.0, 10.0, AOVoltageUnits.Volts); } if (Properties.Settings.Default.UseCineplex) { stimPulseTask.Timing.ReferenceClockSource = videoTask.Timing.ReferenceClockSource; stimPulseTask.Timing.ReferenceClockRate = videoTask.Timing.ReferenceClockRate; } else { stimPulseTask.Timing.ReferenceClockSource = "OnboardClock"; //stimPulseTask.Timing.ReferenceClockRate = 10000000.0; //10 MHz timebase } stimDigitalTask.Timing.ConfigureSampleClock("100kHzTimebase", STIM_SAMPLING_FREQ, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples); stimPulseTask.Timing.ConfigureSampleClock("100kHzTimebase", STIM_SAMPLING_FREQ, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples); stimDigitalTask.SynchronizeCallbacks = false; stimPulseTask.SynchronizeCallbacks = false; stimDigitalWriter = new DigitalSingleChannelWriter(stimDigitalTask.Stream); stimPulseWriter = new AnalogMultiChannelWriter(stimPulseTask.Stream); stimPulseTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger( "/" + Properties.Settings.Default.StimulatorDevice + "/PFI6", DigitalEdgeStartTriggerEdge.Rising); stimDigitalTask.Control(TaskAction.Verify); stimPulseTask.Control(TaskAction.Verify); //Check to ensure one of the I/V buttons is checked if (!radioButton_impCurrent.Checked && !radioButton_impVoltage.Checked) { radioButton_impCurrent.Checked = true; radioButton_impVoltage.Checked = false; radioButton_stimCurrentControlled.Checked = true; radioButton_stimVoltageControlled.Checked = false; } if (Properties.Settings.Default.UseStimulator) { stimIvsVTask = new Task("stimIvsV"); stimIvsVTask.DOChannels.CreateChannel(Properties.Settings.Default.StimIvsVDevice + "/Port1/line0", "", ChannelLineGrouping.OneChannelForAllLines); stimIvsVWriter = new DigitalSingleChannelWriter(stimIvsVTask.Stream); //stimIvsVTask.Timing.ConfigureSampleClock("100kHztimebase", 100000, // SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples); stimIvsVTask.Control(TaskAction.Verify); //byte[] b_array; //if (radioButton_impCurrent.Checked) // b_array = new byte[5] { 255, 255, 255, 255, 255 }; //else // b_array = new byte[5] { 0, 0, 0, 0, 0 }; //DigitalWaveform wfm = new DigitalWaveform(5, 8, DigitalState.ForceDown); //wfm = NationalInstruments.DigitalWaveform.FromPort(b_array); //stimIvsVWriter.WriteWaveform(true, wfm); if (radioButton_impCurrent.Checked) stimIvsVWriter.WriteSingleSampleSingleLine(true, true); else stimIvsVWriter.WriteSingleSampleSingleLine(true, false); stimIvsVTask.WaitUntilDone(); stimIvsVTask.Stop(); stimIvsVTask.Dispose(); if (!placedzeros)//try again { double[,] AnalogBuffer = new double[stimPulseTask.AOChannels.Count, STIMBUFFSIZE]; // buffer for analog channels UInt32[] DigitalBuffer = new UInt32[STIMBUFFSIZE]; stimPulseTask.Stop(); stimDigitalTask.Stop(); stimPulseWriter.WriteMultiSample(true, AnalogBuffer); stimDigitalWriter.WriteMultiSamplePort(true, DigitalBuffer); //stimPulseTask.Start(); //stimDigitalTask.Start(); //stimPulseTask.WaitUntilDone(); stimPulseTask.Stop(); stimDigitalTask.Stop(); } } button_stim.Enabled = true; button_stimExpt.Enabled = true; openLoopStart.Enabled = true; radioButton_impCurrent.Enabled = true; radioButton_impVoltage.Enabled = true; radioButton_stimCurrentControlled.Enabled = true; radioButton_stimVoltageControlled.Enabled = true; button_impedanceTest.Enabled = true; } else { button_stim.Enabled = false; button_stimExpt.Enabled = false; openLoopStart.Enabled = false; radioButton_impCurrent.Enabled = false; radioButton_impVoltage.Enabled = false; radioButton_stimCurrentControlled.Enabled = false; radioButton_stimVoltageControlled.Enabled = false; button_impedanceTest.Enabled = false; } } Console.WriteLine("updateStim"); }
// Called when stimulation is stopped private void resetStim() { //Zero out IvsV and dispose stimIvsVTask = new Task("stimIvsV"); stimIvsVTask.DOChannels.CreateChannel(Properties.Settings.Default.StimIvsVDevice + "/Port1/line0", "", ChannelLineGrouping.OneChannelForAllLines); stimIvsVWriter = new DigitalSingleChannelWriter(stimIvsVTask.Stream); stimIvsVTask.Control(TaskAction.Verify); stimIvsVWriter.WriteSingleSampleSingleLine(true, false); stimIvsVTask.WaitUntilDone(); stimIvsVTask.Stop(); stimIvsVTask.Dispose(); // Sero out stim digital output and dispose if (stimDigitalTask != null) stimDigitalTask.Dispose(); stimDigitalTask = new Task("stimDigitalTask_formClosing"); if (Properties.Settings.Default.StimPortBandwidth == 32) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:31", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes else if (Properties.Settings.Default.StimPortBandwidth == 8) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:7", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes stimDigitalWriter = new DigitalSingleChannelWriter(stimDigitalTask.Stream); bool[] fData = new bool[Properties.Settings.Default.StimPortBandwidth]; stimDigitalWriter.WriteSingleSampleMultiLine(true, fData); stimDigitalTask.WaitUntilDone(); stimDigitalTask.Stop(); Console.WriteLine("resetStim completed"); }
private void button_computeGain_Click(object sender, EventArgs e) { double startFreq = Convert.ToDouble(numericUpDown_startFreq.Value); double stopFreq = Convert.ToDouble(numericUpDown_stopFreq.Value); double numPeriods = Convert.ToDouble(numericUpDown_numPeriods.Value); double[] freqs = new double[1 + Convert.ToInt32(Math.Floor(Math.Log(stopFreq / startFreq) / Math.Log(Convert.ToDouble(textBox_diagnosticsMult.Text))))]; //This determines the number of frequencies counting by doublings radioButton_stimVoltageControlled.Checked = true; radioButton_stimVoltageControlled_Click(null, null); //Populate freqs vector freqs[0] = startFreq; for (int i = 1; i < freqs.GetLength(0); ++i) freqs[i] = freqs[i - 1] * Convert.ToDouble(textBox_diagnosticsMult.Text); spikeSamplingRate = Properties.Settings.Default.RawSampleFrequency; buttonStart.Enabled = false; //So users can't try to get data from the same card button_computeGain.Enabled = false; button_computeGain.Refresh(); buttonStart.Refresh(); spikeTask = new List<Task>(Properties.Settings.Default.AnalogInDevice.Count); diagnosticsReaders = new List<AnalogMultiChannelReader>(Properties.Settings.Default.AnalogInDevice.Count); for (int i = 0; i < Properties.Settings.Default.AnalogInDevice.Count; ++i) { spikeTask.Add(new Task("spikeTask_Diagnostics_" + i)); int numChannelsPerDevice = (numChannels < 32 ? numChannels : 32); for (int j = 0; j < numChannelsPerDevice; ++j) spikeTask[i].AIChannels.CreateVoltageChannel(Properties.Settings.Default.AnalogInDevice[0] + "/ai" + j.ToString(), "", AITerminalConfiguration.Nrse, -10.0, 10.0, AIVoltageUnits.Volts); //Change gain based on comboBox values (1-100) setGain(spikeTask[i], Properties.Settings.Default.A2Dgain); //Verify the Task spikeTask[i].Control(TaskAction.Verify); spikeTask[i].Timing.ConfigureSampleClock("", spikeSamplingRate, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples); diagnosticsReaders.Add(new AnalogMultiChannelReader(spikeTask[i].Stream)); } spikeTask[0].Timing.ReferenceClockSource = "OnboardClock"; for (int i = 1; i < spikeTask.Count; ++i) { spikeTask[i].Timing.ReferenceClockSource = spikeTask[0].Timing.ReferenceClockSource; spikeTask[i].Timing.ReferenceClockRate = spikeTask[0].Timing.ReferenceClockRate; } stimPulseTask.Timing.ReferenceClockSource = spikeTask[0].Timing.ReferenceClockSource; stimPulseTask.Timing.ReferenceClockRate = spikeTask[0].Timing.ReferenceClockRate; stimDigitalTask.Dispose(); stimDigitalTask = new Task("stimDigitalTask"); if (Properties.Settings.Default.StimPortBandwidth == 32) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:31", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes else if (Properties.Settings.Default.StimPortBandwidth == 8) stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:7", "", ChannelLineGrouping.OneChannelForAllLines); //To control MUXes stimDigitalWriter = new DigitalSingleChannelWriter(stimDigitalTask.Stream); stimPulseTask.Timing.ConfigureSampleClock("/" + Properties.Settings.Default.AnalogInDevice[0] + "/ai/SampleClock", spikeSamplingRate, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples); stimPulseTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger("/" + Properties.Settings.Default.AnalogInDevice[0] + "/ai/StartTrigger", DigitalEdgeStartTriggerEdge.Rising); stimDigitalTask.Control(TaskAction.Verify); stimPulseTask.Control(TaskAction.Verify); switch (Properties.Settings.Default.NumChannels) { case 0: numChannels = 16; break; case 1: numChannels = 32; break; case 2: numChannels = 48; break; case 3: numChannels = 64; break; } //gains = new double[numChannels, freqs.GetLength(0)]; //numChannels = 1; gains = new double[numChannels][]; for (int i = 0; i < numChannels; ++i) gains[i] = new double[freqs.GetLength(0)]; scatterGraph_diagnostics.ClearData(); scatterGraph_diagnostics.Plots.Clear(); textBox_diagnosticsResults.Clear(); if (!checkBox_diagnosticsBulk.Checked) { //for (int c = 1; c <= numChannels; ++c) for (int c = 13; c < 14; ++c) { textBox_diagnosticsResults.Text += "Channel " + c.ToString() + "\r\n\tFrequency (Hz)\tGain (dB)\r\n"; scatterGraph_diagnostics.Plots.Add(new ScatterPlot()); UInt32 data = StimPulse.channel2MUX((double)c); //Get data bits lined up to control MUXes //Setup digital waveform stimDigitalWriter.WriteSingleSamplePort(true, data); stimDigitalTask.WaitUntilDone(); stimDigitalTask.Stop(); for (int f = 0; f < freqs.GetLength(0); ++f) { double numSeconds = 1 / freqs[f]; if (numSeconds * numPeriods < 0.1) { numPeriods = Math.Ceiling(0.1 * freqs[f]); } int size = Convert.ToInt32(numSeconds * spikeSamplingRate); SineSignal testWave = new SineSignal(freqs[f], Convert.ToDouble(numericUpDown_diagnosticsVoltage.Value)); //Generate a 100 mV sine wave at 1000 Hz double[] testWaveValues = testWave.Generate(spikeSamplingRate, size); double[,] analogPulse = new double[2, size]; for (int i = 0; i < size; ++i) analogPulse[0, i] = testWaveValues[i]; for (int i = 0; i < spikeTask.Count; ++i) spikeTask[i].Timing.SamplesPerChannel = (long)(numPeriods * size); stimPulseTask.Timing.SamplesPerChannel = (long)(numPeriods * size); //Do numperiods cycles of sine wave stimPulseWriter.WriteMultiSample(true, analogPulse); double[] stateData = new double[4]; stateData[0] = (double)c; stateData[1] = freqs[f]; stateData[2] = (double)f; for (int i = diagnosticsReaders.Count - 1; i >= 0; --i) { stateData[3] = (double)i; diagnosticsReaders[i].BeginReadMultiSample((int)(numPeriods * size), analogInCallback_computeGain, (Object)stateData); //Get 5 seconds of "noise" } stimPulseTask.WaitUntilDone(); for (int i = 0; i < spikeTask.Count; ++i) { spikeTask[i].WaitUntilDone(); spikeTask[i].Stop(); } stimPulseTask.Stop(); } stimDigitalWriter.WriteSingleSamplePort(true, 0); stimDigitalTask.WaitUntilDone(); stimDigitalTask.Stop(); //DEBUGGING c = 1; scatterGraph_diagnostics.Plots[c - 1].PlotXY(freqs, gains[c - 1]); for (int f = 0; f < freqs.GetLength(0); ++f) { textBox_diagnosticsResults.Text += "\t" + freqs[f].ToString() + "\t" + gains[c - 1][f] + "\r\n"; } textBox_diagnosticsResults.Text += "\r\n"; scatterGraph_diagnostics.Refresh(); //DEBUGGING c = 100; } } else { for (int f = 0; f < freqs.GetLength(0); ++f) { double numSeconds = 1 / freqs[f]; if (numSeconds * numPeriods < 0.1) { numPeriods = Math.Ceiling(0.1 * freqs[f]); } int size = Convert.ToInt32(numSeconds * spikeSamplingRate); SineSignal testWave = new SineSignal(freqs[f], Convert.ToDouble(numericUpDown_diagnosticsVoltage.Value)); //Generate a 100 mV sine wave at 1000 Hz double[] testWaveValues = testWave.Generate(spikeSamplingRate, size); double[,] analogPulse = new double[2, size]; for (int i = 0; i < size; ++i) analogPulse[0, i] = testWaveValues[i]; for (int i = 0; i < spikeTask.Count; ++i) spikeTask[i].Timing.SamplesPerChannel = (long)(numPeriods * size); stimPulseTask.Timing.SamplesPerChannel = (long)(numPeriods * size); //Do numperiods cycles of sine wave stimPulseWriter.WriteMultiSample(true, analogPulse); double[] stateData = new double[4]; stateData[0] = -1.0; stateData[1] = freqs[f]; stateData[2] = (double)f; //Frequency of interest for (int i = diagnosticsReaders.Count - 1; i >= 0; --i) { stateData[3] = (double)i; //Keeps track of which device called the reader diagnosticsReaders[i].BeginReadMultiSample((int)(numPeriods * size), analogInCallback_computeGain, (Object)stateData); //Get 5 seconds of "noise" } stimPulseTask.WaitUntilDone(); for (int i = 0; i < spikeTask.Count; ++i) { spikeTask[i].WaitUntilDone(); spikeTask[i].Stop(); } stimPulseTask.Stop(); } for (int c = 0; c < numChannels; ++c) { scatterGraph_diagnostics.Plots.Add(new ScatterPlot()); scatterGraph_diagnostics.Plots[c].PlotXY(freqs, gains[c]); textBox_diagnosticsResults.Text += "Channel " + (c + 1).ToString() + "\r\n\tFrequency (Hz)\tGain (dB)\r\n"; for (int f = 0; f < freqs.GetLength(0); ++f) { textBox_diagnosticsResults.Text += "\t" + freqs[f].ToString() + "\t" + gains[c][f].ToString() + "\r\n"; } textBox_diagnosticsResults.Text += "\r\n"; } scatterGraph_diagnostics.Refresh(); } buttonStart.Enabled = true; button_computeGain.Enabled = true; //Now, destroy the objects we made updateSettings(); gains = null; diagnosticsReaders = null; }