private void button1_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
try
{
using (Task digitalWriteTask = new Task())
{
digitalWriteTask.DOChannels.CreateChannel(comboBox1.Text, "", ChannelLineGrouping
.OneChannelForAllLines);
bool[] dataArray = new bool[8];
dataArray[0] = bit0CheckBox.Checked;
dataArray[1] = bit1CheckBox.Checked;
dataArray[2] = bit2CheckBox.Checked;
dataArray[3] = bit3CheckBox.Checked;
dataArray[4] = bit4CheckBox.Checked;
dataArray[5] = bit5CheckBox.Checked;
dataArray[6] = bit6CheckBox.Checked;
dataArray[7] = bit7CheckBox.Checked;
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
writer.WriteSingleSampleMultiLine(true, dataArray);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public void writeValue(bool data)
{
ddata = data;
bool[] dataArray = new bool[1];
dataArray[0] = !data;
writer.WriteSingleSampleMultiLine(true, dataArray);
}
public int WriteDigChannel2(string lines, string name, uint val, uint mask)
{
//Create a task such that it will be disposed after
//we are done using it.
int res = 0;
Task digitalWriteTask = new Task();
try
{
//Create channel
digitalWriteTask.DOChannels.CreateChannel(lines, "port0", ChannelLineGrouping.OneChannelForEachLine);
bool[] dataArray = new bool[7];
CheckLines(ref dataArray);
DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
digitalWriteTask.Start();
writer.WriteSingleSampleMultiLine(false, dataArray);
digitalWriteTask.Stop();
//UpdateDigitalShadows(lines, (int)val);
}
catch (DaqException ex)
{
DaqError(ex.Message);
res = -1;
}
finally {
//dispose task
digitalWriteTask.Dispose();
}
return(res);
}
//포트0 연결
public bool Connect_port0_write()
{
bool flag = false;
try
{
flag = true;
Writetask = new NationalInstruments.DAQmx.Task();
Writetask.DOChannels.CreateChannel(ini.GetIniValue("NI", "Name") + "/port0/line0:7", "Digital Output Port0", ChannelLineGrouping.OneChannelForAllLines);
writer = new DigitalSingleChannelWriter(Writetask.Stream);
for (int i = 0; i < 8; i++)
{
LED[i] = false;
}
if (writer != null)
{
writer.WriteSingleSampleMultiLine(true, LED);
}
}
catch
{
flag = false;
}
return(flag);
}
public bool Digital_Connect(string DAQName)
{
bool flag = false;
try
{
flag = true;
Writetask = new NationalInstruments.DAQmx.Task();
Writetask.DOChannels.CreateChannel(DAQName + "/port0/line0:7", "", ChannelLineGrouping.OneChannelForAllLines);
Writer = new DigitalSingleChannelWriter(Writetask.Stream);
for (int i = 0; i < 8; i++)
{
LED[i] = false;
}
if (Writer != null)
{
Writer.WriteSingleSampleMultiLine(true, LED);
}
}
catch (DaqException Exception)
{
flag = false;
MessageBox.Show(Exception.Message);
}
return(flag);
}
//포트0 출력
public void port0_Output(int index, bool value, ref string ErrorMsg)
{
LED[index] = value;
if (writer != null)
{
try
{
writer.WriteSingleSampleMultiLine(true, LED);
}
catch (DaqException de)
{
ErrorMsg = de.Message;
}
catch (Exception e)
{
ErrorMsg = e.Message;
}
}
}
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;
}
}
public void Digital_Write(int index, bool value)
{
LED[index] = value;
if (Writer != null)
{
try
{
Writer.WriteSingleSampleMultiLine(true, LED);
}
catch (DaqException de)
{
if (Writetask != null)
{
Writetask.Dispose();
Writetask = null;
}
IsConnect = false;
//return IsConnect;
}
}
}
// Called when stimulation is stopped
private void resetStim()
{
//Zero out IvsV and dispose
stimIvsVTask = new Task("stimIvsV");
stimIvsVTask.DOChannels.CreateChannel(Properties.Settings.Default.StimIvsVDevice + "/Port1/line0", "",
ChannelLineGrouping.OneChannelForAllLines);
stimIvsVWriter = new DigitalSingleChannelWriter(stimIvsVTask.Stream);
stimIvsVTask.Control(TaskAction.Verify);
stimIvsVWriter.WriteSingleSampleSingleLine(true, false);
stimIvsVTask.WaitUntilDone();
stimIvsVTask.Stop();
stimIvsVTask.Dispose();
// Sero out stim digital output and dispose
if (stimDigitalTask != null)
{
stimDigitalTask.Dispose();
}
stimDigitalTask = new Task("stimDigitalTask_formClosing");
if (Properties.Settings.Default.StimPortBandwidth == 32)
{
stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:31", "",
ChannelLineGrouping.OneChannelForAllLines); //To control MUXes
}
else if (Properties.Settings.Default.StimPortBandwidth == 8)
{
stimDigitalTask.DOChannels.CreateChannel(Properties.Settings.Default.StimulatorDevice + "/Port0/line0:7", "",
ChannelLineGrouping.OneChannelForAllLines); //To control MUXes
}
stimDigitalWriter = new DigitalSingleChannelWriter(stimDigitalTask.Stream);
bool[] fData = new bool[Properties.Settings.Default.StimPortBandwidth];
stimDigitalWriter.WriteSingleSampleMultiLine(true, fData);
stimDigitalTask.WaitUntilDone();
stimDigitalTask.Stop();
Console.WriteLine("resetStim completed");
}
private void button_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;
}
/// <summary>
/// Escribe los valores de unos puertos de salida binarios
/// </summary>
/// <param name="nombres">Nombres de puertos de salida</param>
/// <param name="data">Valor para escribir</param>
/// <param name="persistente">true - para crear una tarea de escritura permanente</param>
/// <exception cref="ArgumentNullException">
/// 1. Nombres es null
/// 2. Data es null
/// </exception>
/// <exception cref="ArgumentException">
/// 1. El nombre de canal es null
/// 2. El nombre de canal no es valido
/// 3. Se presente el puerto y el canal de mismo puerto
/// 4. Numero de canales en data no corrsponde al numero de canales especificados
/// </exception>
/// <exception cref="DriverException">Error de driver de la tarjeta</exception>
public void EscribirBinario(string[] nombres, bool[] data, bool persistente = false)
{
var canales = ValidarCanales(nombres);
if (data == null)
{
throw new ArgumentNullException("data");
}
if (data.Length != canales)
{
throw new ArgumentException("El numero de canales especificados " + canales.ToString() +
" no corresponde al numero de canales en datos " + data.Length.ToString());
}
Task digitalWriteTask = null;
try
{
// Generar nombre de la tarea
var nombreTarea = "E" + String.Join(",", nombres);
// Si la tarea esta creada antes
if (tareas.ContainsKey(nombreTarea))
{
digitalWriteTask = tareas[nombreTarea];
persistente = true;
}
else
{
// Crear nueva tarea
digitalWriteTask = new Task();
// Agregar los canales
digitalWriteTask.DOChannels.CreateChannel(
String.Join(",", nombres),
"",
ChannelLineGrouping.OneChannelForAllLines);
// Guardar tarea persistente
if (persistente)
{
tareas.Add(nombreTarea, digitalWriteTask);
}
}
// Escribir los datos
var writer = new DigitalSingleChannelWriter(digitalWriteTask.Stream);
writer.WriteSingleSampleMultiLine(true, data);
}
catch (DaqException ex)
{
throw new DriverException(ex);
}
finally
{
if (!persistente && (digitalWriteTask != null))
{
digitalWriteTask.Dispose();
digitalWriteTask = null;
}
}
}
// 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");
}
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();
}
