logger_read_device_list_c

	status.i4.v = logger_read_device_list_c(device_indices.i4a.r,
						array_indices.i4a.r,
						properties.i2a.r,
						nodes.u2a.r, time.u4.v,
						nanos.u4.v, num_devices.i4.v,
						timestamps.u4a.r,
						nanoseconds.u4a.r, values.r8a.r,
						errors.i2a.r [,sample_spec.g.v]
						[,sample_type.i4.v]
						[,sda_case.i4.v] [,sda_set.i4.v]
						[,sda_final_data.i4.v]
						[,options.u4.v]
						[,actual_nodes.u2a.r])

	This routine returns a single logged value for one or more devices.

	device_indices	device index or an array of device indices
	array_indices	index into array device or an array of indices
			(starts at 0)  (If a value of NULL is passed for
			this argument, an array index of zero will be
			used for all devices.)
	properties	property index or array of property indices
			(If the first value is less than zero, all devices
			 will be submitted with the same property.  The
			 property value used will be the absolute value of
			 this argument.)
			(constants are in dbprops)
			(PRREAD -> reading property,
			 PRSET -> setting property,
			 PRBSTS -> basic status property,
			 PRBCTL -> basic control property)
	nodes		Lumberjack source node or array of nodes
			(LOGGER_ANY_NODE -> routine picks a node logging this
					    device and property,
			 LOGGER_FASTEST_NODE -> routine picks node which is
						logging this device and
						property at the fastest rate,
			 LOGGER_COLLIDER_SDA_NODE -> Collider SDA node,
			 LOGGER_PBAR_SDA_NODE -> Pbar SDA node,
			 otherwise -> Lumberjack node value
				      (constants are in nodedefs))
	time		data acquisition time
			(seconds since January 1, 1970 UTC)
	nanos		acquisition time offset in nanoseconds
	num_devices	number of devices
	timestamps	returned timestamp value or an array of timestamp
			values
	nanoseconds	returned timestamp fractions of a second in
			nanoseconds or array of nanoseconds
	values		returned device value or an array of device values
	errors		returned ACNET status value or an array of returned
			ACNET status values
			(OK -> success,
			 DBM_NOREC -> invalid device index,
			 LJ_INVARG -> invalid property or array index,
			 LJ_NO_SUCH -> requested Lumberjack does not have the
				       requested device and property or there
				       is no data point at the requested time)
	[sample_spec]	data sample specifier whose type depends on the
			value of the "sample_type" argument
			(LOGGER_SAMPLE_TYPE_DATA_EVENT -> string describing
							  data event,
			 LOGGER_SAMPLE_TYPE_LIST_ID -> integer containing
						       list ID number)
			(default is NULL)
	[sample_type]	type of sample specifier
			(LOGGER_SAMPLE_TYPE_NONE -> don't use the sample
						    specifier (default),
			 LOGGER_SAMPLE_TYPE_DATA_EVENT -> return data sampled
							  on a particular
							  data event,
			 LOGGER_SAMPLE_TYPE_LIST_ID -> return data from a
						       particular list)
	[sda_case]	SDA case to return data for (A value of
			LOGGER_ALL_SDA_CASES indicates that all cases
			should be returned.)
			(default is LOGGER_ALL_SDA_CASES)
	[sda_set]	SDA set to return data for (A value of
			LOGGER_ALL_SDA_SETS indicates that all sets
			should be returned.)
			(default is LOGGER_ALL_SDA_SETS)
	[sda_final_data] indicates whether or not to return only the
			 final data samples
			 (LOGGER_ANY_SDA_DATA -> return all SDA data values,
			  LOGGER_FINAL_SDA_DATA -> only return the final data
						   values (default))
	[options]	read options
			(LOGGER_OPT_NONE -> no options selected (default),
			 LOGGER_OPT_SAME_DI -> use the same device index for
					       all entries,
			 LOGGER_OPT_SAME_NODE -> use the same node for
						 all entries)
	[actual_nodes]	returned nodes actually used for data acquisition

	This function returns status values as follows:

	OK			success
	LJ_MEMFAIL		dynamic memory allocation failure
	positive value		number of devices in error

	This function requires the following include files:

	dbprops_h, nodedefs_h, clib_h, acnet_errors_h

	Related functions:

	logger_get_device_list_c, logger_read_device_c,
	logger_read_device_by_name_c, logger_get_device_c,
	logger_get_device_by_name_c, logger_return_data,
	logger_get_array_device_c, logger_setnode, logger_return_names,
	logger_check_alive, logger_restart_lists, logger_shutdown,
	logger_find_device_c, logger_name_to_node,
	logger_available_device_dates_c, logger_available_device_data_entries_c,
	logger_get_list_data_events_c, logger_find_lists_by_data_event_c,
	logger_find_devices_by_data_event_c

	C/C++ usage:

	short	errors[NUM_DEVICES];
	static const short	properties[NUM_DEVICES] = {PRREAD, PRREAD};
	static const unsigned short	nodes[NUM_DEVICES] =
					{LOGGER_FASTEST_NODE, LOGGER_FASTEST_NODE};
	unsigned short	actual_nodes[NUM_DEVICES];
	int	status;
	static const int	device_index[NUM_DEVICES] = {27235, 27236};
	static const int	array_indices[NUM_DEVICES] = {0, 0};
	int	num_devices = NUM_DEVICES;
	int	sample_type = LOGGER_SAMPLE_TYPE_NONE;
	int	sda_case = LOGGER_ALL_SDA_CASES;
	int	sda_set = LOGGER_ALL_SDA_SETS;
	int	sda_final_data = LOGGER_FINAL_SDA_DATA;
	unsigned int	TIME;
	unsigned int	nanos = 0;
	unsigned int	timestamps[NUM_DEVICES];
	unsigned int	nanoseconds[NUM_DEVICES];
	unsigned int	options = LOGGER_OPT_NONE;
	double	values[NUM_DEVICES];
	void	*sample_spec = (void *) NULL;
	void	update_func(LOGGER_UPDATE_DATA *update_data);

	TIME = date_to_clinks("01-JAN-2006 12:00",&status);
	TIME = convert_seconds_c(TIME,DATE_CLINKS_TO_UTC_CTIME);

	status = logger_read_device_list_c(device_indices,array_indices,
					   properties,nodes,TIME,nanos,
					   num_devices,timestamps,nanoseconds,
					   values,errors,sample_spec,
					   sample_type,sda_case,sda_set,
					   sda_final_data,options,actual_nodes);