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