HART — The HART Testing Framework¶
The HART Testing Framework allows users to
- write automatable tests for HART slaves
- simulate HART devices and HART masters
- add device specific commands
- develop and debug a HART device interactively using the HART-Shell
- monitor HART messages using the HART-Monitor
- send corrupted frames and
- run HART Fuzzing tests
It is based on version 7.6 of the HART specification and implements all universal and common practice commands (0..533). Extended commands up to 16-bit are supported.
You need the hart
feature in your license to unlock the HART Testing Framework.
HART Interface¶
The HartInterface
implements the data link layer and physical layer.
It enables you to write binary data that is sent to the connected
HART devices and reads HART frames.
The used serial port must support the RS485 mode
that sets RTS
high
while sending. Many USB-Uarts do not support this feature and thus
cannot be used.
It is recommended to use USB-HART-Modems such as the MACTek Viator. The do support this feature and are known to work.
Real COM port are very sparse nowadays.
-
class
htf.communication.hart.
HartInterface
(comport, timeout=0.3)¶ Data-Link-Layer and Physical-Layer for HART.
Parameters: -
close
()¶ Close the HART interface. Is called in __del__, too.
-
get_last_preamble_count
()¶ Gets the count of preambles that was most recently received. This does NOT require a full HART frame to be read, but does require the preambles to be followed by a valid delimiter.
Returns: the most recently received number of consecutive preambles Return type: int
-
query
(data, number_of_preambles=5, preamble=b'\xff', timeout=1.0)¶ Query a HART command.
Parameters: Returns: - if no frame was recieved
None
is returned else a HART frame is returned.
Return type: - if no frame was recieved
-
Example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartInterface
>>>
>>> hi = HartInterface(comport="/dev/ttyUSB1")
>>> cmd0_request = b"\x02\x80\x00\x00\x82"
>>> response = hi.query(cmd0_request)
>>> print(oser.to_hex(response))
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x06\x80\x00\x0e\x00\x00\x00\x13\x37\x00\x00\x00\x00\x00\x00\x00\x00\x23\x8f
>>> hi.close()
HART Frame¶
The HartFrame
abstracts the HART-PDU that is
used for HART communication.
It is based on OSER and lets the user specify device specific commands.
The check byte is generated automatically when
encode()
is called.
-
class
htf.communication.hart.
HartFrame
(command=None, auto_length=True, auto_checkbyte=True)¶ A HART frame abstraction.
Parameters: - command=None (int or None) – the HART command number.
- auto_length=True (bool) – if set to
True
the byte count of the HART frame is calculated automatically when callingencode
. - auto_checkbyte=True (bool) – if set to
True
the checkbyte of the HART frame is calculated automatically when callingencode
.
-
byte_size
()¶ Return the size in bytes.
Returns: the length of the byte type in bytes. Return type: int
-
decode
(data, full_data=b'', context_data=b'')¶ Decode a binary string and return the number of bytes that were decoded.
Parameters: Returns: the number of bytes that were decoded.
Return type:
-
encode
(full_data=b'', context_data=b'')¶ Return the encoded binary string.
byte_count
is set automatically ifauto_length
is supplied.Parameters:
-
fuzzing_iterator
(copy=False)¶ The fuzzing iterator iterates over all combinations of set fuzzing values (
oser.ByteType.set_fuzzing_values()
). If no fuzzing values are set the current struct is yielded.Parameters: copy=False (bool) – if set to True
the generated fuzzing values are deep copies of the original. Creating these deep copies is slow. If set toFalse
the original struct is retruned and the generated value must be used immediately since the next generated overwrites the values on the same value.Yields: the fuzzing combinations.
-
get_command_request_parser
(command)¶ Get a command request parser.
Parameters: command (int) – the command number to be returned. Returns: the command parser. Return type: ByteStruct Raises: KeyError
– Raises aKeyError
if the command if the command is not set.
-
get_command_response_parser
(command)¶ Get a command response parser.
Parameters: command (int) – the command number to be returned. Returns: the command parser. Return type: ByteStruct Raises: KeyError
– Raises aKeyError
if the command if the command is not set.
-
introspect
(stop_at=None)¶ Return the introspection representation of the object as a string.
Parameters: stop_at=None (object) – stop introspection at stop_at
.
-
requests_generator
()¶ A generator that yields command, parser tuples for requests.
This method shall be overwritten to realize device specific commands.
Yields: tuples of command and parser
-
responses_generator
()¶ A generator that yields command, parser tuples for responses.
This method shall be overwritten to realize device specific commands.
Yields: tuples of command and parser
-
root
()¶ return root element
-
set_auto_check_byte_enable
(enable_auto_check_byte=True)¶ Enable or disable the automatic checkbyte calculation on
encode
.Parameters: enable_auto_check_byte=True (bool) – the new enable state.
-
set_auto_length_enable
(enable_auto_length=True)¶ Enable or disable the auto length feature.
Parameters: enable_auto_length=True (bool) – the new enable state.
-
set_command_request_parser
(command, parser)¶ Set a command request parser. This overwrites exising command parsers.
Parameters: - command (int) – the command number to be set.
- parser (ByteStruct) – the parser for the command.
-
set_command_response_parser
(command, parser)¶ Set a command response parser. This overwrites exising command parsers.
Parameters: - command (int) – the command number to be set.
- parser (ByteStruct) – the parser for the command.
-
up
()¶ return parent element
Example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>>
>>> hf = HartFrame(1)
>>> hf.address.address.set(0x13370023)
>>> encoded = hf.encode()
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 322371619 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command1_ReadPrimaryVariableRequest():
check_byte: 4 (CheckByte)
>>> print(oser.to_hex(encoded))
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x13\x37\x00\x23\x01\x00\x04
HART Application Layer¶
The HART Application Layer interfaces
the HartInterface
and
the abstracted protocol with HartFrame
.
It lets the user communicate with a single HART device easily.
Additionally you can search for HART devices, set the master address and the device address.
-
class
htf.communication.hart.
HartApplicationLayer
(interface, decoder_generator=None)¶ HART Application-Layer.
Parameters: - interface (HartInterface or compatible) – the HART interface to be used.
- decoder_generator=None (callable or None) – a callable that returns a HartFrame instance with or without device specific commands.
-
close
()¶ Close the HART application layer and close the HART interface supplied. Is called in __del__, too.
-
find_device
(polling_addresses=None)¶ Find the first HART device by polling all addresses stated in
polling_addresses
and use the first device found.If no device is found an
AssertionError
is raised.Parameters: polling_addresses=[0] (list of int or int) – the polling addresses used to find a HART device. Returns: Unique HART address of the first device found in polling. Return type: int
-
poll_devices
(polling_addresses=None)¶ Poll
polling_addresses
to find HART devices.Parameters: polling_addresses=[0] (list of int) – list of HART polling addresses Yields: int – HART device addresses
-
query
(request, number_of_preambles=5, preamble=b'\xff', timeout=1.0)¶ Query a HART command. The HART frame is encoded automatically.
Parameters: Returns: if no frame was recieved
None
is returned.Return type:
-
read
(timeout=1.0)¶ Read a message using the interface and decode it using the decoder.
Parameters: timeout=1.0 (float or int) – the timeout in seconds. Returns: if no frame was recieved None
is returned.Return type: HartFrame or None
-
set_decoder_generator
(decoder_generator=None)¶ Set the frame generator.
Parameters: decoder_generator=HartFrame (callable) – when called returns
-
set_device_address
(device_address)¶ Set the current HART device address.
Parameters: device_address (int) – the HART device address to be used (<= 38 bits)
-
set_master_address
(master_address)¶ Set the current simulated master address.
Parameters: master_address (str) – “primary_master” or “secondary_master”
-
write
(frame, number_of_preambles=5, preamble=b'\xff')¶ Write a HART frame. The HART frame is encoded automatically.
Except for command 0 the HART device address is set automatically before sending the frame content.
Parameters:
Find device at polling address 0 manually:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import \
... HartInterface, HartApplicationLayer, HartFrame
>>>
>>> hi = HartInterface(comport="/dev/ttyUSB1")
>>> hal = HartApplicationLayer(hi)
>>>
>>> # search for HART device at polling address 0 manually
... cmd0_request = HartFrame(0)
>>> cmd0_request.delimiter.frame_type.set("stx")
>>> cmd0_request.delimiter.address_type.set("polling")
>>> cmd0_request.address.address.set(0)
>>> print(cmd0_request)
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command0_ReadUniqueIdentifierRequest():
check_byte: 0 (CheckByte)
>>> response = hal.query(cmd0_request)
>>> print(response)
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command0_ReadUniqueIdentifierResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
data_object_id: 0 (UBInt8)
device_type: 4919 (UBInt16)
minimum_preambles_request: 0 (UBInt8)
protocol_revision: 0 (UBInt8)
device_revision_level: 0 (UBInt8)
software_revision_level: 0 (UBInt8)
hardware_revision_level_and_physical_signaling_code: 0 (UBInt8)
flags: 0 (UBInt8)
device_id: BitStruct():
value: 35 (BitField(24))
check_byte: 143 (CheckByte)
>>> device_address = (response.payload.device_type.get() << 24) +\
... response.payload.device_id.value.get()
>>> print("0x%x" % device_address)
0x1337000023
>>> hal.close()
Find device at polling address 0:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import \
... HartInterface, HartApplicationLayer
>>>
>>> hi = HartInterface(comport="/dev/ttyUSB1")
>>> hal = HartApplicationLayer(hi)
>>>
>>> # search for HART device at polling address 0
... device_address = hal.find_device()
>>> print("0x%x" % device_address)
0x1337000023
>>> hal.close()
Poll addresses 0 .. 9:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import \
... HartInterface, HartApplicationLayer
>>>
>>> hi = HartInterface(comport="/dev/ttyUSB1")
>>> hal = HartApplicationLayer(hi)
>>>
>>> # poll address 0 .. 9
... device_addresses = hal.poll_devices(range(10))
>>> for device_address in device_addresses:
... print("0x%x" % device_address)
...
0x1337000023
>>> hal.close()
Query Command 1 from first found HART device and print primary variable:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import \
... HartInterface, HartApplicationLayer, HartFrame
>>>
>>> hi = HartInterface(comport="/dev/ttyUSB1")
>>> hal = HartApplicationLayer(hi)
>>>
>>> # search for HART device at polling address 0
... hal.find_device()
82527125539
>>>
>>> # query command 1
... cmd1_request = HartFrame(1)
>>> response = hal.query(cmd1_request)
>>> print(response)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 82527125539 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'buffer_overflow' (UBInt8)
field_device_status: non-primary_variable_out_of_limits (FieldDeviceStatus)
units: 123 (UBInt8)
primary_variable: 456.78900146484375 (BFloat)
check_byte: 193 (CheckByte)
>>> primary_variable = response.payload.primary_variable.get()
>>> print("PV:", primary_variable)
PV: 456.78900146484375
>>> hal.close()
Data Types¶
The data types implement the needed components to build HART frames.
Packed ASCII¶
PackedASCII
implements the
Packed ASCII
data type for the HART protocol.
-
class
htf.communication.hart.data_types.
PackedASCII
(length=None, value=b'', padding=b'x00')¶ The HART Packed ASCII data type
-
byte_size
()¶ Return the size in bytes.
-
decode
(data, full_data=b'', context_data=b'')¶ Decode a binary string and return the number of bytes that were decoded.
Parameters: Returns: the number of bytes that were decoded.
Return type:
-
encode
(full_data=b'', context_data=b'')¶ Return the encoded binary string.
Parameters: Returns: the encoded binary string.
Return type:
-
get
()¶ Return the value.
-
introspect
(stop_at=None)¶ Return the introspection representation of the object as a string.
-
root
()¶ return root element
-
set
(value)¶ Set the value.
Parameters: value – the new value
-
set_fuzzing_values
(values)¶ Set fuzzing values.
Parameters: values (iterable) – the values used for fuzzing.
-
set_length
(length)¶ Set the length.
Parameters: length=None – states the string length. Can be a callable (e.g. lambda) or a scalar. If set to None
the result is a null-terminated string. If set to an Integer the result is a fixed length string padded withpadding
. If set to acallable
(lambda or function) the result is a fixed or variable length string padded withpadding
.
-
size
()¶ Return the size in bytes.
-
up
()¶ Return the parent element.
-
Example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import PackedASCII
>>>
>>> pa = PackedASCII(length=6, value=b"ABCDEFGH")
>>> encoded = pa.encode()
>>> print(oser.to_hex(encoded))
0| 1| 2| 3| 4| 5
\x04\x20\xc4\x14\x61\xc8
>>> pa2 = PackedASCII(length=3, value=b"ABC")
>>> pa2.decode(encoded)
3
>>> print(pa2)
b'ABCD'
Date¶
Date
implements the
Date
data type for the HART protocol.
-
class
htf.communication.hart.data_types.
Date
(date)¶ The HART Date data type
Parameters: date (datetime.date) – an instance of datetime.date()
ordatetime.datetime()
between1900-01-01
and2155-12-31
.-
byte_size
()¶ Return the size in bytes.
-
decode
(data, full_data=b'', context_data=b'')¶ Decode a binary string and return the number of bytes that were decoded.
Parameters: Returns: the number of bytes that were decoded.
Return type:
-
encode
(full_data=b'', context_data=b'')¶ Return the encoded binary string.
Parameters: Returns: the encoded binary string.
Return type:
-
get
()¶ Return the value.
-
introspect
(stop_at=None)¶ Return the introspection representation of the object as a string.
-
root
()¶ return root element
-
set
(value)¶ Set the value.
Parameters: value – the new value
-
set_fuzzing_values
(values)¶ Set fuzzing values.
Parameters: values (iterable) – the values used for fuzzing.
-
set_length
(length)¶ Set the length.
Parameters: length=None – states the string length. Can be a callable (e.g. lambda) or a scalar. If set to None
the result is a null-terminated string. If set to an Integer the result is a fixed length string padded withpadding
. If set to acallable
(lambda or function) the result is a fixed or variable length string padded withpadding
.
-
size
()¶ Return the size in bytes.
-
up
()¶ Return the parent element.
-
Example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import Date
>>> import datetime
>>>
>>> date = Date(datetime.date(2017, 1, 11))
>>> encoded = date.encode()
>>> print(oser.to_hex(encoded))
0| 1| 2
\x75\x01\x0b
>>> date2 = Date(None)
>>> date2.decode(encoded)
3
>>> print(date2)
datetime.date(2017, 1, 11)
Time¶
Time
implements the
Time
data type for the HART protocol.
-
class
htf.communication.hart.data_types.
Time
(time)¶ The HART Time data type.
Parameters: time (datetime.time) – an instance of datetime.time()
ordatetime.datetime()
between00:00:00
and23:59:59
.-
byte_size
()¶ Return the length of the byte type in bytes.
Returns: the length of the byte type in bytes. Return type: int
-
decode
(data, full_data=b'', context_data=b'')¶ Decode a binary string and return the number of bytes that were decoded.
Parameters: Returns: the number of bytes that were decoded.
Return type:
-
encode
(full_data=b'', context_data=b'')¶ Return the encoded binary string.
Parameters:
-
get
()¶ Return the value.
Returns: the value.
-
introspect
(stop_at=None)¶ Return the introspection representation of the object as a string.
-
root
()¶ return root element
-
set
(value)¶ Set the value.
Parameters: value – the new value
-
set_fuzzing_values
(values)¶ Set fuzzing values.
Parameters: values (iterable) – the values used for fuzzing.
-
size
()¶ Return the length of the byte type in bytes.
Returns: the length of the byte type in bytes. Return type: int
-
up
()¶ Return the parent element.
-
Example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import Time
>>> import datetime
>>>
>>> time = Time(datetime.time(23, 24, 7, 1000))
>>> encoded = time.encode()
>>> print(oser.to_hex(encoded))
0| 1| 2| 3
\xa0\xb0\x3b\x20
>>> time2 = Time(None)
>>> time2.decode(encoded)
4
>>> print(time2)
23:24:07.001000 (Time)
Response Code¶
ResponseCode
implements the
Response Code
data type for the HART protocol.
When printed the states are concatenated with ;
.
-
class
htf.communication.hart.data_types.
ResponseCode
(**kwargs)¶ HART device specific response code generator.
0: "success"
is added automatically.-
byte_size
()¶ Return the size in bytes.
-
decode
(data, full_data=b'', context_data=b'')¶ Decode a binary string and return the number of bytes that were decoded.
Parameters: Returns: the number of bytes that were decoded.
Return type:
-
encode
(full_data=b'', context_data=b'')¶ Return the encoded binary string.
Parameters: Returns: the encoded binary string.
Return type:
-
get
()¶ Return the value.
Returns: the value
-
introspect
(stop_at=None)¶ Return the introspection representation of the object as a string.
-
is_error
()¶ Checks if the response code is of class ‘error’ or not. Warning response codes must have the ‘warning_’-prefix. If there is no prefix the response is considered to be an error.
-
root
()¶ return root element
-
set
(value)¶ Set the value.
Parameters: value – the new value
-
set_fuzzing_values
(values)¶ Set fuzzing values.
Parameters: values (iterable) – the values used for fuzzing.
-
size
()¶ Return the size in bytes.
-
up
()¶ Return the parent element.
-
If the MSB of the response code’s value is set a communication error is represented:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import ResponseCode
>>>
>>> response_code = ResponseCode()
>>> response_code.set(0x82)
>>> encoded = response_code.encode()
>>> print(oser.to_hex(encoded))
0
\x82
>>> print(response_code)
'buffer_overflow' (UBInt8)
>>>
>>> response_code2 = ResponseCode()
>>> response_code2.decode(b"\xff")
1
>>> print(response_code2)
'vertical_perity_error; overrun_error; framing_error; longitudinal_error; buffer_overflow' (UBInt8)
If the MSB is not set a command specific response code can be represented.
Command specific response codes are passed to
ResponseCode
as named parameters.
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import ResponseCode
>>>
>>>
>>> class Command48_ReadAdditionalDeviceStatusResponse(oser.ByteStruct):
... """
... HART command 48 response abstraction.
... """
... def __init__(self):
... super(Command48_ReadAdditionalDeviceStatusResponse, self).__init__()
...
... self.response_code = ResponseCode(
... error_device_specific_command_error=6,
... warning_update_in_progress=8,
... error_access_restricted=16,
... error_busy=32)
... self.data = oser.String(length=3)
... # ...
...
>>> c48 = Command48_ReadAdditionalDeviceStatusResponse()
>>> c48.response_code.set(32)
>>> print(c48)
Command48_ReadAdditionalDeviceStatusResponse():
response_code: 'error_busy' (UBInt8)
data: b''
>>>
>>> encoded = c48.encode()
>>> print(oser.to_hex(encoded))
0| 1| 2| 3
\x20\x00\x00\x00
>>>
>>> c48_2 = Command48_ReadAdditionalDeviceStatusResponse()
>>> c48_2.decode(b"\x08\x00\x00\x00")
4
>>> print(c48_2)
Command48_ReadAdditionalDeviceStatusResponse():
response_code: 'warning_update_in_progress' (UBInt8)
data: b'\x00\x00\x00'
Field Device Status¶
FieldDeviceStatus
implements the
Field Device Status
data type for the HART protocol.
When printed the states are concatenated with ;
.
-
class
htf.communication.hart.data_types.
FieldDeviceStatus
(value=0)¶ HART Field Device Status data type.
Parameters: value – the initial value. -
byte_size
()¶ Return the length of the byte type in bytes.
Returns: the length of the byte type in bytes. Return type: int
-
decode
(data, full_data=b'', context_data=b'')¶ Decode a binary string and return the number of bytes that were decoded.
Parameters: Returns: the number of bytes that were decoded.
Return type:
-
encode
(full_data=b'', context_data=b'')¶ Return the encoded binary string.
Parameters:
-
get
()¶ Return the value.
Returns: the value.
-
introspect
(stop_at=None)¶ Return the introspection representation of the object as a string.
-
root
()¶ return root element
-
set
(value)¶ Set the value.
Parameters: value – the new value
-
set_fuzzing_values
(values)¶ Set fuzzing values.
Parameters: values (iterable) – the values used for fuzzing.
-
size
()¶ Return the length of the byte type in bytes.
Returns: the length of the byte type in bytes. Return type: int
-
up
()¶ Return the parent element.
-
The FieldDeviceStatus
is a bit field for predefined values:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import FieldDeviceStatus
>>>
>>> fds = FieldDeviceStatus(0x42)
>>> print(fds)
configuration_changed; non-primary_variable_out_of_limits (FieldDeviceStatus)
>>>
>>> fds2 = FieldDeviceStatus(0x02)
>>> print(fds2)
non-primary_variable_out_of_limits (FieldDeviceStatus)
>>>
>>> encoded = fds2.encode()
>>> print(oser.to_hex(encoded))
0
\x02
>>>
>>> fds3 = FieldDeviceStatus(0x00)
>>> fds3.decode(encoded)
1
>>> print(fds3)
non-primary_variable_out_of_limits (FieldDeviceStatus)
HART Responses¶
HartResponse
implements a
HART response
data type to automatically handle error responses.
All HART responses should be derived from this class.
-
class
htf.communication.hart.data_types.
HartResponse
(*args, **kwargs)¶ A ByteStruct for HART responses which checks for error response codes in _items() and stops iteration after field_device_status. All HART responses should be derived from this class.
-
byte_size
()¶ Return the size in bytes.
Returns: the length of the byte type in bytes. Return type: int
-
decode
(data, full_data=b'', context_data=b'')¶ Decode a binary string and return the number of bytes that were decoded.
Parameters: Returns: the number of bytes that were decoded.
Return type:
-
encode
(full_data=b'', context_data=b'')¶ Return the encoded binary string.
Parameters:
-
fuzzing_iterator
(copy=False)¶ The fuzzing iterator iterates over all combinations of set fuzzing values (
oser.ByteType.set_fuzzing_values()
). If no fuzzing values are set the current struct is yielded.Parameters: copy=False (bool) – if set to True
the generated fuzzing values are deep copies of the original. Creating these deep copies is slow. If set toFalse
the original struct is retruned and the generated value must be used immediately since the next generated overwrites the values on the same value.Yields: the fuzzing combinations.
-
introspect
(stop_at=None)¶ Return the introspection representation of the object as a string.
Parameters: stop_at=None (object) – stop introspection at stop_at
.
-
root
()¶ return root element
-
up
()¶ return parent element
-
Universal Commands¶
Command 0¶
Command 0 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(0)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command0_ReadUniqueIdentifierRequest():
check_byte: 130 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4
\x02\x80\x00\x00\x82
>>> # response
>>> hf = HartFrame(0)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command0_ReadUniqueIdentifierResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
data_object_id: 0 (UBInt8)
device_type: 0 (UBInt16)
minimum_preambles_request: 0 (UBInt8)
protocol_revision: 0 (UBInt8)
device_revision_level: 0 (UBInt8)
software_revision_level: 0 (UBInt8)
hardware_revision_level_and_physical_signaling_code: 0 (UBInt8)
flags: 0 (UBInt8)
device_id: BitStruct():
value: 0 (BitField(24))
check_byte: 136 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x06\x80\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88
Command 1¶
Command 1 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(1)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command1_ReadPrimaryVariableRequest():
check_byte: 3 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x01\x00\x03
>>> # response
>>> hf = HartFrame(1)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
units: 0 (UBInt8)
primary_variable: 0 (BFloat)
check_byte: 0 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x86\x80\x00\x00\x00\x00\x01\x07\x00\x00\x00\x00\x00\x00\x00\x00
Command 2¶
Command 2 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(2)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 2 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command2_ReadLoopCurrentAndPercentageOfRangeRequest():
check_byte: 0 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x02\x00\x00
>>> # response
>>> hf = HartFrame(2)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 2 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command2_ReadLoopCurrentAndPercentageOfRangeResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_loop_current: 0 (BFloat)
primary_variable_percentage_of_range: 0 (BFloat)
check_byte: 14 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x02\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e
Command 3¶
Command 3 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(3)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 3 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command3_ReadDynamicVariablesAndLoopCurrentRequest():
check_byte: 1 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x03\x00\x01
>>> # response
>>> hf = HartFrame(3)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 3 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command3_ReadDynamicVariablesAndLoopCurrentResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_loop_current: 0 (BFloat)
units_and_variables: Array():
[
]
check_byte: 3 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x03\x06\x00\x00\x00\x00\x00\x00\x03
Command 6¶
Command 6 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(6)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 6 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command6_WritePollingAddressRequest():
polling_address: 0 (UBInt8)
loop_current_mode: 0 (UBInt8)
check_byte: 6 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x06\x02\x00\x00\x06
>>> # response
>>> hf = HartFrame(6)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 6 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command6_WritePollingAddressResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
polling_address: 0 (UBInt8)
loop_current_mode: 0 (UBInt8)
check_byte: 4 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x06\x04\x00\x00\x00\x00\x04
Command 7¶
Command 7 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(7)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 7 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command7_ReadLoopConfigurationRequest():
check_byte: 5 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x07\x00\x05
>>> # response
>>> hf = HartFrame(7)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 7 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command7_ReadLoopConfigurationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
polling_address: 0 (UBInt8)
loop_current_mode: 0 (UBInt8)
check_byte: 5 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x07\x04\x00\x00\x00\x00\x05
Command 8¶
Command 8 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(8)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 8 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command8_ReadDynamicVariableClassificationsRequest():
check_byte: 10 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x08\x00\x0a
>>> # response
>>> hf = HartFrame(8)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 8 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command8_ReadDynamicVariableClassificationsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_classification: 0 (UBInt8)
secondary_variable_classification: 0 (UBInt8)
tertiary_variable_classification: 0 (UBInt8)
quaternary_variable_classification: 0 (UBInt8)
check_byte: 8 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x08\x06\x00\x00\x00\x00\x00\x00\x08
Command 9¶
Command 9 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(9)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 9 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command9_ReadDeviceVariablesWithStatusRequest():
device_variable_codes: Array():
[
]
check_byte: 11 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x09\x00\x0b
>>> # response
>>> hf = HartFrame(9)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 9 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command9_ReadDeviceVariablesWithStatusResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
extended_field_device_status: 0 (UBInt8)
variables_and_statuses: Array():
[
]
slot0_data_time_stamp: 0 (UBInt32)
check_byte: 8 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x86\x80\x00\x00\x00\x00\x09\x07\x00\x00\x00\x00\x00\x00\x00\x08
Command 11¶
Command 11 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(11)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 11 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command11_ReadUniqueIdentifierAssociatedWithTagRequest():
tag: b'????????'
check_byte: 15 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x82\x80\x00\x00\x00\x00\x0b\x06\xff\xff\xff\xff\xff\xff\x0f
>>> # response
>>> hf = HartFrame(11)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 11 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command11_ReadUniqueIdentifierAssociatedWithTagResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
data_object_id: 0 (UBInt8)
device_type: 0 (UBInt16)
minimum_preambles_request: 0 (UBInt8)
protocol_revision: 0 (UBInt8)
device_revision_level: 0 (UBInt8)
software_revision_level: 0 (UBInt8)
hardware_revision_level_and_physical_signaling_code: 0 (UBInt8)
flags: 0 (UBInt8)
device_id: BitStruct():
value: 0 (BitField(24))
check_byte: 3 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22
\x86\x80\x00\x00\x00\x00\x0b\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03
Command 12¶
Command 12 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(12)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 12 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command12_ReadMessageRequest():
check_byte: 14 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x0c\x00\x0e
>>> # response
>>> hf = HartFrame(12)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 12 (UBInt8)
byte_count: 26 (UBInt8)
payload: Command12_ReadMessageResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
message: b'????????????????????????????????'
check_byte: 16 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34
\x86\x80\x00\x00\x00\x00\x0c\x1a\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10
Command 13¶
Command 13 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(13)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 13 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command13_ReadTagDescriptorDateRequest():
check_byte: 15 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x0d\x00\x0f
>>> # response
>>> hf = HartFrame(13)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 13 (UBInt8)
byte_count: 23 (UBInt8)
payload: Command13_ReadTagDescriptorDateResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
tag: b'????????'
descriptor: b'????????????????'
date: datetime.date(1900, 1, 1)
check_byte: 28 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31
\x86\x80\x00\x00\x00\x00\x0d\x17\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x1c
Command 14¶
Command 14 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(14)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 14 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command14_ReadPrimaryVariableTransducerInformationRequest():
check_byte: 12 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x0e\x00\x0c
>>> # response
>>> hf = HartFrame(14)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 14 (UBInt8)
byte_count: 18 (UBInt8)
payload: Command14_ReadPrimaryVariableTransducerInformationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
serial_number: BitStruct():
value: 0 (BitField(24))
units_code: 0 (UBInt8)
upper_limit: 0 (BFloat)
lower_limit: 0 (BFloat)
minimum_span: 0 (BFloat)
check_byte: 26 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26
\x86\x80\x00\x00\x00\x00\x0e\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a
Command 15¶
Command 15 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(15)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 15 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command15_ReadDeviceInformationRequest():
check_byte: 13 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x0f\x00\x0d
>>> # response
>>> hf = HartFrame(15)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 15 (UBInt8)
byte_count: 20 (UBInt8)
payload: Command15_ReadDeviceInformationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
alarm_selection_code: 0 (UBInt8)
transfer_function_code: 0 (UBInt8)
units_code: 0 (UBInt8)
upper_range_value: 0 (BFloat)
lower_range_value: 0 (BFloat)
daming_value: 0 (BFloat)
write_protect_code: 0 (UBInt8)
reserved: 250 (UBInt8)
analog_channel_flags: 0 (UBInt8)
check_byte: 231 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28
\x86\x80\x00\x00\x00\x00\x0f\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\xe7
Command 16¶
Command 16 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(16)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 16 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command16_ReadFinalAssemblyNumberRequest():
check_byte: 18 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x10\x00\x12
>>> # response
>>> hf = HartFrame(16)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 16 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command16_ReadFinalAssemblyNumberResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
final_assembly_number: BitStruct():
value: 0 (BitField(24))
check_byte: 19 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x86\x80\x00\x00\x00\x00\x10\x05\x00\x00\x00\x00\x00\x13
Command 17¶
Command 17 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(17)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 17 (UBInt8)
byte_count: 24 (UBInt8)
payload: Command17_WriteMessageRequest():
message: b'????????????????????????????????'
check_byte: 11 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32
\x82\x80\x00\x00\x00\x00\x11\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b
>>> # response
>>> hf = HartFrame(17)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 17 (UBInt8)
byte_count: 26 (UBInt8)
payload: Command17_WriteMessageResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
message: b'????????????????????????????????'
check_byte: 13 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34
\x86\x80\x00\x00\x00\x00\x11\x1a\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d
Command 18¶
Command 18 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(18)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 18 (UBInt8)
byte_count: 21 (UBInt8)
payload: Command18_WriteTageDescriptorDateRequest():
tag: b'????????'
descriptor: b'????????????????'
date: datetime.date(1900, 1, 1)
check_byte: 5 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29
\x82\x80\x00\x00\x00\x00\x12\x15\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x05
>>> # response
>>> hf = HartFrame(18)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 18 (UBInt8)
byte_count: 23 (UBInt8)
payload: Command18_WriteTageDescriptorDateResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
tag: b'????????'
descriptor: b'????????????????'
date: datetime.date(1900, 1, 1)
check_byte: 3 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31
\x86\x80\x00\x00\x00\x00\x12\x17\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\x01\x03
Command 19¶
Command 19 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(19)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 19 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command19_WriteFinalAssemblyNumberRequest():
final_assembly_number: BitStruct():
value: 0 (BitField(24))
check_byte: 18 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x82\x80\x00\x00\x00\x00\x13\x03\x00\x00\x00\x12
>>> # response
>>> hf = HartFrame(19)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 19 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command19_WriteFinalAssemblyNumberResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
final_assembly_number: BitStruct():
value: 0 (BitField(24))
check_byte: 16 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x86\x80\x00\x00\x00\x00\x13\x05\x00\x00\x00\x00\x00\x10
Command 20¶
Command 20 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(20)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 20 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command20_ReadLongTagRequest():
check_byte: 22 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x14\x00\x16
>>> # response
>>> hf = HartFrame(20)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 20 (UBInt8)
byte_count: 34 (UBInt8)
payload: Command20_ReadLongTagResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
long_tag: b''
check_byte: 48 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40| 41| 42
\x86\x80\x00\x00\x00\x00\x14\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30
Command 21¶
Command 21 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(21)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 21 (UBInt8)
byte_count: 32 (UBInt8)
payload: Command21_ReadUniqueIdentifierAssociatedWithLongTagRequest():
long_tag: b''
check_byte: 55 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40
\x82\x80\x00\x00\x00\x00\x15\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37
>>> # response
>>> hf = HartFrame(21)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 21 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command21_ReadUniqueIdentifierAssociatedWithLongTagResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
data_object_id: 0 (UBInt8)
device_type: 0 (UBInt16)
minimum_preambles_request: 0 (UBInt8)
protocol_revision: 0 (UBInt8)
device_revision_level: 0 (UBInt8)
software_revision_level: 0 (UBInt8)
hardware_revision_level_and_physical_signaling_code: 0 (UBInt8)
flags: 0 (UBInt8)
device_id: BitStruct():
value: 0 (BitField(24))
check_byte: 29 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22
\x86\x80\x00\x00\x00\x00\x15\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d
Command 22¶
Command 22 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(22)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 22 (UBInt8)
byte_count: 32 (UBInt8)
payload: Command22_WriteLongTagRequest():
long_tag: b''
check_byte: 52 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40
\x82\x80\x00\x00\x00\x00\x16\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34
>>> # response
>>> hf = HartFrame(22)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 22 (UBInt8)
byte_count: 34 (UBInt8)
payload: Command22_WriteLongTagResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
long_tag: b''
check_byte: 50 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40| 41| 42
\x86\x80\x00\x00\x00\x00\x16\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32
Command 38¶
Command 38 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(38)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 38 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command38_ResetConfigurationChangedFlagRequest():
check_byte: 36 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x26\x00\x24
>>> # response
>>> hf = HartFrame(38)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 38 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command38_ResetConfigurationChangedFlagResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
configuration_change_counter: 0 (UBInt16)
check_byte: 36 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x26\x04\x00\x00\x00\x00\x24
Command 40¶
Command 40 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(40)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 40 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command40_EnterExitFixedCurrentModeRequest():
primary_variable_fixed_current: 0 (BFloat)
check_byte: 46 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x82\x80\x00\x00\x00\x00\x28\x04\x00\x00\x00\x00\x2e
>>> # response
>>> hf = HartFrame(40)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 40 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command40_EnterExitFixedCurrentModeResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
actual_primary_variable_current_level: 0 (BFloat)
check_byte: 40 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x28\x06\x00\x00\x00\x00\x00\x00\x28
Common Practice Commands¶
Command 33¶
Command 33 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(33)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 33 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command33_ReadDeviceVariablesRequest():
device_variable_codes: Array():
[
]
check_byte: 35 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x21\x00\x23
>>> # response
>>> hf = HartFrame(33)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 33 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command33_ReadDeviceVariablesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_codes_units_and_values: Array():
[
]
check_byte: 37 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x21\x02\x00\x00\x25
Command 34¶
Command 34 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(34)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 34 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command34_WritePrimaryVariableDampingValueRequest():
primary_variable_damping_value: 0 (BFloat)
check_byte: 36 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x82\x80\x00\x00\x00\x00\x22\x04\x00\x00\x00\x00\x24
>>> # response
>>> hf = HartFrame(34)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 34 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command34_WritePrimaryVariableDampingValueResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
actual_primary_variable_damping_value: 0 (BFloat)
check_byte: 34 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x22\x06\x00\x00\x00\x00\x00\x00\x22
Command 35¶
Command 35 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(35)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 35 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command35_WritePrimaryVariableRangeValuesRequest():
primary_variable_upper_and_lower_range_value_units_code: 0 (UBInt8)
primary_variable_upper_range_value: 0 (BFloat)
primary_variable_lower_range_value: 0 (BFloat)
check_byte: 40 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x82\x80\x00\x00\x00\x00\x23\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28
>>> # response
>>> hf = HartFrame(35)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 35 (UBInt8)
byte_count: 11 (UBInt8)
payload: Command35_WritePrimaryVariableRangeValuesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_upper_and_lower_range_value_units_code: 0 (UBInt8)
primary_variable_upper_range_value: 0 (BFloat)
primary_variable_lower_range_value: 0 (BFloat)
check_byte: 46 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19
\x86\x80\x00\x00\x00\x00\x23\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e
Command 36¶
Command 36 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(36)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 36 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command36_SetPrimaryVariableUpperRangeValueRequest():
check_byte: 38 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x24\x00\x26
>>> # response
>>> hf = HartFrame(36)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 36 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command36_SetPrimaryVariableUpperRangeValueResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
check_byte: 32 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x24\x02\x00\x00\x20
Command 37¶
Command 37 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(37)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 37 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command37_SetPrimaryVariableLowerRangeValueRequest():
check_byte: 39 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x25\x00\x27
>>> # response
>>> hf = HartFrame(37)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 37 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command37_SetPrimaryVariableLowerRangeValueResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
check_byte: 33 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x25\x02\x00\x00\x21
Command 39¶
Command 39 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(39)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 39 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command39_EEPROMControlRequest():
eeprom_control_code: 0 (UBInt8)
check_byte: 36 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x27\x01\x00\x24
>>> # response
>>> hf = HartFrame(39)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 39 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command39_EEPROMControlResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
eeprom_control_code: 0 (UBInt8)
check_byte: 34 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x27\x03\x00\x00\x00\x22
Command 40¶
Command 40 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(40)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 40 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command40_EnterExitFixedCurrentModeRequest():
primary_variable_fixed_current_level: 0 (BFloat)
check_byte: 46 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x82\x80\x00\x00\x00\x00\x28\x04\x00\x00\x00\x00\x2e
>>> # response
>>> hf = HartFrame(40)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 40 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command40_EnterExitFixedCurrentModeResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
actual_primary_variable_current_level: 0 (BFloat)
check_byte: 40 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x28\x06\x00\x00\x00\x00\x00\x00\x28
Command 41¶
Command 41 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(41)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 41 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command41_PerformSelfTestRequest():
check_byte: 43 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x29\x00\x2b
>>> # response
>>> hf = HartFrame(41)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 41 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command41_PerformSelfTestResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
check_byte: 45 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x29\x02\x00\x00\x2d
Command 42¶
Command 42 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(42)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 42 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command42_PerformDeviceResetRequest():
check_byte: 40 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x2a\x00\x28
>>> # response
>>> hf = HartFrame(42)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 42 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command42_PerformDeviceResetResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
check_byte: 46 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x2a\x02\x00\x00\x2e
Command 43¶
Command 43 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(43)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 43 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command43_SetPrimaryVariableZeroRequest():
check_byte: 41 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x2b\x00\x29
>>> # response
>>> hf = HartFrame(43)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 43 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command43_SetPrimaryVariableZeroResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
check_byte: 47 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x2b\x02\x00\x00\x2f
Command 44¶
Command 44 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(44)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 44 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command44_WritePrimaryVariableUnitsRequest():
primary_variable_units_code: 0 (UBInt8)
check_byte: 47 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x2c\x01\x00\x2f
>>> # response
>>> hf = HartFrame(44)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 44 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command44_WritePrimaryVariableUnitsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_units_code: 0 (UBInt8)
check_byte: 41 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x2c\x03\x00\x00\x00\x29
Command 45¶
Command 45 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(45)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 45 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command45_TrimLoopCurrentZeroRequest():
externally_measured_primary_variable_loop_current_level: 0 (BFloat)
check_byte: 43 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x82\x80\x00\x00\x00\x00\x2d\x04\x00\x00\x00\x00\x2b
>>> # response
>>> hf = HartFrame(45)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 45 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command45_TrimLoopCurrentZeroResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
actual_measured_primary_variable_loop_current_level: 0 (BFloat)
check_byte: 45 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x2d\x06\x00\x00\x00\x00\x00\x00\x2d
Command 46¶
Command 46 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(46)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 46 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command46_TrimLoopCurrentGainRequest():
externally_measured_primary_variable_loop_current_level: 0 (BFloat)
check_byte: 40 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x82\x80\x00\x00\x00\x00\x2e\x04\x00\x00\x00\x00\x28
>>> # response
>>> hf = HartFrame(46)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 46 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command46_TrimLoopCurrentGainResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
actual_measured_primary_variable_loop_current_level: 0 (BFloat)
check_byte: 46 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x2e\x06\x00\x00\x00\x00\x00\x00\x2e
Command 47¶
Command 47 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(47)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 47 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command47_WritePrimaryVariableTransferFunctionRequest():
primary_variable_transfer_function_code: 0 (UBInt8)
check_byte: 44 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x2f\x01\x00\x2c
>>> # response
>>> hf = HartFrame(47)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 47 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command47_WritePrimaryVariableTransferFunctionResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_transfer_function_code: 0 (UBInt8)
check_byte: 42 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x2f\x03\x00\x00\x00\x2a
Command 49¶
Command 49 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(49)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 49 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command49_WritePrimaryVariableTransducerSerialNumberRequest():
primary_variable_transducer_serial_number: BitStruct():
value: 0 (BitField(24))
check_byte: 48 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x82\x80\x00\x00\x00\x00\x31\x03\x00\x00\x00\x30
>>> # response
>>> hf = HartFrame(49)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 49 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command49_WritePrimaryVariableTransducerSerialNumberResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_transducer_serial_number: BitStruct():
value: 0 (BitField(24))
check_byte: 50 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x86\x80\x00\x00\x00\x00\x31\x05\x00\x00\x00\x00\x00\x32
Command 50¶
Command 50 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(50)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 50 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command50_ReadDynamicVariableAssignmentsRequest():
check_byte: 48 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x32\x00\x30
>>> # response
>>> hf = HartFrame(50)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 50 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command50_ReadDynamicVariableAssignmentsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_device_variable: 0 (UBInt8)
secondary_variable_device_variable: 0 (UBInt8)
tertiary_variable_device_variable: 0 (UBInt8)
quaternary_variable_device_variable: 0 (UBInt8)
check_byte: 50 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x32\x06\x00\x00\x00\x00\x00\x00\x32
Command 51¶
Command 51 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(51)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 51 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command51_WriteDynamicVariableAssignmentsRequest():
device_variables: Array():
[
]
check_byte: 49 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x33\x00\x31
>>> # response
>>> hf = HartFrame(51)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 51 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command51_WriteDynamicVariableAssignmentsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variables: Array():
[
]
check_byte: 55 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x33\x02\x00\x00\x37
Command 52¶
Command 52 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(52)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 52 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command52_SetDeviceVariableZeroRequest():
device_variable_to_zero: 0 (UBInt8)
check_byte: 55 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x34\x01\x00\x37
>>> # response
>>> hf = HartFrame(52)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 52 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command52_SetDeviceVariableZeroResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_to_zero: 0 (UBInt8)
check_byte: 49 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x34\x03\x00\x00\x00\x31
Command 53¶
Command 53 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(53)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 53 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command53_WriteDeviceVariableUnitsRequest():
device_variable_code: 0 (UBInt8)
device_variable_units_code: 0 (UBInt8)
check_byte: 53 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x35\x02\x00\x00\x35
>>> # response
>>> hf = HartFrame(53)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 53 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command53_WriteDeviceVariableUnitsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
device_variable_units_code: 0 (UBInt8)
check_byte: 55 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x35\x04\x00\x00\x00\x00\x37
Command 54¶
Command 54 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(54)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 54 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command54_ReadDeviceVariableInformationRequest():
device_variable_code: 0 (UBInt8)
check_byte: 53 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x36\x01\x00\x35
>>> # response
>>> hf = HartFrame(54)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 54 (UBInt8)
byte_count: 30 (UBInt8)
payload: Command54_ReadDeviceVariableInformationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
device_variable_transducer_serial_number: BitStruct():
value: 0 (BitField(24))
device_variable_limits: 0 (UBInt8)
device_variable_upper_transducer_limit: 0 (BFloat)
device_variable_lower_transducer_limit: 0 (BFloat)
device_variable_damping_value: 0 (BFloat)
device_variable_minimum_span: 0 (BFloat)
device_variable_classification: 0 (UBInt8)
device_variable_family: 0 (UBInt8)
acquisition_period: 0 (UBInt32)
device_variable_properties: 0 (UBInt8)
check_byte: 46 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38
\x86\x80\x00\x00\x00\x00\x36\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e
Command 55¶
Command 55 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(55)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 55 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command55_WriteDeviceVariableDampingValueRequest():
device_variable_code: 0 (UBInt8)
device_variable_damping_value: 0 (BFloat)
check_byte: 48 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x82\x80\x00\x00\x00\x00\x37\x05\x00\x00\x00\x00\x00\x30
>>> # response
>>> hf = HartFrame(55)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 55 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command55_WriteDeviceVariableDampingValueResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
device_variable_damping_value: 0 (BFloat)
check_byte: 54 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x86\x80\x00\x00\x00\x00\x37\x07\x00\x00\x00\x00\x00\x00\x00\x36
Command 56¶
Command 56 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(56)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 56 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command56_WriteDeviceVariableTransducerSerialNumberRequest():
device_variable_code: 0 (UBInt8)
device_variable_transducer_serial_number: BitStruct():
value: 0 (BitField(24))
check_byte: 62 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x82\x80\x00\x00\x00\x00\x38\x04\x00\x00\x00\x00\x3e
>>> # response
>>> hf = HartFrame(56)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 56 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command56_WriteDeviceVariableTransducerSerialNumberResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
device_variable_transducer_serial_number: BitStruct():
value: 0 (BitField(24))
check_byte: 56 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x38\x06\x00\x00\x00\x00\x00\x00\x38
Command 57¶
Command 57 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(57)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 57 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command57_ReadUnitTagDescriptorDateRequest():
check_byte: 59 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x39\x00\x3b
>>> # response
>>> hf = HartFrame(57)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 57 (UBInt8)
byte_count: 23 (UBInt8)
payload: Command57_ReadUnitTagDescriptorDateResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
unit_tag: '????????'
unit_descriptor: '????????????????'
unit_date: BitStruct():
value: 0 (BitField(24))
check_byte: 40 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31
\x86\x80\x00\x00\x00\x00\x39\x17\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x28
Command 58¶
Command 58 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(58)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 58 (UBInt8)
byte_count: 21 (UBInt8)
payload: Command58_WriteUnitTagDescriptorDateRequest():
unit_tag: '????????'
unit_descriptor: '????????????????'
unit_date: BitStruct():
value: 0 (BitField(24))
check_byte: 45 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29
\x82\x80\x00\x00\x00\x00\x3a\x15\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x2d
>>> # response
>>> hf = HartFrame(58)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 58 (UBInt8)
byte_count: 23 (UBInt8)
payload: Command58_WriteUnitTagDescriptorDateResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
unit_tag: '????????'
unit_descriptor: '????????????????'
unit_date: BitStruct():
value: 0 (BitField(24))
check_byte: 43 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31
\x86\x80\x00\x00\x00\x00\x3a\x17\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x2b
Command 59¶
Command 59 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(59)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 59 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command59_WriteNumberOfResponsePreamblesRequest():
number_of_preambles: 0 (UBInt8)
check_byte: 56 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x3b\x01\x00\x38
>>> # response
>>> hf = HartFrame(59)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 59 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command59_WriteNumberOfResponsePreamblesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
number_of_preambles: 0 (UBInt8)
check_byte: 62 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x3b\x03\x00\x00\x00\x3e
Command 60¶
Command 60 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(60)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 60 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command60_ReadAnalogChannelAndPercentOfRangeRequest():
analog_channel_number_code: 0 (UBInt8)
check_byte: 63 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x3c\x01\x00\x3f
>>> # response
>>> hf = HartFrame(60)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 60 (UBInt8)
byte_count: 12 (UBInt8)
payload: Command60_ReadAnalogChannelAndPercentOfRangeResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_units_code: 0 (UBInt8)
analog_channel_level: 0 (BFloat)
analog_channel_percent_of_range: 0 (BFloat)
check_byte: 54 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20
\x86\x80\x00\x00\x00\x00\x3c\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36
Command 61¶
Command 61 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(61)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 61 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command61_ReadDynamicVariablesAndPrimaryVariableAnalogChannelRequest():
check_byte: 63 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x3d\x00\x3f
>>> # response
>>> hf = HartFrame(61)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 61 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command61_ReadDynamicVariablesAndPrimaryVariableAnalogChannelResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_analog_channel_units_code: 0 (UBInt8)
primary_variable_analog_level: 0 (BFloat)
dynamic_variables: Array():
[
]
check_byte: 60 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x86\x80\x00\x00\x00\x00\x3d\x07\x00\x00\x00\x00\x00\x00\x00\x3c
Command 62¶
Command 62 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(62)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 62 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command62_ReadAnalogChannelsRequest():
analog_channel_number_codes: Array():
[
]
check_byte: 60 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x3e\x00\x3c
>>> # response
>>> hf = HartFrame(62)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 62 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command62_ReadAnalogChannelsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_levels: Array():
[
]
check_byte: 58 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x3e\x02\x00\x00\x3a
Command 63¶
Command 63 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(63)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 63 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command63_ReadAnalogChannelInformationRequest():
analog_channel_number_code: 0 (UBInt8)
check_byte: 60 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x3f\x01\x00\x3c
>>> # response
>>> hf = HartFrame(63)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 63 (UBInt8)
byte_count: 19 (UBInt8)
payload: Command63_ReadAnalogChannelInformationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_alarm_selection_code: 0 (UBInt8)
analog_channel_transfer_function_code: 0 (UBInt8)
analog_channel_upper_and_lower_range_value_units_code: 0 (UBInt8)
analog_channel_upper_range_value: 0 (BFloat)
analog_channel_lower_range_value: 0 (BFloat)
analog_channel_damping_value: 0 (BFloat)
analog_channel_flags: 0 (UBInt8)
check_byte: 42 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27
\x86\x80\x00\x00\x00\x00\x3f\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a
Command 64¶
Command 64 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(64)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 64 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command64_WriteAnalogChannelAdditionalDampingValueRequest():
analog_channel_number_code: 0 (UBInt8)
analog_channel_additional_damping_value: 0 (BFloat)
check_byte: 71 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x82\x80\x00\x00\x00\x00\x40\x05\x00\x00\x00\x00\x00\x47
>>> # response
>>> hf = HartFrame(64)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 64 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command64_WriteAnalogChannelAdditionalDampingValueResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_additional_damping_value: 0 (BFloat)
check_byte: 65 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x86\x80\x00\x00\x00\x00\x40\x07\x00\x00\x00\x00\x00\x00\x00\x41
Command 65¶
Command 65 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(65)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 65 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command65_WriteAnalogChannelRangeValuesRequest():
analog_channel_number_code: 0 (UBInt8)
analog_channel_upper_and_lower_range_value_units_code: 0 (UBInt8)
analog_channel_upper_range_value: 0 (BFloat)
analog_channel_lower_range_value: 0 (BFloat)
check_byte: 73 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x82\x80\x00\x00\x00\x00\x41\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49
>>> # response
>>> hf = HartFrame(65)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 65 (UBInt8)
byte_count: 12 (UBInt8)
payload: Command65_WriteAnalogChannelRangeValuesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_upper_and_lower_range_value_units_code: 0 (UBInt8)
analog_channel_upper_range_value: 0 (BFloat)
analog_channel_lower_range_value: 0 (BFloat)
check_byte: 75 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20
\x86\x80\x00\x00\x00\x00\x41\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b
Command 66¶
Command 66 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(66)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 66 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command66_EnterExitFixedAnalogChannelModeRequest():
analog_channel_number_code: 0 (UBInt8)
analog_channel_units_code: 0 (UBInt8)
fixed_analog_channel_level: 0 (BFloat)
check_byte: 70 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x82\x80\x00\x00\x00\x00\x42\x06\x00\x00\x00\x00\x00\x00\x46
>>> # response
>>> hf = HartFrame(66)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 66 (UBInt8)
byte_count: 8 (UBInt8)
payload: Command66_EnterExitFixedAnalogChannelModeResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_units_code: 0 (UBInt8)
fixed_analog_channel_level: 0 (BFloat)
check_byte: 76 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16
\x86\x80\x00\x00\x00\x00\x42\x08\x00\x00\x00\x00\x00\x00\x00\x00\x4c
Command 67¶
Command 67 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(67)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 67 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command67_TrimAnalogChannelZeroRequest():
analog_channel_number_code: 0 (UBInt8)
analog_channel_units_code: 0 (UBInt8)
externally_measured_analog_channel_level: 0 (BFloat)
check_byte: 71 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x82\x80\x00\x00\x00\x00\x43\x06\x00\x00\x00\x00\x00\x00\x47
>>> # response
>>> hf = HartFrame(67)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 67 (UBInt8)
byte_count: 8 (UBInt8)
payload: Command67_TrimAnalogChannelZeroResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_units_code: 0 (UBInt8)
actual_channel_level: 0 (BFloat)
check_byte: 77 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16
\x86\x80\x00\x00\x00\x00\x43\x08\x00\x00\x00\x00\x00\x00\x00\x00\x4d
Command 68¶
Command 68 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(68)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 68 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command68_TrimAnalogChannelGainRequest():
analog_channel_number_code: 0 (UBInt8)
analog_channel_units_code: 0 (UBInt8)
externally_measured_analog_channel_level: 0 (BFloat)
check_byte: 64 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x82\x80\x00\x00\x00\x00\x44\x06\x00\x00\x00\x00\x00\x00\x40
>>> # response
>>> hf = HartFrame(68)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 68 (UBInt8)
byte_count: 8 (UBInt8)
payload: Command68_TrimAnalogChannelGainResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_units_code: 0 (UBInt8)
externally_measured_analog_channel_level: 0 (BFloat)
check_byte: 74 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16
\x86\x80\x00\x00\x00\x00\x44\x08\x00\x00\x00\x00\x00\x00\x00\x00\x4a
Command 69¶
Command 69 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(69)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 69 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command69_WriteAnalogChannelTransferFunctionRequest():
analog_channel_number_code: 0 (UBInt8)
analog_channel_transfer_function_code: 0 (UBInt8)
check_byte: 69 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x45\x02\x00\x00\x45
>>> # response
>>> hf = HartFrame(69)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 69 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command69_WriteAnalogChannelTransferFunctionResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_transfer_function_code: 0 (UBInt8)
check_byte: 71 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x45\x04\x00\x00\x00\x00\x47
Command 70¶
Command 70 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(70)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 70 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command70_ReadAnalogChannelEndpointValuesRequest():
analog_channel_number_code: 0 (UBInt8)
check_byte: 69 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x46\x01\x00\x45
>>> # response
>>> hf = HartFrame(70)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 70 (UBInt8)
byte_count: 20 (UBInt8)
payload: Command70_ReadAnalogChannelEndpointValuesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
analog_channel_number_code: 0 (UBInt8)
analog_channel_upper_and_lower_range_value_units_code: 0 (UBInt8)
analog_channel_upper_endpoint_value: 0 (BFloat)
analog_channel_lower_endpoint_value: 0 (BFloat)
analog_channel_upper_limit_value: 0 (BFloat)
analog_channel_lower_limit_value: 0 (BFloat)
check_byte: 84 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28
\x86\x80\x00\x00\x00\x00\x46\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54
Command 71¶
Command 71 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(71)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 71 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command71_LockDeviceRequest():
lock_code: 0 (UBInt8)
check_byte: 68 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x47\x01\x00\x44
>>> # response
>>> hf = HartFrame(71)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 71 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command71_LockDeviceResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
lock_code: 0 (UBInt8)
check_byte: 66 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x47\x03\x00\x00\x00\x42
Command 72¶
Command 72 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(72)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 72 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command72_SquawkRequest():
squawk_control: 0 (UBInt8)
check_byte: 75 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x48\x01\x00\x4b
>>> # response
>>> hf = HartFrame(72)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 72 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command72_SquawkResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
squawk_control: 0 (UBInt8)
check_byte: 77 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x48\x03\x00\x00\x00\x4d
Command 73¶
Command 73 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(73)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 73 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command73_FindDeviceRequest():
check_byte: 75 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x49\x00\x4b
>>> # response
>>> hf = HartFrame(73)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 73 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command73_FindDeviceResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
data_object_id: 0 (UBInt8)
device_type: 0 (UBInt16)
minimum_preambles_request: 0 (UBInt8)
protocol_revision: 0 (UBInt8)
device_revision_level: 0 (UBInt8)
software_revision_level: 0 (UBInt8)
hardware_revision_level_and_physical_signaling_code: 0 (UBInt8)
flags: 0 (UBInt8)
device_id: BitStruct():
value: 0 (BitField(24))
check_byte: 65 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22
\x86\x80\x00\x00\x00\x00\x49\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41
Command 74¶
Command 74 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(74)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 74 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command74_ReadIOSystemCapabilitiesRequest():
check_byte: 72 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x4a\x00\x48
>>> # response
>>> hf = HartFrame(74)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 74 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command74_ReadIOSystemCapabilitiesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
maximum_number_of_io_cards: 0 (UBInt8)
maximum_number_of_channels_per_card: 0 (UBInt8)
maximum_number_of_subdevices_per_channel: 0 (UBInt8)
number_of_devices: 0 (UBInt16)
maximum_number_of_delayed_responses: 0 (UBInt8)
master_mode: 0 (UBInt8)
retry_count: 0 (UBInt8)
check_byte: 70 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x4a\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46
Command 75¶
Command 75 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(75)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 75 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command75_PollSubDeviceRequest():
io_card: 0 (UBInt8)
channel: 0 (UBInt8)
subdevice_polling_address: 0 (UBInt8)
check_byte: 74 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x82\x80\x00\x00\x00\x00\x4b\x03\x00\x00\x00\x4a
>>> # response
>>> hf = HartFrame(75)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 75 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command75_PollSubDeviceResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
data_object_id: 0 (UBInt8)
device_type: 0 (UBInt16)
minimum_preambles_request: 0 (UBInt8)
protocol_revision: 0 (UBInt8)
device_revision_level: 0 (UBInt8)
software_revision_level: 0 (UBInt8)
hardware_revision_level_and_physical_signaling_code: 0 (UBInt8)
flags: 0 (UBInt8)
device_id: BitStruct():
value: 0 (BitField(24))
check_byte: 67 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22
\x86\x80\x00\x00\x00\x00\x4b\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43
Command 76¶
Command 76 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(76)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 76 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command76_ReadLockDeviceStateRequest():
check_byte: 78 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x4c\x00\x4e
>>> # response
>>> hf = HartFrame(76)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 76 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command76_ReadLockDeviceStateResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
lock_status: 0 (UBInt8)
check_byte: 73 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x4c\x03\x00\x00\x00\x49
Command 77¶
Command 77 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(77)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 77 (UBInt8)
byte_count: 11 (UBInt8)
payload: Command77_SendCommandToSubDeviceRequest():
io_card: 0 (UBInt8)
channel: 0 (UBInt8)
transmit_preamble_count: 0 (UBInt8)
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Array():
[
@0: 0 (UBInt8)
@1: 0 (UBInt8)
@2: 0 (UBInt8)
@3: 0 (UBInt8)
@4: 0 (UBInt8)
]
command: 0 (UBInt8)
byte_count: 0 (UBInt8)
data: Array():
[
]
check_byte: 198 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19
\x82\x80\x00\x00\x00\x00\x4d\x0b\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\xc6
>>> # response
>>> hf = HartFrame(77)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 77 (UBInt8)
byte_count: 12 (UBInt8)
payload: Command77_SendCommandToSubDeviceResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
io_card: 0 (UBInt8)
channel: 0 (UBInt8)
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Array():
[
@0: 0 (UBInt8)
@1: 0 (UBInt8)
@2: 0 (UBInt8)
@3: 0 (UBInt8)
@4: 0 (UBInt8)
]
command: 0 (UBInt8)
byte_count: 0 (UBInt8)
data: Array():
[
]
check_byte: 197 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20
\x86\x80\x00\x00\x00\x00\x4d\x0c\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\xc5
Command 78¶
Command 78 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(78)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 78 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command78_ReadAggregatedCommandsRequest():
requested_commands: 0 (UBInt8)
commands: Array():
[
]
check_byte: 77 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x4e\x01\x00\x4d
>>> # response
>>> hf = HartFrame(78)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 78 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command78_ReadAggregatedCommandsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
extended_field_device_status: 0 (UBInt8)
requested_commands: 0 (UBInt8)
commands: Array():
[
]
check_byte: 76 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x4e\x04\x00\x00\x00\x00\x4c
Command 79¶
Command 79 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(79)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 79 (UBInt8)
byte_count: 8 (UBInt8)
payload: Command79_WriteDeviceVariableRequest():
device_variable_code: 0 (UBInt8)
write_device_variable_command_code: 0 (UBInt8)
units_code: 0 (UBInt8)
device_variable_value: 0 (BFloat)
device_variable_status: 0 (UBInt8)
check_byte: 69 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16
\x82\x80\x00\x00\x00\x00\x4f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x45
>>> # response
>>> hf = HartFrame(79)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 79 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command79_WriteDeviceVariableResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
write_device_variable_command_code: 0 (UBInt8)
units_code: 0 (UBInt8)
device_variable_value: 0 (BFloat)
device_variable_status: 0 (UBInt8)
check_byte: 67 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x4f\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43
Command 80¶
Command 80 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(80)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 80 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command80_ReadDeviceVariableTrimPointsRequest():
device_variable_code: 0 (UBInt8)
check_byte: 83 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x50\x01\x00\x53
>>> # response
>>> hf = HartFrame(80)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 80 (UBInt8)
byte_count: 12 (UBInt8)
payload: Command80_ReadDeviceVariableTrimPointsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
trim_points_units_code: 0 (UBInt8)
lower_trim_point: 0 (BFloat)
upper_trim_point: 0 (BFloat)
check_byte: 90 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20
\x86\x80\x00\x00\x00\x00\x50\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a
Command 81¶
Command 81 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(81)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 81 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command81_ReadDeviceVariableTrimGuidelinesRequest():
device_variable_guidelines: 0 (UBInt8)
check_byte: 82 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x51\x01\x00\x52
>>> # response
>>> hf = HartFrame(81)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 81 (UBInt8)
byte_count: 25 (UBInt8)
payload: Command81_ReadDeviceVariableTrimGuidelinesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_guidelines: 0 (UBInt8)
trim_points_supported: 0 (UBInt8)
trim_points_units_code: 0 (UBInt8)
minimum_lower_trim_point_value: 0 (BFloat)
maximum_lower_trim_point_value: 0 (BFloat)
minimum_upper_trim_point_value: 0 (BFloat)
maximum_upper_trim_point_value: 0 (BFloat)
minimum_differential: 0 (BFloat)
check_byte: 78 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33
\x86\x80\x00\x00\x00\x00\x51\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e
Command 82¶
Command 82 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(82)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 82 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command82_WriteDeviceVariableTrimPointRequest():
device_variable_code: 0 (UBInt8)
trim_point: 0 (UBInt8)
trim_point_units_code: 0 (UBInt8)
trim_point_value: 0 (BFloat)
check_byte: 87 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x82\x80\x00\x00\x00\x00\x52\x07\x00\x00\x00\x00\x00\x00\x00\x57
>>> # response
>>> hf = HartFrame(82)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 82 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command82_WriteDeviceVariableTrimPointResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
trim_point: 0 (UBInt8)
trim_point_units_code: 0 (UBInt8)
trim_point_value: 0 (BFloat)
check_byte: 93 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x86\x80\x00\x00\x00\x00\x52\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d
Command 83¶
Command 83 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(83)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 83 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command83_ResetDeviceVariableTrimRequest():
device_variable_code: 0 (UBInt8)
check_byte: 80 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x53\x01\x00\x50
>>> # response
>>> hf = HartFrame(83)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 83 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command83_ResetDeviceVariableTrimResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code: 0 (UBInt8)
check_byte: 86 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x53\x03\x00\x00\x00\x56
Command 84¶
Command 84 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(84)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 84 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command84_ReadSubDeviceIdentitySummaryRequest():
subdevice_index: 0 (UBInt16)
check_byte: 84 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x54\x02\x00\x00\x54
>>> # response
>>> hf = HartFrame(84)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 84 (UBInt8)
byte_count: 50 (UBInt8)
payload: Command84_ReadSubDeviceIdentitySummaryResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
subdevice_index: 0 (UBInt16)
io_card: 0 (UBInt8)
channel: 0 (UBInt8)
manufacturer_id: 0 (UBInt16)
expanded_device_type_code: 0 (UBInt16)
device_id: BitStruct():
value: 0 (BitField(24))
universal_command_revision_level: 0 (UBInt8)
long_tag: ''
device_revision: 0 (UBInt8)
device_profile: 0 (UBInt8)
private_label_distributor_code: 0 (UBInt16)
check_byte: 96 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40| 41| 42| 43| 44| 45| 46| 47| 48| 49| 50| 51| 52| 53| 54| 55| 56| 57| 58
\x86\x80\x00\x00\x00\x00\x54\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60
Command 85¶
Command 85 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(85)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 85 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command85_ReadIOChannelStatisticsRequest():
io_card: 0 (UBInt8)
channel: 0 (UBInt8)
check_byte: 85 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x55\x02\x00\x00\x55
>>> # response
>>> hf = HartFrame(85)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 85 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command85_ReadIOChannelStatisticsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
io_card: 0 (UBInt8)
channel: 0 (UBInt8)
stx_count: 0 (UBInt16)
ack_count: 0 (UBInt16)
ostx_count: 0 (UBInt16)
oack_count: 0 (UBInt16)
back_count: 0 (UBInt16)
check_byte: 93 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22
\x86\x80\x00\x00\x00\x00\x55\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d
Command 86¶
Command 86 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(86)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 86 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command86_ReadSubDeviceStatisticsRequest():
subdevice_index: 0 (UBInt16)
check_byte: 86 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x56\x02\x00\x00\x56
>>> # response
>>> hf = HartFrame(86)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 86 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command86_ReadSubDeviceStatisticsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
subdevice_index: 0 (UBInt16)
stx_count: 0 (UBInt16)
ack_count: 0 (UBInt16)
back_count: 0 (UBInt16)
check_byte: 90 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x56\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a
Command 87¶
Command 87 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(87)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 87 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command87_WriteIOSystemMasterModeRequest():
master_mode: 0 (UBInt8)
check_byte: 84 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x57\x01\x00\x54
>>> # response
>>> hf = HartFrame(87)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 87 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command87_WriteIOSystemMasterModeResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
master_mode: 0 (UBInt8)
check_byte: 82 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x57\x03\x00\x00\x00\x52
Command 88¶
Command 88 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(88)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 88 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command88_WriteIOSystemRetryCountRequest():
retry_count: 0 (UBInt8)
check_byte: 91 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x58\x01\x00\x5b
>>> # response
>>> hf = HartFrame(88)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 88 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command88_WriteIOSystemRetryCountResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
retry_count: 0 (UBInt8)
check_byte: 93 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x58\x03\x00\x00\x00\x5d
Command 89¶
Command 89 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(89)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 89 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command89_SetRealTimeClockRequest():
time_set_code: 0 (UBInt8)
date: datetime.date(1900, 1, 1)
time: 0 (UBInt32)
padding: 0 (UBInt16)
check_byte: 81 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x82\x80\x00\x00\x00\x00\x59\x0a\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x51
>>> # response
>>> hf = HartFrame(89)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 89 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command89_SetRealTimeClockResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
time_set_code: 0 (UBInt8)
date: datetime.date(1900, 1, 1)
time: 0 (UBInt32)
check_byte: 85 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x59\x0a\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x55
Command 90¶
Command 90 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(90)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 90 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command90_ReadRealTimeClockRequest():
check_byte: 88 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x5a\x00\x58
>>> # response
>>> hf = HartFrame(90)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 90 (UBInt8)
byte_count: 17 (UBInt8)
payload: Command90_ReadRealTimeClockResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
date: datetime.date(1900, 1, 1)
time: 0 (UBInt32)
date_clock_last_set: datetime.date(1900, 1, 1)
time_clock_last_set: 0 (UBInt32)
rtc_flags: 0 (UBInt8)
check_byte: 77 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25
\x86\x80\x00\x00\x00\x00\x5a\x11\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x4d
Command 91¶
Command 91 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(91)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 91 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command91_ReadTrendConfigurationRequest():
trend_number: 0 (UBInt8)
check_byte: 88 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x5b\x01\x00\x58
>>> # response
>>> hf = HartFrame(91)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 91 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command91_ReadTrendConfigurationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
trend_number: 0 (UBInt8)
total_trends_supported: 0 (UBInt8)
trend_control_code: 0 (UBInt8)
device_variable_code: 0 (UBInt8)
trend_sample_interval: 0 (UBInt32)
check_byte: 87 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x5b\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57
Command 92¶
Command 92 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(92)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 92 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command92_WriteTrendConfigurationRequest():
trend_number: 0 (UBInt8)
trend_control_code: 0 (UBInt8)
device_variable_code: 0 (UBInt8)
trend_sample_interval: 0 (UBInt32)
check_byte: 89 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x82\x80\x00\x00\x00\x00\x5c\x07\x00\x00\x00\x00\x00\x00\x00\x59
>>> # response
>>> hf = HartFrame(92)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 92 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command92_WriteTrendConfigurationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
trend_number: 0 (UBInt8)
trend_control_code: 0 (UBInt8)
device_variable_code: 0 (UBInt8)
trend_sample_interval: 0 (UBInt32)
check_byte: 83 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x86\x80\x00\x00\x00\x00\x5c\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53
Command 93¶
Command 93 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(93)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 93 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command93_ReadTrendRequest():
trend_number: 0 (UBInt8)
check_byte: 94 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x5d\x01\x00\x5e
>>> # response
>>> hf = HartFrame(93)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 93 (UBInt8)
byte_count: 77 (UBInt8)
payload: Command93_ReadTrendResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
trend_number: 0 (UBInt8)
device_variable_code: 0 (UBInt8)
device_variable_classification: 0 (UBInt8)
device_variable_units_code: 0 (UBInt8)
date_trend_value0: datetime.date(1900, 1, 1)
time_trend_value0: 0 (UBInt32)
time_sample_interval: 0 (UBInt32)
trend_values: Array():
[
@0: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@1: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@2: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@3: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@4: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@5: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@6: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@7: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@8: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@9: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@10: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
@11: TrendValueAndStatus():
trend_value: 0 (BFloat)
trend_status: 0 (UBInt8)
]
check_byte: 22 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40| 41| 42| 43| 44| 45| 46| 47| 48| 49| 50| 51| 52| 53| 54| 55| 56| 57| 58| 59| 60| 61| 62| 63| 64| 65| 66| 67| 68| 69| 70| 71| 72| 73| 74| 75| 76| 77| 78| 79| 80| 81| 82| 83| 84| 85
\x86\x80\x00\x00\x00\x00\x5d\x4d\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16
Command 94¶
Command 94 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(94)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 94 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command94_ReadIOSystemClientSideCommunicationStatisticsRequest():
check_byte: 92 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x5e\x00\x5c
>>> # response
>>> hf = HartFrame(94)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 94 (UBInt8)
byte_count: 18 (UBInt8)
payload: Command94_ReadIOSystemClientSideCommunicationStatisticsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
messages_received: 0 (UBInt32)
messages_returned: 0 (UBInt32)
requests_forwared: 0 (UBInt32)
responses_returned: 0 (UBInt32)
check_byte: 74 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26
\x86\x80\x00\x00\x00\x00\x5e\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a
Command 95¶
Command 95 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(95)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 95 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command95_ReadDeviceCommunicationStatisticsRequest():
check_byte: 93 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x5f\x00\x5d
>>> # response
>>> hf = HartFrame(95)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 95 (UBInt8)
byte_count: 8 (UBInt8)
payload: Command95_ReadDeviceCommunicationStatisticsResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
stx_count: 0 (UBInt16)
ack_count: 0 (UBInt16)
back_count: 0 (UBInt16)
check_byte: 81 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16
\x86\x80\x00\x00\x00\x00\x5f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x51
Command 96¶
Command 96 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(96)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 96 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command96_ReadSynchronousActionRequest():
action_number: 0 (UBInt8)
check_byte: 99 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x60\x01\x00\x63
>>> # response
>>> hf = HartFrame(96)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 96 (UBInt8)
byte_count: 15 (UBInt8)
payload: Command96_ReadSynchronousActionResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
action_number: 0 (UBInt8)
total_action: 0 (UBInt8)
action_control: 0 (UBInt8)
device_variable_code: 0 (UBInt8)
command: 0 (UBInt16)
trigger_date: datetime.date(1900, 1, 1)
trigger_time: 0 (UBInt32)
check_byte: 105 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23
\x86\x80\x00\x00\x00\x00\x60\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x69
Command 97¶
Command 97 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(97)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 97 (UBInt8)
byte_count: 12 (UBInt8)
payload: Command97_ConfigureSynchronousActionRequest():
action_number: 0 (UBInt8)
action_control: 0 (UBInt8)
device_variable_code: 0 (UBInt8)
command: 0 (UBInt16)
trigger_date: datetime.date(1900, 1, 1)
trigger_time: 0 (UBInt32)
check_byte: 111 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20
\x82\x80\x00\x00\x00\x00\x61\x0c\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x6f
>>> # response
>>> hf = HartFrame(97)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 97 (UBInt8)
byte_count: 14 (UBInt8)
payload: Command97_ConfigureSynchronousActionResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
action_number: 0 (UBInt8)
action_control: 0 (UBInt8)
device_variable_code: 0 (UBInt8)
command: 0 (UBInt16)
trigger_date: datetime.date(1900, 1, 1)
trigger_time: 0 (UBInt32)
check_byte: 105 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22
\x86\x80\x00\x00\x00\x00\x61\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x69
Command 98¶
Command 98 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(98)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 98 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command98_ReadCommandActionRequest():
action_number: 0 (UBInt8)
check_byte: 97 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x62\x01\x00\x61
>>> # response
>>> hf = HartFrame(98)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 98 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command98_ReadCommandActionResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
action_number: 0 (UBInt8)
command: 0 (UBInt16)
byte_count: 0 (UBInt8)
data: Array():
[
]
check_byte: 98 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x62\x06\x00\x00\x00\x00\x00\x00\x62
Command 99¶
Command 99 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(99)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 99 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command99_ConfigureCommandActionRequest():
action_number: 0 (UBInt8)
command: 0 (UBInt16)
byte_count: 0 (UBInt8)
data: Array():
[
]
check_byte: 101 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x82\x80\x00\x00\x00\x00\x63\x04\x00\x00\x00\x00\x65
>>> # response
>>> hf = HartFrame(99)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 99 (UBInt8)
byte_count: 6 (UBInt8)
payload: Command99_ConfigureCommandActionResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
action_number: 0 (UBInt8)
command: 0 (UBInt16)
byte_count: 0 (UBInt8)
data: Array():
[
]
check_byte: 99 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14
\x86\x80\x00\x00\x00\x00\x63\x06\x00\x00\x00\x00\x00\x00\x63
Command 100¶
Command 100 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(100)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 100 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command100_WritePrimaryVariableAlarmCodeRequest():
primary_variable_alarm_selection_code: 0 (UBInt8)
check_byte: 103 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x64\x01\x00\x67
>>> # response
>>> hf = HartFrame(100)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 100 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command100_WritePrimaryVariableAlarmCodeResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
primary_variable_alarm_selection_code: 0 (UBInt8)
check_byte: 97 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x86\x80\x00\x00\x00\x00\x64\x03\x00\x00\x00\x61
Command 101¶
Command 101 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(101)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 101 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command101_ReadSubDeviceToBurstMessageMapRequest():
burst_message: 0 (UBInt8)
check_byte: 102 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x65\x01\x00\x66
>>> # response
>>> hf = HartFrame(101)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 101 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command101_ReadSubDeviceToBurstMessageMapResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
burst_message: 0 (UBInt8)
subdevice_index: 0 (UBInt16)
check_byte: 102 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x86\x80\x00\x00\x00\x00\x65\x05\x00\x00\x00\x00\x00\x66
Command 102¶
Command 102 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(102)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 102 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command102_MapSubdeviceToBurstMessageRequest():
burst_message: 0 (UBInt8)
subdevice_index: 0 (UBInt16)
check_byte: 103 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x82\x80\x00\x00\x00\x00\x66\x03\x00\x00\x00\x67
>>> # response
>>> hf = HartFrame(102)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 102 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command102_MapSubdeviceToBurstMessageResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
burst_message: 0 (UBInt8)
subdevice_index: 0 (UBInt16)
check_byte: 101 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x86\x80\x00\x00\x00\x00\x66\x05\x00\x00\x00\x00\x00\x65
Command 103¶
Command 103 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(103)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 103 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command103_WriteBurstPeriodRequest():
burst_message: 0 (UBInt8)
update_period: 0 (UBInt32)
maximum_update_period: 0 (UBInt32)
check_byte: 108 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x82\x80\x00\x00\x00\x00\x67\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c
>>> # response
>>> hf = HartFrame(103)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 103 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command103_WriteBurstPeriodResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
burst_message: 0 (UBInt8)
subdevice_index: 0 (UBInt16)
check_byte: 100 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x86\x80\x00\x00\x00\x00\x67\x05\x00\x00\x00\x00\x00\x64
Command 104¶
Command 104 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(104)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 104 (UBInt8)
byte_count: 8 (UBInt8)
payload: Command104_WriteBurstTriggerRequest():
burst_message: 0 (UBInt8)
burst_trigger_mode_selection_code: 0 (UBInt8)
device_variable_classification: 0 (UBInt8)
units_code: 0 (UBInt8)
trigger_level: 0 (BFloat)
check_byte: 98 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16
\x82\x80\x00\x00\x00\x00\x68\x08\x00\x00\x00\x00\x00\x00\x00\x00\x62
>>> # response
>>> hf = HartFrame(104)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 104 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command104_WriteBurstTriggerResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
burst_message: 0 (UBInt8)
burst_trigger_mode_selection_code: 0 (UBInt8)
device_variable_classification: 0 (UBInt8)
units_code: 0 (UBInt8)
trigger_level: 0 (BFloat)
check_byte: 100 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x68\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64
Command 105¶
Command 105 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(105)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 105 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command105_ReadBurstModeConfigurationRequest():
burst_message: 0 (UBInt8)
check_byte: 106 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x69\x01\x00\x6a
>>> # response
>>> hf = HartFrame(105)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 105 (UBInt8)
byte_count: 31 (UBInt8)
payload: Command105_ReadBurstModeConfigurationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
burst_mode_control_code: 0 (UBInt8)
command_number_expansion_flag: 0 (UBInt8)
device_variable_code_slot0: 0 (UBInt8)
device_variable_code_slot1: 0 (UBInt8)
device_variable_code_slot2: 0 (UBInt8)
device_variable_code_slot3: 0 (UBInt8)
device_variable_code_slot4: 0 (UBInt8)
device_variable_code_slot5: 0 (UBInt8)
device_variable_code_slot6: 0 (UBInt8)
device_variable_code_slot7: 0 (UBInt8)
burst_message: 0 (UBInt8)
maximum_burst_messages: 0 (UBInt8)
extended_command_number: 0 (UBInt16)
update_time: 0 (UBInt32)
maximum_update_time: 0 (UBInt32)
burst_trigger_mode_code: 0 (UBInt8)
device_variable_classification: 0 (UBInt8)
units_code: 0 (UBInt8)
trigger_value: 0 (BFloat)
check_byte: 112 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39
\x86\x80\x00\x00\x00\x00\x69\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70
Command 106¶
Command 106 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(106)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 106 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command106_FlushDelayedResponsesRequest():
check_byte: 104 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x6a\x00\x68
>>> # response
>>> hf = HartFrame(106)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 106 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command106_FlushDelayedResponsesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
check_byte: 110 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x6a\x02\x00\x00\x6e
Command 107¶
Command 107 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(107)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 107 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command107_WriteBurstDeviceVariablesRequest():
device_variable_code_slot0: 0 (UBInt8)
device_variable_code_slot1: 0 (UBInt8)
device_variable_code_slot2: 0 (UBInt8)
device_variable_code_slot3: 0 (UBInt8)
device_variable_code_slot4: 0 (UBInt8)
device_variable_code_slot5: 0 (UBInt8)
device_variable_code_slot6: 0 (UBInt8)
device_variable_code_slot7: 0 (UBInt8)
burst_message: 0 (UBInt8)
check_byte: 96 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x82\x80\x00\x00\x00\x00\x6b\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60
>>> # response
>>> hf = HartFrame(107)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 107 (UBInt8)
byte_count: 11 (UBInt8)
payload: Command107_WriteBurstDeviceVariablesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
device_variable_code_slot0: 0 (UBInt8)
device_variable_code_slot1: 0 (UBInt8)
device_variable_code_slot2: 0 (UBInt8)
device_variable_code_slot3: 0 (UBInt8)
device_variable_code_slot4: 0 (UBInt8)
device_variable_code_slot5: 0 (UBInt8)
device_variable_code_slot6: 0 (UBInt8)
device_variable_code_slot7: 0 (UBInt8)
burst_message: 0 (UBInt8)
check_byte: 102 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19
\x86\x80\x00\x00\x00\x00\x6b\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66
Command 108¶
Command 108 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(108)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 108 (UBInt8)
byte_count: 3 (UBInt8)
payload: Command108_WriteBurstModeCommandNumberRequest():
command: 0 (UBInt16)
burst_message: 0 (UBInt8)
check_byte: 109 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11
\x82\x80\x00\x00\x00\x00\x6c\x03\x00\x00\x00\x6d
>>> # response
>>> hf = HartFrame(108)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 108 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command108_WriteBurstModeCommandNumberResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
command: 0 (UBInt16)
burst_message: 0 (UBInt8)
check_byte: 111 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x86\x80\x00\x00\x00\x00\x6c\x05\x00\x00\x00\x00\x00\x6f
Command 109¶
Command 109 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(109)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 109 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command109_BurstModeControlRequest():
burst_mode_control_code: 0 (UBInt8)
burst_message: 0 (UBInt8)
check_byte: 109 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x6d\x02\x00\x00\x6d
>>> # response
>>> hf = HartFrame(109)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 109 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command109_BurstModeControlResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
burst_mode_control_code: 0 (UBInt8)
burst_message: 0 (UBInt8)
check_byte: 111 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x6d\x04\x00\x00\x00\x00\x6f
Command 110¶
Command 110 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(110)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 110 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command110_ReadAllDynamicVariablesRequest():
check_byte: 108 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8
\x82\x80\x00\x00\x00\x00\x6e\x00\x6c
>>> # response
>>> hf = HartFrame(110)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 110 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command110_ReadAllDynamicVariablesResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
dynamic_variables: Array():
[
]
check_byte: 106 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x86\x80\x00\x00\x00\x00\x6e\x02\x00\x00\x6a
Command 111¶
Command 111 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(111)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 111 (UBInt8)
byte_count: 5 (UBInt8)
payload: Command111_TransferServiceControlRequest():
port: 0 (UBInt8)
function_code: 0 (UBInt8)
maximum_segment_length: 0 (UBInt8)
starting_master_byte_counter: 0 (UBInt16)
check_byte: 104 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13
\x82\x80\x00\x00\x00\x00\x6f\x05\x00\x00\x00\x00\x00\x68
>>> # response
>>> hf = HartFrame(111)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 111 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command111_TransferServiceControlResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
port: 0 (UBInt8)
function_code: 0 (UBInt8)
maximum_segment_length: 0 (UBInt8)
starting_master_byte_counter: 0 (UBInt16)
starting_field_device_byte_counter: 0 (UBInt16)
check_byte: 96 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x86\x80\x00\x00\x00\x00\x6f\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60
Command 112¶
Command 112 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(112)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 112 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command112_BlockTransferRequest():
port: 0 (UBInt8)
function_code: 0 (UBInt8)
number_of_bytes_transferred: 0 (UBInt8)
master_byte_count: 0 (UBInt16)
slave_byte_count: 0 (UBInt16)
data: Array():
[
]
check_byte: 117 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15
\x82\x80\x00\x00\x00\x00\x70\x07\x00\x00\x00\x00\x00\x00\x00\x75
>>> # response
>>> hf = HartFrame(112)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 112 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command112_BlockTransferResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
port: 0 (UBInt8)
function_code: 0 (UBInt8)
number_of_bytes_transferred: 0 (UBInt8)
master_byte_count: 0 (UBInt16)
slave_byte_count: 0 (UBInt16)
data: Array():
[
]
check_byte: 127 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x86\x80\x00\x00\x00\x00\x70\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f
Command 113¶
Command 113 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(113)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 113 (UBInt8)
byte_count: 15 (UBInt8)
payload: Command113_CatchDeviceVariableRequest():
destination_device_variable: 0 (UBInt8)
capture_mode_code: 0 (UBInt8)
source_slave_expanded_device_type_code: 0 (UBInt16)
source_slave_device_id: BitStruct():
value: 0 (BitField(24))
command_number_expansion_flag: 0 (UBInt8)
source_slot_number: 0 (UBInt8)
shed_time: 0 (BFloat)
source_command_number: 0 (UBInt16)
check_byte: 124 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23
\x82\x80\x00\x00\x00\x00\x71\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c
>>> # response
>>> hf = HartFrame(113)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 113 (UBInt8)
byte_count: 17 (UBInt8)
payload: Command113_CatchDeviceVariableResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
destination_device_variable: 0 (UBInt8)
capture_mode_code: 0 (UBInt8)
source_slave_address: BitStruct():
value: 0 (BitField(40))
command_number_expansion_flag: 0 (UBInt8)
source_slot_number: 0 (UBInt8)
shed_time: 0 (BFloat)
source_command_number: 0 (UBInt16)
check_byte: 102 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25
\x86\x80\x00\x00\x00\x00\x71\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66
Command 114¶
Command 114 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(114)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 114 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command114_ReadCaughtDeviceVariableRequest():
destination_device_variable: 0 (UBInt8)
check_byte: 113 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x72\x01\x00\x71
>>> # response
>>> hf = HartFrame(114)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 114 (UBInt8)
byte_count: 17 (UBInt8)
payload: Command114_ReadCaughtDeviceVariableResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
destination_device_variable: 0 (UBInt8)
capture_mode_code: 0 (UBInt8)
source_slave_address: BitStruct():
value: 0 (BitField(40))
LSB_of_source_command_number: 0 (UBInt8)
source_slot_number: 0 (UBInt8)
shed_time: 0 (BFloat)
source_command_number: 0 (UBInt16)
check_byte: 101 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25
\x86\x80\x00\x00\x00\x00\x72\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65
Command 115¶
Command 115 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(115)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 115 (UBInt8)
byte_count: 1 (UBInt8)
payload: Command115_ReadEventNotificationSummaryRequest():
event_specification_number: 0 (UBInt8)
check_byte: 112 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9
\x82\x80\x00\x00\x00\x00\x73\x01\x00\x70
>>> # response
>>> hf = HartFrame(115)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 115 (UBInt8)
byte_count: 22 (UBInt8)
payload: Command115_ReadEventNotificationSummaryResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
event_specification_number: 0 (UBInt8)
number_of_events_supported: 0 (UBInt8)
event_status_notification_control: BitStruct():
event_status: 0 (Nibble)
notification_control_code: 0 (Nibble)
first_event_trigger_time: 0 (UBInt32)
event_notification_retry_time: 0 (UBInt32)
maximum_update_time: 0 (UBInt32)
event_debounce_interval: 0 (UBInt32)
device_status_mask: BitStruct():
value: 0 (BitField(8))
event_mask: Array():
[
]
check_byte: 99 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30
\x86\x80\x00\x00\x00\x00\x73\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63
Command 116¶
Command 116 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(116)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 116 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command116_WriteEventNotificationBitMaskRequest():
event_specification_number: 0 (UBInt8)
device_status_mask: BitStruct():
value: 0 (BitField(8))
event_mask: Array():
[
]
check_byte: 116 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x74\x02\x00\x00\x74
>>> # response
>>> hf = HartFrame(116)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 116 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command116_WriteEventNotificationBitMaskResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
event_specification_number: 0 (UBInt8)
device_status_mask: BitStruct():
value: 0 (BitField(8))
event_mask: Array():
[
]
check_byte: 118 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x74\x04\x00\x00\x00\x00\x76
Command 117¶
Command 117 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(117)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 117 (UBInt8)
byte_count: 13 (UBInt8)
payload: Command117_WriteEventNotificationTimingRequest():
event_specification_number: 0 (UBInt8)
event_notification_retry_time: 0 (UBInt32)
maximum_update_time: 0 (UBInt32)
event_debounce_interval: 0 (UBInt32)
check_byte: 122 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21
\x82\x80\x00\x00\x00\x00\x75\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a
>>> # response
>>> hf = HartFrame(117)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 117 (UBInt8)
byte_count: 15 (UBInt8)
payload: Command117_WriteEventNotificationTimingResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
event_specification_number: 0 (UBInt8)
event_notification_retry_time: 0 (UBInt32)
maximum_update_time: 0 (UBInt32)
event_debounce_interval: 0 (UBInt32)
check_byte: 124 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23
\x86\x80\x00\x00\x00\x00\x75\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c
Command 118¶
Command 118 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(118)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 118 (UBInt8)
byte_count: 2 (UBInt8)
payload: Command118_EventNotificationControlRequest():
event_specification_number: 0 (UBInt8)
event_notification_control_code: 0 (UBInt8)
check_byte: 118 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10
\x82\x80\x00\x00\x00\x00\x76\x02\x00\x00\x76
>>> # response
>>> hf = HartFrame(118)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 118 (UBInt8)
byte_count: 4 (UBInt8)
payload: Command118_EventNotificationControlResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
event_specification_number: 0 (UBInt8)
event_notification_control_code: 0 (UBInt8)
check_byte: 116 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12
\x86\x80\x00\x00\x00\x00\x76\x04\x00\x00\x00\x00\x74
Command 119¶
Command 119 example:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> import oser
>>> from htf.communication.hart import HartFrame
>>> # request
>>> hf = HartFrame(119)
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 119 (UBInt8)
byte_count: 8 (UBInt8)
payload: Command119_AcknowledgeEventNotificationRequest():
event_specification_number: 0 (UBInt8)
first_event_trigger_time: 0 (UBInt32)
configuration_change_counter: 0 (UBInt16)
device_status: BitStruct():
value: 0 (BitField(8))
command48_data: Array():
[
]
check_byte: 125 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16
\x82\x80\x00\x00\x00\x00\x77\x08\x00\x00\x00\x00\x00\x00\x00\x00\x7d
>>> # response
>>> hf = HartFrame(119)
>>> hf.delimiter.frame_type.set("ack")
>>> print(hf)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 119 (UBInt8)
byte_count: 10 (UBInt8)
payload: Command119_AcknowledgeEventNotificationResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
event_specification_number: 0 (UBInt8)
first_event_trigger_time: 0 (UBInt32)
configuration_change_counter: 0 (UBInt16)
device_status: BitStruct():
value: 0 (BitField(8))
command48_data: Array():
[
]
check_byte: 123 (CheckByte)
>>> encoded = hf.encode()
>>> printf(oser.to_hex(encoded)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18
\x86\x80\x00\x00\x00\x00\x77\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b
Device Specific Commands¶
To realize device specific commands HartFrame
must be subclassed and the methods
requests_generator()
and
responses_generator()
must be
overwritten.
Both methods are generators that yield tuples consisting of the command number and a device specific parser.
It is recommended to use oser.Lazy
to wrap the parser to speed up
the initialization of the HART frame.
In the following example the command 48 and 181 are implemented:
from __future__ import \
absolute_import, division, print_function, unicode_literals
from oser import \
ByteStruct, BitStruct, BitField, Switch, String, \
Enum, UBInt8, Lazy, BFloat, to_hex
from htf.communication.hart import HartFrame, ResponseCode, FieldDeviceStatus
class Command48_ReadAdditionalDeviceStatusRequest(ByteStruct):
def __init__(self):
super(Command48_ReadAdditionalDeviceStatusRequest, self).__init__()
self.device_specific_status = BitStruct()
self.device_specific_status.value = BitField(length=48)
self.extended_device_status = UBInt8()
self.device_operating_mode = UBInt8()
self.status0 = UBInt8()
self.status1 = UBInt8()
self.analog_channel_saturated = UBInt8()
self.status2 = UBInt8()
self.status3 = UBInt8()
self.analog_channel_fixed = UBInt8()
self.device_specific_status = BitStruct()
self.device_specific_status.value = BitField(length=88)
class Command48_ReadAdditionalDeviceStatusResponse(ByteStruct):
def __init__(self):
super(Command48_ReadAdditionalDeviceStatusResponse, self).__init__()
self.response_code = ResponseCode(
error_device_specific_command_error=6,
warning_update_in_progress=8,
error_access_restricted=16,
error_busy=32)
self.field_device_status = FieldDeviceStatus()
self.device_specific_status = BitStruct()
self.device_specific_status.value = BitField(length=48)
self.extended_device_status = UBInt8()
self.device_operating_mode = UBInt8()
self.status0 = UBInt8()
self.status1 = UBInt8()
self.analog_channel_saturated = UBInt8()
self.status2 = UBInt8()
self.status3 = UBInt8()
self.analog_channel_fixed = UBInt8()
self.device_specific_status = BitStruct()
self.device_specific_status.value = BitField(length=88)
class Command181_SetAnalogOutputRequest(ByteStruct):
def __init__(self):
super(Command181_SetAnalogOutputRequest, self).__init__()
self.temporary_analog_output = Enum(
prototype=UBInt8,
values={
"invalid": 0x07,
"beamblock_signal": 0x06,
"fixed_current": 0x05,
"current_corresponding_to_gas_concentration": 0x04,
"maintenance_signal": 0x03,
"error_signal": 0x02,
"warning_signal": 0x01,
"analog_normal": 0x00,
},
value="invalid",
strict=True)
self.gas_concentration = BFloat(.0)
self.fixed_current_mA = BFloat(.0)
class Command181_SetAnalogOutputResponse(ByteStruct):
def __init__(self):
super(Command181_SetAnalogOutputResponse, self).__init__()
self.response_code = ResponseCode()
self.field_device_status = FieldDeviceStatus()
self.temporary_analog_output = Enum(
prototype=UBInt8,
values={
"invalid": 0x07,
"beamblock_signal": 0x06,
"fixed_current": 0x05,
"current_corresponding_to_gas_concentration": 0x04,
"maintenance_signal": 0x03,
"error_signal": 0x02,
"warning_signal": 0x01,
"analog_normal": 0x00,
},
value="invalid",
strict=True)
self.gas_concentration = BFloat(.0)
self.fixed_current_mA = BFloat(.0)
class DeviceHartFrame(HartFrame):
def requests_generator(self):
# this is only needed in subclass hierarchies
for command, parser in super(DeviceHartFrame, self).requests_generator():
yield command, parser
# the following commands are device specific
yield 48, Lazy(Command48_ReadAdditionalDeviceStatusRequest)
yield 181, Lazy(Command181_SetAnalogOutputRequest)
def responses_generator(self):
# this is only needed in subclass hierarchies
for command, parser in super(DeviceHartFrame, self).responses_generator():
yield command, parser
# the following commands are device specific
yield 48, Lazy(Command48_ReadAdditionalDeviceStatusResponse)
yield 181, Lazy(Command181_SetAnalogOutputResponse)
These commands can be easily adapted for the customer’s needs.
In the following example the usage is demonstrated.
>>> # command 48
... hf = DeviceHartFrame(command=48)
>>>
>>> # request
... hf.delimiter.frame_type.set("stx")
>>>
>>> binary = hf.encode()
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 48 (UBInt8)
byte_count: 19 (UBInt8)
payload: Command48_ReadAdditionalDeviceStatusRequest():
device_specific_status: BitStruct():
value: 0 (BitField(88))
extended_device_status: 0 (UBInt8)
device_operating_mode: 0 (UBInt8)
status0: 0 (UBInt8)
status1: 0 (UBInt8)
analog_channel_saturated: 0 (UBInt8)
status2: 0 (UBInt8)
status3: 0 (UBInt8)
analog_channel_fixed: 0 (UBInt8)
check_byte: 33 (CheckByte)
>>> print(to_hex(binary))
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27
\x82\x80\x00\x00\x00\x00\x30\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21
>>>
>>> # response
... hf.delimiter.frame_type.set("ack")
>>> binary = hf.encode()
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 48 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command48_ReadAdditionalDeviceStatusResponse():
check_byte: 54 (CheckByte)
>>> print(to_hex(binary))
0| 1| 2| 3| 4| 5| 6| 7| 8
\x86\x80\x00\x00\x00\x00\x30\x00\x36
>>>
>>> # command 181
... hf = DeviceHartFrame(command=181)
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 181 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command181_SetAnalogOutputRequest():
temporary_analog_output: 'invalid' (UBInt8)
gas_concentration: 0.0 (BFloat)
fixed_current_mA: 0.0 (BFloat)
check_byte: 0 (CheckByte)
>>> # request
... hf.delimiter.frame_type.set("stx")
>>> hf.payload.temporary_analog_output.set(0x04)
>>> hf.payload.gas_concentration.set(15.0)
>>> hf.payload.fixed_current_mA.set(4.5)
>>>
>>> binary = hf.encode()
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 181 (UBInt8)
byte_count: 9 (UBInt8)
payload: Command181_SetAnalogOutputRequest():
temporary_analog_output: 'current_corresponding_to_gas_concentration' (UBInt8)
gas_concentration: 15.0 (BFloat)
fixed_current_mA: 4.5 (BFloat)
check_byte: 91 (CheckByte)
>>> print(to_hex(binary))
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17
\x82\x80\x00\x00\x00\x00\xb5\x09\x04\x41\x70\x00\x00\x40\x90\x00\x00\x5b
>>>
>>> # response
... hf.delimiter.frame_type.set("ack")
>>> binary = hf.encode()
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 181 (UBInt8)
byte_count: 11 (UBInt8)
payload: Command181_SetAnalogOutputResponse():
response_code: 'success' (UBInt8)
field_device_status: (FieldDeviceStatus)
temporary_analog_output: 'invalid' (UBInt8)
gas_concentration: 0.0 (BFloat)
fixed_current_mA: 0.0 (BFloat)
check_byte: 191 (CheckByte)
>>> print(to_hex(binary))
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19
\x86\x80\x00\x00\x00\x00\xb5\x0b\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\xbf
Protocol Factory¶
A protocol factory creates device specific HART frame abstractions respecting the device type or device address.
It is useful for the HART-shell and the HART-monitor.
A protocol factory needs two methods that return a device specific HART frame by device type or device address (in which the device type is included).
from __future__ import \
absolute_import, division, print_function, unicode_literals
from htf.communication.hart import HartFrame
from htf.communication.hart.universal_commands import \
Command48_ReadAdditionalDeviceStatusRequest,\
Command48_ReadAdditionalDeviceStatusResponse
from oser import Lazy
import logging
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.DEBUG)
class DeviceHartFrame(HartFrame):
def requests_generator(self):
# here come the device specific commands
yield 48, Lazy(Command48_ReadAdditionalDeviceStatusRequest)
def responses_generator(self):
# here come the device specific commands
yield 48, Lazy(Command48_ReadAdditionalDeviceStatusResponse)
_frame_parser_db = {
# the two LSBs in the device type cannot be used in the
# device address so they must be masked
0x1337 & 0x3fff: ["SpecificHartDevice", DeviceHartFrame],
# ...
}
def get_hart_frame_by_device_type(device_type):
"""
Create a HartFrame with device specific commands
for the given device type.
Args:
device_type (int): the device type to be used
Returns:
HartFrame: a HartFrame generator for device specific commands
"""
logger.info("Selecting frame by device type 0x%010x" % device_type)
# the two LSBs in the device type cannot be used in the
# device address so they must be masked
device_type = device_type & 0x3fff
try:
name, DeviceSpecificHartFrame = _frame_parser_db[device_type]
logger.info(
"Found specific frame parser for %s (0x%x)" %
(name, device_type))
def _generator(command=None, auto_length=True):
return DeviceSpecificHartFrame(command=command, auto_length=auto_length)
return _generator
except KeyError:
logger.info("No specific frame parser found for device id 0x%010x. "
"Using default HartFrame()." % device_type)
return HartFrame
def get_hart_frame_by_device_address(device_address):
"""
Create a HartFrame with device specific commands
for the given device address by extracting the
device type from the device address
Args:
device_address (int): the device address to be used
Returns:
HartFrame: a HartFrame generator for device specific commands
"""
device_type = device_address >> 24
return get_hart_frame_by_device_type(device_type)
An exemplary usage looks like:
>>> DeviceSpecificHartFrame = get_hart_frame_by_device_type(device_type=0x1337)
>>> hf = DeviceSpecificHartFrame(command=48)
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 48 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command48_ReadAdditionalDeviceStatusRequest():
device_specific_status: BitStruct():
value: 0 (BitField(88))
extended_device_status: 0 (UBInt8)
device_operating_mode: 0 (UBInt8)
status0: 0 (UBInt8)
status1: 0 (UBInt8)
analog_channel_saturated: 0 (UBInt8)
status2: 0 (UBInt8)
status3: 0 (UBInt8)
analog_channel_fixed: 0 (UBInt8)
check_byte: 0 (CheckByte)
>>> hf = DeviceSpecificHartFrame(command=181)
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 181 (UBInt8)
byte_count: 0 (UBInt8)
payload: b''
check_byte: 0 (CheckByte)
>>>
>>> DeviceSpecificHartFrame = get_hart_frame_by_device_address(device_address=0x1337000023)
INFO:__main__:Selecting frame by device type 0x0000001337
INFO:__main__:Found specific frame parser for SpecificHartDevice (0x1337)
>>> hf = DeviceSpecificHartFrame(command=48)
>>> print(hf)
DeviceHartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 48 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command48_ReadAdditionalDeviceStatusRequest():
device_specific_status: BitStruct():
value: 0 (BitField(88))
extended_device_status: 0 (UBInt8)
device_operating_mode: 0 (UBInt8)
status0: 0 (UBInt8)
status1: 0 (UBInt8)
analog_channel_saturated: 0 (UBInt8)
status2: 0 (UBInt8)
status3: 0 (UBInt8)
analog_channel_fixed: 0 (UBInt8)
check_byte: 0 (CheckByte)
HART-Shell¶
The HART-shell enables you to develop and debug a HART device interactively. It is intended to be used interactively but can also be used non-interactively. The HART-shell is also customizable.
-
class
htf.communication.hart.
HartShell
(comport=None, decoder_generator=None, protocol_factory=None, timeout=None, interactive=True, loglevel=2, argv=None)¶ A HART Shell that can be used interactively.
Parameters: - comport (str) – the comport to be used where the HART modem is connected to.
- decoder_generator=None (callable or None) – a callable that returns a HartFrame instance with or without device specific commands.
- protocol_factory=None (callable) – a protocol factory that returns a device specific HART frame parser with respect to the supplied device type.
- timeout=None (float or int) – the default timeout in seconds.
- interactive=True (bool) – if set to
True
the HART Shell becomes interactive. - loglevel=2 (int) – set loglevel for loggnig to
loglevel
. - argv=None (list of str or None) – used for testing, etc.
-
close
()¶ Close the HART application layer and close the HART interface supplied. Is called in __del__, too.
-
cmd
(command, inputs=None, edit_all=False, interactive=True, timeout=None)¶ Query a HART command.
Parameters: - command (int) – the HART command number.
- inputs=None (None or list of object) – the inputs to be set in order to be put into the HART request.
- edit_all=False (bool) – if set to
True
and the HART shell runs interactively all request fields are edited interactively. - interactive=True (bool) – if set to
True
the request is edited interactively. - timeout=None (float or int) – the timeout in seconds. If
None
is supplied the default timeout is used. If the default timeout is not set 1.0 is used.
-
find_device
(polling_addresses=None)¶ Find the first HART device by polling all addresses stated in
polling_addresses
and use the first device found.If no device is found an
AssertionError
is raised.Parameters: polling_addresses=[0] (list of int or int) – the polling addresses used to find a HART device. Returns: Unique HART address of the first device found in polling. Return type: int
-
last_preamble_count
()¶ Returns the number of preambles most recently received by the HartInterface.
Returns: number of preambles Return type: int
-
last_response
()¶ Get the last response.
The last received packet can also be access via
self.response
.Returns: the last received packet. Return type: object
-
list_device_commands
(commands=None)¶ List the implemented commands of a HART device. Helps to find undocumented commands.
Parameters: commands (list of int) – the list of commands to be probed. If set to None
0 .. 255
is used.Returns: the implemented commands. Return type: list of int
-
poll_devices
(polling_addresses=None)¶ Poll
polling_addresses
to find HART devices.Parameters: polling_addresses=[0] (list of int) – list of HART polling addresses Yields: int – HART device addresses
-
set_decoder_by_device_address
(device_address)¶ Select the frame decoder and encoder by the device address
Parameters: device_address (int) – the device address
-
set_decoder_generator
(decoder_generator=None)¶ Set the frame generator.
Parameters: decoder_generator=HartFrame (callable) – a parser for HART frames.
-
set_device_address
(device_address)¶ Set the current HART device address.
Parameters: device_address (int) – the HART device address to be used (<= 38 bits)
-
set_loglevel
(loglevel)¶ Set the loglevel.
Loglevel
0
meansquiet
.Loglevel
1
meansbinary
output. All packets are printed in a compact binary format.Loglevel
2
meansbinary+payload of interest
output. All packets are printed in a compact binary format. Additionally the interesting payload is printed.response_code
is left out if it issuccess
andfield_device_status
is left out in case of0
. Other payload is printed line by line.Loglevel
3
meansbinary+whole packet
output. All packets are printed in a compact binary format. Additionally the packets are fully printed.Parameters: loglevel (int) – Set loglevel to loglevel
.
-
set_master_address
(master_address)¶ Set the current simulated master address.
Parameters: master_address (str) – “primary_master” or “secondary_master”
-
set_number_of_preambles
(number_of_preambles)¶ Set the number of preambles for requests.
Parameters: number_of_preambles (int) – the number of preambles for requests.
-
set_protocol_factory
(protocol_factory=None)¶ Set the protocol factory.
Parameters: protocol_factory=None (callable) – a protocol factory that returns a device specific HART frame parser with respect to the supplied device type.
Interactive usage¶
htf
comes with a HART-shell command line utility called hart-shell
.
When run interactively all methods in htf.communication.hart.HartShell
are put into the local namespace so they can be run by entering the name.
Additionally macros are created for each possible command, eg. cmd0
,
cmd1
, ..
, cmd255
. These can be run by name, too.
The command line utility is based on IPython. IPython allows tab-completion.
To enter long commands enter the first characters and press TAB
and select
the command using the arrow keys.
To run the hart-shell
simply enter
$ hart-shell -c <comport>
Show help¶
$ hart-shell -h
usage: hart-shell [-h] -c COMPORT [-d Protocol database] [-t timeout]
[-v loglevel] [-V]
hart-shell - HILSTER Testing Framework (HILSTER GmbH, http://hilster.de)
optional arguments:
-h, --help show this help message and exit
-c COMPORT, --comport COMPORT
comport for HART communication
-d Protocol database, --database Protocol database
An import string to the protocol database where device
specific HART frames can be found. See docs for
details.
-t timeout, --timeout timeout
The default timeout for commands.
-v loglevel, --loglevel loglevel
The loglevel: 0: quiet, 1: binary, 2: binary+payload
of interest, 3: binary+debug
-V, --version Show version and exit
Find and select the first device¶
To find and select a device
htf.communication.hart.HartShell.find_device()
is used.
If a device or multiple devices are found the first device address is
selected and the address is used for all other commands entered.
Find and select the first device for polling address 0
:
In [1]: find_device()
Using first device with address 0x1337000023
Find and select the first device for polling addresses 0..9
:
In [2]: find_device(range(10))
Using first device with address 0x1337000023
Poll devices¶
To poll HART devices
htf.communication.hart.HartShell.poll_devices()
is used.
To poll polling address 0
enter:
In [1]: poll_devices()
Found 1 HART device.
0x1337000023
To poll polling addresses 0..9
enter:
In [2]: poll_devices(range(10))
Found 1 HART device.
0x1337000023
Set the timeout¶
The timeout for commands can be set using
htf.communication.hart.HartShell.set_timeout()
.
To set the timeout to 3.0
seconds enter:
In [1]: set_timeout(3.0)
Device selection¶
To select a device manually the device address can be set using
htf.communication.hart.HartShell.set_device_address()
.
To set the device address to 0x1337000024
enter:
In [1]: set_device_address(0x1337000024)
Running commands interactively¶
You can run commands interactively to debug, test and develop a HART-device.
The easiest way is to enter cmd
plus the command number to be run, eg.
cmd1
to run command 1.
By default the device address selected by
htf.communication.hart.HartShell.find_device()
or set by
htf.communication.hart.HartShell.set_device_address()
is used
automatically.
To select a device and run command 1 on it enter:
In [1]: find_device()
Using first device with address 0x1337000023
Out[1]: 82527125539
In [2]: cmd1()
Running Command 1
Request:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command1_ReadPrimaryVariableRequest():
check_byte: 0 (CheckByte)
Response:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 82527125539 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'buffer_overflow' (UBInt8)
field_device_status: non-primary_variable_out_of_limits (FieldDeviceStatus)
units: 123 (UBInt8)
primary_variable: 456.78900146484375 (BFloat)
check_byte: 193 (CheckByte)
Out[2]: <htf.communication.hart.protocol.HartFrame at 0x7fb4d4165080>
The timeout set by htf.communication.hart.HartShell.set_timeout()
is used if not specified for the specific comamnd.
To set the timeout add a timeout=3.0
agrument.
In [3]: cmd1(timeout=3.0)
Loglevel¶
The loglevel can be set via commandline using the -v
option or within the HART-Shell using
In [1]: set_loglevel(loglevel)
The values for loglevel
reach from 0
to 3
.
0
means quiet.
1
means binary short form.
2
means binary short form and payload of interest.
3
means binary short form and debug.
The following example lists all loglevel usages:
In [1]: find_device()
Using first device with address 0x52eb021ce5
Out[1]: 356130102501
In [2]: set_loglevel(0)
In [3]: cmd1()
Out[3]: <htf.communication.hart.protocol.HartFrame at 0x7419a90>
In [4]: set_loglevel(1)
In [5]: cmd1()
STX: 5FF 82 92EB021CE5 01
ACK: 5FF 86 92EB021CE5 00508B7FE00000 06
Out[5]: <htf.communication.hart.protocol.HartFrame at 0x71da278>
In [6]: set_loglevel(2)
In [7]: cmd1()
STX: 5FF 82 92EB021CE5 01
ACK: 5FF 86 92EB021CE5 00508B7FE00000 06
field_device_status: 80
units: 139
primary_variable: nan
Out[7]: <htf.communication.hart.protocol.HartFrame at 0x1f862e8>
In [8]: set_loglevel(3)
In [9]: cmd1()
STX: 5FF 82 92EB021CE5 01
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0x52eb021ce5 (SlaveAddress(38))
expansion_bytes: Array():
[
]
command: 1 (Command)
byte_count: 0 (UBInt8)
payload: Command1_ReadPrimaryVariableRequest():
check_byte: 1 (CheckByte)
ACK: 5FF 86 92EB021CE5 00508B7FE00000 06
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0x12eb021ce5 (SlaveAddress(38))
expansion_bytes: Array():
[
]
command: 1 (Command)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'success' (UBInt8)
field_device_status: configuration_changed; more_status_available (FieldDeviceStatus)
units: 139 (UBInt8)
primary_variable: nan (BFloat)
check_byte: 6 (CheckByte)
Out[9]: <htf.communication.hart.protocol.HartFrame at 0x6ed22b0>
The default loglevel is 2
.
Set the number of preambles¶
You can set the number of preambles for requests using
In [2]: set_number_of_preambles(3)
In [3]: cmd1()
STX: 3FF 82 92EB021CE5 01
ACK: 5FF 86 92EB021CE5 00508B7FE00000 06
field_device_status: 80
units: 139
primary_variable: 0.0
Out[3]: <htf.communication.hart.protocol.HartFrame at 0x7238ef0>
In [4]: set_number_of_preambles(5)
In [5]: cmd1()
STX: 5FF 82 92EB021CE5 01
ACK: 5FF 86 92EB021CE5 00508B7FE00000 06
field_device_status: 80
units: 139
primary_variable: nan
Out[5]: <htf.communication.hart.protocol.HartFrame at 0x6edab70>
Access last response¶
The last response can be accessed using self.response
.
In [1]: find_device()
Using first device with address 0x52eb021ce5
Out[1]: 356130102501
In [2]: cmd1()
STX: 5FF 82 92EB021CE5 01
ACK: 5FF 86 92EB021CE5 00508B7FE00000 06
field_device_status: 80
units: 139
primary_variable: nan
Out[2]: <htf.communication.hart.protocol.HartFrame at 0x7014240>
In [3]: print(self.response)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0x12eb021ce5 (SlaveAddress(38))
expansion_bytes: Array():
[
]
command: 1 (Command)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'success' (UBInt8)
field_device_status: configuration_changed; more_status_available (FieldDeviceStatus)
units: 139 (UBInt8)
primary_variable: 0.0 (BFloat)
check_byte: 6 (CheckByte)
List device commands¶
You can poll a list of device commands to see which are supported. This way it is possible to find undocumented commands.
If you do not specify a list of commands to be polled 0 .. 255
is used.
In [1]: find_device()
Using first device with address 0x52eb021ce5
Out[1]: 356130102501
In [2]: list_device_commands()
command 0 .. is supported
command 1 .. is supported
command 2 .. is supported
command 3 .. is supported
command 4 .. is supported
command 5 .. is supported
command 6 .. is not supported
command 7 .. is not supported
command 8 .. is not supported
command 9 .. is not supported
command 10 .. is supported
command 11 .. is not supported
command 12 .. is supported
command 13 .. is not supported
command 14 .. is supported
command 15 .. is not supported
[...]
command 248 .. is supported
command 249 .. is supported
command 250 .. is supported
command 251 .. is supported
command 252 .. is supported
command 253 .. is supported
command 254 .. is supported
command 255 .. is supported
Out[2]:
[0,
1,
2,
3,
4,
5,
10,
12,
14,
[...]
248,
249,
250,
251,
252,
253,
254,
255]
You can specify the commands to poll by adding commands=<iterable>
:
In [2]: list_device_commands(commands=[1, 2, 3])
command 1 .. is supported
command 2 .. is supported
command 3 .. is supported
Out[2]: [1, 2, 3]
Master address¶
To set the master address
htf.communication.hart.HartShell.set_master_address()
is used.
To set the master address to secondary_master enter:
In [1]: set_master_address('secondary_master')
Exit¶
To exit hart-shell
enter exit()
, exit
or press CTRL+d
followed
by y
and Return
.
Method documentation¶
You can easily see the documentation for a method by adding a ?
at the
end of the command.
In [1]: set_master_address?
Signature: set_master_address(master_address)
Docstring:
Set the current simulated master address.
Args:
master_address (str): "primary_master" or "secondary_master"
Editing command payload interactively¶
By default a commands payload can be changed interactively. If the payload is empty there is nothing to be changed and the command is sent immediately.
For example the command 6 (set polling address) has a changeable payload.
To change the polling address to 1
enter:
In [1]: find_device()
Using first device with address 0x1337000023
Out[1]: 82527125539
In [2]: cmd6()
Running Command 6
Enter value for HartFrame.payload.polling_address (UBInt8) [0]> 1
Enter value for HartFrame.payload.loop_current_mode (UBInt8) [0]>
Request:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 6 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command6_WritePollingAddressRequest():
polling_address: 1 (UBInt8)
loop_current_mode: 0 (UBInt8)
check_byte: 0 (CheckByte)
If you do not want to change a value simply press Return
. The value
in the [
]
is the current value that is not changed then.
Editing commands interactively¶
If you want to edit the whole request frame add a edit_all=True
argument.
In this case you can also change the command number, etc. on the fly.
In [1]: find_device()
Using first device with address 0x1337000023
Out[1]: 82527125539
In [2]: cmd1(edit_all=True)
Running Command 1
Enter value for HartFrame().delimiter.address_type (Enum of Flag) ['unique']>
Enter value for HartFrame().delimiter.number_of_expansion_bytes (BitField) [0]>
Enter value for HartFrame().delimiter.physical_layer_type (Enum of BitField) ['asynchronous']>
Enter value for HartFrame().delimiter.frame_type (Enum of BitField) ['stx']>
Enter value for HartFrame().address.master_address (Enum of Flag) ['primary_master']>
Enter value for HartFrame().address.burst_mode (Flag) [0]>
Enter value for HartFrame().command (UBInt8) [1]>
Enter value for HartFrame().byte_count (UBInt8) [0]>
Enter value for HartFrame().check_byte (CheckByte) [0]>
Request:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command1_ReadPrimaryVariableRequest():
check_byte: 0 (CheckByte)
Response:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 82527125539 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'buffer_overflow' (UBInt8)
field_device_status: non-primary_variable_out_of_limits (FieldDeviceStatus)
units: 123 (UBInt8)
primary_variable: 456.78900146484375 (BFloat)
check_byte: 193 (CheckByte)
Out[2]: <htf.communication.hart.protocol.HartFrame at 0x7fead57fabe0>
Passing contents to a command¶
The contents for interactively editable payload or frame contents
can also be passed using the inputs=[..]
argument.
To set the polling address to 2
non-interactively enter:
In [1]: find_device()
Using first device with address 0x1337000023
Out[1]: 82527125539
In [2]: cmd6(inputs=[2, 0])
Running Command 6
Request:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 6 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command6_WritePollingAddressRequest():
polling_address: 2 (UBInt8)
loop_current_mode: 0 (UBInt8)
check_byte: 0 (CheckByte)
Enabling autocall¶
To enable the autocall-feature enter:
In [1]: %autocall 2
Automatic calling is: Full
Now you do not need to add brackets to the commands to be called:
In [2]: find_device
------> find_device()
Using first device with address 0x1337000023
Out[2]: 82527125539
In [3]: cmd1
------> cmd1()
Running Command 1
Request:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command1_ReadPrimaryVariableRequest():
check_byte: 0 (CheckByte)
Response:
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 82527125539 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'buffer_overflow' (UBInt8)
field_device_status: non-primary_variable_out_of_limits (FieldDeviceStatus)
units: 123 (UBInt8)
primary_variable: 456.78900146484375 (BFloat)
check_byte: 193 (CheckByte)
Out[3]: <htf.communication.hart.protocol.HartFrame at 0x7f39eef2c3c8>
Setting the protocol factory¶
To use the protocol factory created for your device enter:
hart-shell -c /dev/ttyUSB0 -d protocol_factory.get_hart_frame_by_device_type
hart-shell
needs a protocol factory that created a HART-frame by device
type.
In the example protocol_factory
is an importable python file and
get_hart_frame_by_device_type
is a method within it.
Scripting the HART-Shell¶
You can script the HART-Shell by putting your commands into a text file for easy reuse.
$ cat >hart_commands.txt <<EOL
find_device()
cmd1()
EOL
$ hart-shell -c /dev/ttyUSB0 < hart_commands.txt
You can even use the autocall-feature.
HART-Monitor¶
The HartMonitor
enables you to debug HART communications. It can be run within
a python script or via command line.
The HartMonitor
support two types
of decoders. One is used in the underlying
HartApplicationLayer
to decode
frames in the first decoding phase. This is called the decoder_generator
.
To be able to monitor multiple different devices with different device
specific commands it is possible to do a second step decoding with the
protocol_factory
.
This is a factory method that returns a device specific HART-frame by device address.
-
class
htf.communication.hart.monitor.
HartMonitor
(comport=None, decoder_generator=None, protocol_factory=None, interactive=False, argv=None)¶ A HART Monitor that can be used interactively.
Parameters: - comport (str) – the comport to be used where the HART modem is connected to.
- decoder_generator=None (callable or None) – a callable that returns
a HartFrame instance with or without device specific commands that
is used to decode all frames (if
protocol_factory
isNone
). - protocol_factory=None (callable) – a protocol factory that returns
a device specific HART frame parser with respect to the
supplied device address. For every received frame the frame is
decoded using the
decoder_generator
that may beNone
and after that a device specific decoder is created respecting the device address. - interactive=True (bool) – if set to
True
the HART Monitor becomes interactive - argv=None (list of str or None) – used for testing, etc.
-
handle_exception
(frame, exc)¶ The exception handler that prints the formatted output. This method can be overwritten.
This overwritten method may or may not call
raise
at the end to raise the exception again.Parameters: - frame (HartFrame) – the HART frame to be monitored.
- exc (BaseException) – the exception that can be formatted.
-
handle_frame
(frame)¶ The frame handler that prints the formatted output. This method can be overwritten.
Parameters: frame (HartFrame) – the HART frame to be monitored.
-
run
(frame_count=0)¶ Run the monitor and display received HART frames.
Parameters: frame_count (int) – The number of frames to be received. 0
means forever.
-
set_decoder_generator
(decoder_generator=None)¶ Set the decoder generator. If
decoder_generator
isNone
HartFrame
is used.Parameters: decoder_generator=HartFrame (callable) – a parser for HART frames.
-
set_protocol_factory
(protocol_factory)¶ Set the protocol factory.
Parameters: protocol_factory=None (callable) – a protocol factory that returns a device specific HART frame parser with respect to the supplied device address.
Command line usage¶
htf
comes with a HART-Monitor command line utility called hart-monitor
.
To start it enter
$ hart-monitor -c <comport>
Show help¶
$ hart-monitor -h
usage: hart-monitor [-h] -c COMPORT [-d Protocol database] [-V]
hart-monitor - HILSTER Testing Framework (HILSTER GmbH, http://hilster.de)
optional arguments:
-h, --help show this help message and exit
-c COMPORT, --comport COMPORT
comport for HART communication
-d Protocol database, --database Protocol database
An import string to the protocol database where device
specific HART frames can be found. See docs for
details.
-V, --version Show version and exit
Setting the protocol factory¶
To use the protocol factory created for your device enter:
hart-monitor -c /dev/ttyUSB0 -d protocol_factory.get_hart_frame_by_device_type
hart-monitor
needs a protocol factory that created a HART-frame by
device type.
In the example protocol_factory
is an importable python file and
get_hart_frame_by_device_type
is a method within it.
Customizing the HART-Monitor¶
If a different output format is needed etc. the class
HartMonitor
can be subclassed
and handle_frame()
can be
overwritten.
In the following example every received frame is serializied to be printed on a single line with a timestamp.
from __future__ import \
absolute_import, division, print_function, unicode_literals
from htf.communication.hart.monitor import HartMonitor
import datetime
class MyHartMonitor(HartMonitor):
def handle_frame(self, frame):
frame_type = frame.delimiter.frame_type.get()
direction = " ->"
if frame_type == "ack":
direction = "<- "
command = frame.command.get()
byte_count = frame.byte_count.get()
address = frame.address.address.get()
payload = str(frame.payload).replace("\n", "").replace(" ", ", ")
print(str(datetime.datetime.utcnow()) +
": " + "%s %3i %s 0x%010x %3i (%s)" %
(frame_type.upper(),
command,
direction,
address,
byte_count,
payload))
if __name__ == "__main__":
hm = MyHartMonitor(comport="COM46")
hm.run(n=0)
HART Device Communication¶
The
HartDeviceCommunication
simplifies the communication with a HART device.
It can be either used as an instance or as a context block and helps to find a device and to query commands on that device.
-
class
htf.communication.hart.device_communication.
HartDeviceCommunication
(comport, polling_addresses=[0], device_address=None, decoder_generator=None)¶ A communication to a HART device usable as a context block.
Parameters: - comport (str) – the comport to be used where the HART modem is connected to.
- polling_addresses=[0] (list of int or int) – the polling addresses used to find a HART device.
- device_address=None (int or None) – the initial HART device address. If set to an interger no device must be looked up.
- decoder_generator=None (callable or None) – a callable that returns a HartFrame instance with or without device specific commands.
-
close
()¶ Close the HART application layer and close the HART interface supplied. Is called in __del__, too.
-
find_device
(polling_addresses=None)¶ Find the first HART device by polling all addresses stated in
polling_addresses
and use the first device found.If no device is found an
AssertionError
is raised.Parameters: polling_addresses=[0] (list of int or int) – the polling addresses used to find a HART device. Returns: Unique HART address of the first device found in polling. Return type: int
-
query
(request, number_of_preambles=5, preamble=b'\xff', timeout=1.0)¶ Query a HART command. The HART frame is encoded automatically.
Parameters: Returns: if no frame was recieved
None
is returned.Return type:
In the following examples Command 1
is queried on the first found device.
Usage with an instance:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> from htf.communication.hart import HartDeviceCommunication
>>> from htf.communication.hart.protocol import HartFrame
>>>
>>>
>>> dc = HartDeviceCommunication(comport="/dev/ttyUSB1")
>>> dc.find_device()
82527125539
>>> cmd1_request = HartFrame(command=1)
>>> cmd1_response = dc.query(cmd1_request)
>>> print(cmd1_response)
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 82527125539 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'buffer_overflow' (UBInt8)
field_device_status: non-primary_variable_out_of_limits (FieldDeviceStatus)
units: 123 (UBInt8)
primary_variable: 456.78900146484375 (BFloat)
check_byte: 193 (CheckByte)
>>> dc.close()
If a device_address
is supplied
find_device()
needs not to be called.
When used as a context block and no device_address
is supplied
find_device()
is called automatically.
When the context block is left the underlying HART interface and Application
Layer are closed automatically.
Example usage with a context block:
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> from htf.communication.hart import HartDeviceCommunication
>>> from htf.communication.hart.protocol import HartFrame
>>>
>>>
>>> with HartDeviceCommunication(comport="/dev/ttyUSB1") as dc:
... dc.find_device()
... cmd1_request = HartFrame(command=1)
... cmd1_response = dc.query(cmd1_request)
... print(cmd1_response)
...
82527125539
HartFrame():
delimiter: Delimiter():
address_type: 'unique' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'ack' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 82527125539 (BitField(38))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 7 (UBInt8)
payload: Command1_ReadPrimaryVariableResponse():
response_code: 'buffer_overflow' (UBInt8)
field_device_status: non-primary_variable_out_of_limits (FieldDeviceStatus)
units: 123 (UBInt8)
primary_variable: 456.78900146484375 (BFloat)
check_byte: 193 (CheckByte)
HART Fuzzing¶
The HART Testing Framework lets you easily run fuzzing tests on your HART device since it is based on OSER. You should have read the OSER documentation.
In the first example all HART frames shall have a valid checkbyte at the end.
All commands from 0
to 255
shall be sent to the target. The payload is
the default.
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> from htf.communication.hart import HartFrame
>>> import oser
>>>
>>> h = HartFrame(0)
>>>
>>> h.command.set_fuzzing_values(range(256))
>>>
>>> for frame in h.fuzzing_iterator():
... encoded = frame.encode() # update checkbyte
... print(frame)
... print(oser.to_hex(encoded))
...
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command0_ReadUniqueIdentifierRequest():
check_byte: 130 (CheckByte)
0| 1| 2| 3| 4
\x02\x80\x00\x00\x82
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 1 (UBInt8)
byte_count: 0 (UBInt8)
payload: Command1_ReadPrimaryVariableRequest():
check_byte: 131 (CheckByte)
# [%< %< %< %< %< %< %< %< %< %<]
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23
\x02\x80\xfd\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 254 (UBInt8)
byte_count: 19 (UBInt8)
payload: b''
check_byte: 111 (CheckByte)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23
\x02\x80\xfe\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 255 (UBInt8)
byte_count: 19 (UBInt8)
payload: b''
check_byte: 110 (CheckByte)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23
\x02\x80\xff\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e
In the second example the whole payload is random with a random length. All frames have a valid length field and a valid checkbyte.
>>> from __future__ import \
... absolute_import, division, print_function, unicode_literals
>>>
>>> from htf.communication.hart import HartFrame
>>> import oser
>>> import string
>>>
>>> h = HartFrame(0)
>>>
>>> _random_length_iterator = oser.RandomIntegerFuzzingValue(a=0, b=40, count=1)
>>>
>>> h.payload = oser.String(length=lambda self: next(_random_length_iterator()))
>>> h.payload.set_fuzzing_values(
... oser.RandomBytesFuzzingValue(length=40, count=5)
... )
>>>
>>> for frame in h.fuzzing_iterator():
... encoded = frame.encode() # update checkbyte
... print(frame)
... print(oser.to_hex(encoded))
...
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 28 (UBInt8)
payload: b'\x8c\xdd\x0b]\x0cd\xf9\xde\x1a1fo\xea{@n\x82\x94dG \xf3\x9e\xbb`\x06\x83`\xe5L\xa7\xdb?q*?\xbeW\x08\x8c'
check_byte: 150 (CheckByte)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38
\x02\x80\x00\x1c\x8c\xdd\x0b\x5d\x0c\x64\xf9\xde\x1a\x31\x66\x6f\xea\x7b\x40\x6e\x82\x94\x64\x47\x20\xf3\x9e\xbb\x60\x06\x83\x60\xe5\x4c\xa7\xdb\x3f\x71\x96
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 34 (UBInt8)
payload: b'\xc4OHo\x17\xcb\xaf\xf5\x9b\xd0[N\x88n\x9b\x013\xa4z\xf2\\\x15\xa8\xcb\xd9;2\x15\x10H\x7fC\xf3\xbd~\xf2&>\xab$'
check_byte: 235 (CheckByte)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25
\x02\x80\x00\x22\xc4\x4f\x48\x6f\x17\xcb\xaf\xf5\x9b\xd0\x5b\x4e\x88\x6e\x9b\x01\x33\xa4\x7a\xf2\x5c\xeb
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 24 (UBInt8)
payload: b'w]w_\xeb\x1b\x9f\xad\t\xcd\x9ei\xf7te\x17\x0c\x96\x9e\xe0/\x9f\x1cR\xd7\xeb\x87\x9f\xfc\x1aC^q\xed/\x085\xfc\xaf6'
check_byte: 182 (CheckByte)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40| 41| 42| 43| 44
\x02\x80\x00\x18\x77\x5d\x77\x5f\xeb\x1b\x9f\xad\x09\xcd\x9e\x69\xf7\x74\x65\x17\x0c\x96\x9e\xe0\x2f\x9f\x1c\x52\xd7\xeb\x87\x9f\xfc\x1a\x43\x5e\x71\xed\x2f\x08\x35\xfc\xaf\x36\xb6
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 25 (UBInt8)
payload: b'\x9e\x8dR\xebO\xb8\xa3\xe8\x0b|c\x02,>GpFD4\xdc\xed\xe9,\xa6\xbd\x1f\xa2;`\xd3\xb5\x83Nv\xe7\x8a\xcc\xd7\xbeW'
check_byte: 225 (CheckByte)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32
\x02\x80\x00\x19\x9e\x8d\x52\xeb\x4f\xb8\xa3\xe8\x0b\x7c\x63\x02\x2c\x3e\x47\x70\x46\x44\x34\xdc\xed\xe9\x2c\xa6\xbd\x1f\xa2\x3b\xe1
HartFrame():
delimiter: Delimiter():
address_type: 'polling' (Flag)
number_of_expansion_bytes: 0 (BitField(2))
physical_layer_type: 'asynchronous' (BitField(2))
frame_type: 'stx' (BitField(3))
address: Address():
master_address: 'primary_master' (Flag)
burst_mode: 0 (Flag)
address: 0 (BitField(6))
expansion_bytes: Array():
[
]
command: 0 (UBInt8)
byte_count: 32 (UBInt8)
payload: b"\x1c`]\xbain'\x8dq\xcb\x0fw\xa3\x9b\x89\xb8T\xe4&\x08\x90{\xfa\x9f\x08\xb2\xbe\xd5\xec\x12\xe7\xf2b&\x943Yc\xd0I"
check_byte: 165 (CheckByte)
0| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39
\x02\x80\x00\x20\x1c\x60\x5d\xba\x69\x6e\x27\x8d\x71\xcb\x0f\x77\xa3\x9b\x89\xb8\x54\xe4\x26\x08\x90\x7b\xfa\x9f\x08\xb2\xbe\xd5\xec\x12\xe7\xf2\x62\x26\x94\xa5
HART Slave Simulator¶
The HartSlaveSimulator
allows simulation of HART slaves by sub-classing the HartSlaveSimulator
.
-
class
htf.communication.hart.slave_simulator.
HartSlaveSimulator
(comport, decoder_generator, polling_address=0, device_type=0, device_id=0)¶ -
close
()¶ Closes the HART Application Layer of the simulator.
-
handle_command0
(frame)¶ Handler for command 0 HART requests. Checks if the polling address in the frame matches the one set in the simulator.
Parameters: frame (HartFrame) – the command 0 HART request Returns: the response containing device type, device id and protocol revision Return type: HartFrame
-
handle_default
(frame)¶ Default handler for HART requests that don’t have a specialized handler.
Parameters: frame (HartFrame) – the HART frame to handle
-
handle_exception
(exc)¶ The exception handler that prints the raised exception.
Parameters: exc (BaseException) – the exception that was raised.
-
handle_frame
(frame)¶ Checks that the device address matches and whether responses to the HART command are disabled. Calls possible frame callbacks and sends a HART response frame if there is one.
Parameters: frame (HartFrame) – the HART frame to handle
-
register_frame_callback
(callback)¶ Registers a callback for every HART request and response that is received or send out. Callbacks are called with two arguments: a timestamp and the HART frame.
Parameters: callback (callable) – callback for HART frames
-
run
(frame_count=0)¶ Run the HART device simulator
Parameters: frame_count (int) – The number of frames to handle. 0
means forever.
-
run_while
(condition)¶ Simulate while the condition is
True
.Parameters: condition (bool or callable) – the condition for the run.
-
set_response_enabled
(command, enabled=True)¶ Enables/disables responses to a given HART command number. Responses to all commands are enabled by default.
Parameters:
-
unregister_frame_callback
(callback)¶ Unregisters a previously registered callback.
Parameters: callback (callable) – callback for HART frames
-
If you’d like to add other handlers for different commands simply add
a handler method that fits the name convention handle_command<cmd>
where <cmd>>
is the desired command number.
from htf.communication.hart.slave_simulator import HartSlaveSimulator
from htf.communication.hart import HartFrame, ResponseCode, FieldDeviceStatus
import oser
# Command abstractions
class Command123_ReadValueRequest(oser.ByteStruct):
def __init__(self):
super(Command123_ReadValue, self).__init__()
self.double_value = oser.Flag(False)
class Command123_ReadValueResponse(oser.ByteStruct):
def __init__(self):
super(Command123_ReadValue, self).__init__()
self.response_code = ResponseCode()
self.field_device_status = FieldDeviceStatus()
self.value = oser.UBInt8()
# Decoder generator extending the default HART frame implementation
class MyHartDeviceFrame(HartFrame):
def requests_generator(self):
for command, parser in super(MyHartDeviceFrame, self).requests_generator():
yield command, parser
yield 123, oser.Lazy(Command123_ReadValueRequest)
def responses_generator(self):
for command, parser in super(MyHartDeviceFrame, self).responses_generator():
yield command, parser
yield 123, oser.Lazy(Command123_ReadValueResponse)
# Slave simulator with the extended HART frame (MyHartDeviceFrame)
class MyHartDevice(HartSlaveSimulator):
# Initialization of the device attributes
def __init__(self, comport):
super(MyHartDevice, self).__init__(comport, decoder_generator=MyHartDeviceFrame,
polling_address=0, device_type=0x1337,
device_id=0x23)
self.value = 321
# Implementation of the response behavior
def handle_command123(self, request):
response = self._create_response(request)
if request.payload.double_value.get():
response.payload.value.set(self.value * 2)
else:
response.payload.value.set(self.value)
return response
if __name__ == "__main__":
sim = MyHartDevice("COM1")
sim.run(10)