Mirrors/VILLASnode
1
0
Fork 0
mirror of https://git.rwth-aachen.de/acs/public/villas/node/ synced 2025-03-23 00:00:01 +01:00
Code Issues Releases Wiki Activity
VILLASnode/lib/nodes/uldaq.cpp
Manuel Pitz 3c06705110 fix correct selection of uldaq hardware
2020-10-21 21:04:45 +02:00

801 lines
25 KiB
C++
Raw Blame History

/** Node-type for uldaq connections.
*
* @file
* @author Manuel Pitz <manuel.pitz@eonerc.rwth-aachen.de>
* @author Steffen Vogel <stvogel@eonerc.rwth-aachen.de>
* @copyright 2014-2020, Institute for Automation of Complex Power Systems, EONERC
* @license GNU General Public License (version 3)
*
* VILLASnode
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************************/
#include <cstring>
#include <villas/node.h>
#include <villas/plugin.h>
#include <villas/config.h>
#include <villas/nodes/uldaq.hpp>
#include <villas/exceptions.hpp>
#include <villas/memory.h>
using namespace villas;
using namespace villas::utils;
static unsigned num_devs = ULDAQ_MAX_DEV_COUNT;
static DaqDeviceDescriptor descriptors[ULDAQ_MAX_DEV_COUNT];
static const struct {
const char *errStr;
uint bitPos;
} errorList[] = {
{"No error has occurred ERR_NO_ERROR" , 0},
{"Unhandled internal exception ERR_UNHANDLED_EXCEPTION" , 1},
{"Invalid device handle ERR_BAD_DEV_HANDLE" , 2},
{"This function cannot be used with this device ERR_BAD_DEV_TYPE" , 3},
{"Insufficient permission to access this device ERR_USB_DEV_NO_PERMISSION" , 4},
{"USB interface is already claimed ERR_USB_INTERFACE_CLAIMED" , 5},
{"Device not found ERR_DEV_NOT_FOUND" , 6},
{"Device not connected or connection lost ERR_DEV_NOT_CONNECTED" , 7},
{"Device no longer responding ERR_DEAD_DEV" , 8},
{"Buffer too small for operation ERR_BAD_BUFFER_SIZE" , 9},
{"Invalid buffer ERR_BAD_BUFFER" , 10},
{"Invalid memory type ERR_BAD_MEM_TYPE" , 11},
{"Invalid memory region ERR_BAD_MEM_REGION" , 12},
{"Invalid range ERR_BAD_RANGE" , 13},
{"Invalid analog input channel specified ERR_BAD_AI_CHAN" , 14},
{"Invalid input mode specified ERR_BAD_INPUT_MODE" , 15},
{"A background process is already in progress ERR_ALREADY_ACTIVE" , 16},
{"Invalid trigger type specified ERR_BAD_TRIG_TYPE" , 17},
{"FIFO overrun, data was not transferred from device fast enough ERR_OVERRUN" , 18},
{"FIFO underrun, data was not transferred to device fast enough ERR_UNDERRUN" , 19},
{"Operation timed out ERR_TIMEDOUT" , 20},
{"Invalid option specified ERR_BAD_OPTION" , 21},
{"Invalid sampling rate specified ERR_BAD_RATE" , 22},
{"Sample count cannot be greater than FIFO size for BURSTIO scans ERR_BAD_BURSTIO_COUNT" , 23},
{"Configuration not supported ERR_CONFIG_NOT_SUPPORTED" , 24},
{"Invalid configuration value ERR_BAD_CONFIG_VAL" , 25},
{"Invalid analog input channel type specified ERR_BAD_AI_CHAN_TYPE" , 26},
{"ADC overrun occurred ERR_ADC_OVERRUN" , 27},
{"Invalid thermocouple type specified ERR_BAD_TC_TYPE" , 28},
{"Invalid unit specified ERR_BAD_UNIT" , 29},
{"Invalid queue size ERR_BAD_QUEUE_SIZE" , 30},
{"Invalid config item specified ERR_BAD_CONFIG_ITEM" , 31},
{"Invalid info item specified ERR_BAD_INFO_ITEM" , 32},
{"Invalid flag specified ERR_BAD_FLAG" , 33},
{"Invalid sample count specified ERR_BAD_SAMPLE_COUNT" , 34},
{"Internal error ERR_INTERNAL" , 35},
{"Invalid coupling mode ERR_BAD_COUPLING_MODE" , 36},
{"Invalid sensor sensitivity ERR_BAD_SENSOR_SENSITIVITY" , 37},
{"Invalid IEPE mode ERR_BAD_IEPE_MODE" , 38},
{"Invalid channel queue specified ERR_BAD_AI_CHAN_QUEUE" , 39},
{"Invalid gain queue specified ERR_BAD_AI_GAIN_QUEUE" , 40},
{"Invalid mode queue specified ERR_BAD_AI_MODE_QUEUE" , 41},
{"FPGA file not found ERR_FPGA_FILE_NOT_FOUND" , 42},
{"Unable to read FPGA file ERR_UNABLE_TO_READ_FPGA_FILE" , 43},
{"FPGA not loaded ERR_NO_FPGA" , 44},
{"Invalid argument ERR_BAD_ARG" , 45},
{"Minimum slope value reached ERR_MIN_SLOPE_VAL_REACHED" , 46},
{"Maximum slope value reached ERR_MAX_SLOPE_VAL_REACHED" , 47},
{"Minimum offset value reached ERR_MIN_OFFSET_VAL_REACHED" , 48},
{"Maximum offset value reached ERR_MAX_OFFSET_VAL_REACHED" , 49},
{"Invalid port type specified ERR_BAD_PORT_TYPE" , 50},
{"Digital I/O is configured incorrectly ERR_WRONG_DIG_CONFIG" , 51},
{"Invalid bit number ERR_BAD_BIT_NUM" , 52},
{"Invalid port value specified ERR_BAD_PORT_VAL" , 53},
{"Invalid re-trigger count ERR_BAD_RETRIG_COUNT" , 54},
{"Invalid analog output channel specified ERR_BAD_AO_CHAN" , 55},
{"Invalid D/A output value specified ERR_BAD_DA_VAL" , 56},
{"Invalid timer specified ERR_BAD_TMR" , 57},
{"Invalid frequency specified ERR_BAD_FREQUENCY" , 58},
{"Invalid duty cycle specified ERR_BAD_DUTY_CYCLE" , 59},
{"Invalid initial delay specified ERR_BAD_INITIAL_DELAY" , 60},
{"Invalid counter specified ERR_BAD_CTR" , 61},
{"Invalid counter value specified ERR_BAD_CTR_VAL" , 62},
{"Invalid DAQ input channel type specified ERR_BAD_DAQI_CHAN_TYPE" , 63},
{"Invalid number of channels specified ERR_BAD_NUM_CHANS" , 64},
{"Invalid counter register specified ERR_BAD_CTR_REG" , 65},
{"Invalid counter measurement type specified ERR_BAD_CTR_MEASURE_TYPE" , 66},
{"Invalid counter measurement mode specified ERR_BAD_CTR_MEASURE_MODE" , 67},
{"Invalid debounce time specified ERR_BAD_DEBOUNCE_TIME" , 68},
{"Invalid debounce mode specified ERR_BAD_DEBOUNCE_MODE" , 69},
{"Invalid edge detection mode specified ERR_BAD_EDGE_DETECTION" , 70},
{"Invalid tick size specified ERR_BAD_TICK_SIZE" , 71},
{"Invalid DAQ output channel type specified ERR_BAD_DAQO_CHAN_TYPE" , 72},
{"No connection established ERR_NO_CONNECTION_ESTABLISHED" , 73},
{"Invalid event type specified ERR_BAD_EVENT_TYPE" , 74},
{"An event handler has already been enabled for this event type ERR_EVENT_ALREADY_ENABLED" , 75},
{"Invalid event parameter specified ERR_BAD_EVENT_PARAMETER" , 76},
{"Invalid callback function specified ERR_BAD_CALLBACK_FUCNTION" , 77},
{"Invalid memory address ERR_BAD_MEM_ADDRESS" , 78},
{"Memory access denied ERR_MEM_ACCESS_DENIED" , 79},
{"Device is not available at time of request ERR_DEV_UNAVAILABLE" , 80},
{"Re-trigger option is not supported for the specified trigger type ERR_BAD_RETRIG_TRIG_TYPE" , 81},
{"This function cannot be used with this version of the device ERR_BAD_DEV_VER" , 82},
{"This digital operation is not supported on the specified port ERR_BAD_DIG_OPERATION" , 83},
{"Invalid digital port index specified ERR_BAD_PORT_INDEX" , 84},
{"Temperature input has open connection ERR_OPEN_CONNECTION" , 85},
{"Device is not ready to send data ERR_DEV_NOT_READY" , 86},
{"Pacer overrun, external clock rate too fast. ERR_PACER_OVERRUN" , 7},
{"Invalid trigger channel specified ERR_BAD_TRIG_CHANNEL" , 88},
{"Invalid trigger level specified ERR_BAD_TRIG_LEVEL" , 89},
{"Invalid channel order ERR_BAD_CHAN_ORDER" , 90},
{"Temperature input is out of range ERR_TEMP_OUT_OF_RANGE" , 91},
{"Trigger threshold is out of range ERR_TRIG_THRESHOLD_OUT_OF_RANGE" , 92},
{"Incompatible firmware version, firmware update required ERR_INCOMPATIBLE_FIRMWARE" , 93},
{"Specified network interface is not available or disconnected ERR_BAD_NET_IFC" , 94},
{"Invalid host specified ERR_BAD_NET_HOST" , 95},
{"Invalid port specified ERR_BAD_NET_PORT" , 96},
{"Network interface used to obtain the device descriptor not available or disconnected ERR_NET_IFC_UNAVAILABLE" , 97},
{"Network connection failed ERR_NET_CONNECTION_FAILED" , 98},
{"Invalid connection code ERR_BAD_CONNECTION_CODE" , 99},
{"Connection code ignored ERR_CONNECTION_CODE_IGNORED" , 100},
{"Network device already in use ERR_NET_DEV_IN_USE" , 101},
{"Invalid network frame ERR_BAD_NET_FRAME" , 102},
{"Network device did not respond within expected time ERR_NET_TIMEOUT" , 103},
{"Data socket connection failed ERR_DATA_SOCKET_CONNECTION_FAILED" , 104},
{"One or more bits on the specified port are used for alarm ERR_PORT_USED_FOR_ALARM" , 105},
{"The specified bit is used for alarm ERR_BIT_USED_FOR_ALARM" , 106},
{"Common-mode voltage range exceeded ERR_CMR_EXCEEDED" , 107},
{"Network buffer overrun, data was not transferred from buffer fast enough ERR_NET_BUFFER_OVERRUN" , 108},
{"Invalid network buffer ERR_BAD_NET_BUFFER" , 109}
};
static const struct {
const char *name;
AiInputMode mode;
} input_modes[] = {
{ "differential", AI_DIFFERENTIAL },
{ "single-ended", AI_SINGLE_ENDED },
{ "pseudo-differential", AI_PSEUDO_DIFFERENTIAL }
};
static const struct {
const char *name;
DaqDeviceInterface interface;
} interface_types[] = {
{ "usb", USB_IFC },
{ "bluetooth", BLUETOOTH_IFC },
{ "ethernet", ETHERNET_IFC },
{ "any", ANY_IFC }
};
static const struct {
const char *name;
Range range;
float min, max;
} ranges[] = {
{ "bipolar-60", BIP60VOLTS, -60.0, +60.0 },
{ "bipolar-60", BIP60VOLTS, -60.0, +60.0 },
{ "bipolar-30", BIP30VOLTS, -30.0, +30.0 },
{ "bipolar-15", BIP15VOLTS, -15.0, +15.0 },
{ "bipolar-20", BIP20VOLTS, -20.0, +20.0 },
{ "bipolar-10", BIP10VOLTS, -10.0, +10.0 },
{ "bipolar-5", BIP5VOLTS, -5.0, +5.0 },
{ "bipolar-4", BIP4VOLTS, -4.0, +4.0 },
{ "bipolar-2.5", BIP2PT5VOLTS, -2.5, +2.5 },
{ "bipolar-2", BIP2VOLTS, -2.0, +2.0 },
{ "bipolar-1.25", BIP1PT25VOLTS, -1.25, +1.25 },
{ "bipolar-1", BIP1VOLTS, -1.0, +1.0 },
{ "bipolar-0.625", BIPPT625VOLTS, -0.625, +0.625 },
{ "bipolar-0.5", BIPPT5VOLTS, -0.5, +0.5 },
{ "bipolar-0.25", BIPPT25VOLTS, -0.25, +0.25 },
{ "bipolar-0.125", BIPPT125VOLTS, -0.125, +0.125 },
{ "bipolar-0.2", BIPPT2VOLTS, -0.2, +0.2 },
{ "bipolar-0.1", BIPPT1VOLTS, -0.1, +0.1 },
{ "bipolar-0.078", BIPPT078VOLTS, -0.078, +0.078 },
{ "bipolar-0.05", BIPPT05VOLTS, -0.05, +0.05 },
{ "bipolar-0.01", BIPPT01VOLTS, -0.01, +0.01 },
{ "bipolar-0.005", BIPPT005VOLTS, -0.005, +0.005 },
{ "unipolar-60", UNI60VOLTS , 0.0, +60.0 },
{ "unipolar-30", UNI30VOLTS , 0.0, +30.0 },
{ "unipolar-15", UNI15VOLTS , 0.0, +15.0 },
{ "unipolar-20", UNI20VOLTS , 0.0, +20.0 },
{ "unipolar-10", UNI10VOLTS , 0.0, +10.0 },
{ "unipolar-5", UNI5VOLTS , 0.0, +5.0 },
{ "unipolar-4", UNI4VOLTS , 0.0, +4.0 },
{ "unipolar-2.5", UNI2PT5VOLTS, 0.0, +2.5 },
{ "unipolar-2", UNI2VOLTS , 0.0, +2.0 },
{ "unipolar-1.25", UNI1PT25VOLTS, 0.0, +1.25 },
{ "unipolar-1", UNI1VOLTS , 0.0, +1.0 },
{ "unipolar-0.625", UNIPT625VOLTS, 0.0, +0.625 },
{ "unipolar-0.5", UNIPT5VOLTS, 0.0, +0.5 },
{ "unipolar-0.25", UNIPT25VOLTS, 0.0, +0.25 },
{ "unipolar-0.125", UNIPT125VOLTS, 0.0, +0.125 },
{ "unipolar-0.2", UNIPT2VOLTS, 0.0, +0.2 },
{ "unipolar-0.1", UNIPT1VOLTS, 0.0, +0.1 },
{ "unipolar-0.078", UNIPT078VOLTS, 0.0, +0.078 },
{ "unipolar-0.05", UNIPT05VOLTS, 0.0, +0.05 },
{ "unipolar-0.01", UNIPT01VOLTS, 0.0, +0.01 },
{ "unipolar-0.005", UNIPT005VOLTS, 0.0, +0.005 }
};
static void ul_decode_error(UlError err){
for( uint i=0; i < ARRAY_LEN(errorList) ;i++){
if(err&(1<<errorList[i].bitPos))
warning("Found error: %s",errorList[i].errStr);
}
}
static AiInputMode uldaq_parse_input_mode(const char *str)
{
for (unsigned i = 0; i < ARRAY_LEN(input_modes); i++) {
if (!strcmp(input_modes[i].name, str))
return input_modes[i].mode;
}
return (AiInputMode) -1;
}
static DaqDeviceInterface uldaq_parse_interface_type(const char *str)
{
for (unsigned i = 0; i < ARRAY_LEN(interface_types); i++) {
if (!strcmp(interface_types[i].name, str))
return interface_types[i].interface;
}
return (DaqDeviceInterface) -1;
}
static const char * uldaq_print_interface_type(DaqDeviceInterface iftype)
{
for (unsigned i = 0; i < ARRAY_LEN(interface_types); i++) {
if (interface_types[i].interface == iftype)
return interface_types[i].name;
}
return nullptr;
}
static Range uldaq_parse_range(const char *str)
{
for (unsigned i = 0; i < ARRAY_LEN(ranges); i++) {
if (!strcmp(ranges[i].name, str))
return ranges[i].range;
}
return (Range) -1;
}
static DaqDeviceDescriptor * uldaq_find_device(struct uldaq *u) {
DaqDeviceDescriptor *d = nullptr;
if (num_devs == 0)
return nullptr;
if (u->device_interface_type == ANY_IFC && u->device_id == nullptr)
return &descriptors[0];
for (unsigned i = 0; i < num_devs; i++) {
d = &descriptors[i];
if (u->device_id) {
if (strcmp(u->device_id, d->uniqueId))
break;
}
if (u->device_interface_type != ANY_IFC) {
if (u->device_interface_type != d->devInterface)
break;
}
return d;
}
return nullptr;
}
static int uldaq_connect(struct vnode *n)
{
struct uldaq *u = (struct uldaq *) n->_vd;
UlError err;
/* Find Matching device */
if (!u->device_descriptor) {
u->device_descriptor = uldaq_find_device(u);
if (!u->device_descriptor) {
warning("Unable to find a matching device for node '%s'", node_name(n));
return -1;
}
}
/* Get a handle to the DAQ device associated with the first descriptor */
if (!u->device_handle) {
u->device_handle = ulCreateDaqDevice(*u->device_descriptor);
if (!u->device_handle) {
warning("Unable to create handle for DAQ device for node '%s'", node_name(n));
return -1;
}
}
/* Check if device is already connected */
int connected;
err = ulIsDaqDeviceConnected(u->device_handle, &connected);
if (err != ERR_NO_ERROR)
return -1;
/* Connect to device */
if (!connected) {
err = ulConnectDaqDevice(u->device_handle);
if (err != ERR_NO_ERROR) {
warning("Failed to connect to DAQ device for node '%s'", node_name(n));
ul_decode_error(err);
return -1;
}
}
return 0;
}
int uldaq_type_start(villas::node::SuperNode *sn)
{
UlError err;
/* Get descriptors for all of the available DAQ devices */
err = ulGetDaqDeviceInventory(ANY_IFC, descriptors, &num_devs);
if (err != ERR_NO_ERROR) {
warning("Failed to retrieve DAQ device list");
return -1;
}
info("Found %d DAQ devices", num_devs);
for (unsigned i = 0; i < num_devs; i++) {
DaqDeviceDescriptor *desc = &descriptors[i];
info(" %d: %s %s (%s)", i, desc->uniqueId, desc->devString, uldaq_print_interface_type(desc->devInterface));
}
return 0;
}
int uldaq_init(struct vnode *n)
{
int ret;
struct uldaq *u = (struct uldaq *) n->_vd;
u->device_id = nullptr;
u->device_interface_type = ANY_IFC;
u->in.queues = nullptr;
u->in.sample_rate = 1000;
u->in.scan_options = (ScanOption) (SO_DEFAULTIO | SO_CONTINUOUS);
u->in.flags = AINSCAN_FF_DEFAULT;
ret = pthread_mutex_init(&u->in.mutex, nullptr);
if (ret)
return ret;
ret = pthread_cond_init(&u->in.cv, nullptr);
if (ret)
return ret;
return 0;
}
int uldaq_destroy(struct vnode *n)
{
int ret;
struct uldaq *u = (struct uldaq *) n->_vd;
if (u->in.queues)
delete[] u->in.queues;
ret = pthread_mutex_destroy(&u->in.mutex);
if (ret)
return ret;
ret = pthread_cond_destroy(&u->in.cv);
if (ret)
return ret;
return 0;
}
int uldaq_parse(struct vnode *n, json_t *cfg)
{
int ret;
struct uldaq *u = (struct uldaq *) n->_vd;
const char *default_range_str = nullptr;
const char *default_input_mode_str = nullptr;
const char *interface_type = nullptr;
size_t i;
json_t *json_signals;
json_t *json_signal;
json_error_t err;
ret = json_unpack_ex(cfg, &err, 0, "{ s?: s, s?: s, s: { s: o, s: F, s?: s, s?: s } }",
"interface_type", &interface_type,
"device_id", &u->device_id,
"in",
"signals", &json_signals,
"sample_rate", &u->in.sample_rate,
"range", &default_range_str,
"input_mode", &default_input_mode_str
);
if (ret)
jerror(&err, "Failed to parse configuration of node %s", node_name(n));
if (interface_type) {
int iftype = uldaq_parse_interface_type(interface_type);
if (iftype < 0)
error("Invalid interface type: %s for node '%s'", interface_type, node_name(n));
u->device_interface_type = (DaqDeviceInterface) iftype;
}
if (u->in.queues)
delete[] u->in.queues;
u->in.channel_count = vlist_length(&n->in.signals);
u->in.queues = new struct AiQueueElement[u->in.channel_count];
if (!u->in.queues)
throw MemoryAllocationError();
json_array_foreach(json_signals, i, json_signal) {
const char *range_str = nullptr, *input_mode_str = nullptr;
int channel = -1, input_mode, range;
ret = json_unpack_ex(json_signal, &err, 0, "{ s?: s, s?: s, s?: i }",
"range", &range_str,
"input_mode", &input_mode_str,
"channel", &channel
);
if (ret)
jerror(&err, "Failed to parse signal configuration of node %s", node_name(n));
if (!range_str)
range_str = default_range_str;
if (!input_mode_str)
input_mode_str = default_input_mode_str;
if (channel < 0)
channel = i;
if (!range_str)
error("No input range specified for signal %zu of node %s.", i, node_name(n));
if (!input_mode_str)
error("No input mode specified for signal %zu of node %s.", i, node_name(n));
range = uldaq_parse_range(range_str);
if (range < 0)
error("Invalid input range specified for signal %zu of node %s.", i, node_name(n));
input_mode = uldaq_parse_input_mode(input_mode_str);
if (input_mode < 0)
error("Invalid input mode specified for signal %zu of node %s.", i, node_name(n));
u->in.queues[i].range = (Range) range;
u->in.queues[i].inputMode = (AiInputMode) input_mode;
u->in.queues[i].channel = channel;
}
return ret;
}
char * uldaq_print(struct vnode *n)
{
struct uldaq *u = (struct uldaq *) n->_vd;
char *buf = nullptr;
if (u->device_descriptor) {
char *uid = u->device_descriptor->uniqueId;
char *name = u->device_descriptor->productName;
const char *iftype = uldaq_print_interface_type(u->device_descriptor->devInterface);
buf = strcatf(&buf, "device=%s (%s), interface=%s", uid, name, iftype);
}
else {
const char *uid = u->device_id;
const char *iftype = uldaq_print_interface_type(u->device_interface_type);
buf = strcatf(&buf, "device=%s, interface=%s", uid, iftype);
}
buf = strcatf(&buf, ", in.sample_rate=%f", u->in.sample_rate);
return buf;
}
int uldaq_check(struct vnode *n)
{
int ret;
long long has_ai, event_types, max_channel, scan_options, num_ranges_se, num_ranges_diff;
struct uldaq *u = (struct uldaq *) n->_vd;
UlError err;
if (n->in.vectorize < 100) {
warning("vectorize setting of node '%s' must be larger than 100", node_name(n));
return -1;
}
ret = uldaq_connect(n);
if (ret)
return ret;
err = ulDevGetInfo(u->device_handle, DEV_INFO_HAS_AI_DEV, 0, &has_ai);
if (err != ERR_NO_ERROR)
return -1;
err = ulDevGetInfo(u->device_handle, DEV_INFO_DAQ_EVENT_TYPES, 0, &event_types);
if (err != ERR_NO_ERROR)
return -1;
err = ulAIGetInfo(u->device_handle, AI_INFO_NUM_CHANS, 0, &max_channel);
if (err != ERR_NO_ERROR)
return -1;
err = ulAIGetInfo(u->device_handle, AI_INFO_SCAN_OPTIONS, 0, &scan_options);
if (err != ERR_NO_ERROR)
return -1;
err = ulAIGetInfo(u->device_handle, AI_INFO_NUM_DIFF_RANGES, 0, &num_ranges_diff);
if (err != ERR_NO_ERROR)
return -1;
err = ulAIGetInfo(u->device_handle, AI_INFO_NUM_SE_RANGES, 0, &num_ranges_se);
if (err != ERR_NO_ERROR)
return -1;
Range ranges_diff[num_ranges_diff];
Range ranges_se[num_ranges_se];
for (int i = 0; i < num_ranges_diff; i++) {
err = ulAIGetInfo(u->device_handle, AI_INFO_DIFF_RANGE, i, (long long *) &ranges_diff[i]);
if (err != ERR_NO_ERROR)
return -1;
}
for (int i = 0; i < num_ranges_se; i++) {
err = ulAIGetInfo(u->device_handle, AI_INFO_SE_RANGE, i, (long long *) &ranges_se[i]);
if (err != ERR_NO_ERROR)
return -1;
}
if (!has_ai) {
warning("DAQ device has no analog input channels");
return -1;
}
if (!(event_types & DE_ON_DATA_AVAILABLE)) {
warning("DAQ device does not support events");
return -1;
}
if ((scan_options & u->in.scan_options) != u->in.scan_options) {
warning("DAQ device does not support required scan options");
return -1;
}
for (size_t i = 0; i < vlist_length(&n->in.signals); i++) {
struct signal *s = (struct signal *) vlist_at(&n->in.signals, i);
AiQueueElement *q = &u->in.queues[i];
if (s->type != SignalType::FLOAT) {
warning("Node '%s' only supports signals of type = float!", node_name(n));
return -1;
}
switch (q->inputMode) {
case AI_PSEUDO_DIFFERENTIAL:
case AI_DIFFERENTIAL:
for (int j = 0; j < num_ranges_diff; j++) {
if (q->range == ranges_diff[j])
goto found;
}
break;
case AI_SINGLE_ENDED:
for (int j = 0; j < num_ranges_se; j++) {
if (q->range == ranges_se[j])
goto found;
}
break;
}
warning("Unsupported range for signal %zu", i);
return -1;
found: if (q->channel > max_channel) {
warning("DAQ device does not support more than %lld channels", max_channel);
return -1;
}
}
return 0;
}
void uldaq_data_available(DaqDeviceHandle device_handle, DaqEventType event_type, unsigned long long event_data, void *ctx)
{
struct vnode *n = (struct vnode *) ctx;
struct uldaq *u = (struct uldaq *) n->_vd;
pthread_mutex_lock(&u->in.mutex);
UlError err;
err = ulAInScanStatus(device_handle, &u->in.status, &u->in.transfer_status);
if (err != ERR_NO_ERROR)
warning("Failed to retrieve scan status in event callback");
pthread_mutex_unlock(&u->in.mutex);
/* Signal uldaq_read() about new data */
pthread_cond_signal(&u->in.cv);
}
int uldaq_start(struct vnode *n)
{
struct uldaq *u = (struct uldaq *) n->_vd;
u->sequence = 0;
u->in.buffer_pos = 0;
int ret;
UlError err;
/* Allocate a buffer to receive the data */
u->in.buffer_len = u->in.channel_count * n->in.vectorize * 50;
u->in.buffer = new double[u->in.buffer_len];
if (!u->in.buffer)
throw MemoryAllocationError();
ret = uldaq_connect(n);
if (ret)
return ret;
err = ulAInLoadQueue(u->device_handle, u->in.queues, vlist_length(&n->in.signals));
if (err != ERR_NO_ERROR) {
warning("Failed to load input queue to DAQ device for node '%s'", node_name(n));
return -1;
}
/* Enable the event to be notified every time samples are available */
err = ulEnableEvent(u->device_handle, DE_ON_DATA_AVAILABLE, n->in.vectorize, uldaq_data_available, n);
/* Start the acquisition */
err = ulAInScan(u->device_handle, 0, 0, (AiInputMode) 0, (Range) 0, u->in.buffer_len / u->in.channel_count, &u->in.sample_rate, u->in.scan_options, u->in.flags, u->in.buffer);
if (err != ERR_NO_ERROR) {
ul_decode_error(err);
warning("Failed to start acquisition on DAQ device for node '%s'", node_name(n));
return -1;
}
/* Get the initial status of the acquisition */
err = ulAInScanStatus(u->device_handle, &u->in.status, &u->in.transfer_status);
if (err != ERR_NO_ERROR) {
ul_decode_error(err);
warning("Failed to retrieve scan status on DAQ device for node '%s'", node_name(n));
return -1;
}
if (u->in.status != SS_RUNNING) {
ul_decode_error(err);
warning("Acquisition did not start on DAQ device for node '%s'", node_name(n));
return -1;
}
return 0;
}
int uldaq_stop(struct vnode *n)
{
struct uldaq *u = (struct uldaq *) n->_vd;
UlError err;
/* @todo: Fix deadlock */
//pthread_mutex_lock(&u->in.mutex);
/* Get the current status of the acquisition */
err = ulAInScanStatus(u->device_handle, &u->in.status, &u->in.transfer_status);
if (err != ERR_NO_ERROR)
return -1;
/* Stop the acquisition if it is still running */
if (u->in.status == SS_RUNNING) {
err = ulAInScanStop(u->device_handle);
if (err != ERR_NO_ERROR)
return -1;
}
//pthread_mutex_unlock(&u->in.mutex);
err = ulDisconnectDaqDevice(u->device_handle);
if (err != ERR_NO_ERROR)
return -1;
err = ulReleaseDaqDevice(u->device_handle);
if (err != ERR_NO_ERROR)
return -1;
return 0;
}
int uldaq_read(struct vnode *n, struct sample *smps[], unsigned cnt, unsigned *release)
{
struct uldaq *u = (struct uldaq *) n->_vd;
pthread_mutex_lock(&u->in.mutex);
if (u->in.status != SS_RUNNING)
return -1;
size_t start_index = u->in.buffer_pos;
/* Wait for data available condition triggered by event callback */
if (start_index + n->in.vectorize * u->in.channel_count > u->in.transfer_status.currentTotalCount)
pthread_cond_wait(&u->in.cv, &u->in.mutex);
for (unsigned j = 0; j < cnt; j++) {
struct sample *smp = smps[j];
long long scan_index = start_index + j * u->in.channel_count;
for (unsigned i = 0; i < u->in.channel_count; i++) {
long long channel_index = (scan_index + i) % u->in.buffer_len;
smp->data[i].f = u->in.buffer[channel_index];
}
smp->length = u->in.channel_count;
smp->signals = &n->in.signals;
smp->sequence = u->sequence++;
smp->flags = (int) SampleFlags::HAS_SEQUENCE | (int) SampleFlags::HAS_DATA;
}
u->in.buffer_pos += u->in.channel_count * cnt;
pthread_mutex_unlock(&u->in.mutex);
return cnt;
}
static struct plugin p;
__attribute__((constructor(110)))
static void register_plugin() {
p.name = "uldaq";
p.description = "Measurement Computing DAQ devices like UL201 (libuldaq)";
p.type = PluginType::NODE;
p.node.instances.state = State::DESTROYED;
p.node.vectorize = 0;
p.node.flags = 0;
p.node.size = sizeof(struct uldaq);
p.node.type.start = uldaq_type_start;
p.node.init = uldaq_init;
p.node.destroy = uldaq_destroy;
p.node.parse = uldaq_parse;
p.node.print = uldaq_print;
p.node.start = uldaq_start;
p.node.stop = uldaq_stop;
p.node.read = uldaq_read;
int ret = vlist_init(&p.node.instances);
if (!ret)
vlist_init_and_push(&plugins, &p);
}
__attribute__((destructor(110)))
static void deregister_plugin() {
vlist_remove_all(&plugins, &p);
}
Reference in a new issue View git blame Copy permalink