def __init__(self):
"""Init Frame."""
super().__init__(Command.GW_STATUS_REQUEST_NTF)
self.session_id = 0
self.status_id = 0
self.node_id = 0
self.run_status = RunStatus.EXECUTION_COMPLETED
self.status_reply = StatusReply.UNKNOWN_STATUS_REPLY
self.status_type = StatusType.REQUEST_TARGET_POSITION
self.status_count = 0
self.parameter_data = {}
self.target_position = Parameter()
self.current_position = Parameter()
self.remaining_time = 0
self.last_master_execution_address = 0
self.last_command_originator = 0
def __init__(self,
node_ids=None,
parameter=Parameter(),
active_parameter=0,
session_id=None,
originator=Originator.USER,
**functional_parameter):
"""Init Frame."""
super().__init__(Command.GW_COMMAND_SEND_REQ)
self.node_ids = node_ids
self.parameter = parameter
self.active_parameter = active_parameter
self.fpi1 = 0
self.fpi2 = 0
self.functional_parameter = {}
self.session_id = session_id
self.originator = originator
self.priority = Priority.USER_LEVEL_2
"""Set the functional parameter indicator bytes in order to show which functional
parameters are included in the frame. Functional parameter dictionary will be checked
for keys 'fp1' to 'fp16' to set the appropriate indicator and the corresponding
self.functional_parameter."""
for i in range(1, 17):
key = "fp%s" % (i)
if key in functional_parameter:
self.functional_parameter[key] = functional_parameter[key]
if i < 9:
self.fpi1 += 2**(8 - i)
if i >= 9:
self.fpi2 += 2**(16 - i)
else:
self.functional_parameter[key] = bytes(2)
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0] * 256 + payload[1]
self.status_id = payload[2]
self.node_id = payload[3]
self.run_status = RunStatus(payload[4])
self.status_reply = StatusReply(payload[5])
self.status_type = StatusType(payload[6])
if self.status_type == StatusType.REQUEST_MAIN_INFO:
self.target_position = Parameter(payload[7:8])
self.current_position = Parameter(payload[9:10])
self.remaining_time = payload[11] * 256 + payload[12]
self.last_master_execution_address = payload[13:16]
self.last_command_originator = payload[17]
else:
self.status_count = payload[7]
for i in range(8, 8 + self.status_count * 3, 3):
self.parameter_data.update({
NodeParameter(payload[i]):
Parameter(payload[i + 1:i + 3])
})
def __init__(self,
node_ids=None,
parameter=Parameter(),
session_id=None,
originator=Originator.USER):
"""Init Frame."""
super().__init__(Command.GW_COMMAND_SEND_REQ)
self.node_ids = node_ids
self.parameter = parameter
self.session_id = session_id
self.originator = originator
self.priority = Priority.USER_LEVEL_2
def __init__(self):
"""Init Frame."""
super().__init__(Command.GW_GET_NODE_INFORMATION_NTF)
self.node_id = 0
self.order = 0
self.placement = 0
self.name = ""
self.velocity = Velocity.DEFAULT
self.node_type = NodeTypeWithSubtype.NO_TYPE
self.product_group = 0
self.product_type = 0
self.node_variation = NodeVariation.NOT_SET
self.power_mode = 0
self.build_number = 0
self._serial_number = bytes(8)
self.state = 0
self.current_position = Parameter()
self.target = Parameter()
self.current_position_fp1 = Parameter()
self.current_position_fp2 = Parameter()
self.current_position_fp3 = Parameter()
self.current_position_fp4 = Parameter()
self.remaining_time = 0
self.timestamp = 0
self.alias_array = AliasArray()
def from_payload(self, payload):
"""Init frame from binary data."""
self.node_id = payload[0]
self.order = payload[1] * 256 + payload[2]
self.placement = payload[3]
self.name = bytes_to_string(payload[4:68])
self.velocity = Velocity(payload[68])
self.node_type = NodeTypeWithSubtype(payload[69] * 256 + payload[70])
self.product_group = payload[71]
self.product_type = payload[72]
self.node_variation = NodeVariation(payload[73])
self.power_mode = payload[74]
self.build_number = payload[
75] # <-- hey @VELUX: your documentation is wrong here
self._serial_number = payload[76:84]
self.state = payload[84]
self.current_position = Parameter(payload[85:87])
self.target = Parameter(payload[87:89])
self.current_position_fp1 = Parameter(payload[89:91])
self.current_position_fp2 = Parameter(payload[91:93])
self.current_position_fp3 = Parameter(payload[93:95])
self.current_position_fp4 = Parameter(payload[95:97])
self.remaining_time = payload[97] * 256 + payload[98]
self.timestamp = struct.unpack(">I", payload[99:103])[0]
self.alias_array = AliasArray(payload[103:125])
def from_payload(self, payload):
"""Init frame from binary data."""
self.session_id = payload[0] * 256 + payload[1]
self.originator = Originator(payload[2])
self.priority = Priority(payload[3])
len_node_ids = payload[41]
if len_node_ids > 20:
raise PyVLXException("command_send_request_wrong_node_length")
self.node_ids = []
for i in range(len_node_ids):
self.node_ids.append(payload[42] + i)
self.parameter = Parameter(payload[7:9])
def __str__(self):
"""Return human readable string."""
functional_parameter = ""
for key, value in self.functional_parameter.items():
functional_parameter += "%s: %s, " % (
str(key),
Position(Parameter(bytes(value))),
)
return ('<{} node_ids="{}" parameter="{}" functional_parameter="{}" '
'session_id="{}" originator="{}"/>'.format(
type(self).__name__,
self.node_ids,
self.parameter,
functional_parameter,
self.session_id,
self.originator,
))
def __init__(self):
"""Init Frame."""
super().__init__(Command.GW_NODE_STATE_POSITION_CHANGED_NTF)
self.node_id = 0
self.state = 0
self.current_position = Parameter()
self.target = Parameter()
self.current_position_fp1 = Parameter()
self.current_position_fp2 = Parameter()
self.current_position_fp3 = Parameter()
self.current_position_fp4 = Parameter()
self.remaining_time = 0
self.timestamp = 0
def from_payload(self, payload):
"""Init frame from binary data."""
self.node_id = payload[0]
self.state = payload[1]
self.current_position = Parameter(payload[2:4])
self.target = Parameter(payload[4:6])
self.current_position_fp1 = Parameter(payload[6:8])
self.current_position_fp2 = Parameter(payload[8:10])
self.current_position_fp3 = Parameter(payload[10:12])
self.current_position_fp4 = Parameter(payload[12:14])
self.remaining_time = payload[14] * 256 + payload[15]
# @VELUX: looks like your timestamp is wrong. Looks like
# you are only transmitting the two lower bytes.
self.timestamp = struct.unpack(">I", payload[16:20])[0]
