/// <summary>
/// Set the trigger by writing a high on the trigger line
/// </summary>
public static void TriggerAll()
{
if (!TriggerInititalized)
{
throw new ApplicationException("Trigger not initialized. Create PWMTask object first or call InitializeTrigger.");
}
System.Diagnostics.Debug.WriteLineIf(_refcount < 1, "Triggering but no PWMTaskobject was created!");
lock (_triggerTaskLock)
_triggerWriter.WriteSingleSamplePort(true, 1);
}
public void SetScopeAddr(int addr)
{
byte addrOut = (byte)(~addr & 0xFF);
//Ignore any invalid addresses and set to 0
if (addr > MaxAddr)
{
addrOut = 0;
}
//Set address using a single port write
try
{
using (NationalInstruments.DAQmx.Task digitalWriteTask = new NationalInstruments.DAQmx.Task())
{
string addressCh = outputs[(int)OutputSignals.ScopeAddr0].slot;
addressCh += "/port" + outputs[(int)OutputSignals.ScopeAddr0].port.ToString();
//addressCh += "/line0:7";
digitalWriteTask.DOChannels.CreateChannel(addressCh, "", ChannelLineGrouping.OneChannelForAllLines);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
writer.WriteSingleSamplePort(true, addrOut);
}
}
catch
{
}
//Wait for relays to switch
Thread.Sleep(RelayWaitMs);
}
public void WriteData(int length)
{
// Sends data down an open channel to the NI ELVIS device.
if (writer != null)
{
writer.WriteSingleSamplePort(true, (UInt32)length);
}
}
public void WriteData(int length)
{
//call WriteSignleSamplePort method to write the data to the channel
if (writer != null)
{
writer.WriteSingleSamplePort(true, (UInt32)length);
}
}
private int Init()
{
try
{
digitalWriteTaskP00 = new Task();
digitalWriteTaskP01 = new Task();
digitalWriteTaskP02 = new Task();
digitalWriteTaskP03 = new Task();
digitalWriteTaskP04 = new Task();
digitalWriteTaskP05 = new Task();
digitalWriteTaskP09 = new Task();
digitalWriteTaskP00.DOChannels.CreateChannel("DIO/port0", "port0",
ChannelLineGrouping.OneChannelForAllLines);
digitalWriteTaskP01.DOChannels.CreateChannel("DIO/port1", "port1",
ChannelLineGrouping.OneChannelForAllLines);
digitalWriteTaskP02.DOChannels.CreateChannel("DIO/port2", "port2",
ChannelLineGrouping.OneChannelForAllLines);
digitalWriteTaskP03.DOChannels.CreateChannel("DIO/port3", "port3",
ChannelLineGrouping.OneChannelForAllLines);
digitalWriteTaskP04.DOChannels.CreateChannel("DIO/port4", "port4",
ChannelLineGrouping.OneChannelForAllLines);
digitalWriteTaskP05.DOChannels.CreateChannel("DIO/port5", "port5",
ChannelLineGrouping.OneChannelForAllLines);
digitalWriteTaskP09.DOChannels.CreateChannel("DIO/port9", "port9",
ChannelLineGrouping.OneChannelForAllLines);
writerP00 = new DigitalSingleChannelWriter(digitalWriteTaskP00.Stream);
writerP01 = new DigitalSingleChannelWriter(digitalWriteTaskP01.Stream);
writerP02 = new DigitalSingleChannelWriter(digitalWriteTaskP02.Stream);
writerP03 = new DigitalSingleChannelWriter(digitalWriteTaskP03.Stream);
writerP04 = new DigitalSingleChannelWriter(digitalWriteTaskP04.Stream);
writerP05 = new DigitalSingleChannelWriter(digitalWriteTaskP05.Stream);
writerP09 = new DigitalSingleChannelWriter(digitalWriteTaskP09.Stream);
writerP00.WriteSingleSamplePort(true, 0);
writerP01.WriteSingleSamplePort(true, 0);
writerP02.WriteSingleSamplePort(true, 0);
writerP03.WriteSingleSamplePort(true, 0);
writerP04.WriteSingleSamplePort(true, 0);
writerP05.WriteSingleSamplePort(true, 0);
writerP09.WriteSingleSamplePort(true, 0);
return(0);
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "Initialize");
return(-1);
}
}
/// <summary>
/// Reset all lines/pins to 0 - called by Dispose method
/// </summary>
private void ResetPort()
{
Task reset = new Task("Reset");
reset.DOChannels.CreateChannel(_line, "do0", ChannelLineGrouping.OneChannelForAllLines);
DigitalSingleChannelWriter resetWriter = new DigitalSingleChannelWriter(reset.Stream);
resetWriter.WriteSingleSamplePort(true, (uint)0);
reset.Dispose();
}
public void SetPath(string val)
{
string[] tempdata;
tempdata = val.Split(';');
string[] tempdata2;
try
{
for (int i = 0; i < tempdata.Length; i++)
{
tempdata2 = tempdata[i].Split('_');
switch (tempdata2[0].ToUpper())
{
case "P0":
_writerP00.WriteSingleSamplePort(true, Convert.ToUInt32(tempdata2[1]));
break;
case "P1":
_writerP01.WriteSingleSamplePort(true, Convert.ToUInt32(tempdata2[1]));
break;
case "P2":
_writerP02.WriteSingleSamplePort(true, Convert.ToUInt32(tempdata2[1]));
break;
case "P3":
_writerP03.WriteSingleSamplePort(true, Convert.ToUInt32(tempdata2[1]));
break;
case "P4":
_writerP04.WriteSingleSamplePort(true, Convert.ToUInt32(tempdata2[1]));
break;
case "P5":
_writerP05.WriteSingleSamplePort(true, Convert.ToUInt32(tempdata2[1]));
break;
case "P9":
_writerP09.WriteSingleSamplePort(true, Convert.ToUInt32(tempdata2[1]));
break;
default:
MessageBox.Show("Port No : " + tempdata2[1].ToUpper(), "Only P0,P1,P2,P3,P4,P5 AND P9 ALLOWED !!!!\n" + "Pls check your switching configuration in Input Folder");
break;
}
}
}
catch (Exception ex)
{
throw new Exception("Agilent3499: SetPath -> " + ex.Message);
}
}
public void Initialize()
{
try
{
_digitalWriteTaskP00 = new Task();
_digitalWriteTaskP01 = new Task();
_digitalWriteTaskP02 = new Task();
_digitalWriteTaskP03 = new Task();
_digitalWriteTaskP04 = new Task();
_digitalWriteTaskP05 = new Task();
_digitalWriteTaskP09 = new Task();
_digitalWriteTaskP00.DOChannels.CreateChannel(IoAddress + "/port0", "port0",
ChannelLineGrouping.OneChannelForAllLines);
_digitalWriteTaskP01.DOChannels.CreateChannel(IoAddress + "/port1", "port1",
ChannelLineGrouping.OneChannelForAllLines);
_digitalWriteTaskP02.DOChannels.CreateChannel(IoAddress + "/port2", "port2",
ChannelLineGrouping.OneChannelForAllLines);
_digitalWriteTaskP03.DOChannels.CreateChannel(IoAddress + "/port3", "port3",
ChannelLineGrouping.OneChannelForAllLines);
_digitalWriteTaskP04.DOChannels.CreateChannel(IoAddress + "/port4", "port4",
ChannelLineGrouping.OneChannelForAllLines);
_digitalWriteTaskP05.DOChannels.CreateChannel(IoAddress + "/port5", "port5",
ChannelLineGrouping.OneChannelForAllLines);
_digitalWriteTaskP09.DOChannels.CreateChannel(IoAddress + "/port9", "port9",
ChannelLineGrouping.OneChannelForAllLines);
_writerP00 = new DigitalSingleChannelWriter(_digitalWriteTaskP00.Stream);
_writerP01 = new DigitalSingleChannelWriter(_digitalWriteTaskP01.Stream);
_writerP02 = new DigitalSingleChannelWriter(_digitalWriteTaskP02.Stream);
_writerP03 = new DigitalSingleChannelWriter(_digitalWriteTaskP03.Stream);
_writerP04 = new DigitalSingleChannelWriter(_digitalWriteTaskP04.Stream);
_writerP05 = new DigitalSingleChannelWriter(_digitalWriteTaskP05.Stream);
_writerP09 = new DigitalSingleChannelWriter(_digitalWriteTaskP09.Stream);
_writerP00.WriteSingleSamplePort(true, 0);
_writerP01.WriteSingleSamplePort(true, 0);
_writerP02.WriteSingleSamplePort(true, 0);
_writerP03.WriteSingleSamplePort(true, 0);
_writerP04.WriteSingleSamplePort(true, 0);
_writerP05.WriteSingleSamplePort(true, 0);
_writerP09.WriteSingleSamplePort(true, 0);
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "Initialize");
}
}
private void digitalOutLow(int selectPort)
{
switch (selectPort)
{
case 0:
Task digitalOutTask0 = new Task();
DOChannel DOChannel0;
DOChannel0 = digitalOutTask0.DOChannels.CreateChannel(P_pump, "Port1",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer0 = new DigitalSingleChannelWriter(digitalOutTask0.Stream);
writer0.WriteSingleSamplePort(true, 0);
break;
case 1:
Task digitalOutTask1 = new Task();
DOChannel DOChannel1;
DOChannel1 = digitalOutTask1.DOChannels.CreateChannel(P_v1, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer1 = new DigitalSingleChannelWriter(digitalOutTask1.Stream);
writer1.WriteSingleSamplePort(true, 0);
break;
case 2:
Task digitalOutTask2 = new Task();
DOChannel DOChannel2;
DOChannel2 = digitalOutTask2.DOChannels.CreateChannel(P_preH1, "Port1",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer2 = new DigitalSingleChannelWriter(digitalOutTask2.Stream);
writer2.WriteSingleSamplePort(true, 0);
break;
case 3:
Task digitalOutTask3 = new Task();
DOChannel DOChannel3;
DOChannel3 = digitalOutTask3.DOChannels.CreateChannel(P_preOn1, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer3 = new DigitalSingleChannelWriter(digitalOutTask3.Stream);
writer3.WriteSingleSamplePort(true, 0);
break;
case 4:
Task digitalOutTask4 = new Task();
DOChannel DOChannel4;
DOChannel4 = digitalOutTask4.DOChannels.CreateChannel(P_column, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer4 = new DigitalSingleChannelWriter(digitalOutTask4.Stream);
writer4.WriteSingleSamplePort(true, 0);
break;
}
}
//write Digital Out(port0|) - out value decimal value to bin
//(1 - 0000 0001, 2 - 0000 0010, 3 - 0000 0011, 4 - 0000 0100, 5 - 0000 0101, 8 - 0000 1000)
//(64 - 0100 0000, 32 - 0010 0000)
//(255 - 1111 1111)
public void writing_DO(string device, string port_name, uint val)
{
UInt32 dataDO = val;
Task digitalWriteTask = new Task();
// Create an Digital Output channel and name it.
digitalWriteTask.DOChannels.CreateChannel("dev1/port0", "port0", ChannelLineGrouping.OneChannelForAllLines);
// 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.WriteSingleSamplePort(true, (UInt32)dataDO);
}
public void WriteDigPortLine(string lines, string name, int val)
{
//Create a task such that it will be disposed after
//we are done using it.
Task digitalWriteTask = new Task();
DOChannel ch;
try
{
//Create a Digital Output channel and name it.
ch = digitalWriteTask.DOChannels.CreateChannel(lines, "line0", ChannelLineGrouping.OneChannelForAllLines);
//get the states of the lines before we get started
//Verify the Task
//m_digitalWriteTask.Control(TaskAction.Verify)
//Dim st As DOLineStatesStartState
//st = ch.LineStatesStartState()
//Dim data As UInt32
//Dim reader As DigitalSingleChannelReader = New DigitalSingleChannelReader(digitalReadTask.Stream)
//digitalReadTask.Start()
//data = reader.ReadSingleSamplePortUInt32()
//digitalReadTask.Stop()
// 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);
DaqBuffer buf;
buf = digitalWriteTask.Stream.Buffer;
digitalWriteTask.Start();
//st = ch.LineStatesStartState
writer.WriteSingleSamplePort(false, val);
//st = ch.LineStatesStartState
digitalWriteTask.Stop();
buf = digitalWriteTask.Stream.Buffer;
//UpdateDigitalShadows(lines, (int)val);
}
catch (System.Exception ex) {
DaqError(ex.Message);
}
finally {
//dispose task
digitalWriteTask.Dispose();
}
}
public static string TurnSwitch(int line, int value, string sourceDevice = "Dev1")
{
try
{
NationalInstruments.DAQmx.Task dIOTask = new NationalInstruments.DAQmx.Task();
dIOTask.DOChannels.CreateChannel(sourceDevice + "/port0/line" + line.ToString(),
"DigitalOut_0", ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(dIOTask.Stream);
writer.WriteSingleSamplePort(true, value);
}
catch (DaqException)
{
return("Fail");
}
return("OK");
}
public int WriteDigChannelGroup(string lines, string name, uint val)
{
//Create a task such that it will be disposed after
//we are done using it.
int res = 0;
Task digitalWriteTask = new Task();
DOChannel ch;
try
{
//Create channel
ch = digitalWriteTask.DOChannels.CreateChannel(lines, "digwrite", ChannelLineGrouping.OneChannelForAllLines);
//Dim st As DOLineStatesStartState
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
DigitalSingleChannelReader reader = new DigitalSingleChannelReader(digitalWriteTask.Stream);
bool[] data;
data = reader.ReadSingleSampleMultiLine();
digitalWriteTask.Start();
//st = ch.LineStatesStartState
if (ch.Tristate == true)
{
ch.Tristate = false;
}
writer.WriteSingleSamplePort(false, val);
digitalWriteTask.Stop();
//UpdateDigitalShadows(lines, CInt(val));
}
catch (DaqException ex)
{
DaqError(ex.Message);
res = -1;
}
finally
{
//dispose task
digitalWriteTask.Dispose();
}
return(res);
}
private string P1_3 = "dev1/port1/line3"; //precon H1
/*packed methods*/
private void digitalOutHigh(int selectPort)
{
switch (selectPort)
{
case 0:
Task digitalOutTask0 = new Task();
DOChannel DOChannel0;
DOChannel0 = digitalOutTask0.DOChannels.CreateChannel(P0_0, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer0 = new DigitalSingleChannelWriter(digitalOutTask0.Stream);
writer0.WriteSingleSamplePort(true, 1);
break;
case 1:
Task digitalOutTask1 = new Task();
DOChannel DOChannel1;
DOChannel1 = digitalOutTask1.DOChannels.CreateChannel(P0_1, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer1 = new DigitalSingleChannelWriter(digitalOutTask1.Stream);
writer1.WriteSingleSamplePort(true, -1);
break;
case 2:
Task digitalOutTask2 = new Task();
DOChannel DOChannel2;
DOChannel2 = digitalOutTask2.DOChannels.CreateChannel(P0_2, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer2 = new DigitalSingleChannelWriter(digitalOutTask2.Stream);
writer2.WriteSingleSamplePort(true, -1);
break;
case 3:
Task digitalOutTask3 = new Task();
DOChannel DOChannel3;
DOChannel3 = digitalOutTask3.DOChannels.CreateChannel(P0_3, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer3 = new DigitalSingleChannelWriter(digitalOutTask3.Stream);
writer3.WriteSingleSamplePort(true, -1);
break;
case 4:
Task digitalOutTask4 = new Task();
DOChannel DOChannel4;
DOChannel4 = digitalOutTask4.DOChannels.CreateChannel(P0_4, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer4 = new DigitalSingleChannelWriter(digitalOutTask4.Stream);
writer4.WriteSingleSamplePort(true, -1);
break;
case 5:
Task digitalOutTask5 = new Task();
DOChannel DOChannel5;
DOChannel5 = digitalOutTask5.DOChannels.CreateChannel(P0_5, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer5 = new DigitalSingleChannelWriter(digitalOutTask5.Stream);
writer5.WriteSingleSamplePort(true, -1);
break;
case 6:
Task digitalOutTask6 = new Task();
DOChannel DOChannel6;
DOChannel6 = digitalOutTask6.DOChannels.CreateChannel(P0_6, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer6 = new DigitalSingleChannelWriter(digitalOutTask6.Stream);
writer6.WriteSingleSamplePort(true, -1);
break;
case 7:
Task digitalOutTask7 = new Task();
DOChannel DOChannel7;
DOChannel7 = digitalOutTask7.DOChannels.CreateChannel(P0_7, "Port0",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer7 = new DigitalSingleChannelWriter(digitalOutTask7.Stream);
writer7.WriteSingleSamplePort(true, -1);
break;
case 10:
Task digitalOutTask10 = new Task();
DOChannel DOChannel10;
DOChannel10 = digitalOutTask10.DOChannels.CreateChannel(P1_0, "Port1",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer10 = new DigitalSingleChannelWriter(digitalOutTask10.Stream);
writer10.WriteSingleSamplePort(true, -1);
break;
case 11:
Task digitalOutTask11 = new Task();
DOChannel DOChannel11;
DOChannel11 = digitalOutTask11.DOChannels.CreateChannel(P1_1, "Port1",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer11 = new DigitalSingleChannelWriter(digitalOutTask11.Stream);
writer11.WriteSingleSamplePort(true, -1);
break;
case 12:
Task digitalOutTask12 = new Task();
DOChannel DOChannel12;
DOChannel12 = digitalOutTask12.DOChannels.CreateChannel(P1_2, "Port1",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer12 = new DigitalSingleChannelWriter(digitalOutTask12.Stream);
writer12.WriteSingleSamplePort(true, -1);
break;
case 13:
Task digitalOutTask13 = new Task();
DOChannel DOChannel13;
DOChannel13 = digitalOutTask13.DOChannels.CreateChannel(P1_3, "Port1",
ChannelLineGrouping.OneChannelForEachLine);
DigitalSingleChannelWriter writer13 = new DigitalSingleChannelWriter(digitalOutTask13.Stream);
writer13.WriteSingleSamplePort(true, -1);
break;
}
}
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;
}
/// <summary>
/// Writes the specified byte to the dev/port
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void writeButton_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
try
{
using (Task digitalWriteTask = new Task())
{
// Create an Digital Output channel and name it.
digitalWriteTask.DOChannels.CreateChannel(physicalChannelComboBox.Text, "port0", ChannelLineGrouping.OneChannelForAllLines);
// 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.WriteSingleSamplePort(true, (UInt32)NumericUpDowndataToWrite.Value);
}
refreshNumericUpDownValue();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
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;
}
private void WriteSingleDigital(NIDAQOutputStream stream, double value)
{
using (var t = new DAQTask())
{
t.DOChannels.CreateChannel(stream.PhysicalName, "", ChannelLineGrouping.OneChannelForAllLines);
var writer = new DigitalSingleChannelWriter(t.Stream);
writer.WriteSingleSamplePort(true, (UInt32) value);
}
}
private int SetPortPath(string PortPath)
{
try
{
string[] SwitchNoAndStatus = PortPath.Split(' ');
int NoOfSwitch = SwitchNoAndStatus.Length;
int[] SwitchNo = new int[NoOfSwitch];
int[] SwitchStatus = new int[NoOfSwitch];
string[] tempSwitchNoAndStatus = new string[2];
// Generate arrays for switch no and switch on/off status
for (int i = 0; i < NoOfSwitch; i++)
{
tempSwitchNoAndStatus = SwitchNoAndStatus[i].Split(':');
SwitchNo[i] = Convert.ToInt32(tempSwitchNoAndStatus[0]);
SwitchStatus[i] = Convert.ToInt32(tempSwitchNoAndStatus[1]);
}
// Clear the channel write need status
bool[] ChannelWriteNeeded = new bool[12];
int PortNo = 0;
int ChNo = 0;
for (int i = 0; i < NoOfSwitch; i++)
{
if (SwitchNo[i] == 48)
{
PortNo = 9;
}
else
{
PortNo = Convert.ToInt32(Math.Truncate(SwitchNo[i] / 8d));
}
ChNo = SwitchNo[i] - PortNo * 8;
int tempChValue = Convert.ToInt32(Math.Pow(2, ChNo));
int tempBitAnd = (ChannelValue[PortNo] & tempChValue);
if ((tempBitAnd == tempChValue) && (SwitchStatus[i] == 1))
{
// Do nothing
}
else if ((tempBitAnd == tempChValue) && (SwitchStatus[i] == 0))
{
ChannelValue[PortNo] -= tempChValue;
ChannelWriteNeeded[PortNo] = true;
}
else if ((tempBitAnd != tempChValue) && (SwitchStatus[i] == 1))
{
ChannelValue[PortNo] += tempChValue;
ChannelWriteNeeded[PortNo] = true;
}
else if ((tempBitAnd != tempChValue) && (SwitchStatus[i] == 0))
{
// Do nothing
}
else
{
MessageBox.Show("Error");
}
}
// Channel Write
if (ChannelWriteNeeded[0])
{
// writerP10.WriteSingleSamplePort(true, portValue);
writerP00.WriteSingleSamplePort(true, ChannelValue[0]);
}
if (ChannelWriteNeeded[1])
{
// writerP10.WriteSingleSamplePort(true, portValue);
writerP01.WriteSingleSamplePort(true, ChannelValue[1]);
}
if (ChannelWriteNeeded[2])
{
// writerP10.WriteSingleSamplePort(true, portValue);
writerP02.WriteSingleSamplePort(true, ChannelValue[2]);
}
if (ChannelWriteNeeded[3])
{
// writerP10.WriteSingleSamplePort(true, portValue);
writerP03.WriteSingleSamplePort(true, ChannelValue[3]);
}
if (ChannelWriteNeeded[4])
{
// writerP10.WriteSingleSamplePort(true, portValue);
writerP04.WriteSingleSamplePort(true, ChannelValue[4]);
}
if (ChannelWriteNeeded[5])
{
// writerP10.WriteSingleSamplePort(true, portValue);
writerP05.WriteSingleSamplePort(true, ChannelValue[5]);
}
if (ChannelWriteNeeded[9])
{
// writerP10.WriteSingleSamplePort(true, portValue);
writerP09.WriteSingleSamplePort(true, ChannelValue[9]);
}
return(0);
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "SetPortPath");
return(-1);
}
}
void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
//Measure each channel
for (int c = 0; c < numChannels && !bgWorker.CancellationPending; ++c)
{
UInt32 MuxData = StimPulse.channel2MUX(Convert.ToDouble(startChannel + c));
//Setup digital waveform, open MUX channel
stimDigitalWriter.WriteSingleSamplePort(true, MuxData);
stimDigitalTask.WaitUntilDone();
stimDigitalTask.Stop();
double numPeriodsUsed = numPeriods;
for (int f = 0; f < freqs.GetLength(0) && !bgWorker.CancellationPending; ++f)
{
//Update progress bars
bgWorker.ReportProgress(100 * (f + (c * freqs.Length)) / (numChannels * freqs.Length), new double[] { startChannel + c, freqs[f] });
//Create test wave
double numSeconds = 1 / freqs[f];
if (numSeconds * numPeriods < 0.1)
{
numPeriodsUsed = Math.Ceiling(0.1 * freqs[f]);
}
SineSignal testWave = new SineSignal(freqs[f], commandVoltage); //Generate a 100 mV sine wave at 1000 Hz
double[] testWaveValues = testWave.Generate(IMPEDANCE_SAMPLING_RATE, (long)Math.Round(numSeconds * (double)IMPEDANCE_SAMPLING_RATE));
int size = Convert.ToInt32(numSeconds * IMPEDANCE_SAMPLING_RATE);
double[,] analogPulse = new double[4, size];
for (int i = 0; i < size; ++i)
{
analogPulse[0 + 2, i] = testWaveValues[i];
}
impedanceRecord.Timing.SamplesPerChannel = (long)(numPeriodsUsed * size);
stimAnalogTask.Timing.SamplesPerChannel = (long)(numPeriodsUsed * size); //Do numperiods cycles of sine wave
//Deliver pulse
stimAnalogWriter.WriteMultiSample(true, analogPulse);
double[] data = impedanceReader.ReadMultiSample((int)(numPeriodsUsed * size));
#region Calculate Impedance
//Remove DC offset
double mData = 0.0;
for (int i = 0; i < data.Length; ++i)
{
mData += data[i];
}
mData /= data.Length;
for (int i = 0; i < data.Length; ++i)
{
data[i] -= mData;
}
//Filter data with Butterworth, if checked
if (useBandpassFilter)
{
ButterworthBandpassFilter bwfilt = new ButterworthBandpassFilter(1, IMPEDANCE_SAMPLING_RATE, freqs[f] - freqs[f] / 4, freqs[f] + freqs[f] / 4);
data = bwfilt.FilterData(data);
}
//Use matched filter to reduce noise, if checked (slow)
if (useMatchedFilter)
{
SineSignal wave = new SineSignal(freqs[f], 1.0); //Create a sine wave at test frequency of amplitude 1
double[] h; //filter
//If data is very long, subsample by an order of magnitude
if (data.Length > 1E6)
{
double[] dataNew = new double[(int)Math.Floor((double)data.Length / 10)];
for (int i = 0; i < dataNew.Length; ++i)
{
dataNew[i] = data[i * 10];
}
data = dataNew;
dataNew = null;
h = wave.Generate(IMPEDANCE_SAMPLING_RATE / 10, (long)Math.Round((double)IMPEDANCE_SAMPLING_RATE / (freqs[f] * 10))); //Generate one period
}
else
{
h = wave.Generate(IMPEDANCE_SAMPLING_RATE, (long)Math.Round((double)IMPEDANCE_SAMPLING_RATE / freqs[f])); //Generate one period
}
wave = null;
//Compute filter power
double phh = 0.0;
for (int i = 0; i < h.Length; ++i)
{
phh += h[i] * h[i];
}
//Normalize filter so power is 1
for (int i = 0; i < h.Length; ++i)
{
h[i] /= phh;
}
//sw.Start();
double[] x = NationalInstruments.Analysis.Dsp.SignalProcessing.Convolve(data, h);
//sw.Stop();
//TimeSpan ts = sw.Elapsed;
//System.Diagnostics.Debug.WriteLine("ms = " + ts.Milliseconds + "\t s = " + ts.Seconds + "\t min = " + ts.Minutes);
int offset = (int)(h.Length * 0.5);
for (int i = 0; i < data.Length; ++i)
{
data[i] = x[i + offset]; //Take center values
}
}
double rms = rootMeanSquared(data);
if (isCurrentControlled) //Current-controlled
{
impedance[c][f] = rms / (0.707106704695506 * commandVoltage / RCurr);
//Account for 6.8 MOhm resistor in parallel
impedance[c][f] = 1.0 / (1.0 / impedance[c][f] - 1.0 / 6800000.0);
}
else //Voltage-controlled
{
double gain = 1.0 + (49400.0 / RGain); //Based on LT in-amp
impedance[c][f] = (0.707106704695506 * commandVoltage) / ((rms / gain) / RMeas);
}
#endregion
//Wait until recording and stim are finished
stimAnalogTask.WaitUntilDone();
impedanceRecord.WaitUntilDone();
stimAnalogTask.Stop();
impedanceRecord.Stop();
}
//De-select channel on mux
stimDigitalWriter.WriteSingleSamplePort(true, 0);
stimDigitalTask.WaitUntilDone();
stimDigitalTask.Stop();
//Notify that channel is done
if (alertChannelFinished != null)
{
alertChannelFinished(this, c, startChannel + c, impedance, freqs);
}
}
//Reset muxes
bool[] fData = new bool[Properties.Settings.Default.StimPortBandwidth];
stimDigitalWriter.WriteSingleSampleMultiLine(true, fData);
stimDigitalTask.WaitUntilDone();
stimDigitalTask.Stop();
}
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 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;
}
public void resetFlipFlop()
{
ResetSignal = new Task("Reset Signal");
DOChannel myDOChannel;
myDOChannel = ResetSignal.DOChannels.CreateChannel(
prevodnikId + "/port0",
"write0",
ChannelLineGrouping.OneChannelForAllLines
);
writer = new DigitalSingleChannelWriter(ResetSignal.Stream);
writer.WriteSingleSamplePort(true, 127);//nastavit P0 na 01111111, => reset
Thread.Sleep(100);
writer.WriteSingleSamplePort(true, 255);//nastavit P0 na 11111111, => reset resetu
ResetSignal.Dispose();
}
