Intermitte​nt 200010 errors

Question

I am getting intermittent error 200010 results from DAQmxReadAnalogF64(). We are using a PCI-6259 card.
My app is a C++ program, running under Windows 7. It does two main types of A/D reads: One is initiated by interactive user action, and can result in a large amount of  samples. The channel count is normally 1-3, while the sample time is user specified, and could be fairly large (e.g. a few hundred seconds.)
We try and sample at the highest rate the card supports (e.g. 1.25 MHz for 1 channel, or 1 MHz for 2 or 3 channels.) There is a maximum sample count
that we will try and read, currently 62.5 million samples, the size of our allocated data buffer, and if the user request exceeds this, we will drop the sample rate to fit this limit.
 The second type of read is done periodically, c. 3 times per second, and reads for just 12.5 msec, typically for 6 channels or so. (This second provides a periodic update of the instrument state.) These second types read just 2084 samples total, at the full 1 MHz sample rate.
Anyways, the reads work most of the time, but occasionally fail. Failure seems most common when the first type of read is done for a long time period, say 120 sec. (By this point we would be reducing the sample frequency, assuming 1 channel, to about 520 kHz.) Interestingly, the failures then occur usually for the second type of sample (the short 12.5 msec reads), although they have occurred on the long reads (which are more critical.)
If I double our data buffer size to 1 GB, meaning we would read up to 125 million samples (and so maintain 1.25 MHz sample rate for longer times), then the errors become much more common.
I have just upgraded to NIDAQmx version 9.1, I had been using 8.9, but these errors persist with the upgrade. Previously, I had also had occasional errors 50352 [Memory allocation error], and error 50202 [Unspecified error], but I have not seen these since the upgrade. So the upgrade may have helped some, but not completely.
Thanks for any advice.
  - Mark

Answer 1

And now the main read function...
 void ReadAnalogInterval (
    const char* device_name,
    const char* physical_channels[],
    int    num_channels,
    int    num_samps_per_channel,
    double samp_freq_per_channel,
    double min_range,
    double max_range,
    double timeout_sec,
    bool   triggered,
    int    trigger_type,
    const char* trigger_source,
    Simulation simulants[],
    double data[],
    int    data_size)
// Sample data over an interval. The whole interval is sampled in one piece.
    int32 result;
    TaskHandle handle;
    result = DAQmxCreateTask (NULL, &handle);
    if (result != 0)
        CleanupTask (&handle);
        RaiseNidaqError (result);
    // combine channel names
    string physical_channels_combined =
        CombinePhysicalChannelNames (device_name, physical_channels, num_channels);
    // create channel for reading voltage
    result = DAQmxCreateAIVoltageChan
        (handle,
         physical_channels_combined.c_str(),
         NULL,
         DAQmx_Val_Cfg_Default,
         min_range,
         max_range,
         DAQmx_Val_Volts,        // units
         NULL);
    if (result != 0)
        CleanupTask (&handle);
        RaiseNidaqError (result);
    // get channel count
    uInt32 nidaq_num_channels;
    result = DAQmxGetTaskNumChans (handle, &nidaq_num_channels);
    if (result != 0)
        CleanupTask (&handle);
        RaiseNidaqError (result);
    // check
    assert (nidaq_num_channels == num_channels);
    assert (data_size == (num_samps_per_channel * num_channels));
    // configure trigger if requested
    if (triggered)
        // trigger type
        int trigger_edge = 0;
        if (trigger_type == NIDAQ_TRIGGER_FALLING)
            trigger_edge = DAQmx_Val_Falling;     // normal [VB TriggerType = 0]
        else if (trigger_type == NIDAQ_TRIGGER_RISING)
            trigger_edge = DAQmx_Val_Rising;      // [VB TriggerType = 1,3]
        else
            assert (0 && "Invalid trigger type.");
        // configure trigger
        result = DAQmxCfgDigEdgeStartTrig
            (handle,
             trigger_source,
             trigger_edge);
        if (result != 0)
            CleanupTask (&handle);
            RaiseNidaqError (result);
    else
        assert (trigger_type == NIDAQ_TRIGGER_NONE);  // else set a trigger type when wanted no trigger
    // configure sample clock - frequency is based on the number of channels in task
    result = DAQmxCfgSampClkTiming
        (handle,
         NULL,                    // "OnboardClock" is ok too
         samp_freq_per_channel,
         DAQmx_Val_Rising,        // collect on the rising edge of the clock
         DAQmx_Val_FiniteSamps,
         num_samps_per_channel);
    if (result != 0)
        CleanupTask (&handle);
        RaiseNidaqError (result);
    // read data
    int32 samps_per_chan_read;
    result = DAQmxReadAnalogF64
        (handle,
         num_samps_per_channel,
         timeout_sec,
         DAQmx_Val_GroupByScanNumber,  // interleaved
         data,
         data_size,
         &samps_per_chan_read,
         NULL);
    // if for some reason, not all samples are read, fill in the remainder with zeros.
    if (samps_per_chan_read != num_samps_per_channel)
        sf_print ("A/D: Requested %d samples, but read %d instead. Remainder taken as 0.0.\n",
            num_samps_per_channel, samps_per_chan_read);
        for (int i=samps_per_chan_read; i < num_samps_per_channel; i++)
            for (int j=0; j < num_channels; j++)
                int index = (i * num_channels) + j;
                assert (index >= 0);
                assert (index < data_size);
                data [index] = 0.0;
    if (result != 0)
        CleanupTask (&handle);
        RaiseNidaqError (result);
    // clean up
    CleanupTask (&handle);
    // leave all simulants in default state (implying no data).