HART — The HART Testing Framework¶

The HART Testing Framework enables 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 read 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. They do support this feature and are known to work.

Real COM ports 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.

from_dict(data)¶

Fill self with data.

Parameters: data (dict) – data to be used to fill the calling instance.

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

to_dict()¶: Return self as a dict()

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

Parameters

length=None – states the string length. Can be a callable (e.g. lambda) or a scalar. 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. The length must be a multiple of three.
value="" – the initial string value.
padding="" – that padding pattern used for filling the encoded data if value is shorter than length.

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.

Parameters: stop_at=None (object) – stop introspection at stop_at.

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.

Parameters: stop_at=None (object) – stop introspection at stop_at.

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.

Parameters: stop_at=None (object) – stop introspection at stop_at.

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.

Parameters: stop_at=None (object) – stop introspection at stop_at.

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, format=None)¶

HART Field Device Status data type.

Parameters

value – the initial value.
format=None (string) – Use “hex” to format values to hexadecimal. Use “bin” to format values to binary.

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.

Parameters: stop_at=None (object) – stop introspection at stop_at.

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.

from_dict(data)¶

Fill self with data.

Parameters: data (dict) – data to be used to fill the calling instance.

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

to_dict()¶: Return self as a dict()

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: False (Flag)
            address: 0x0 (PollingAddress(6))
        expansion_bytes: Array():
        [
        ]
        command: 0 (Command)
        byte_count: 0 (UBInt8)
        payload: Command0_ReadUniqueIdentifierRequest():
        check_byte: 130 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (PollingAddress(6))
    expansion_bytes: Array():
    [
    ]
    command: 0 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 1 (Command)
        byte_count: 0 (UBInt8)
        payload: Command1_ReadPrimaryVariableRequest():
        check_byte: 3 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 1 (Command)
    byte_count: 7 (UBInt8)
    payload: Command1_ReadPrimaryVariableResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        units: 0 (UBInt8)
        primary_variable: 0.0 (BFloat)
    check_byte: 0 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 2 (Command)
        byte_count: 0 (UBInt8)
        payload: Command2_ReadLoopCurrentAndPercentageOfRangeRequest():
        check_byte: 0 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 2 (Command)
    byte_count: 10 (UBInt8)
    payload: Command2_ReadLoopCurrentAndPercentageOfRangeResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        primary_variable_loop_current: 0.0 (BFloat)
        primary_variable_percentage_of_range: 0.0 (BFloat)
    check_byte: 14 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 3 (Command)
        byte_count: 0 (UBInt8)
        payload: Command3_ReadDynamicVariablesAndLoopCurrentRequest():
        check_byte: 1 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 3 (Command)
    byte_count: 6 (UBInt8)
    payload: Command3_ReadDynamicVariablesAndLoopCurrentResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        primary_variable_loop_current: 0.0 (BFloat)
        units_and_variables: Array():
        [
        ]
    check_byte: 3 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 6 (Command)
        byte_count: 1 (UBInt8)
        payload: Command6_WritePollingAddressRequest():
            polling_address: 0 (UBInt8)
        check_byte: 5 (CheckByte)

encoded = hf.encode()
print(oser.to_hex(encoded))
   0|  1|  2|  3|  4|  5|  6|  7|  8|  9
\x82\x80\x00\x00\x00\x00\x06\x01\x00\x05
# 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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 6 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 7 (Command)
        byte_count: 0 (UBInt8)
        payload: Command7_ReadLoopConfigurationRequest():
        check_byte: 5 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 7 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 8 (Command)
        byte_count: 0 (UBInt8)
        payload: Command8_ReadDynamicVariableClassificationsRequest():
        check_byte: 10 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 8 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 9 (Command)
        byte_count: 0 (UBInt8)
        payload: Command9_ReadDeviceVariablesWithStatusRequest():
            device_variable_codes: Array():
            [
            ]
        check_byte: 11 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 9 (Command)
    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: 00:00:00 (Time)
    check_byte: 8 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 11 (Command)
        byte_count: 6 (UBInt8)
        payload: Command11_ReadUniqueIdentifierAssociatedWithTagRequest():
            tag: b'????????'
        check_byte: 15 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 11 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 12 (Command)
        byte_count: 0 (UBInt8)
        payload: Command12_ReadMessageRequest():
        check_byte: 14 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 12 (Command)
    byte_count: 26 (UBInt8)
    payload: Command12_ReadMessageResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        message: b'????????????????????????????????'
    check_byte: 16 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 13 (Command)
        byte_count: 0 (UBInt8)
        payload: Command13_ReadTagDescriptorDateRequest():
        check_byte: 15 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 13 (Command)
    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()
print(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\x01\x01\x00\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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 14 (Command)
        byte_count: 0 (UBInt8)
        payload: Command14_ReadPrimaryVariableTransducerInformationRequest():
        check_byte: 12 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 14 (Command)
    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.0 (BFloat)
        lower_limit: 0.0 (BFloat)
        minimum_span: 0.0 (BFloat)
    check_byte: 26 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 15 (Command)
        byte_count: 0 (UBInt8)
        payload: Command15_ReadDeviceInformationRequest():
        check_byte: 13 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 15 (Command)
    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.0 (BFloat)
        lower_range_value: 0.0 (BFloat)
        daming_value: 0.0 (BFloat)
        write_protect_code: 0 (UBInt8)
        reserved: 250 (UBInt8)
        analog_channel_flags: 0 (UBInt8)
    check_byte: 231 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 16 (Command)
        byte_count: 0 (UBInt8)
        payload: Command16_ReadFinalAssemblyNumberRequest():
        check_byte: 18 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 16 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 17 (Command)
        byte_count: 24 (UBInt8)
        payload: Command17_WriteMessageRequest():
            message: b'????????????????????????????????'
        check_byte: 11 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 17 (Command)
    byte_count: 26 (UBInt8)
    payload: Command17_WriteMessageResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        message: b'????????????????????????????????'
    check_byte: 13 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 18 (Command)
        byte_count: 21 (UBInt8)
        payload: Command18_WriteTageDescriptorDateRequest():
            tag: b'????????'
            descriptor: b'????????????????'
            date: datetime.date(1900, 1, 1)
        check_byte: 5 (CheckByte)

encoded = hf.encode()
print(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\x01\x01\x00\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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 18 (Command)
    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()
print(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\x01\x01\x00\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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 19 (Command)
        byte_count: 3 (UBInt8)
        payload: Command19_WriteFinalAssemblyNumberRequest():
            final_assembly_number: BitStruct():
                value: 0 (BitField(24))
        check_byte: 18 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 19 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 20 (Command)
        byte_count: 0 (UBInt8)
        payload: Command20_ReadLongTagRequest():
        check_byte: 22 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 20 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 21 (Command)
        byte_count: 32 (UBInt8)
        payload: Command21_ReadUniqueIdentifierAssociatedWithLongTagRequest():
            long_tag: b''
        check_byte: 55 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 21 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 22 (Command)
        byte_count: 32 (UBInt8)
        payload: Command22_WriteLongTagRequest():
            long_tag: b''
        check_byte: 52 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 22 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 38 (Command)
        byte_count: 0 (UBInt8)
        payload: Command38_ResetConfigurationChangedFlagRequest():
        check_byte: 36 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 38 (Command)
    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()
print(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

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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 33 (Command)
        byte_count: 0 (UBInt8)
        payload: Command33_ReadDeviceVariablesRequest():
            device_variable_codes: Array():
            [
            ]
        check_byte: 35 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 33 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 34 (Command)
        byte_count: 4 (UBInt8)
        payload: Command34_WritePrimaryVariableDampingValueRequest():
            primary_variable_damping_value: 0.0 (BFloat)
        check_byte: 36 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 34 (Command)
    byte_count: 6 (UBInt8)
    payload: Command34_WritePrimaryVariableDampingValueResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        actual_primary_variable_damping_value: 0.0 (BFloat)
    check_byte: 34 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 35 (Command)
        byte_count: 9 (UBInt8)
        payload: Command35_WritePrimaryVariableRangeValuesRequest():
            primary_variable_upper_and_lower_range_value_units_code: 0 (UBInt8)
            primary_variable_upper_range_value: 0.0 (BFloat)
            primary_variable_lower_range_value: 0.0 (BFloat)
        check_byte: 40 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 35 (Command)
    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.0 (BFloat)
        primary_variable_lower_range_value: 0.0 (BFloat)
    check_byte: 46 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 36 (Command)
        byte_count: 0 (UBInt8)
        payload: Command36_SetPrimaryVariableUpperRangeValueRequest():
        check_byte: 38 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 36 (Command)
    byte_count: 2 (UBInt8)
    payload: Command36_SetPrimaryVariableUpperRangeValueResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
    check_byte: 32 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 37 (Command)
        byte_count: 0 (UBInt8)
        payload: Command37_SetPrimaryVariableLowerRangeValueRequest():
        check_byte: 39 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 37 (Command)
    byte_count: 2 (UBInt8)
    payload: Command37_SetPrimaryVariableLowerRangeValueResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
    check_byte: 33 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 39 (Command)
        byte_count: 1 (UBInt8)
        payload: Command39_EEPROMControlRequest():
            eeprom_control_code: 0 (UBInt8)
        check_byte: 36 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 39 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 40 (Command)
        byte_count: 4 (UBInt8)
        payload: Command40_EnterExitFixedCurrentModeRequest():
            primary_variable_fixed_current_level: 0.0 (BFloat)
        check_byte: 46 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 40 (Command)
    byte_count: 6 (UBInt8)
    payload: Command40_EnterExitFixedCurrentModeResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        actual_primary_variable_current_level: 0.0 (BFloat)
    check_byte: 40 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 41 (Command)
        byte_count: 0 (UBInt8)
        payload: Command41_PerformSelfTestRequest():
        check_byte: 43 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 41 (Command)
    byte_count: 2 (UBInt8)
    payload: Command41_PerformSelfTestResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
    check_byte: 45 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 42 (Command)
        byte_count: 0 (UBInt8)
        payload: Command42_PerformDeviceResetRequest():
        check_byte: 40 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 42 (Command)
    byte_count: 2 (UBInt8)
    payload: Command42_PerformDeviceResetResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
    check_byte: 46 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 43 (Command)
        byte_count: 0 (UBInt8)
        payload: Command43_SetPrimaryVariableZeroRequest():
        check_byte: 41 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 43 (Command)
    byte_count: 2 (UBInt8)
    payload: Command43_SetPrimaryVariableZeroResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
    check_byte: 47 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 44 (Command)
        byte_count: 1 (UBInt8)
        payload: Command44_WritePrimaryVariableUnitsRequest():
            primary_variable_units_code: 0 (UBInt8)
        check_byte: 47 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 44 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 45 (Command)
        byte_count: 4 (UBInt8)
        payload: Command45_TrimLoopCurrentZeroRequest():
            externally_measured_primary_variable_loop_current_level: 0.0 (BFloat)
        check_byte: 43 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 45 (Command)
    byte_count: 6 (UBInt8)
    payload: Command45_TrimLoopCurrentZeroResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        actual_measured_primary_variable_loop_current_level: 0.0 (BFloat)
    check_byte: 45 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 46 (Command)
        byte_count: 4 (UBInt8)
        payload: Command46_TrimLoopCurrentGainRequest():
            externally_measured_primary_variable_loop_current_level: 0.0 (BFloat)
        check_byte: 40 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 46 (Command)
    byte_count: 6 (UBInt8)
    payload: Command46_TrimLoopCurrentGainResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        actual_measured_primary_variable_loop_current_level: 0.0 (BFloat)
    check_byte: 46 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 47 (Command)
        byte_count: 1 (UBInt8)
        payload: Command47_WritePrimaryVariableTransferFunctionRequest():
            primary_variable_transfer_function_code: 0 (UBInt8)
        check_byte: 44 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 47 (Command)
    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()
print(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 48¶

Command 48 example:

from __future__ import \
     absolute_import, division, print_function, unicode_literals

import oser
from htf.communication.hart import HartFrame
# request
hf = HartFrame(48)
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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 48 (Command)
        byte_count: 0 (UBInt8)
        payload: Command48_ReadAdditionalDeviceStatusRequest():
        check_byte: 50 (CheckByte)

encoded = hf.encode()
print(oser.to_hex(encoded))
   0|  1|  2|  3|  4|  5|  6|  7|  8
\x82\x80\x00\x00\x00\x00\x30\x00\x32
# response
hf = HartFrame(48)
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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 48 (Command)
    byte_count: 11 (UBInt8)
    payload: Command48_ReadAdditionalDeviceStatusResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        device_specific_status: BitStruct():
            value: 0 (BitField(48))
        extended_device_status: 0 (UBInt8)
        device_operating_mode: 0 (UBInt8)
        status0: 0 (UBInt8)
    check_byte: 61 (CheckByte)

encoded = hf.encode()
print(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\x30\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d

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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 49 (Command)
        byte_count: 3 (UBInt8)
        payload: Command49_WritePrimaryVariableTransducerSerialNumberRequest():
            primary_variable_transducer_serial_number: BitStruct():
                value: 0 (BitField(24))
        check_byte: 48 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 49 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 50 (Command)
        byte_count: 0 (UBInt8)
        payload: Command50_ReadDynamicVariableAssignmentsRequest():
        check_byte: 48 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 50 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 51 (Command)
        byte_count: 0 (UBInt8)
        payload: Command51_WriteDynamicVariableAssignmentsRequest():
            device_variables: Array():
            [
            ]
        check_byte: 49 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 51 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 52 (Command)
        byte_count: 1 (UBInt8)
        payload: Command52_SetDeviceVariableZeroRequest():
            device_variable_to_zero: 0 (UBInt8)
        check_byte: 55 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 52 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 53 (Command)
        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()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 53 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 54 (Command)
        byte_count: 1 (UBInt8)
        payload: Command54_ReadDeviceVariableInformationRequest():
            device_variable_code: 0 (UBInt8)
        check_byte: 53 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 54 (Command)
    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.0 (BFloat)
        device_variable_lower_transducer_limit: 0.0 (BFloat)
        device_variable_damping_value: 0.0 (BFloat)
        device_variable_minimum_span: 0.0 (BFloat)
        device_variable_classification: 0 (UBInt8)
        device_variable_family: 0 (UBInt8)
        acquisition_period: 00:00:00 (Time)
        device_variable_properties: 0 (UBInt8)
    check_byte: 46 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 55 (Command)
        byte_count: 5 (UBInt8)
        payload: Command55_WriteDeviceVariableDampingValueRequest():
            device_variable_code: 0 (UBInt8)
            device_variable_damping_value: 0.0 (BFloat)
        check_byte: 48 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 55 (Command)
    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.0 (BFloat)
    check_byte: 54 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 56 (Command)
        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()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 56 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 57 (Command)
        byte_count: 0 (UBInt8)
        payload: Command57_ReadUnitTagDescriptorDateRequest():
        check_byte: 59 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 57 (Command)
    byte_count: 23 (UBInt8)
    payload: Command57_ReadUnitTagDescriptorDateResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        unit_tag: b'????????'
        unit_descriptor: b'????????????????'
        unit_date: BitStruct():
            value: 0 (BitField(24))
    check_byte: 40 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 58 (Command)
        byte_count: 21 (UBInt8)
        payload: Command58_WriteUnitTagDescriptorDateRequest():
            unit_tag: b'????????'
            unit_descriptor: b'????????????????'
            unit_date: BitStruct():
                value: 0 (BitField(24))
        check_byte: 45 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 58 (Command)
    byte_count: 23 (UBInt8)
    payload: Command58_WriteUnitTagDescriptorDateResponse():
        response_code: 'success' (UBInt8)
        field_device_status:  (FieldDeviceStatus)
        unit_tag: b'????????'
        unit_descriptor: b'????????????????'
        unit_date: BitStruct():
            value: 0 (BitField(24))
    check_byte: 43 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 59 (Command)
        byte_count: 1 (UBInt8)
        payload: Command59_WriteNumberOfResponsePreamblesRequest():
            number_of_preambles: 0 (UBInt8)
        check_byte: 56 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 59 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 60 (Command)
        byte_count: 1 (UBInt8)
        payload: Command60_ReadAnalogChannelAndPercentOfRangeRequest():
            analog_channel_number_code: 0 (UBInt8)
        check_byte: 63 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 60 (Command)
    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.0 (BFloat)
        analog_channel_percent_of_range: 0.0 (BFloat)
    check_byte: 54 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 61 (Command)
        byte_count: 0 (UBInt8)
        payload: Command61_ReadDynamicVariablesAndPrimaryVariableAnalogChannelRequest():
        check_byte: 63 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 61 (Command)
    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.0 (BFloat)
        dynamic_variables: Array():
        [
        ]
    check_byte: 60 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 62 (Command)
        byte_count: 0 (UBInt8)
        payload: Command62_ReadAnalogChannelsRequest():
            analog_channel_number_codes: Array():
            [
            ]
        check_byte: 60 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 62 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 63 (Command)
        byte_count: 1 (UBInt8)
        payload: Command63_ReadAnalogChannelInformationRequest():
            analog_channel_number_code: 0 (UBInt8)
        check_byte: 60 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 63 (Command)
    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.0 (BFloat)
        analog_channel_lower_range_value: 0.0 (BFloat)
        analog_channel_damping_value: 0.0 (BFloat)
        analog_channel_flags: 0 (UBInt8)
    check_byte: 42 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 64 (Command)
        byte_count: 5 (UBInt8)
        payload: Command64_WriteAnalogChannelAdditionalDampingValueRequest():
            analog_channel_number_code: 0 (UBInt8)
            analog_channel_additional_damping_value: 0.0 (BFloat)
        check_byte: 71 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 64 (Command)
    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.0 (BFloat)
    check_byte: 65 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 65 (Command)
        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.0 (BFloat)
            analog_channel_lower_range_value: 0.0 (BFloat)
        check_byte: 73 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 65 (Command)
    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.0 (BFloat)
        analog_channel_lower_range_value: 0.0 (BFloat)
    check_byte: 75 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 66 (Command)
        byte_count: 6 (UBInt8)
        payload: Command66_EnterExitFixedAnalogChannelModeRequest():
            analog_channel_number_code: 0 (UBInt8)
            analog_channel_units_code: 0 (UBInt8)
            fixed_analog_channel_level: 0.0 (BFloat)
        check_byte: 70 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 66 (Command)
    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.0 (BFloat)
    check_byte: 76 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 67 (Command)
        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.0 (BFloat)
        check_byte: 71 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 67 (Command)
    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.0 (BFloat)
    check_byte: 77 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 68 (Command)
        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.0 (BFloat)
        check_byte: 64 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 68 (Command)
    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.0 (BFloat)
    check_byte: 74 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 69 (Command)
        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()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 69 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 70 (Command)
        byte_count: 1 (UBInt8)
        payload: Command70_ReadAnalogChannelEndpointValuesRequest():
            analog_channel_number_code: 0 (UBInt8)
        check_byte: 69 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 70 (Command)
    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.0 (BFloat)
        analog_channel_lower_endpoint_value: 0.0 (BFloat)
        analog_channel_upper_limit_value: 0.0 (BFloat)
        analog_channel_lower_limit_value: 0.0 (BFloat)
    check_byte: 84 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 71 (Command)
        byte_count: 1 (UBInt8)
        payload: Command71_LockDeviceRequest():
            lock_code: 0 (UBInt8)
        check_byte: 68 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 71 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 72 (Command)
        byte_count: 1 (UBInt8)
        payload: Command72_SquawkRequest():
            squawk_control: 0 (UBInt8)
        check_byte: 75 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 72 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 73 (Command)
        byte_count: 0 (UBInt8)
        payload: Command73_FindDeviceRequest():
        check_byte: 75 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 73 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 74 (Command)
        byte_count: 0 (UBInt8)
        payload: Command74_ReadIOSystemCapabilitiesRequest():
        check_byte: 72 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 74 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 75 (Command)
        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()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 75 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 76 (Command)
        byte_count: 0 (UBInt8)
        payload: Command76_ReadLockDeviceStateRequest():
        check_byte: 78 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 76 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 77 (Command)
        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()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 77 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 78 (Command)
        byte_count: 1 (UBInt8)
        payload: Command78_ReadAggregatedCommandsRequest():
            requested_commands: 0 (UBInt8)
            commands: Array():
            [
            ]
        check_byte: 77 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 78 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 79 (Command)
        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.0 (BFloat)
            device_variable_status: 0 (UBInt8)
        check_byte: 69 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 79 (Command)
    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.0 (BFloat)
        device_variable_status: 0 (UBInt8)
    check_byte: 67 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 80 (Command)
        byte_count: 1 (UBInt8)
        payload: Command80_ReadDeviceVariableTrimPointsRequest():
            device_variable_code: 0 (UBInt8)
        check_byte: 83 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 80 (Command)
    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.0 (BFloat)
        upper_trim_point: 0.0 (BFloat)
    check_byte: 90 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 81 (Command)
        byte_count: 1 (UBInt8)
        payload: Command81_ReadDeviceVariableTrimGuidelinesRequest():
            device_variable_guidelines: 0 (UBInt8)
        check_byte: 82 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 81 (Command)
    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.0 (BFloat)
        maximum_lower_trim_point_value: 0.0 (BFloat)
        minimum_upper_trim_point_value: 0.0 (BFloat)
        maximum_upper_trim_point_value: 0.0 (BFloat)
        minimum_differential: 0.0 (BFloat)
    check_byte: 78 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 82 (Command)
        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.0 (BFloat)
        check_byte: 87 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 82 (Command)
    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.0 (BFloat)
    check_byte: 93 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 83 (Command)
        byte_count: 1 (UBInt8)
        payload: Command83_ResetDeviceVariableTrimRequest():
            device_variable_code: 0 (UBInt8)
        check_byte: 80 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 83 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 84 (Command)
        byte_count: 2 (UBInt8)
        payload: Command84_ReadSubDeviceIdentitySummaryRequest():
            subdevice_index: 0 (UBInt16)
        check_byte: 84 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 84 (Command)
    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: b''
        device_revision: 0 (UBInt8)
        device_profile: 0 (UBInt8)
        private_label_distributor_code: 0 (UBInt16)
    check_byte: 96 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 85 (Command)
        byte_count: 2 (UBInt8)
        payload: Command85_ReadIOChannelStatisticsRequest():
            io_card: 0 (UBInt8)
            channel: 0 (UBInt8)
        check_byte: 85 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 85 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 86 (Command)
        byte_count: 2 (UBInt8)
        payload: Command86_ReadSubDeviceStatisticsRequest():
            subdevice_index: 0 (UBInt16)
        check_byte: 86 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 86 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 87 (Command)
        byte_count: 1 (UBInt8)
        payload: Command87_WriteIOSystemMasterModeRequest():
            master_mode: 0 (UBInt8)
        check_byte: 84 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 87 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 88 (Command)
        byte_count: 1 (UBInt8)
        payload: Command88_WriteIOSystemRetryCountRequest():
            retry_count: 0 (UBInt8)
        check_byte: 91 (CheckByte)

encoded = hf.encode()
print(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: False (Flag)
        address: 0x0 (SlaveAddress(38))
    expansion_bytes: Array():
    [
    ]
    command: 88 (Command)
    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()
print(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: False (Flag)
            address: 0x0 (SlaveAddress(38))
        expansion_bytes: Array():
        [
        ]
        command: 89 (Command)
        byte_count: 10 (UBInt8)
        payload: Command89_SetRealTimeClockRequest():
            time_set_code: 0 (UBInt8)
            date: datetime.date(1900, 1, 1)
            time:</