def check_config_status(self):
# type: () -> None
"""Check this signal's configuration status.
By default, incorrectly configured signals in the database are not returned from
:any:`Frame.sigs` because they cannot be used in the bus communication.
You can change this behavior by setting :any:`Database.show_invalid_from_open` to `True`.
When a signal configuration status becomes invalid after the database is opened,
the signal still is returned from :any:`Frame.sigs`
even if :any:`Database.show_invalid_from_open` is `False`.
Examples of invalid signal configuration:
* The signal is specified using bits outside the frame payload.
* The signal overlaps another signal in the frame.
For example,
two multiplexed signals with the same multiplexer value are using the same bit in the frame payload.
* The signal with integer data type (signed or unsigned) is specified with more than 52 bits.
This is not allowed due to internal limitation of the double data type that NI-XNET uses for signal values.
* The frame containing the signal is invalid
(for example, a CAN frame is defined with more than 8 payload bytes).
Raises:
:any:`XnetError`: The signal is incorrectly configured.
"""
status_code = _props.get_signal_config_status(self._handle)
_errors.check_for_error(status_code)
def nxdb_remove_alias(
database_alias, # type: typing.Text
):
# type: (...) -> None
database_alias_ctypes = _ctypedefs.char_p(database_alias.encode('ascii'))
result = _cfuncs.lib.nxdb_remove_alias(database_alias_ctypes, )
_errors.check_for_error(result.value)
def nx_flush(
session_ref, # type: int
):
# type: (...) -> None
session_ref_ctypes = _ctypedefs.nxSessionRef_t(session_ref)
result = _cfuncs.lib.nx_flush(session_ref_ctypes, )
_errors.check_for_error(result.value)
def flatten_items(list):
# (typing.Union[typing.Text, typing.List[typing.Text]]) -> typing.Text
"""Flatten an item list to a string
>>> str(flatten_items('Item'))
'Item'
>>> str(flatten_items(['A', 'B']))
'A,B'
>>> str(flatten_items(None))
''
"""
if isinstance(list, six.string_types):
# For FRAME_IN_QUEUED / FRAME_OUT_QUEUED
# Convenience for everything else
if ',' in list:
# A bit of an abuse of an error code
_errors.check_for_error(_cconsts.NX_ERR_INVALID_PROPERTY_VALUE)
flattened = list
elif isinstance(list, collections.Iterable):
flattened = ",".join(list)
elif list is None:
# For FRAME_IN_STREAM / FRAME_OUT_STREAM
flattened = ''
else:
# A bit of an abuse of an error code
_errors.check_for_error(_cconsts.NX_ERR_INVALID_PROPERTY_VALUE)
return flattened
def nx_write_signal_xy(
session_ref, # type: int
timeout, # type: float
value_buffer, # type: typing.List[float]
timestamp_buffer, # type: typing.List[int]
num_pairs_buffer, # type: typing.List[int]
):
# type: (...) -> None
session_ref_ctypes = _ctypedefs.nxSessionRef_t(session_ref)
timeout_ctypes = _ctypedefs.f64(timeout)
value_buffer_ctypes = (_ctypedefs.f64 * len(value_buffer))(*value_buffer) # type: ignore
size_of_value_buffer_ctypes = _ctypedefs.u32(len(value_buffer) * _ctypedefs.f64.BYTES)
timestamp_buffer_ctypes = (_ctypedefs.nxTimestamp_t * len(timestamp_buffer))(*timestamp_buffer) # type: ignore
size_of_timestamp_buffer_ctypes = _ctypedefs.u32(len(timestamp_buffer) * _ctypedefs.nxTimestamp_t.BYTES)
num_pairs_buffer_ctypes = (_ctypedefs.u32 * len(num_pairs_buffer))(*num_pairs_buffer) # type: ignore
size_of_num_pairs_buffer_ctypes = _ctypedefs.u32(len(num_pairs_buffer) * _ctypedefs.u32.BYTES)
result = _cfuncs.lib.nx_write_signal_xy(
session_ref_ctypes,
timeout_ctypes,
value_buffer_ctypes,
size_of_value_buffer_ctypes,
timestamp_buffer_ctypes,
size_of_timestamp_buffer_ctypes,
num_pairs_buffer_ctypes,
size_of_num_pairs_buffer_ctypes,
)
_errors.check_for_error(result.value)
def test_known_warning():
with pytest.warns(errors.XnetWarning) as record:
_errors.check_for_error(_enums.Warn.DATABASE_IMPORT.value)
assert len(record) == 1
assert record[0].message.warning_code == _enums.Warn.DATABASE_IMPORT.value
assert record[0].message.warning_type == _enums.Warn.DATABASE_IMPORT
assert record[0].message.args == ('Warning 1073098885 occurred.\n\n', )
def nxdb_get_dbc_attribute(
db_object_ref, # type: int
mode, # type: _enums.GetDbcAttributeMode
attribute_name, # type: typing.Text
attribute_text_size, # type: int
):
# type: (...) -> typing.Tuple[typing.Text, bool]
db_object_ref_ctypes = _ctypedefs.nxDatabaseRef_t(db_object_ref)
mode_ctypes = _ctypedefs.u32(mode.value)
attribute_name_ctypes = ctypes.create_string_buffer(
attribute_name.encode('ascii'))
attribute_text_size_ctypes = _ctypedefs.u32(attribute_text_size)
attribute_text_ctypes = ctypes.create_string_buffer(attribute_text_size)
is_default_ctypes = _ctypedefs.u32()
result = _cfuncs.lib.nxdb_get_dbc_attribute(
db_object_ref_ctypes,
mode_ctypes,
attribute_name_ctypes,
attribute_text_size_ctypes,
attribute_text_ctypes,
ctypes.pointer(is_default_ctypes),
)
_errors.check_for_error(result.value)
attribute_text = attribute_text_ctypes.value.decode("ascii")
is_default = bool(is_default_ctypes.value)
return attribute_text, is_default
def nxdb_get_database_list(
ip_address, # type: typing.Text
size_of_alias_buffer, # type: int
size_of_filepath_buffer, # type: int
):
# type: (...) -> typing.Tuple[typing.Text, typing.Text, int]
ip_address_ctypes = ctypes.create_string_buffer(ip_address.encode('ascii'))
size_of_alias_buffer_ctypes = _ctypedefs.u32(size_of_alias_buffer)
size_of_filepath_buffer_ctypes = _ctypedefs.u32(size_of_filepath_buffer)
alias_buffer_ctypes = ctypes.create_string_buffer(size_of_alias_buffer)
filepath_buffer_ctypes = ctypes.create_string_buffer(
size_of_filepath_buffer)
number_of_databases_ctypes = _ctypedefs.u32()
result = _cfuncs.lib.nxdb_get_database_list(
ip_address_ctypes,
size_of_alias_buffer_ctypes,
alias_buffer_ctypes,
size_of_filepath_buffer_ctypes,
filepath_buffer_ctypes,
number_of_databases_ctypes,
)
_errors.check_for_error(result.value)
alias_buffer = alias_buffer_ctypes.value.decode("ascii")
filepath_buffer = filepath_buffer_ctypes.value.decode("ascii")
return alias_buffer, filepath_buffer, number_of_databases_ctypes.value
def nx_system_close(
system_ref, # type: int
):
# type: (...) -> None
system_ref_ctypes = _ctypedefs.nxSessionRef_t(system_ref)
result = _cfuncs.lib.nx_system_close(system_ref_ctypes, )
_errors.check_for_error(result.value)
def nxdb_delete_object(
db_object_ref, # type: int
):
# type: (...) -> None
db_object_ref_ctypes = _ctypedefs.nxDatabaseRef_t(db_object_ref)
result = _cfuncs.lib.nxdb_delete_object(db_object_ref_ctypes, )
_errors.check_for_error(result.value)
def nx_convert_signals_to_frames_single_point(
session_ref, # type: int
value_buffer, # type: typing.List[float]
bytes_to_read, # type: int
):
# type: (...) -> typing.Tuple[bytes, int]
session_ref_ctypes = _ctypedefs.nxSessionRef_t(session_ref)
value_buffer_ctypes = (_ctypedefs.f64 * len(value_buffer))(
*value_buffer) # type: ignore
size_of_value_buffer_ctypes = _ctypedefs.u32(
len(value_buffer) * _ctypedefs.f64.BYTES)
buffer_ctypes = (_ctypedefs.byte * bytes_to_read)() # type: ignore
size_of_buffer_ctypes = _ctypedefs.u32(_ctypedefs.byte.BYTES *
bytes_to_read)
number_of_bytes_returned_ctypes = _ctypedefs.u32()
result = _cfuncs.lib.nx_convert_signals_to_frames_single_point(
session_ref_ctypes,
value_buffer_ctypes,
size_of_value_buffer_ctypes,
buffer_ctypes,
size_of_buffer_ctypes,
ctypes.pointer(number_of_bytes_returned_ctypes),
)
_errors.check_for_error(result.value)
return buffer_ctypes.raw, number_of_bytes_returned_ctypes.value
def iterate_frames(bytes):
"""Yields RawFrames from the bytes"""
base_pos = 0
next_pos = base_pos
while next_pos != len(bytes):
base_pos = next_pos
next_pos += nxFrameFixed_t.size
if len(bytes) < next_pos:
_errors.check_for_error(_cconsts.NX_ERR_INTERNAL_ERROR)
raw_base = bytes[base_pos:next_pos]
base_unit = nxFrameFixed_t.unpack(raw_base)
payload_length = _get_frame_payload_length(base_unit)
base_unit_length, payload_unit_length = _split_payload_length(payload_length)
payload_pos = next_pos
payload_pad_pos = payload_pos + payload_unit_length
next_pos += _calculate_payload_unit_size(payload_length)
base_unit_payload = base_unit[FRAME_PAYLOAD_INDEX:FRAME_PAYLOAD_INDEX + base_unit_length]
payload_unit = bytes[payload_pos:payload_pad_pos]
payload = b''.join(itertools.chain(base_unit_payload, (payload_unit, )))
yield types.RawFrame(
base_unit[FRAME_TIMESTAMP_INDEX],
base_unit[FRAME_IDENTIFIER_INDEX],
constants.FrameType(base_unit[FRAME_TYPE_INDEX]),
base_unit[FRAME_FLAG_INDEX],
base_unit[FRAME_INFO_INDEX],
payload)
def nx_convert_frames_to_signals_single_point(
session_ref, # type: int
frame_buffer, # type: bytes
num_signals, # type: int
):
# type: (...) -> typing.Tuple[typing.List[_ctypedefs.nxTimestamp_t], typing.List[_ctypedefs.f64]]
session_ref_ctypes = _ctypedefs.nxSessionRef_t(session_ref)
frame_buffer_ctypes = (_ctypedefs.byte * len(frame_buffer))(
*frame_buffer) # type: ignore
size_of_frame_buffer_ctypes = _ctypedefs.u32(
len(frame_buffer) * _ctypedefs.byte.BYTES)
value_buffer_ctypes = (_ctypedefs.f64 * num_signals)() # type: ignore
size_of_value_buffer_ctypes = _ctypedefs.u32(_ctypedefs.f64.BYTES *
num_signals)
timestamp_buffer_ctypes = (_ctypedefs.nxTimestamp_t *
num_signals)() # type: ignore
size_of_timestamp_buffer_ctypes = _ctypedefs.u32(
_ctypedefs.nxTimestamp_t.BYTES * num_signals)
result = _cfuncs.lib.nx_convert_frames_to_signals_single_point(
session_ref_ctypes,
frame_buffer_ctypes,
size_of_frame_buffer_ctypes,
value_buffer_ctypes,
size_of_value_buffer_ctypes,
timestamp_buffer_ctypes,
size_of_timestamp_buffer_ctypes,
)
_errors.check_for_error(result.value)
return timestamp_buffer_ctypes, value_buffer_ctypes
def nx_create_session(
database_name, # type: typing.Text
cluster_name, # type: typing.Text
list, # type: typing.Text
interface, # type: typing.Text
mode, # type: _enums.CreateSessionMode
):
# type: (...) -> int
database_name_ctypes = ctypes.create_string_buffer(
database_name.encode('ascii'))
cluster_name_ctypes = ctypes.create_string_buffer(
cluster_name.encode('ascii'))
list_ctypes = ctypes.create_string_buffer(list.encode('ascii'))
interface_ctypes = ctypes.create_string_buffer(interface.encode('ascii'))
mode_ctypes = _ctypedefs.u32(mode.value)
session_ref_ctypes = _ctypedefs.nxSessionRef_t()
result = _cfuncs.lib.nx_create_session(
database_name_ctypes,
cluster_name_ctypes,
list_ctypes,
interface_ctypes,
mode_ctypes,
ctypes.pointer(session_ref_ctypes),
)
_errors.check_for_error(result.value)
return session_ref_ctypes.value
def nx_write_signal_xy(
session_ref,
timeout,
value_buffer,
timestamp_buffer,
num_pairs_buffer,
):
session_ref_ctypes = _ctypedefs.nxSessionRef_t(session_ref)
timeout_ctypes = _ctypedefs.f64(timeout)
value_buffer_ctypes = (_ctypedefs.f64 * len(value_buffer))(*value_buffer)
size_of_value_buffer_ctypes = _ctypedefs.u32(
len(value_buffer) * _ctypedefs.f64.BYTES)
timestamp_buffer_ctypes = (_ctypedefs.nxTimestamp_t *
len(timestamp_buffer))(*timestamp_buffer)
size_of_timestamp_buffer_ctypes = _ctypedefs.u32(
len(timestamp_buffer) * _ctypedefs.nxTimestamp_t.BYTES)
num_pairs_buffer_ctypes = (_ctypedefs.u32 *
len(num_pairs_buffer))(*num_pairs_buffer)
size_of_num_pairs_buffer_ctypes = _ctypedefs.u32(
len(num_pairs_buffer) * _ctypedefs.u32.BYTES)
result = _cfuncs.lib.nx_write_signal_xy(
session_ref_ctypes,
timeout_ctypes,
value_buffer_ctypes,
size_of_value_buffer_ctypes,
timestamp_buffer_ctypes,
size_of_timestamp_buffer_ctypes,
num_pairs_buffer_ctypes,
size_of_num_pairs_buffer_ctypes,
)
_errors.check_for_error(result.value)
def nx_write_frame(session_ref, buffer, timeout):
session_ref_ctypes = _ctypedefs.nxSessionRef_t(session_ref)
buffer_ctypes = (_ctypedefs.char * len(buffer))(*buffer)
size_of_buffer_ctypes = _ctypedefs.u32(_ctypedefs.char.BYTES * len(buffer))
timeout_ctypes = _ctypedefs.f64(timeout)
result = _cfuncs.lib.nx_write_frame(session_ref_ctypes, buffer_ctypes,
size_of_buffer_ctypes, timeout_ctypes)
_errors.check_for_error(result.value)
def nx_system_open(
):
# type: (...) -> int
system_ref_ctypes = _ctypedefs.nxSessionRef_t()
result = _cfuncs.lib.nx_system_open(
ctypes.pointer(system_ref_ctypes),
)
_errors.check_for_error(result.value)
return system_ref_ctypes.value
def set_session_u32(ref, prop_id, value):
ref_ctypes = _ctypedefs.nxSessionRef_t(ref)
prop_id_ctypes = _ctypedefs.u32(prop_id)
prop_size_ctypes = _ctypedefs.u32(_ctypedefs.u32.BYTES)
value_ctypes = _ctypedefs.u32(value)
value_ctypes_ptr = ctypes.pointer(value_ctypes)
result = _cfuncs.lib.nx_set_property(ref_ctypes, prop_id_ctypes,
prop_size_ctypes, value_ctypes_ptr)
_errors.check_for_error(result.value)
def set_database_ref(ref, prop_id, value):
ref_ctypes = _ctypedefs.nxDatabaseRef_t(ref)
prop_id_ctypes = _ctypedefs.u32(prop_id)
prop_size_ctypes = _ctypedefs.u32(_ctypedefs.nxDatabase_t.BYTES)
value_ctypes = _ctypedefs.nxDatabaseRef_t(value)
value_ctypes_ptr = ctypes.pointer(value_ctypes)
result = _cfuncs.lib.nxdb_set_property(ref_ctypes, prop_id_ctypes,
prop_size_ctypes, value_ctypes_ptr)
_errors.check_for_error(result.value)
def test_driver_call():
with pytest.raises(errors.XnetError) as excinfo:
_errors.check_for_error(_enums.Err.SELF_TEST_ERROR1.value)
assert excinfo.value.error_code == _enums.Err.SELF_TEST_ERROR1.value
assert excinfo.value.error_type == _enums.Err.SELF_TEST_ERROR1
assert excinfo.value.args == (
'NI-XNET: (Hex 0xBFF63002) Board self test failed(code 2). '
'Solution: try reinstalling the driver or switching the slot(s) of the board(s). '
'If the error persists,contact National Instruments.', )
def nxdb_open_database(database_name, ):
database_name_ctypes = _ctypedefs.char_p(database_name.encode('ascii'))
database_ref_ctypes = _ctypedefs.nxDatabaseRef_t()
result = _cfuncs.lib.nxdb_open_database(
database_name_ctypes,
ctypes.pointer(database_ref_ctypes),
)
_errors.check_for_error(result.value)
return database_ref_ctypes.value
def get_database_f64(ref, prop_id):
ref_ctypes = _ctypedefs.nxDatabaseRef_t(ref)
prop_id_ctypes = _ctypedefs.u32(prop_id)
prop_size_ctypes = _ctypedefs.u32(_ctypedefs.f64.BYTES)
value_ctypes = _ctypedefs.f64()
value_ctypes_ptr = ctypes.pointer(value_ctypes)
result = _cfuncs.lib.nxdb_get_property(ref_ctypes, prop_id_ctypes,
prop_size_ctypes, value_ctypes_ptr)
_errors.check_for_error(result.value)
return value_ctypes.value
def set_database_f64(ref, prop_id, value):
# type: (int, int, float) -> None
ref_ctypes = _ctypedefs.nxDatabaseRef_t(ref)
prop_id_ctypes = _ctypedefs.u32(prop_id)
prop_size_ctypes = _ctypedefs.u32(_ctypedefs.f64.BYTES)
value_ctypes = _ctypedefs.f64(value)
value_ctypes_ptr = ctypes.pointer(value_ctypes)
result = _cfuncs.lib.nxdb_set_property(ref_ctypes, prop_id_ctypes,
prop_size_ctypes, value_ctypes_ptr)
_errors.check_for_error(result.value)
def nxdb_undeploy(
ip_address,
database_alias,
):
ip_address_ctypes = _ctypedefs.char_p(ip_address.encode('ascii'))
database_alias_ctypes = _ctypedefs.char_p(database_alias.encode('ascii'))
result = _cfuncs.lib.nxdb_undeploy(
ip_address_ctypes,
database_alias_ctypes,
)
_errors.check_for_error(result.value)
def nxdb_save_database(
database_ref,
db_filepath,
):
database_ref_ctypes = _ctypedefs.nxDatabaseRef_t(database_ref)
db_filepath_ctypes = _ctypedefs.char_p(db_filepath.encode('ascii'))
result = _cfuncs.lib.nxdb_save_database(
database_ref_ctypes,
db_filepath_ctypes,
)
_errors.check_for_error(result.value)
def nxdb_close_database(
database_ref,
close_all_refs,
):
database_ref_ctypes = _ctypedefs.nxDatabaseRef_t(database_ref)
close_all_refs_ctypes = _ctypedefs.bool32(close_all_refs)
result = _cfuncs.lib.nxdb_close_database(
database_ref_ctypes,
close_all_refs_ctypes,
)
_errors.check_for_error(result.value)
def nx_stop(
session_ref,
scope,
):
session_ref_ctypes = _ctypedefs.nxSessionRef_t(session_ref)
scope_ctypes = _ctypedefs.u32(scope.value)
result = _cfuncs.lib.nx_stop(
session_ref_ctypes,
scope_ctypes,
)
_errors.check_for_error(result.value)
def nx_blink(
interface_ref,
modifier,
):
interface_ref_ctypes = _ctypedefs.nxSessionRef_t(interface_ref)
modifier_ctypes = _ctypedefs.u32(modifier.value)
result = _cfuncs.lib.nx_blink(
interface_ref_ctypes,
modifier_ctypes,
)
_errors.check_for_error(result.value)
def set_session_u32_array(ref, prop_id, value):
value_size = len(value) * _ctypedefs.u32.BYTES
ref_ctypes = _ctypedefs.nxSessionRef_t(ref)
prop_id_ctypes = _ctypedefs.u32(prop_id)
prop_size_ctypes = _ctypedefs.u32(value_size)
value_ctypes = (_ctypedefs.u32 *
(value_size // _ctypedefs.u32.BYTES))(*value)
result = _cfuncs.lib.nx_set_property(ref_ctypes, prop_id_ctypes,
prop_size_ctypes, value_ctypes)
_errors.check_for_error(result.value)
def get_session_u32(ref, prop_id):
# type: (int, int) -> int
ref_ctypes = _ctypedefs.nxSessionRef_t(ref)
prop_id_ctypes = _ctypedefs.u32(prop_id)
prop_size_ctypes = _ctypedefs.u32(_ctypedefs.u32.BYTES)
value_ctypes = _ctypedefs.u32()
value_ctypes_ptr = ctypes.pointer(value_ctypes)
result = _cfuncs.lib.nx_get_property(ref_ctypes, prop_id_ctypes,
prop_size_ctypes, value_ctypes_ptr)
_errors.check_for_error(result.value)
return value_ctypes.value
