logger_read_device_status_list_c

	status.i4.v = logger_read_device_status_list_c(device_indices.i4a.r,
						       array_indices.i4a.r,
						       nodes.u2a.r, time.u4.v,
						       nanos.u4.v,
						       num_devices.i4.v,
						       timestamps.u4a.r,
						       nanoseconds.u4a.r,
						       on_states.i4a.r,
						       ready_states.i4a.r,
						       remote_states.i4a.r,
						       positive_states.i4a.r,
						       ramp_states.i4a.r,
						       status_text.sa.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 status 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.)
	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
	on_states	returned on/off status values
			(TRUE -> device was on,
			 FALSE -> device was off,
			 DIO_NOATT -> on/off attribute not defined)
	ready_states	returned ready/tripped status values
			(TRUE -> device was ready,
			 FALSE -> device was tripped,
			 DIO_NOATT -> ready/tripped attribute not defined)
	remote_states	returned remote/local status values
			(TRUE -> device was in remote,
			 FALSE -> device was in local,
			 DIO_NOATT -> remote/local attribute not defined)
	positive_states	returned polarity status values
			(TRUE -> device was in positive polarity,
			 FALSE -> device was in negative polarity,
			 DIO_NOATT -> polarity attribute not defined)
	ramp_states	returned ramp/DC status values
			(TRUE -> device was ramping,
			 FALSE -> device was DC,
			 DIO_NOATT -> ramp/DC attribute not defined)
	status_text	returned DIO_NUM_STATUS_TYPES + 1 characters of XCHAR
			format color coded status text
			(array of XCHAR structures)
	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_read_device_list_c, 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 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	on_states[NUM_DEVICES];
	int	ready_states[NUM_DEVICES];
	int	remote_states[NUM_DEVICES];
	int	positive_states[NUM_DEVICES];
	int	ramp_states[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;
	void	*sample_spec = (void *) NULL;
	void	update_func(LOGGER_UPDATE_DATA *update_data);
	XCHAR	status_text[NUM_DEVICES][DIO_NUM_STATUS_TYPES+1];

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

	status = logger_read_device_status_list_c(device_indices,array_indices,
						  nodes,TIME,nanos,num_devices,
						  timestamps,nanoseconds,
						  on_states,ready_states,
						  remote_states,positive_states,
						  ramp_states,status_text,
						  errors,sample_spec,
						  sample_type,sda_case,sda_set,
						  sda_final_data,options,
						  actual_nodes);