public void SendScanTriggerAndWaitUntilDone()
{
triggerWriter.WriteSingleSampleSingleLine(true, false);
sendScanTriggerTask.Stop();
triggerWriter.WriteSingleSampleSingleLine(true, true);
sendScanTriggerTask.Start();
outputCavityTask.WaitUntilDone();
readPhotodiodesTask.WaitUntilDone();
}
/// <summary>
/// Set the direction of the traverse
/// </summary>
private void SetDirection(Direction dir)
{
Direction = dir;
if (dir == Direction.Up)
{
dirWriter.WriteSingleSampleSingleLine(true, true);
}
else
{
dirWriter.WriteSingleSampleSingleLine(true, false);
}
}
/// <summary>
/// Turn on the component and update the state
/// </summary>
public virtual void TurnOn()
{
writer.WriteSingleSampleSingleLine(true, true);
_state = true;
DateTime date = DateTime.Now;
string str = string.Format("{0}-{1}-{2}, {3:00}:{4:00}:{5:00}: ",
date.Year,
date.Month,
date.Day, date.Hour, date.Minute, date.Second) + channelName + " turned on";
using StreamWriter writer2 = new StreamWriter("log.txt", true);
writer2.WriteLine(str);
}
public void setHi(bool[] device)
{
if (device[0])
{
myDigitalWriter1.WriteSingleSampleSingleLine(true, device[0]);
}
if (device[1])
{
myDigitalWriter2.WriteSingleSampleSingleLine(true, device[1]);
}
if (device[2])
{
myDigitalWriter3.WriteSingleSampleSingleLine(true, device[2]);
}
}
public RelayBoxComponent(string port, string channelName)
{
control = new DOTask(port, channelName);
writer = new DigitalSingleChannelWriter(control.Stream);
this.channelName = channelName;
writer.WriteSingleSampleSingleLine(true, true);
}
public void SetDigitalLine(string name, bool value)
{
Task digitalTask = ((Task)digitalTasks[name]);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalTask.Stream);
writer.WriteSingleSampleSingleLine(true, value);
digitalTask.Control(TaskAction.Unreserve);
}
public ThorlabsLDC240Controller(string device, string aoCurrent, string doOnOff)
{
_laserOn = false;
_current = 0;
//Set up tasks and channel writers
_onOffTask = new Task("LaserOnOff");
_onOffTask.DOChannels.CreateChannel(device + "/" + doOnOff, "OnOff", ChannelLineGrouping.OneChannelForAllLines);
_onOffWriter = new DigitalSingleChannelWriter(_onOffTask.Stream);
_currentTask = new Task("LaserCurrent");
_currentTask.AOChannels.CreateVoltageChannel(device + "/" + aoCurrent, "Current", 0, 10, AOVoltageUnits.Volts);
_currentWriter = new AnalogSingleChannelWriter(_currentTask.Stream);
//Set current to 0
_currentWriter.WriteSingleSample(true, 0);
//The laser controller only reacts to edges on the TTL line - so to gain control briefly switch on, then off
_onOffWriter.WriteSingleSampleSingleLine(true, true);
Thread.Sleep(100);
_onOffWriter.WriteSingleSampleSingleLine(true, false);
}
public void DAQDO()
{
NationalInstruments.DAQmx.Task digitalWriteTask = DaqSystem.Local.LoadTask("Digital_Write_Single");
DigitalSingleChannelWriter DO_Channel = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
do
{
DO_Channel.WriteSingleSampleSingleLine(true, Global.DO);
} while (exit == false);
}
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();
}
private const double STEP = 250e-4; // in mm
#endregion
#region Constructors
public Traverse()
{
dirTask = new DOTask(ConfigurationManager.AppSettings["TravDir"], "dir");
dirWriter = new DigitalSingleChannelWriter(dirTask.Stream);
pulse = new DOTask(ConfigurationManager.AppSettings["TravPulse"], "pulse");
pulseWriter = new DigitalSingleChannelWriter(pulse.Stream);
Direction = Direction.Down;
pulseWriter.WriteSingleSampleSingleLine(true, false);
dirWriter.WriteSingleSampleSingleLine(true, false);
}
public void WriteDOut(int nDev, int nPort, int nStartLine, int nEndLine, int nLines)
{
string strDev = "Dev" + string.Format("{0:d}", nDev) + "/port" +
string.Format("{0:d}", nPort) + "/line" +
string.Format("{0:d}", nStartLine) +
":" + string.Format("{0:d}", nEndLine);
try
{
using (Task digitalWriteTask = new Task())
{
digitalWriteTask.DOChannels.CreateChannel(strDev, "",
ChannelLineGrouping.OneChannelForAllLines);
bool[] dataArray = new bool[8];
int nTemp = nLines;
bool bTemp;
for (int i = nStartLine; i <= nEndLine; i++)
{
if ((nTemp & 1) == 1)
{
bTemp = true;
}
else
{
bTemp = false;
}
dataArray[nEndLine - nStartLine - (i - nStartLine)] = bTemp;
nTemp = nTemp >> 1;
}
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
if (nStartLine != nEndLine)
{
writer.WriteSingleSampleMultiLine(true, dataArray);
}
else
{
writer.WriteSingleSampleSingleLine(true, dataArray[0]);
}
}
}
catch (DaqException ex)
{
// MessageBox.Show(ex.Message);
}
finally
{
// Cursor.Current = Cursors.Default;
}
}
static public void Write_SingleDIO(uint linenum, bool value)
{
string ni_port_desc = get_PhysicalDOPortChannel(0);
using (NationalInstruments.DAQmx.Task digitalWriteTask = new Task())
{
// Create an Digital Output channel and name it.
string linestr = string.Format("{0}/line{1}", ni_port_desc, linenum);
string name = string.Format("line{0}", linenum);
digitalWriteTask.DOChannels.CreateChannel(linestr, name, ChannelLineGrouping.OneChannelForEachLine);
// Write digital port data. WriteDigitalSingChanSingSampPort writes a single sample
// of digital data on demand, so no timeout is necessary.
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
writer.WriteSingleSampleSingleLine(true, value);
}
}
//Funtion to enable the specified output signal
public bool EnableOutput(OutputSignals signal, bool enable)
{
OutputLine output = outputs[(int)signal];
//Check if signal has a valid device association
if (output.slot == "")
{
return(false);
}
//Check if signal has a valid port association
if (output.port < 0 || output.port >= PortsPerDevice)
{
return(false);
}
//Check if signal has a valid line association
if (output.line < 0 || output.line >= LinesPerPort)
{
return(false);
}
//Enable or disable the signal based on the assigned device slot, port, and line
bool outputValue = (enable != outputs[(int)signal].activeHigh);
string outputChannel = outputs[(int)signal].slot;
outputChannel += "/port" + outputs[(int)signal].port.ToString();
outputChannel += "/line" + outputs[(int)signal].line.ToString();
try
{
using (NationalInstruments.DAQmx.Task digitalWriteTask = new NationalInstruments.DAQmx.Task())
{
digitalWriteTask.DOChannels.CreateChannel(outputChannel, "", ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
writer.WriteSingleSampleSingleLine(true, outputValue);
}
}
catch
{
}
return(true);
}
public static void WriteDO(string port_num, bool value, int milliseconds = 100, string dev_name = "Dev1")
{
if (RuntimeConfiguration.Mode.HasFlag(RuntimeMode.VirtualNI))
{
return;
}
dev_name = RefactorDevName(dev_name);
Task task = new Task();
string port = port_num.Split(new char[] { '.' })[0];
string line = port_num.Split(new char[] { '.' })[1];
task.DOChannels.CreateChannel(string.Format("{0}/port{1}/line{2}", dev_name, port, line), "", ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(task.Stream);
task.Start();
Thread.Sleep(milliseconds);
writer.WriteSingleSampleSingleLine(false, value);
task.Stop();
task.Dispose();
}
public void Dispose()
{
if (IsDisposed)
{
return;
}
if (_onOffTask != null)
{
_onOffWriter.WriteSingleSampleSingleLine(true, false);
_onOffTask.Dispose();
_onOffTask = null;
}
if (_currentTask != null)
{
_currentWriter.WriteSingleSample(true, 0);
_currentTask.Dispose();
_currentTask = null;
}
IsDisposed = true;
}
// 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");
}
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>
/// Do a step of the traverse in the current direction
/// </summary>
private void Step()
{
pulseWriter.WriteSingleSampleSingleLine(true, true);
pulseWriter.WriteSingleSampleSingleLine(true, false);
}
private void SetDigitalLine(string name, bool value)
{
Task digitalTask = ((Task)digitalTasks[name]);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalTask.Stream);
writer.WriteSingleSampleSingleLine(true, value);
digitalTask.Control(TaskAction.Unreserve);
}
// Look at the stimulation hardware settings and create NI Tasks that reflect the user's choices
private void UpdateStimulationSettings()
{
try
{
if (stimPulseTask != null) { stimPulseTask.Dispose(); stimPulseTask = null; }
if (stimDigitalTask != null) { stimDigitalTask.Dispose(); stimDigitalTask = null; }
if (Properties.Settings.Default.UseStimulator)
{
if (stimDigitalTask == null)
{
stimDigitalTask = new Task("stimDigitalTask");
stimPulseTask = new Task("stimPulseTask");
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
{
string tmp1 = Properties.Settings.Default.StimulatorDevice.ToString();
string tmp2 = Properties.Settings.Default.AnalogInDevice[0].ToString();
if (tmp1.Equals(tmp2))
{
stimPulseTask.Timing.ReferenceClockSource = "OnboardClock";
}
else
{
stimPulseTask.Timing.ReferenceClockSource = "/" + Properties.Settings.Default.StimulatorDevice.ToString() + "/PFI0";
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.Control(TaskAction.Verify);
if (radioButton_impCurrent.Checked) stimIvsVWriter.WriteSingleSampleSingleLine(true, true);
else stimIvsVWriter.WriteSingleSampleSingleLine(true, false);
stimIvsVTask.WaitUntilDone();
//stimIvsVTask.Stop();
stimIvsVTask.Dispose();
}
}
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("UpdateStimulationSettings completed");
}
catch (DaqException exception)
{
MessageBox.Show(exception.Message); //Display Errors
reset();
}
}
//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");
}
// Look at the stimulation hardware settings and create NI Tasks that reflect the user's choices
private void UpdateStimulationSettings()
{
try
{
if (stimPulseTask != null)
{
stimPulseTask.Dispose(); stimPulseTask = null;
}
if (stimDigitalTask != null)
{
stimDigitalTask.Dispose(); stimDigitalTask = null;
}
if (Properties.Settings.Default.UseStimulator)
{
if (stimDigitalTask == null)
{
stimDigitalTask = new Task("stimDigitalTask");
stimPulseTask = new Task("stimPulseTask");
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
{
string tmp1 = Properties.Settings.Default.StimulatorDevice.ToString();
string tmp2 = Properties.Settings.Default.AnalogInDevice[0].ToString();
if (tmp1.Equals(tmp2))
{
stimPulseTask.Timing.ReferenceClockSource = "OnboardClock";
}
else
{
stimPulseTask.Timing.ReferenceClockSource = "/" + Properties.Settings.Default.StimulatorDevice.ToString() + "/PFI0";
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.Control(TaskAction.Verify);
if (radioButton_impCurrent.Checked)
{
stimIvsVWriter.WriteSingleSampleSingleLine(true, true);
}
else
{
stimIvsVWriter.WriteSingleSampleSingleLine(true, false);
}
stimIvsVTask.WaitUntilDone();
//stimIvsVTask.Stop();
stimIvsVTask.Dispose();
}
}
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("UpdateStimulationSettings completed");
}
catch (DaqException exception)
{
MessageBox.Show(exception.Message); //Display Errors
reset();
}
}
/// <summary>
/// Writes to the specified line number
/// </summary>
/// <param name="linenum"></param>
/// <param name="value"></param>
public void WriteLine(uint linenum, bool value)
{
string linename = GetName(linenum);
_dic_values[linename] = value;
if (_dev_type == Device_Types.NI_USB6008)
{
using (Task digitalWriteTask = new Task())
{
// Create an Digital Output channel and name it.
string linestr = string.Format("{0}/line{1}", _ni_port_desc, linenum);
string name = string.Format("line{0}", linenum);
digitalWriteTask.DOChannels.CreateChannel(linestr, name, ChannelLineGrouping.OneChannelForEachLine);
// Write digital port data. WriteDigitalSingChanSingSampPort writes a single sample
// of digital data on demand, so no timeout is necessary.
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
writer.WriteSingleSampleSingleLine(true, value);
}
return;
}
else if (_dev_type == Device_Types.FT232H)
{
FTD2XX_NET.FTDI.FT_STATUS status = _ft232hdio.SetPin(_ftdi_bus, linenum, value);
// ERROR if device is disconnected and then reconnected
// Try to recover
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
try
{
Close();
initFT232H();
Open();
status = _ft232hdio.SetPin(_ftdi_bus, linenum, value);
}
catch { }
}
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
throw new Exception(
string.Format("Error setting pin {0} to state {1}. Error = {2}", linenum, value, status.ToString() ) );
}
return;
}
}
public void SetCryoState(bool state)
{
cryoWriter.WriteSingleSampleSingleLine(true, state);
castView.SetCryoState(state);
}
public void SetHeaterState(bool state)
{
heaterWriter.WriteSingleSampleSingleLine(true, state);
castView.SetHeaterState(state);
}
//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");
}
/// <summary>
/// Take a snap with the Nikon using the intervalometer
/// </summary>
public void Snap()
{
writer.WriteSingleSampleSingleLine(true, true);
Thread.Sleep(100);
writer.WriteSingleSampleSingleLine(true, false);
}
private void WriteDigitalSingleValueOutput(bool outputValue)
{
_writer.WriteSingleSampleSingleLine(AutoStart, outputValue);
}
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;
}
}
// 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");
}
/// <summary>
/// Start internally clocked software triggered tasks, software timed tasks (like gpib tasks), and tasks which act as clocks for other tasks.
/// </summary>
/// <returns></returns>
public override bool generateTrigger()
{
lock (remoteLockObj)
{
try
{
messageLog(this, new MessageEvent("Generating triggers."));
Dictionary<string, DeviceSettings> devicesSettings = myServerSettings.myDevicesSettings;
List<string> devicesToSoftTrigger = new List<string>();
List<Task> tasksToSoftTrigger = new List<Task>();
List<Task> tasksToSoftTriggerLast = new List<Task>();
List<GpibTask> gpibTasksToTrigger = new List<GpibTask>();
List<RS232Task> rs232TasksToTrigger = new List<RS232Task>();
List<RfsgTask> rfsgTasksToTrigger = new List<RfsgTask>();
// This loop adds the NIDAQ analog and digital tasks that require soft trigger to the appropriate list.
// These are software triggered tasks which do NOT use an external sample clock (those that do are started in armTasks)
foreach (string dev in devicesSettings.Keys)
{
if ((devicesSettings[dev].StartTriggerType == DeviceSettings.TriggerType.SoftwareTrigger)
&& (devicesSettings[dev].MySampleClockSource != DeviceSettings.SampleClockSource.External))
{
devicesToSoftTrigger.Add(dev);
if (daqMxTasks.ContainsKey(dev))
{
if (daqMxTasks[dev] != null)
{
if (devicesSettings[dev].SoftTriggerLast)
{
tasksToSoftTriggerLast.Add(daqMxTasks[dev]);
}
else
{
tasksToSoftTrigger.Add(daqMxTasks[dev]);
}
}
}
}
}
// add all the gpib tasks to the soft trigger list
foreach (GpibTask gpTask in gpibTasks.Values)
{
gpibTasksToTrigger.Add(gpTask);
}
foreach (RS232Task task in rs232Tasks.Values)
{
rs232TasksToTrigger.Add(task);
}
foreach (RfsgTask task in rfsgTasks.Values)
{
rfsgTasksToTrigger.Add(task);
}
// If there is an additional "wait for ready" input, then wait for it.
if (serverSettings.ReadyInput != null)
{
if (serverSettings.ReadyInput != "")
{
if (sequence.WaitForReady)
{
messageLog(this, new MessageEvent("Waiting for ready input."));
Task readyReaderTask = new Task("ReadyInput");
readyReaderTask.DIChannels.CreateChannel(serverSettings.ReadyInput, "", ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelReader reader = new DigitalSingleChannelReader(readyReaderTask.Stream);
readyReaderLoopAbort = false;
readyReaderLoopRunning = true;
long startTicks = DateTime.Now.Ticks;
while (!reader.ReadSingleSampleSingleLine() && !readyReaderLoopAbort)
{
if (serverSettings.ReadyTimeout > 0)
{
long durationTicks = DateTime.Now.Ticks - startTicks;
if (durationTicks / 10000 > serverSettings.ReadyTimeout)
{
messageLog(this, new MessageEvent("Timeout waiting for ready input, more than " + serverSettings.ReadyTimeout + "ms elapsed."));
if (serverSettings.ReadyTimeoutRunAnyway)
{
messageLog(this, new MessageEvent("Running sequence anyway..."));
break;
}
else
{
readyReaderTask.Dispose();
messageLog(this, new MessageEvent("Aborting run."));
readyReaderLoopRunning = false;
return false;
}
}
}
}
readyReaderLoopRunning = false;
if (readyReaderLoopAbort)
{
messageLog(this, new MessageEvent("Received an abort request while running the ready input polling loop. Aborting."));
readyReaderTask.Dispose();
return false;
}
messageLog(this, new MessageEvent("Done waiting for ready input. Running sequence."));
readyReaderTask.Dispose();
}
}
}
// ok, done waiting for the ready input (or never stopped to wait)
// Hardware trigger outputs. This is not a recommended way to synchronize things.
if (serverSettings.TriggerOutputChannel != "" && serverSettings.TriggerOutputChannel != null)
{
messageLog(this, new MessageEvent("******* This server is configured to use a trigger output channel. This is not recommended. Instead, either use a variable timebase sample clock, or derive your start trigger from the StartTrigger channel of a software triggered task. *********"));
displayError();
string triggerChannel = serverSettings.TriggerOutputChannel;
// Create trigger tasks
/*List<Task> triggerTasks = new List<Task>();
List<DigitalSingleChannelWriter> triggerWriters = new List<DigitalSingleChannelWriter>();
foreach (string triggerChannel in serverSettings.TriggerOutputChannels)
{*/
Task triggerTask = new Task();
triggerTask.DOChannels.CreateChannel(triggerChannel, "", ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(triggerTask.Stream);
writer.WriteSingleSampleSingleLine(true, false);
// }
// wait for the trigger lines to go low.
Thread.Sleep(1);
// now pounce!
//foreach (DigitalSingleChannelWriter writer in triggerWriters)
writer.WriteSingleSampleSingleLine(true, true);
}
// Software triggering for daqMx tasks.
foreach (Task task in tasksToSoftTrigger)
{
task.Start();
}
if (!myServerSettings.TriggerSoftwareTasksAfterTimebaseTask)
{
// Trigger the software timed operations, but only if these operations are not going to be
// triggered through a triggering task. (see the armTasks function for more info).
if (softwareTriggeringTask == null)
{
if (computerClockProvider != null)
{
computerClockProvider.ArmClockProvider();
computerClockProvider.StartClockProvider();
messageLog(this, new MessageEvent("Triggered computer-software-clock (without sync to a hardware timed task)."));
}
}
}
foreach (Task task in tasksToSoftTriggerLast)
{
task.Start();
}
// finally, if there is a variable timebase output task, we start it.
if (variableTimebaseClockTask != null)
{
long before = DateTime.Now.Ticks;
variableTimebaseClockTask.Start();
long after = DateTime.Now.Ticks;
long elapsed = after - before;
int ms = (int)(elapsed / 10000);
messageLog(this, new MessageEvent("Triggered variable timebase clock task. Time elapsed waiting for task to start: " + ms + " ms."));
if (!myServerSettings.SilenceSoftwareTimebaseDelayError)
{
// Detect possible long delay between timebase and software task trigger.
if (ms > 50)
{
if (gpibTasks.Count + rs232Tasks.Count + rfsgTasks.Count > 0)
{
if (softwareTriggeringTask == null)
{
if (!myServerSettings.TriggerSoftwareTasksAfterTimebaseTask)
{
messageLog(this, new MessageEvent("**** NOTE: There is a delay of ~" + ms + " ms between the start of your software-timed tasks and the start of your variable timebase. To reduce this, either use the DeviceToSyncSoftwareTasksTo sync method, or set TriggerSoftwareTasksAfterTimebaseTask to true. To silence this error, set SilenceSoftwareTimebaseDelayError to true.***"));
displayError();
}
}
}
}
}
}
if (myServerSettings.TriggerSoftwareTasksAfterTimebaseTask)
{
// Trigger the software timed operations, but only if these operations are not going to be
// triggered through a triggering task. (see the armTasks function for more info).
if (softwareTriggeringTask == null)
{
if (computerClockProvider != null)
{
computerClockProvider.ArmClockProvider();
computerClockProvider.StartClockProvider();
messageLog(this, new MessageEvent("Triggered software-timed task(s) (without sync to a hardware timed task)."));
}
}
}
// TO DO. Insert code that waits for external triggers to occur, before returning. This
// Will allow client UI to stay synced with external triggers, if such things are being provided.
if (fpgaTasks != null)
{
foreach (FpgaTimebaseTask ft in fpgaTasks.Values)
{
ft.ArmClockProvider();
ft.StartClockProvider();
ft.Start();
}
}
messageLog(this, new MessageEvent("Triggers generated. Sequence running."));
return true;
}
catch (Exception e)
{
messageLog(this, new MessageEvent("Unable to generate triggers due to exception. " + e.Message + e.StackTrace));
displayError();
return false;
}
}
}
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;
}
}
