public PingLivingReader(ADataReaderParams readerParams, ACounterReader reader)
{
_params = readerParams != null ? readerParams as PingDataReaderParams : PingReaderHelper.GetDefault;
_reader = reader as CounterReader;
_startTime = TimeSpan.Parse(_params?.StartTime ?? PingReaderHelper.StartTime);
_interval = TimeSpan.Parse(_params?.Interval ?? PingReaderHelper.Interval);
}
/// <summary>
/// Stops the read.
/// </summary>
public void Stop()
{
if (IsReading && CurReadWaitResult != null && !CurReadWaitResult.IsCompleted &&
(CounterReader != null || AnalogReader != null))
{
try
{
if (IsCounter)
{
CounterReader.EndReadMultiSampleUInt32(CurReadWaitResult);
}
else
{
AnalogReader.EndReadMultiSample(CurReadWaitResult);
}
}
catch (Exception ex)
{
/// attempt to end he read failed.
}
// clear the async result.
CurReadWaitResult = null;
}
IsReading = false;
DestroyReaderTask();
DestroyTimebaseTask();
}
public ExitReader(ADataReaderParams readerParams, ACounterReader reader)
{
_params = readerParams?.LogicalStorage != null ?
readerParams as ExitDataReaderParams : new ExitDataReaderParams {
LogicalStorage = "UNDEFINED-EXIT-READER"
};
_reader = reader as CounterReader;
}
public DatabaseDataReader(string connStrName, ADataReaderParams readerParams, ACounterReader counterReader)
{
_params = readerParams as DatabaseDataReaderParams;
_counterReader = counterReader as CounterReader;
CheckParams(_params);
_container = new FieldsContainer();
_db = Database.OpenConnection(connStrName);
}
public INotificationDataReader Prepare(ConfigManager.Models.Reader reader, ConfigManager.ConfigManager configManager)
{
var exitReaderParams = new ExitDataReaderParams {
LogicalStorage = reader.LogicalName
};
var setCounterReader = new CounterReader(configManager, reader.ReaderId);
return(new ExitReader.ExitReader(exitReaderParams, setCounterReader));
}
public double ReadDigitalPulseWidth(string counter, CIPulseWidthStartingEdge StartingEdge, double minPW_InSeconds, double maxPW_InSeconds)
{
// This example uses the default source (or gate) terminal for
// the counter of your device. To determine what the default
// counter pins for your device are or to set a different source
// (or gate) pin, refer to the Connecting Counter Signals topic
// in the NI-DAQmx Help (search for "Connecting Counter Signals").
// Uses default PFI 9/P2.1 as the pulse input.
// Returns PW in seconds.
double pulseWidth = 0;
Task myTask = null;
NationalInstruments.DAQmx.CounterReader myCounterReader;
try
{
myTask = new Task();
myTask.CIChannels.CreatePulseWidthChannel(counter,
"Meas Pulse Width", minPW_InSeconds,
maxPW_InSeconds, StartingEdge,
CIPulseWidthUnits.Seconds);
//RLC Wait up to 5 sec default was 10 sec
myTask.Stream.Timeout = 5000;
myCounterReader = new CounterReader(myTask.Stream);
// For .NET Framework 2.0 or later, use SynchronizeCallbacks to specify that the object
// marshals callbacks across threads appropriately.
myCounterReader.SynchronizeCallbacks = true;
// For .NET Framework 1.1, set SynchronizingObject to the Windows Form to specify
// that the object marshals callbacks across threads appropriately.
//myCounterReader.SynchronizingObject = this;
//rlc AsyncCallback myCallback = new AsyncCallback(MeasurementCallback);
//myCounterReader.BeginReadSingleSampleDouble(myCallback, null);
IAsyncResult ar = null;
ar = myCounterReader.BeginReadSingleSampleDouble(null, null);
pulseWidth = myCounterReader.EndReadSingleSampleDouble(ar);
}
catch (Exception exception)
{
mstr_Error = exception.Message;
pulseWidth = -1;
}
finally
{
if (myTask != null)
{
myTask.Dispose();
}
}
return(pulseWidth);
}
/// <summary>
/// Async call to read the data.
/// </summary>
protected void ReadData()
{
if (IsCounter)
{
CurReadWaitResult = CounterReader.BeginReadMultiSampleUInt32(SamplesPerReadTick, OnDataRead, null);
}
else
{
CurReadWaitResult = AnalogReader.BeginReadMultiSample(SamplesPerReadTick, OnDataRead, null);
}
}
public INotificationDataReader Prepare(ConfigManager.Models.Reader reader, ConfigManager.ConfigManager configManager)
{
var pingReaderParams = new PingDataReaderParams
{
LogicalStorage = reader.LogicalName,
StartTime = reader.ReaderAdditionalParams.StartTime,
Interval = reader.ReaderAdditionalParams.Interval,
Occurs = reader.ReaderAdditionalParams.Occurs
};
var setCounterReader = new CounterReader(configManager, reader.ReaderId);
return(new PingLivingReader(pingReaderParams, setCounterReader));
}
/// <summary>
/// On data was read.
/// </summary>
/// <param name="rslt"></param>
protected void OnDataRead(IAsyncResult rslt)
{
if (!rslt.IsCompleted || !IsReading)
{
return;
}
DataChunk c = null;
TimeSpan offset = TimeSpan.FromSeconds(ReadTicks * 1.0 / SamplingFrequency);
if (IsCounter)
{
// data is counter.
uint[,] data = CounterReader.EndReadMultiSampleUInt32(rslt);
ReadTicks += data.GetLength(1);
c = new DataChunk(offset, data);
}
else
{
// data is analog.
double[,] data = AnalogReader.EndReadMultiSample(rslt);
// adding to the read ticks.
ReadTicks += data.GetLength(1);
c = new DataChunk(offset, data);
}
// call async again.
if (IsReading)
{
ReadData();
}
// No data.
if (c.DataCount == 0)
{
return;
}
m_dataQ.Enqueue(c);
// call to process the queue if needed.
DoQueueProcessing();
}
public double Meas2EdgeSeparation(string lines, double min, double max, CITwoEdgeSeparationFirstEdge firstEdge, CITwoEdgeSeparationSecondEdge secondEdge, int Timeout)
{
// This example uses the default source (or gate) terminal for
// the counter of your device. To determine what the default
// counter pins for your device are or to set a different source
// (or gate) pin, refer to the Connecting Counter Signals topic
// in the NI-DAQmx Help (search for "Connecting Counter Signals").
// Uses default PFI 9/P2.1 as the pulse input.
double pulseGap = 0;
Task myTask = null;
NationalInstruments.DAQmx.CounterReader myCounterReader;
try
{
myTask = new Task();
myTask.Stream.Timeout = Timeout;
myTask.CIChannels.CreateTwoEdgeSeparationChannel(
lines, "", min, max,
firstEdge, secondEdge, CITwoEdgeSeparationUnits.Seconds);
myCounterReader = new CounterReader(myTask.Stream);
pulseGap = myCounterReader.ReadSingleSampleDouble();
}
catch (DaqException exception)
{
mstr_Error = exception.Message;
pulseGap = 0;
}
finally
{
if (myTask != null)
{
myTask.Dispose();
}
}
return(pulseGap);
}
public INotificationDataReader Prepare(ConfigManager.Models.Reader reader, ConfigManager.ConfigManager configManager)
{
var databaseDataReaderParams = new DatabaseDataReaderParams
{
LogicalStorage = reader.LogicalName,
Schema = reader.ReaderAdditionalParams.Schema ?? "dbo",
TableName = reader.ReaderAdditionalParams.TableName,
OrderByColumnName = reader.ReaderAdditionalParams.OrderByColumnName,
InitialCounter = reader.InitialCounter,
MessageTypeColumnName = reader.ReaderAdditionalParams.MessageTypeColumnName,
ColumnsNames = reader.ColumnNames
};
var setCounterReader = new CounterReader(configManager, reader.ReaderId);
var notificationDataReaderDecorator = new NotificationDataReaderDecorator(
new DatabaseDataReader.DatabaseDataReader(reader.ConnectionString, databaseDataReaderParams, setCounterReader), reader.ReaderId);
return(notificationDataReaderDecorator);
}
// this method configures and starts the counter.
private void StartCounter()
{
// set up the counter - the fast oscillator is fed into a counter's source input
counterTask = new Task("PhaseLock task");
CounterChannel oscillatorChannel =
((CounterChannel)Environs.Hardware.CounterChannels["phaseLockOscillator"]);
counterTask.CIChannels.CreateCountEdgesChannel(
oscillatorChannel.PhysicalChannel,
oscillatorChannel.Name,
CICountEdgesActiveEdge.Rising,
0,
CICountEdgesCountDirection.Up
);
// this counter is sample-clocked by the slow reference that we are locking to.
// the buffer is set to be "large"
CounterChannel referenceChannel =
((CounterChannel)Environs.Hardware.CounterChannels["phaseLockReference"]);
counterTask.Timing.ConfigureSampleClock(
referenceChannel.PhysicalChannel,
SAMPLE_CLOCK_RATE,
SampleClockActiveEdge.Rising,
SampleQuantityMode.ContinuousSamples,
1000
);
counterReader = new CounterReader(counterTask.Stream);
counterReader.SynchronizeCallbacks = true;
if (!Environs.Debug)
{
counterReader.BeginReadMultiSampleInt32(
SAMPLE_MULTI_READ,
new AsyncCallback(CounterCallBack),
null
);
}
}
public bool ReadDigitalLowFrequency(string lines, string name, double min, double max, double time)
{
// This example uses the default source (or gate) terminal for
// the counter of your device. To determine what the default
// counter pins for your device are or to set a different source
// (or gate) pin, refer to the Connecting Counter Signals topic
// in the NI-DAQmx Help (search for "Connecting Counter Signals").
// Uses default PFI 9/P2.1 as the pulse input.
try
{
m_d_MeasuredFrequency = 0;
Task_MeasureLowFreq = new Task();
Task_MeasureLowFreq.CIChannels.CreateFrequencyChannel(lines, name, min, max, CIFrequencyStartingEdge.Rising,
CIFrequencyMeasurementMethod.LowFrequencyOneCounter, time, 4, CIFrequencyUnits.Hertz);
myCounterReader = new CounterReader(Task_MeasureLowFreq.Stream);
// For .NET Framework 2.0 or later, use SynchronizeCallbacks to specify that the object
// marshals callbacks across threads appropriately.
myCounterReader.SynchronizeCallbacks = true;
myCallBack = new AsyncCallback(CounterInCallback);
myCounterReader.BeginReadSingleSampleDouble(myCallBack, null);
}
catch (Exception exception)
{
mstr_Error = exception.Message;
Task_MeasureLowFreq.Dispose();
return(false);
}
return(true);
}
public override void AcquisitionStarting()
{
//set up an edge-counting task
countingTask = new Task("buffered edge counter gatherer " + (string)settings["channel"]);
//count upwards on rising edges starting from zero
countingTask.CIChannels.CreateCountEdgesChannel(
((CounterChannel)Environs.Hardware.CounterChannels[(string)settings["channel"]]).PhysicalChannel,
"edge counter",
CICountEdgesActiveEdge.Rising,
0,
CICountEdgesCountDirection.Up);
//The counting buffer is triggered by a sample clock, which will be routed to the gate pin of ctr0 (PFI9)
//The number of samples to collect is determined by the "gateLength" setting. We add 1 to this,
// since the first count is not synchronized to anything and will be discarded
countingTask.Timing.ConfigureSampleClock(
(string)Environs.Hardware.Boards["daq"] + "/PFI9",
(int)settings["sampleRate"],
SampleClockActiveEdge.Rising,
SampleQuantityMode.FiniteSamples,
(int)settings["gateLength"] + 1);
countingTask.Control(TaskAction.Verify);
// set up two taska to generate the sample clock on the second counter
freqOutTask1 = new Task("buffered event counter clock generation 1");
freqOutTask2 = new Task("buffered event counter clock generation 2");
//the frequency of the clock is set by the "sampleRate" setting and the duty cycle is set to 0.5
//the two output tasks have the same settings
freqOutTask1.COChannels.CreatePulseChannelFrequency(
((CounterChannel)Environs.Hardware.CounterChannels["sample clock"]).PhysicalChannel,
"photon counter clocking signal",
COPulseFrequencyUnits.Hertz,
COPulseIdleState.Low,
0,
(int)settings["sampleRate"],
0.5);
freqOutTask1.Timing.ConfigureImplicit(SampleQuantityMode.ContinuousSamples, 1000);
freqOutTask2.COChannels.CreatePulseChannelFrequency(
((CounterChannel)Environs.Hardware.CounterChannels["sample clock"]).PhysicalChannel,
"photon counter clocking signal",
COPulseFrequencyUnits.Hertz,
COPulseIdleState.Low,
0,
(int)settings["sampleRate"],
0.5);
freqOutTask2.Timing.ConfigureImplicit(SampleQuantityMode.ContinuousSamples, 1000);
// if we're using a hardware trigger to synchronize data acquisition, we need to set up the
// trigger parameters on the sample clock.
// The first output task is triggered on PFI0 and the second is triggered on PFI1
if ((bool)settings["triggerActive"])
{
freqOutTask1.Triggers.StartTrigger.Type = StartTriggerType.DigitalEdge;
freqOutTask1.Triggers.StartTrigger.DigitalEdge.Edge = DigitalEdgeStartTriggerEdge.Rising;
freqOutTask2.Triggers.StartTrigger.Type = StartTriggerType.DigitalEdge;
freqOutTask2.Triggers.StartTrigger.DigitalEdge.Edge = DigitalEdgeStartTriggerEdge.Rising;
// the trigger is expected to appear on PFI0
freqOutTask1.Triggers.StartTrigger.DigitalEdge.Source = (string)Environs.Hardware.Boards["daq"] + "/PFI0";
// the trigger is expected to appear on PFI1
freqOutTask2.Triggers.StartTrigger.DigitalEdge.Source = (string)Environs.Hardware.Boards["daq"] + "/PFI1";
}
// set up a reader for the edge counter
countReader = new CounterReader(countingTask.Stream);
}
//---------------------------------------------------------------------------------------------------------------------------------------------
internal void triggerInit(double casoKrok)
{
// ttlSignal = new int[NumOfSteps];
Steptime = casoKrok;
CICh = UlohaCounter.CIChannels.CreateCountEdgesChannel(
prevodnikId + "/ctr0",
prevodnikId + "ctr0",
CICountEdgesActiveEdge.Falling,
0,
CICountEdgesCountDirection.Up
);
UlohaCounter.Control(TaskAction.Verify);
Counter = new CounterReader(UlohaCounter.Stream);
// UlohaCounter.Start();
}
/// <summary>
/// Prime the APD for counting. Every time it receives a trigger it will now count photons for a set bintime.
/// The count will be stored in a buffer and can be read at any time.
/// </summary>
public void StartAPDAcquisition()
{
// Reset the total amount of counts read.
this.m_dTotalCountsRead = 0;
// Create an instance of a reader to get counts from the HW buffer.
m_rdrCountReader = new CounterReader(this.m_daqtskAPDCount.Stream);
// Start the task that counts the TTL's coming from the APD first.
m_daqtskAPDCount.Start();
// Now start the pulse with duration of bintime. The length of this pulse will be measured in TTL ticks from the actual APD.
//m_daqtskGatePulse.Start();
}
public override void AcquisitionStarting()
{
//set up an edge-counting task
countingTask = new Task("buffered edge counter gatherer " + (string)settings["channel"]);
//count upwards on rising edges starting from zero
countingTask.CIChannels.CreateCountEdgesChannel(
((CounterChannel)Environs.Hardware.CounterChannels[(string)settings["channel"]]).PhysicalChannel,
"edge counter",
CICountEdgesActiveEdge.Rising,
0,
CICountEdgesCountDirection.Up);
//The counting buffer is triggered by a sample clock, which will be routed to the gate pin of ctr0 (PFI9)
//The number of samples to collect is determined by the "gateLength" setting. We add 1 to this,
// since the first count is not synchronized to anything and will be discarded
countingTask.Timing.ConfigureSampleClock(
(string)Environs.Hardware.Boards["daq"] + "/PFI9",
(int)settings["sampleRate"],
SampleClockActiveEdge.Rising,
SampleQuantityMode.FiniteSamples,
(int)settings["gateLength"] + 1);
countingTask.Control(TaskAction.Verify);
// set up two taska to generate the sample clock on the second counter
freqOutTask1 = new Task("buffered event counter clock generation 1");
freqOutTask2 = new Task("buffered event counter clock generation 2");
//the frequency of the clock is set by the "sampleRate" setting and the duty cycle is set to 0.5
//the two output tasks have the same settings
freqOutTask1.COChannels.CreatePulseChannelFrequency(
((CounterChannel)Environs.Hardware.CounterChannels["sample clock"]).PhysicalChannel,
"photon counter clocking signal",
COPulseFrequencyUnits.Hertz,
COPulseIdleState.Low,
0,
(int)settings["sampleRate"],
0.5);
freqOutTask1.Timing.ConfigureImplicit(SampleQuantityMode.ContinuousSamples, 1000);
freqOutTask2.COChannels.CreatePulseChannelFrequency(
((CounterChannel)Environs.Hardware.CounterChannels["sample clock"]).PhysicalChannel,
"photon counter clocking signal",
COPulseFrequencyUnits.Hertz,
COPulseIdleState.Low,
0,
(int)settings["sampleRate"],
0.5);
freqOutTask2.Timing.ConfigureImplicit(SampleQuantityMode.ContinuousSamples, 1000);
// if we're using a hardware trigger to synchronize data acquisition, we need to set up the
// trigger parameters on the sample clock.
// The first output task is triggered on PFI0 and the second is triggered on PFI1
if((bool)settings["triggerActive"])
{
freqOutTask1.Triggers.StartTrigger.Type = StartTriggerType.DigitalEdge;
freqOutTask1.Triggers.StartTrigger.DigitalEdge.Edge = DigitalEdgeStartTriggerEdge.Rising;
freqOutTask2.Triggers.StartTrigger.Type = StartTriggerType.DigitalEdge;
freqOutTask2.Triggers.StartTrigger.DigitalEdge.Edge = DigitalEdgeStartTriggerEdge.Rising;
// the trigger is expected to appear on PFI0
freqOutTask1.Triggers.StartTrigger.DigitalEdge.Source = (string)Environs.Hardware.Boards["daq"] + "/PFI0";
// the trigger is expected to appear on PFI1
freqOutTask2.Triggers.StartTrigger.DigitalEdge.Source = (string)Environs.Hardware.Boards["daq"] + "/PFI1";
}
// set up a reader for the edge counter
countReader = new CounterReader(countingTask.Stream);
}
// this method configures and starts the counter.
private void StartCounter()
{
// set up the counter - the fast oscillator is fed into a counter's source input
counterTask = new Task("PhaseLock task");
CounterChannel oscillatorChannel =
((CounterChannel)Environs.Hardware.CounterChannels["phaseLockOscillator"]);
counterTask.CIChannels.CreateCountEdgesChannel(
oscillatorChannel.PhysicalChannel,
oscillatorChannel.Name,
CICountEdgesActiveEdge.Rising,
0,
CICountEdgesCountDirection.Up
);
// this counter is sample-clocked by the slow reference that we are locking to.
// the buffer is set to be "large"
CounterChannel referenceChannel =
((CounterChannel)Environs.Hardware.CounterChannels["phaseLockReference"]);
counterTask.Timing.ConfigureSampleClock(
referenceChannel.PhysicalChannel,
SAMPLE_CLOCK_RATE,
SampleClockActiveEdge.Rising,
SampleQuantityMode.ContinuousSamples,
1000
);
counterReader = new CounterReader(counterTask.Stream);
counterReader.SynchronizeCallbacks = true;
if (!Environs.Debug)
counterReader.BeginReadMultiSampleInt32(
SAMPLE_MULTI_READ,
new AsyncCallback(CounterCallBack),
null
);
}