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:
  • comport (str) – the comport to be used where the HART modem is connected to. Must support RS485 mode.
  • timeout=.3 (float) – the time out for a single byte. Timeouts in read() are multiple of this timeout.
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:
  • request (bytes) – the hart frame to be sent.
  • number_of_preambles=5 (int) – the number of preambles.
  • preamble='\xff' (bytes) – number_of_preambles times preamble is sent before the frame content is sent.
  • timeout=1.0 (float or int) – the timeout in seconds.
Returns:

if no frame was recieved None is returned else

a HART frame is returned.

Return type:

bytes or None

read(timeout=1.0)

Read a frame.

Parameters:timeout=1.0 (float or int) – the timeout in seconds.
Returns:
if no frame was recieved None is returned else
a HART frame is returned.
Return type:bytes or None
write(data, number_of_preambles=5, preamble=b'\xff')

Write a HART frame.

Parameters:
  • data (bytes) – the bytes to be sent.
  • number_of_preambles=5 (int) – the number of preambles.
  • preamble='\xff' (bytes) – number_of_preambles times preamble is sent before the frame content is sent.

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 calling encode.
  • auto_checkbyte=True (bool) – if set to True the checkbyte of the HART frame is calculated automatically when calling encode.
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:
  • data (bytes) – the data buffer that is decoded.
  • full_data (bytes) – the binary data string until the part to be decoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the number of bytes that were decoded.

Return type:

int

encode(full_data=b'', context_data=b'')

Return the encoded binary string. byte_count is set automatically if auto_length is supplied.

Parameters:
  • full_data (bytes) – the binary data string until the part to be encoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
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 to False 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 a KeyError 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 a KeyError 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.
size()

Return the size in bytes.

Returns:the length of the byte type in bytes.
Return type:int
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:
  • request (HartFrame) – the hart frame to be sent.
  • number_of_preambles=5 (int) – the number of preambles.
  • preamble='ÿ' (bytes) – number_of_preambles times preamble is sent before the frame content is sent.
  • timeout=1.0 (float or int) – the timeout in seconds.
Returns:

if no frame was recieved None is returned.

Return type:

HartFrame or None

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:
  • frame (HartFrame) – the hart frame to be sent.
  • number_of_preambles=5 (int) – the number of preambles.
  • preamble='ÿ' (bytes) – number_of_preambles times preamble is sent before the frame content is sent.

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:
  • data (bytes) – the data buffer that is decoded.
  • full_data (bytes) – the binary data string until the part to be decoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the number of bytes that were decoded.

Return type:

int

encode(full_data=b'', context_data=b'')

Return the encoded binary string.

Parameters:
  • full_data (bytes) – the binary data string until the part to be encoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the encoded binary string.

Return type:

bytes

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 with padding. If set to a callable (lambda or function) the result is a fixed or variable length string padded with padding.
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() or datetime.datetime() between 1900-01-01 and 2155-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:
  • data (bytes) – the data buffer that is decoded.
  • full_data (bytes) – the binary data string until the part to be decoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the number of bytes that were decoded.

Return type:

int

encode(full_data=b'', context_data=b'')

Return the encoded binary string.

Parameters:
  • full_data (bytes) – the binary data string until the part to be encoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the encoded binary string.

Return type:

bytes

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 with padding. If set to a callable (lambda or function) the result is a fixed or variable length string padded with padding.
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() or datetime.datetime() between 00:00:00 and 23: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:
  • data (bytes) – the data buffer that is decoded.
  • full_data (bytes) – the binary data string until the part to be decoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the number of bytes that were decoded.

Return type:

int

encode(full_data=b'', context_data=b'')

Return the encoded binary string.

Parameters:
  • full_data (bytes) – the binary data string until the part to be encoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
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:
  • data (bytes) – the data buffer that is decoded.
  • full_data (bytes) – the binary data string until the part to be decoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the number of bytes that were decoded.

Return type:

int

encode(full_data=b'', context_data=b'')

Return the encoded binary string.

Parameters:
  • full_data (bytes) – the binary data string until the part to be encoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the encoded binary string.

Return type:

bytes

get()

Return the value.

Returns:the value
get_value()

Return the raw value.

Returns:the raw value.
Return type:object
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 bits or bytes, depending on the prototype.

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:
  • data (bytes) – the data buffer that is decoded.
  • full_data (bytes) – the binary data string until the part to be decoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the number of bytes that were decoded.

Return type:

int

encode(full_data=b'', context_data=b'')

Return the encoded binary string.

Parameters:
  • full_data (bytes) – the binary data string until the part to be encoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
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:
  • data (bytes) – the data buffer that is decoded.
  • full_data (bytes) – the binary data string until the part to be decoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
Returns:

the number of bytes that were decoded.

Return type:

int

encode(full_data=b'', context_data=b'')

Return the encoded binary string.

Parameters:
  • full_data (bytes) – the binary data string until the part to be encoded. The user normally does not need to supply this.
  • context_data (bytes) – the binary data of the current context. The user normally does not need to supply this.
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 to False 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

size()

Return the size in bytes.

Returns:the length of the byte type in bytes.
Return type:int
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 means quiet.

Loglevel 1 means binary output. All packets are printed in a compact binary format.

Loglevel 2 means binary+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 is success and field_device_status is left out in case of 0. Other payload is printed line by line.

Loglevel 3 means binary+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.
set_timeout(timeout)

Set the default timeout.

Parameters:timeout (float or int) – the default timeout in seconds

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 is None).
  • 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 be None 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 is None 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:
  • request (HartFrame) – the hart frame to be sent.
  • number_of_preambles=5 (int) – the number of preambles.
  • preamble='ÿ' (bytes) – number_of_preambles times preamble is sent before the frame content is sent.
  • 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_device_address(device_address)

Set the current HART device address.

Parameters:device_address (int) – the HART device address to be used (<= 38 bits)

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:
  • command (int or str) – HART command number or “any”
  • enabled=True (bool) – enabled state
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)