DAQmxTask.h

#pragma once

// Include and link National Instruments DAQmx library
#include <NIDAQmx.h>
#pragma comment(lib, "NIDAQmx.lib")

#include "ScopeDatatypes.h"

namespace DAQmx {

bool CheckError(const int32& error);

double PredictSampleRate(const double& _desiredrate, const uint32_t& _nochannels, const double& _refclockrate, const int32& _mode); 

double CoerceSampleRates(const double& _desiredrate, const uint32_t& _nochannelsin, const uint32_t& _nochannelsout, const double& _refclockrate);

std::wstring ClockString(const scope::DaqTimingHelper::Mode& _timing, const std::wstring& _externalclocksource);

class CDAQmxTask {

protected:
    TaskHandle task_handle;

public:
    CDAQmxTask();

    ~CDAQmxTask(void);

    void CreateTask(const std::wstring& _name = L"");

    bool Created() const;

    void ConfigureImplicitTiming(const int32& _mode, const int32& _samplesperchan);

    void ConfigureSampleTiming(const std::wstring& _src, const float64& _rate, const int32& _samplesperchan, const int32& _samplingtype = DAQmx_Val_ContSamps, const int32& _actedge = DAQmx_Val_Rising);

    void ConfigureReferenceClock(const std::wstring& _src, const float64& _rate);

    void ConfigureDigStartTrigger(const std::wstring& _src, const int32& _trigedge = DAQmx_Val_Rising);

    void Start(void);
    
    void Stop(void);

    void Clear(void);

    bool IsTaskDone(void);

    int32_t WaitUntilDone(const float64& _waittime);

    void ExportSignal(int32 _signal, const std::wstring& _terminal);

    void SetWriteOffset(int32 posreltofirst);

    void SetRegeneration(const bool& _regenerate);
};

class CDAQmxAnalogOutTask
    : public CDAQmxTask {

public:
    void CreateAOVoltageChannel(const std::wstring& _devices,
        const std::wstring& _channelname = L"",
        float64 _minval = -10.0,
        float64 _maxval = 10.0,
        int32 _units = DAQmx_Val_Volts,
        const std::wstring& _customscalename = L"");

    uInt32 ConfigureBuffer(const uInt32& _sampsperchannel);

    uInt32 ConfigureOnboardBuffer(const uInt32& _sampsperchannel);

    void UseOnlyOnboardMemory(const std::wstring& _channel);

    void SetIdleOutputBehaviour(const std::wstring& _channel, const int32_t& _behav);

    void SetDataTransferCondition(const std::wstring& _channel, const int32_t& _cond);

    void SetDataTransferMode(const std::wstring& _channel, const int32_t& _mode);

    int32 WriteAnalog(const float64* _data, int32 _sampsperchan, bool _autostart = false, int32 _timeout = 2, bool32 _layout = DAQmx_Val_GroupByChannel);

    void WriteAnalogScalar(const float64& _value, bool _autostart = false, int32 _timeout = 1000);

    int32 WriteAnalogI16(const int16* _data, int32 _sampsperchan, bool _autostart = false, int32 _timeout = 2, bool32 _layout = DAQmx_Val_GroupByChannel);
};

class CDAQmxDigitalOutTask
    : public CDAQmxTask {

public:
    void CreateDOChannel(const std::wstring& _devicelines, const std::wstring& _channelname = L"");

    int32 WriteDigitalU8(const uInt8* _data, int32 _sampsperchan, bool _autostart = false, float64 _timeout = 2, bool32 _layout = DAQmx_Val_GroupByChannel);

    int32_t WriteDigitalLines(const uInt8* _data, int32 _sampsperchan, bool _autostart = false, float64 _timeout = 2, bool32 _layout = DAQmx_Val_GroupByChannel);
};


class CDAQmxAnalogInTask
    : public CDAQmxTask {

protected:
    std::mersenne_twister<uint32_t, 32, 624, 397, 31, 0x9908b0df, 11, 7, 0x9d2c5680, 15, 0xefc60000, 18> mtgen;

public:
    CDAQmxAnalogInTask();

    void CreateAIVoltageChannel(const std::wstring& _devicechannel,
        const std::wstring& _name = L"",
        int32 _terminalconfig = DAQmx_Val_Cfg_Default ,
        float64 _minval = -10.0,
        float64 _maxval = 10.0,
        int32 _units = DAQmx_Val_Volts,
        const std::wstring& _customscalename = L"");

    void ConfigureBuffer(const uInt32& _sampsperchannel);

    int32 ReadU16(std::vector<uint16_t>& _data, const int32& _sampsperchan, const uint32_t& _channels, bool& _timedout, const float64& _timeout = 2);

    int32 ReadU16Dummy(std::vector<uint16_t>& _data, const int32& _sampsperchan, const uint32_t& _channels,  bool& _timedout, const float64& _timeout = 2);

    int32 ReadI16(std::vector<int16_t>& _data, const int32& _sampsperchan, const uint32_t& _channels,  bool& _timedout, const float64& _timeout = 2);
};

class CDAQmxCounterOutTask
    : public CDAQmxTask {

public:
    void CreateCOChannel(const std::wstring& _counter
        , const std::wstring& _name = L""
        , int32 _idlestate = 0
        , float64 _initdelay = 0
        , float64 _lowtime = 0.1
        , float64 _hightime = 0.1);
};

}