public void UpdateListening() { if (Recording) { return; } var inputPorts = Ports.OfType <NidaQmxChannel>().Where(p => p.Direction == ChannelDirection.Input && p.Status == DevicePortStatus.Active); var outputPorts = Ports.OfType <NidaQmxChannel>().Where(p => p.Direction == ChannelDirection.Output && p.Status == DevicePortStatus.Active); _listeningPorts = inputPorts.Concat(outputPorts).ToList(); if (_listeningPorts.Count == 0) { return; } double maxMultiChannelRate; var result = NidaQmxHelper.DAQmxGetDevAIMaxMultiChanRate(Name, out maxMultiChannelRate); if (result < 0) { OnError?.Invoke(this, new DeviceErrorArgs(NidaQmxHelper.GetError(result))); return; } SamplerateInput = (int)(maxMultiChannelRate / inputPorts.Count()); SamplesPerChannelInput = (int)(10000.0 * Math.Floor(SamplerateInput / 20.0 / 10000.0)); foreach (var port in inputPorts) { port.Samplerate = SamplerateInput; } }
public bool Stop() { if (!Recording) { return(false); } _stopThread = true; if (_pollThread != null && Thread.CurrentThread != _pollThread) { _pollThread.Join(); } Console.WriteLine("Stop call von Thread " + Thread.CurrentThread.ManagedThreadId); var resultStopTask = NidaQmxHelper.DAQmxStopTask(_device.InputTaskHandle); if (resultStopTask < 0) { _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(resultStopTask))); } Marshal.FreeHGlobal(Data); Data = IntPtr.Zero; Recording = false; return(true); }
private bool RunTask(InOutPortFlags flags) { if (flags.HasFlag(InOutPortFlags.UseInput)) { var result = NidaQmxHelper.DAQmxStartTask(_device.InputTaskHandle); if (result < 0) { NidaQmxHelper.DAQmxClearTask(_device.InputTaskHandle); _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); return(false); } } //if (flags.HasFlag(InOutPortFlags.UseOutput)) { // var result = NidaQmxHelper.DAQmxStartTask(_device.OutputTaskHandle); // if (result < 0) { // NidaQmxHelper.DAQmxStopTask(_device.InputTaskHandle); // NidaQmxHelper.DAQmxClearTask(_device.InputTaskHandle); // NidaQmxHelper.DAQmxClearTask(_device.OutputTaskHandle); // _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); // return false; // } //} return(true); }
public void Write(double[] data, int offset, int samples) { int written; Device.OutputBuffer.Write(ChannelNumber, data, offset, samples); if (Device.OutputBuffer.BufferReady) { unsafe { fixed(double *ptr = Device.OutputBuffer.CurrentBuffer.Data) { var result = NidaQmxHelper.DAQmxWriteAnalogF64( taskHandle: Device.OutputTaskHandle, numSampsPerChan: Device.OutputBuffer.CurrentBuffer.SamplesPerChannel, autoStart: 1, timeout: 10, dataLayout: NidaQmxHelper.DaQmxValGroupByChannel, writeArray: new IntPtr(ptr), sampsPerChanWritten: out written, reserved: IntPtr.Zero ); if (result < 0) { Device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); } } } Device.OutputBuffer.MoveToNextBuffer(); } }
public void DestroyTask() { if (TaskHandle != 0) //throw new InvalidOperationException("Task not yet created. First create a task"); { NidaQmxHelper.DAQmxClearTask(TaskHandle); TaskHandle = 0; } SamplesPerChannel = 0; _nodes.Clear(); State = SessionTaskState.None; }
private bool ConfigureDevClock(InOutPortFlags flags) { if (flags.HasFlag(InOutPortFlags.UseInput)) { var result = NidaQmxHelper.DAQmxCfgSampClkTiming( activeEdge: NidaQmxHelper.DaQmxValRising, sampleMode: NidaQmxHelper.DaQmxValContSamps, sampsPerChan: (ulong)_device.SamplesPerChannelInput, taskHandle: _device.InputTaskHandle, source: "", rate: _device.SamplerateInput ); if (result < 0) { NidaQmxHelper.DAQmxClearTask(_device.InputTaskHandle); _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); return(false); } } if (flags.HasFlag(InOutPortFlags.UseOutput)) { var result = NidaQmxHelper.DAQmxCfgSampClkTiming( activeEdge: NidaQmxHelper.DaQmxValRising, sampleMode: NidaQmxHelper.DaQmxValContSamps, sampsPerChan: (ulong)_device.SamplesPerChannelOutput, taskHandle: _device.OutputTaskHandle, source: "", rate: _device.SamplerateOutput ); if (result < 0) { NidaQmxHelper.DAQmxClearTask(_device.InputTaskHandle); NidaQmxHelper.DAQmxClearTask(_device.OutputTaskHandle); _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); return(false); } result = NidaQmxHelper.DAQmxCfgOutputBuffer(_device.OutputTaskHandle, _device.SamplesPerChannelOutput); if (result < 0) { NidaQmxHelper.DAQmxClearTask(_device.InputTaskHandle); NidaQmxHelper.DAQmxClearTask(_device.OutputTaskHandle); _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); return(false); } } return(true); }
private void CleanupAndThrow(int code) { NidaQmxHelper.DAQmxClearTask(TaskHandle); TaskHandle = 0; SamplesPerChannel = 0; _nodes.Clear(); State = SessionTaskState.None; if (_counter != null) { _counter.Dispose(); } throw new NidaqException(code); }
public void StopSampling() { if (!Recording) { return; } NidaQmx2Singleton.Instance.Stop(); NidaQmxHelper.DAQmxClearTask(InputTaskHandle); NidaQmxHelper.DAQmxClearTask(OutputTaskHandle); CreateTaskHandle(); Recording = false; }
public SettingsDigitalOut(NidaqSingleton.Device dev, string clockPath, int bufferLength, int prebufferLength) { InitializeComponent(); numericUpDownBufferLength.Value = bufferLength; numericUpDownPreBufferLength.Value = prebufferLength; comboBoxClockSource.Text = clockPath; var terms = new StringBuilder(10000); var result = NidaQmxHelper.DAQmxGetDevTerminals(dev.Name, terms, terms.Capacity - 1); if (result >= 0) { comboBoxClockSource.Items.AddRange(terms.ToString().Split(',')); } }
public SettingsDigitalIn(NidaqSingleton.Device dev, NidaqSessionDigitalIn.ClockSource clockSrc, string clockPath, int clockRate) { InitializeComponent(); comboBoxClock.DataSource = Enum.GetValues(typeof(NidaqSessionDigitalIn.ClockSource)); comboBoxClock.SelectedItem = clockSrc; comboBoxClockSource.Text = clockPath; textBoxClockRate.Text = clockRate.ToString(); var terms = new StringBuilder(10000); var result = NidaQmxHelper.DAQmxGetDevTerminals(dev.Name, terms, terms.Capacity - 1); if (result >= 0) { comboBoxClockSource.Items.AddRange(terms.ToString().Split(',')); } }
public void Stop() { if (TaskHandle == 0) { throw new InvalidOperationException("Task not yet created. First create a task"); } var result = NidaQmxHelper.DAQmxStopTask(TaskHandle); if (result < 0) { CleanupAndThrow(result, false); } State = SessionTaskState.Stopped; }
public void DestroyTask() { if (TaskHandle == 0) { throw new InvalidOperationException("Task not yet created. First create a task"); } NidaQmxHelper.DAQmxClearTask(TaskHandle); TaskHandle = 0; SamplesPerChannel = 0; _nodes.Clear(); if (_counter != null) { _counter.Dispose(); } State = SessionTaskState.None; }
private string[] GetDeviceNames() { var buffer = new StringBuilder(256 + 1); var result = NidaQmxHelper.DAQmxGetSysDevNames(buffer, buffer.Length - 1); if (result < 0) { throw new SystemException("Could not query nidaq device list"); } if (buffer.ToString().Length > 0) { return(buffer.ToString() .Split(',') .Select(s => s.Trim()).ToArray()); } return(null); }
private void EveryNCallback() { var hPoll = start_polling(_device.InputTaskHandle, _device.SamplesPerChannelInput * _device.ListeningPorts.Count(), _device.SamplesPerChannelInput); while (!_stopThread) { var result = read_buffer(hPoll, Data, 8 * (_device.SamplesPerChannelInput * _device.ListeningPorts.Count())); switch (result) { case 2: // queue empty, ignore Thread.Sleep(1); break; case 1: _device.ReportError(new DeviceErrorArgs("Buffer too small")); _stopThread = true; break; case 0: var channelData = Data; // this can not be a foreach loop because listeningPorts may change. // For example when there is a buffering problem and listeningPorts is cleared foreach (var port in _device.ListeningPorts.OfType <NidaQmxChannelInput>()) { port.DistributeData(channelData, _device.SamplesPerChannelInput); channelData = IntPtr.Add(channelData, sizeof(double) * _device.SamplesPerChannelInput); } break; default: // read error _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); _stopThread = true; break; } } stop_polling(hPoll); }
private void CleanupAndThrow(int code, bool doThrow = true) { NidaQmxHelper.DAQmxClearTask(TaskHandle); TaskHandle = 0; SamplesPerChannel = 0; _nodes.Clear(); State = SessionTaskState.None; if (doThrow) { throw new NidaqException(code); } else { Parent.SessionGraph.Context.Notify( new NodeSystemLib2.Generic.GraphNotification( NodeSystemLib2.Generic.GraphNotification.NotificationType.Error, NidaQmxHelper.GetError(code) ) ); } }
public void Stop() { if (TaskHandle == 0) { throw new InvalidOperationException("Task not yet created. First create a task"); } var result = NidaQmxHelper.DAQmxStopTask(TaskHandle); if (result < 0) { CleanupAndThrow(result); } try { _counter.Stop(); } catch (NationalInstruments.DAQmx.DaqException e) { CleanupAndThrow(e.Error); } State = SessionTaskState.Stopped; }
private bool CreateTaskHandle() { int[] taskHandle = new int[1]; var result = NidaQmxHelper.DAQmxCreateTask(null, taskHandle); if (result < 0) { OnError?.Invoke(this, new DeviceErrorArgs("Could not create input nidaq task")); return(false); } InputTaskHandle = taskHandle[0]; result = NidaQmxHelper.DAQmxCreateTask(null, taskHandle); if (result < 0) { OnError?.Invoke(this, new DeviceErrorArgs("Could not create output nidaq task")); return(false); } OutputTaskHandle = taskHandle[0]; return(true); }
public List <IDevice> CreateDevices() { var buffer = new StringBuilder(256 + 1); var result = NidaQmxHelper.DAQmxGetSysDevNames(buffer, buffer.Length - 1); if (result < 0) { throw new SystemException("Could not query nidaq device list"); } if (buffer.ToString().Length > 0) { return(buffer.ToString() .Split(',') .Select(s => s.Trim()) .Select(s => new NidaQmxDevice2(s, _gen)) .ToList <IDevice>()); } else { return(new List <IDevice>()); } }
private void ProcessInputData(IReadOnlyList <INidaqMetric> listeningPorts, NILoop.HandleInfo taskInfo, IntPtr buffer, int sample_size_bytes, int hPoll) { var result = NILoop.read_buffer(hPoll, taskInfo.handle, buffer, sample_size_bytes * (taskInfo.samples_per_chan * listeningPorts.Count)); switch (result) { case 3: case 1: // task not found SessionGraph.AsyncEmergencyStop(null); _stopThread = true; break; case 2: // queue empty, ignore Thread.Sleep(1); break; case 0: var channelData = buffer; foreach (var port in listeningPorts) { ((IMetricInput)port).DistributeData(channelData, taskInfo.samples_per_chan); channelData = IntPtr.Add(channelData, sample_size_bytes * taskInfo.samples_per_chan); } break; default: // read error System.Diagnostics.Debug.WriteLine(NidaQmxHelper.GetError(result)); SessionGraph.AsyncEmergencyStop(null); _stopThread = true; break; } }
public NidaQmxDevice2(string device, IIDGenerator idgen) { Name = device; var bufferInputChannelNames = new StringBuilder(256 + 1); var resultQueryAI = NidaQmxHelper.DAQmxGetDevAIPhysicalChans(device, bufferInputChannelNames, bufferInputChannelNames.Length - 1); if (resultQueryAI < 0) { throw new SystemException("Could not query input channels for nidaq device " + device); } var bufferOutputChannelNames = new StringBuilder(256 + 1); var resultQueryAO = NidaQmxHelper.DAQmxGetDevAOPhysicalChans(device, bufferOutputChannelNames, bufferOutputChannelNames.Length - 1); if (resultQueryAO < 0) { throw new SystemException("Could not query input channels for nidaq device " + device); } var ai = bufferInputChannelNames.ToString() .Split(',') .Select(s => (NidaQmxChannel) new NidaQmxChannelInput(this, s.Trim(), idgen)); var ao = bufferOutputChannelNames.ToString() .Split(',') .Select(s => (NidaQmxChannel) new NidaQmxChannelOutput(this, s.Trim(), idgen)); _channels = ai.Concat(ao).ToList(); if (!CreateTaskHandle()) { throw new SystemException("Could not acquire nidaq task handle"); } Id = idgen.GetID(); }
/// <summary> /// Creates a new DAQmx task and adds channels to it /// </summary> /// <param name="nodes">Graph nodes of type MetricAnalogInput</param> /// <exception cref="InvalidCastException">At least one element in <paramref name="nodes"/> not of type MetricAnalogInput</exception> /// <exception cref="InvalidOperationException">At least one element in <paramref name="nodes"/> not connected to the instance's specified device or task already created</exception> /// <exception cref="NidaqException">Task or channel could not be created</exception> public void CreateTask(IEnumerable <INidaqMetric> nodes) { if (TaskHandle != 0) { throw new InvalidOperationException("Task already created. First destroy the old task"); } if (!nodes.All(n => n is MetricAnalogInput)) { throw new InvalidCastException("all passed nodes must be of type MetricAnalogInput"); } if (!nodes.All(n => n.Channel.Device == Device)) { throw new InvalidOperationException("not all passed nodes are connected to device " + Device.Name); } foreach (var node in nodes.OfType <MetricAnalogInput>()) { node.Samplerate = ClockRate; } // 1. create task var taskHandle = new int[1]; var result = NidaQmxHelper.DAQmxCreateTask(null, taskHandle); if (result < 0) { throw new NidaqException(result); } TaskHandle = taskHandle[0]; // 2. create channels foreach (var input in nodes.OfType <MetricAnalogInput>()) { result = NidaQmxHelper.DAQmxCreateAIVoltageChan( maxVal: input.VMax, minVal: input.VMin, units: NidaQmxHelper.DaQmxValVolts, terminalConfig: (int)input.TerminalConfig, physicalChannel: input.Channel.Path, taskHandle: TaskHandle, nameToAssignToChannel: null, customScaleName: null ); if (result < 0) { CleanupAndThrow(result); } _nodes.Add(input); } // 3. configure clock SamplesPerChannel = ClockRate / 5; result = NidaQmxHelper.DAQmxCfgSampClkTiming( activeEdge: NidaQmxHelper.DaQmxValRising, sampleMode: NidaQmxHelper.DaQmxValContSamps, sampsPerChan: (ulong)SamplesPerChannel, taskHandle: TaskHandle, source: "", rate: ClockRate ); if (result < 0) { CleanupAndThrow(result); } State = SessionTaskState.Stopped; }
private bool CreateVirtualChannel(InOutPortFlags flags) { // ------------------------------------ if (flags.HasFlag(InOutPortFlags.UseInput)) { var inputs = _device.ListeningPorts.Where(port => port.Direction == ChannelDirection.Input) .Select(port => port.Name); if (inputs.Any()) { var inputPortStrings = string.Join(",", inputs); var result = NidaQmxHelper.DAQmxCreateAIVoltageChan( maxVal: 10.0, minVal: -10.0, units: NidaQmxHelper.DaQmxValVolts, terminalConfig: NidaQmxHelper.DaQmxValRse, physicalChannel: inputPortStrings, taskHandle: _device.InputTaskHandle, nameToAssignToChannel: "chanI" + _device.Name, customScaleName: null ); if (result < 0) { NidaQmxHelper.DAQmxClearTask(_device.InputTaskHandle); _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); return(false); } } } // ------------------------------------ if (flags.HasFlag(InOutPortFlags.UseOutput)) { var outputs = _device.ListeningPorts.Where(port => port.Direction == ChannelDirection.Output) .Select(port => port.Name); if (outputs.Any()) { var outputPortStrings = string.Join(",", outputs); var channelNumber = 0; foreach (var output in _device.ListeningPorts.Where(port => port.Direction == ChannelDirection.Output)) { ((NidaQmxChannelOutput)output).ChannelNumber = channelNumber++; } var result = NidaQmxHelper.DAQmxCreateAOVoltageChan( maxVal: 10.0, minVal: -10.0, units: NidaQmxHelper.DaQmxValVolts, physicalChannel: outputPortStrings, taskHandle: _device.OutputTaskHandle, nameToAssignToChannel: "chanO" + _device.Name, customScaleName: null ); if (result < 0) { NidaQmxHelper.DAQmxClearTask(_device.OutputTaskHandle); _device.ReportError(new DeviceErrorArgs(NidaQmxHelper.GetError(result))); return(false); } } } // ------------------------------------ return(true); }
public void CreateTask(IEnumerable <INidaqMetric> nodes) { if (TaskHandle != 0) { throw new InvalidOperationException("Task already created. First destroy the old task or task already created"); } if (!nodes.All(n => n is MetricDigitalInput)) { throw new InvalidCastException("all passed nodes must be of type MetricDigitalInput"); } if (!nodes.All(n => n.Channel.Device == Device)) { throw new InvalidOperationException("not all passed nodes are connected to device " + Device.Name); } // 1. create task if (Source == ClockSource.Intern) { _counter = new NidaqCounterOutput(Device.Name + "/ctr0", ClockRate); } var taskHandle = new int[1]; var result = NidaQmxHelper.DAQmxCreateTask(null, taskHandle); if (result < 0) { throw new NidaqException(result); } TaskHandle = taskHandle[0]; // 2. create channels foreach (var input in nodes.OfType <MetricDigitalInput>()) { result = NidaQmxHelper.DAQmxCreateDIChan( lines: input.Channel.Path, taskHandle: TaskHandle, lineGrouping: NidaQmxHelper.DAQmx_Val_ChanForAllLines, nameToAssignToChannel: null ); if (result < 0) { CleanupAndThrow(result); } _nodes.Add(input); } // 3. configure clock SamplesPerChannel = ClockRate / 10; result = NidaQmxHelper.DAQmxCfgSampClkTiming( activeEdge: NidaQmxHelper.DaQmxValRising, sampleMode: NidaQmxHelper.DaQmxValContSamps, sampsPerChan: (ulong)SamplesPerChannel, taskHandle: TaskHandle, source: (this.Source == ClockSource.Intern) ? ("/" + Device.Name + "/Ctr0InternalOutput") : ClockPath, rate: ClockRate ); if (result < 0) { CleanupAndThrow(result); } State = SessionTaskState.Stopped; }
public NidaqException(int code) : base(NidaQmxHelper.GetError(code)) { }