public void PreloadSamples(StreamType channelType, ushort channelNumber, IList <short> samples)
{
ITCMM.ITCChannelDataEx[] channelData = new ITCMM.ITCChannelDataEx[1];
channelData[0].ChannelType = (ushort)channelType;
channelData[0].ChannelNumber = channelNumber;
channelData[0].Value = (short)samples.Count;
channelData[0].Command = ITCMM.PRELOAD_FIFO_COMMAND_EX;
IntPtr samplesPtr = Marshal.AllocHGlobal(samples.Count * sizeof(short));
try
{
Marshal.Copy(samples.ToArray(), 0, samplesPtr, samples.Count);
channelData[0].DataPointer = samplesPtr;
uint err = ItcmmCall(() => ITCMM.ITC_ReadWriteFIFO(DevicePtr, 1, channelData));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to push data", err);
}
}
finally
{
Marshal.FreeHGlobal(samplesPtr);
}
}
public static IEnumerable <HekaDAQController> AvailableControllers()
{
var result = new List <HekaDAQController>();
for (uint deviceType = 0; deviceType < ITCMM.MAX_DEVICE_TYPE_NUMBER; deviceType++)
{
if (deviceType == ITCMM.ITC00_ID)
{
continue;
}
uint numDevices = 0;
uint err = ITCMM.ITC_Devices(deviceType, ref numDevices);
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to find devices", err);
}
for (uint deviceNumber = 0; deviceNumber < numDevices; deviceNumber++)
{
result.Add(new HekaDAQController(deviceType, deviceNumber));
}
}
return(result);
}
public IInputData ReadStreamAsyncIO(HekaDAQInputStream stream)
{
lock (this)
{
var channelData = new ITCMM.ITCChannelDataEx[]
{
new ITCMM.ITCChannelDataEx
{
ChannelNumber = stream.ChannelNumber,
ChannelType = (ushort)stream.ChannelType
}
};
uint err = ItcmmCall(() => ITCMM.ITC_AsyncIO(DevicePtr, 1, channelData));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to read AsyncIO", err);
}
var inData =
new InputData(
new List <IMeasurement> {
new Measurement(channelData[0].Value, HekaDAQInputStream.DAQCountUnits)
},
new Measurement(0, "Hz"),
DateTimeOffset.Now)
.DataWithStreamConfiguration(stream, stream.Configuration);
return(inData.DataWithUnits(stream.MeasurementConversionTarget));
}
}
public void StopHardware()
{
uint err = ItcmmCall(() => ITCMM.ITC_Stop(DevicePtr, IntPtr.Zero));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to stop device", err);
}
}
public void CloseDevice()
{
uint err = ItcmmCall(() => ITCMM.ITC_CloseDevice(DevicePtr));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to close device", err);
}
_cts.Cancel();
}
public void DeviceDetection()
{
uint numDevices = 0;
uint result = ITCMM.ITC_Devices(ITCMM.USB18_ID, ref numDevices);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
result,
ErrorDescription.ErrorString(result));
Assert.GreaterOrEqual(numDevices, 1, "We should find at least one ITC18 device.");
}
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 CanReadITCClock()
{
HekkaDevice device;
uint err = ITCMM.ITC_OpenDevice(ITCMM.USB18_ID, 0, ITCMM.SMART_MODE, out device);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
try
{
//ITCMM.HWFunction sHWFunction = new ITCMM.HWFunction();
err = ITCMM.ITC_InitDevice(device, IntPtr.Zero); //ref sHWFunction);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
double t1;
err = ITCMM.ITC_GetTime(device, out t1);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
double t2 = t1;
err = ITCMM.ITC_GetTime(device, out t2);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
Assert.Greater(t2, t1);
}
finally
{
err = ITCMM.ITC_CloseDevice(device);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
}
}
public int AvailableSamples(StreamType channelType, ushort channelNumber)
{
ItcmmCall(() => ITCMM.ITC_UpdateNow(DevicePtr, System.IntPtr.Zero));
ITCMM.ITCChannelDataEx[] channelData = new ITCMM.ITCChannelDataEx[1];
channelData[0].ChannelType = (ushort)channelType;
channelData[0].ChannelNumber = channelNumber;
uint err = ItcmmCall(() => ITCMM.ITC_GetDataAvailable(DevicePtr, 1, channelData));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to get available FIFO points", err);
}
return(channelData[0].Value);
}
public void StartHardware(bool waitForTrigger)
{
var startInfo = new ITCMM.ITCStartInfo
{
ExternalTrigger = (uint)(waitForTrigger ? 1 : 0),
OutputEnable = 1,
StopOnOverflow = 1,
StopOnUnderrun = 1,
ResetFIFOs = 1,
};
//TODO test waitForTrigger set
uint err = ItcmmCall(() => ITCMM.ITC_Start(DevicePtr, ref startInfo));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to start device", err);
}
}
public int MaxAvailableSamples(StreamType channelType, ushort channelNumber)
{
ITCMM.ITCChannelDataEx info = new ITCMM.ITCChannelDataEx();
info.ChannelType = (ushort)channelType;
info.ChannelNumber = channelNumber;
var infoArr = new ITCMM.ITCChannelDataEx[1];
infoArr[0] = info;
uint err = ItcmmCall(() => ITCMM.ITC_GetFIFOInformation(DevicePtr, 1, infoArr));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to get FIFO information", err);
}
info = infoArr[0];
return(info.Value);
}
internal static IHekaDevice OpenDevice(uint deviceType, uint deviceNumber, out ITCMM.GlobalDeviceInfo deviceInfo)
{
IntPtr dev;
uint err = ITCMM.ITC_OpenDevice(deviceType, deviceNumber, ITCMM.SMART_MODE, out dev);
if (err != ITCMM.ACQ_SUCCESS)
{
log.Error("Unable to open ITC device");
throw new HekaDAQException("Unable to get device handle", err);
}
//ITCMM.HWFunction sHWFunction = new ITCMM.HWFunction();
err = ITCMM.ITC_InitDevice(dev, IntPtr.Zero); //ref sHWFunction);
//ITC_SetSoftKey
// Configure device
ITCMM.ITCPublicConfig config = new ITCMM.ITCPublicConfig();
config.OutputEnable = 1;
config.ControlLight = 1;
err = ITCMM.ITC_ConfigDevice(dev, ref config);
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to configure device", err);
}
deviceInfo = new ITCMM.GlobalDeviceInfo();
err = ITCMM.ITC_GetDeviceInfo(dev, ref deviceInfo);
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to get device info", err);
}
return(new QueuedHekaHardwareDevice(dev,
deviceInfo.NumberOfADCs + deviceInfo.NumberOfDIs +
deviceInfo.NumberOfAUXIs,
deviceInfo.NumberOfDACs + deviceInfo.NumberOfDOs +
deviceInfo.NumberOfAUXOs
));
}
public void ConfigureChannels(IEnumerable <HekaDAQStream> streams)
{
uint err = ItcmmCall(() => ITCMM.ITC_ResetChannels(DevicePtr));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Channel Reset", err);
}
var infoList = streams
.Select((s) => s.ChannelInfo);
err = ItcmmCall(() => ITCMM.ITC_SetChannels(DevicePtr, (uint)infoList.Count(), infoList.ToArray()));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Set Channels", err);
}
err = ItcmmCall(() => ITCMM.ITC_UpdateChannels(DevicePtr));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Update Channels", err);
}
}
public void OpenDevice()
{
HekkaDevice device = HekkaDevice.Zero;
uint err = ITCMM.ITC_OpenDevice(ITCMM.USB18_ID, 0, ITCMM.SMART_MODE, out device);
try
{
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
Assert.NotNull(device);
}
finally
{
err = ITCMM.ITC_CloseDevice(device);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
}
}
private void WriteAsyncIO(HekaDAQOutputStream stream, IMeasurement streamValue)
{
lock (this)
{
var channelData = new[]
{
new ITCMM.ITCChannelDataEx
{
ChannelNumber = stream.ChannelNumber,
ChannelType = (ushort)stream.ChannelType,
Value =
(short)
Converters.Convert(streamValue, HekaDAQOutputStream.DAQCountUnits)
.QuantityInBaseUnit
}
};
uint err = ItcmmCall(() => ITCMM.ITC_AsyncIO(DevicePtr, 1, channelData));
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to write AsyncIO", err);
}
}
}
public void AsyncIORoundTrip()
{
HekkaDevice device = HekkaDevice.Zero;
uint err = ITCMM.ITC_OpenDevice(ITCMM.USB18_ID, 0, ITCMM.SMART_MODE, out device);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
try
{
err = ITCMM.ITC_InitDevice(device, IntPtr.Zero); //ref sHWFunction);
Assert.AreEqual(ITCMM.ACQ_SUCCESS,
err,
ErrorDescription.ErrorString(err)
);
uint expectedValue = 8000;
var channelData = new ITCMM.ITCChannelDataEx[] {
new ITCMM.ITCChannelDataEx {
ChannelNumber = 0,
ChannelType = ITCMM.OUTPUT_GROUP,
Value = (short)expectedValue
}
};
err = ITCMM.ITC_AsyncIO(device, 1, channelData);
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to write AsyncIO", err);
}
channelData = new ITCMM.ITCChannelDataEx[] {
new ITCMM.ITCChannelDataEx {
ChannelNumber = 0,
ChannelType = ITCMM.INPUT_GROUP,
Value = (short)expectedValue
}
};
err = ITCMM.ITC_AsyncIO(device, 1, channelData);
if (err != ITCMM.ACQ_SUCCESS)
{
throw new HekaDAQException("Unable to write AsyncIO", err);
}
var actualValue = channelData[0].Value;
Assert.That(actualValue, Is.InRange(expectedValue - 50, expectedValue + 50));
}
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)
);
}
}
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)
);
}
}