public void RoundTripStreamITChannelInfo()
{
foreach (HekaDAQController daq in HekaDAQController.AvailableControllers())
{
daq.InitHardware();
try
{
daq.ExceptionalStop += (c, arg) =>
{
throw arg.Exception;
};
foreach (HekaDAQStream stream in daq.Streams.Cast <HekaDAQStream>())
{
daq.SampleRate = new Measurement(stream.ChannelNumber, 1, "Hz");
ITCMM.ITCChannelInfo info = stream.ChannelInfo;
Assert.AreEqual(stream.ChannelNumber, info.ChannelNumber);
Assert.AreEqual((uint)stream.ChannelType, info.ChannelType);
//NO_SCALE is seconds scale (Hz)
Assert.AreEqual(ITCMM.USE_FREQUENCY & ITCMM.NO_SCALE & ITCMM.ADJUST_RATE, info.SamplingIntervalFlag);
Assert.That(info.SamplingRate, Is.EqualTo(stream.SampleRate.QuantityInBaseUnit));
Assert.AreEqual(IntPtr.Zero, info.FIFOPointer);
Assert.AreEqual(0, info.Gain);
}
}
finally
{
daq.CloseHardware();
}
}
}
public void ChannelInfoShouldGiveCompleteITCChannelInfo(
[Values((ushort)0, (ushort)1, (ushort)8)]
ushort channelNumber,
[Values(StreamType.ANALOG_OUT, StreamType.DIGITAL_OUT, StreamType.AUX_OUT)]
StreamType streamType
)
{
var controller = new HekaDAQController();
const string name = "UNUSED_NAME";
var s = new HekaDAQOutputStream(name,
streamType,
channelNumber,
controller);
const decimal sampleRate = 9000;
var srate = new Measurement(sampleRate, "Hz");
controller.SampleRate = srate;
ITCMM.ITCChannelInfo info = s.ChannelInfo;
Assert.AreEqual(channelNumber, info.ChannelNumber);
Assert.AreEqual((int)streamType, info.ChannelType);
Assert.AreEqual(s.SampleRate.QuantityInBaseUnit, info.SamplingRate);
Assert.AreEqual(ITCMM.USE_FREQUENCY, info.SamplingIntervalFlag);
Assert.AreEqual(0, info.Gain);
Assert.AreEqual(IntPtr.Zero, info.FIFOPointer);
}
public ITCMM.ITCChannelInfo ChannelInfo(StreamType channelType, ushort channelNumber)
{
ITCMM.ITCChannelInfo[] info = new ITCMM.ITCChannelInfo[1];
info[0] = new ITCMM.ITCChannelInfo()
{
ChannelNumber = channelNumber, ChannelType = (uint)channelType
};
uint err = ItcmmCall(() => ITCMM.ITC_GetChannels(DevicePtr, 1, info));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to retrieve channel info struct.", err);
}
return(info[0]);
}
public void SetsChannelInfo()
{
foreach (HekaDAQController daq in HekaDAQController.AvailableControllers())
{
const decimal srate = 10000;
daq.InitHardware();
Assert.True(daq.HardwareReady);
Assert.False(daq.HardwareRunning);
try
{
foreach (IDAQOutputStream s in daq.OutputStreams)
{
daq.SampleRate = new Measurement(srate, "Hz");
TestDevice externalDevice = new TestDevice("OUT-DEVICE", null);
s.Device = externalDevice;
}
daq.ConfigureChannels();
foreach (HekaDAQStream s in daq.OutputStreams.Cast <HekaDAQStream>())
{
ITCMM.ITCChannelInfo actual = daq.ChannelInfo(s.ChannelType, s.ChannelNumber);
ITCMM.ITCChannelInfo expected = s.ChannelInfo;
Assert.AreEqual(expected.ChannelNumber, actual.ChannelNumber);
Assert.AreEqual(expected.ChannelType, actual.ChannelType);
Assert.AreEqual(expected.SamplingIntervalFlag, actual.SamplingIntervalFlag);
Assert.AreEqual(expected.SamplingRate, actual.SamplingRate);
// Gain set by hardware.
}
}
finally
{
daq.CloseHardware();
}
}
}
public void ReadAvailableSamples()
{
HekkaDevice device = HekkaDevice.Zero;
uint err = ITCMM.ITC_OpenDevice(ITCMM.USB18_ID, 0, ITCMM.SMART_MODE, out device);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
try
{
//ITCMM.HWFunction hwf = new ITCMM.HWFunction();
err = ITCMM.ITC_InitDevice(device, IntPtr.Zero); // ref hwf);
ITCMM.ITCPublicConfig config = new ITCMM.ITCPublicConfig();
config.OutputEnable = 1;
err = ITCMM.ITC_ConfigDevice(device, ref config);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
Assert.NotNull(device);
ITCMM.ITCChannelInfo channelInfo = new ITCMM.ITCChannelInfo();
channelInfo.ChannelType = ITCMM.H2D;
channelInfo.ChannelNumber = 0;
channelInfo.SamplingRate = 1000.0;
Assert.AreEqual(System.IntPtr.Zero, channelInfo.FIFOPointer);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
ITCMM.ITC_SetChannels(device, 1, new ITCMM.ITCChannelInfo[] { channelInfo })
);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
(int)ITCMM.ITC_UpdateChannels(device)
);
ITCMM.ITCChannelDataEx info = new ITCMM.ITCChannelDataEx();
info.ChannelType = ITCMM.H2D;
info.ChannelNumber = 0;
ITCMM.ITCChannelDataEx[] arr = new ITCMM.ITCChannelDataEx[] { info };
err = ITCMM.ITC_GetDataAvailable(device, 1, arr);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
info = arr[0];
Assert.That(info.Value, Is.GreaterThanOrEqualTo(0));
}
finally
{
err = ITCMM.ITC_CloseDevice(device);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
}
}
public void RoundTripChannelConfig()
{
HekkaDevice device = HekkaDevice.Zero;
uint err = ITCMM.ITC_OpenDevice(ITCMM.USB18_ID, 0, ITCMM.SMART_MODE, out device);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
try
{
//ITCMM.HWFunction hwf = new ITCMM.HWFunction();
err = ITCMM.ITC_InitDevice(device, IntPtr.Zero); //ref hwf);
ITCMM.ITCPublicConfig config = new ITCMM.ITCPublicConfig();
config.OutputEnable = 1;
err = ITCMM.ITC_ConfigDevice(device, ref config);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
Assert.NotNull(device);
err = ITCMM.ITC_ResetChannels(device);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
ITCMM.ITCChannelInfo[] info = new ITCMM.ITCChannelInfo[2];
info[0].ChannelNumber = 0;
info[0].ChannelType = ITCMM.OUTPUT_GROUP;
info[1].ChannelNumber = 0;
info[1].ChannelType = ITCMM.INPUT_GROUP;
const double srate = 8000;
info[0].SamplingRate = srate;
info[1].SamplingRate = srate;
err = ITCMM.ITC_SetChannels(device, 2, info);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
err = ITCMM.ITC_UpdateChannels(device);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
ITCMM.ITCChannelInfo[] actual = new ITCMM.ITCChannelInfo[2];
actual[0].ChannelType = info[0].ChannelType;
actual[0].ChannelNumber = info[0].ChannelNumber;
actual[1].ChannelType = info[1].ChannelType;
actual[1].ChannelNumber = info[1].ChannelNumber;
err = ITCMM.ITC_GetChannels(device, 2, actual);
if (err != ITCMM.ACQ_SUCCESS)
{
Assert.Fail(ErrorDescription.ErrorString(err));
}
Assert.AreEqual(info[0].SamplingRate, actual[0].SamplingRate);
Assert.AreEqual(info[1].SamplingRate, actual[1].SamplingRate);
}
finally
{
err = ITCMM.ITC_CloseDevice(device);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
}
}
