-
Notifications
You must be signed in to change notification settings - Fork 26
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge pull request #71 from mago0211/add_limitations
Add function to get limitation for windows with rain sensor
- Loading branch information
Showing
12 changed files
with
426 additions
and
9 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,114 @@ | ||
|
||
"""Module for get local time classes.""" | ||
from pyvlx.const import Command, LimitationType, Originator, Priority | ||
|
||
from .frame import FrameBase | ||
|
||
|
||
class FrameGetLimitationStatus(FrameBase): | ||
"""Frame for requesting limitation status.""" | ||
|
||
PAYLOAD_LEN = 25 | ||
|
||
def __init__(self, node_ids=None, session_id=None, limitation_type=LimitationType.MIN_LIMITATION): | ||
"""Init Frame.""" | ||
super().__init__(Command.GW_GET_LIMITATION_STATUS_REQ) | ||
self.session_id = session_id | ||
self.originator = Originator.USER | ||
self.priority = Priority.USER_LEVEL_2 | ||
self.node_ids = node_ids | ||
|
||
self.parameter_id = 0 # Main Parameter | ||
self.limitations_type = limitation_type | ||
|
||
def get_payload(self): | ||
"""Return Payload.""" | ||
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255]) | ||
ret += bytes([len(self.node_ids)]) # index array count | ||
ret += bytes(self.node_ids) + bytes(20 - len(self.node_ids)) | ||
ret += bytes([self.parameter_id]) | ||
ret += bytes([self.limitations_type.value]) | ||
return ret | ||
|
||
def __str__(self): | ||
"""Return human readable string.""" | ||
return f'<{type(self).__name__} node_ids="{self.node_ids}" ' \ | ||
f'session_id="{self.session_id}" originator="{self.originator}" />' | ||
|
||
|
||
class FrameGetLimitationStatusConfirmation(FrameBase): | ||
"""Frame for response for get limitation requests.""" | ||
|
||
PAYLOAD_LEN = 3 | ||
|
||
def __init__(self, session_id=None, data=None): | ||
"""Init Frame.""" | ||
super().__init__(Command.GW_GET_LIMITATION_STATUS_CFM) | ||
self.session_id = session_id | ||
self.data = data | ||
|
||
def get_payload(self): | ||
"""Return Payload.""" | ||
ret = bytes([self.session_id >> 8 & 255, self.session_id & 255]) | ||
ret += bytes([self.data]) | ||
return ret | ||
|
||
def from_payload(self, payload): | ||
"""Init frame from binary data.""" | ||
self.session_id = payload[0] * 256 + payload[1] | ||
self.data = payload[2] | ||
|
||
def __str__(self): | ||
"""Return human readable string.""" | ||
return '<{} session_id="{}" status="{}"/>'.format( | ||
type(self).__name__, self.session_id, self.data | ||
) | ||
|
||
|
||
class FrameGetLimitationStatusNotification(FrameBase): | ||
"""Frame for notification of note information request.""" | ||
|
||
PAYLOAD_LEN = 10 | ||
|
||
def __init__(self): | ||
"""Init Frame.""" | ||
super().__init__(Command.GW_LIMITATION_STATUS_NTF) | ||
self.session_id = None | ||
self.node_id = 0 | ||
self.parameter_id = 0 | ||
self.min_value = None | ||
self.max_value = None | ||
self.limit_originator = None | ||
self.limit_time = None | ||
|
||
def get_payload(self): | ||
"""Return Payload.""" | ||
payload = bytes([self.session_id >> 8 & 255, self.session_id & 255]) | ||
payload += bytes([self.node_id]) | ||
payload += bytes([self.parameter_id]) | ||
payload += bytes([self.min_value >> 8 & 255, self.min_value & 255]) | ||
payload += bytes([self.max_value >> 8 & 255, self.max_value & 255]) | ||
payload += bytes([self.limit_originator]) | ||
payload += bytes([self.limit_time]) | ||
return payload | ||
|
||
def from_payload(self, payload): | ||
"""Init frame from binary data.""" | ||
self.session_id = payload[0] * 256 + payload[1] | ||
self.node_id = payload[2] | ||
self.parameter_id = payload[3] | ||
self.min_value = payload[4:5] | ||
self.max_value = payload[6:7] | ||
self.limit_originator = Originator(payload[8]) | ||
self.limit_time = payload[9] | ||
|
||
def __str__(self): | ||
"""Return human readable string.""" | ||
return ( | ||
'<{} node_id="{}" session_id="{}" min_value="{}" ' | ||
'max_value="{}" originator="{}" limit_time="{}"/>'.format( | ||
type(self).__name__, self.node_id, self.session_id, | ||
self.min_value, self.max_value, self.limit_originator, | ||
self.limit_time | ||
) | ||
) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,55 @@ | ||
"""Module for retrieving limitation value from API.""" | ||
|
||
from ..const import LimitationType | ||
from ..parameter import Position | ||
from .api_event import ApiEvent | ||
from .frames import ( | ||
FrameGetLimitationStatus, FrameGetLimitationStatusConfirmation, | ||
FrameGetLimitationStatusNotification) | ||
from .session_id import get_new_session_id | ||
|
||
|
||
class GetLimitation(ApiEvent): | ||
"""Class for retrieving gateway state from API.""" | ||
|
||
def __init__(self, pyvlx, node_id, limitation_type=LimitationType.MIN_LIMITATION): | ||
"""Initialize SceneList class.""" | ||
super().__init__(pyvlx=pyvlx) | ||
self.node_id = node_id | ||
self.limitation_type = limitation_type | ||
self.success = False | ||
self.notification_frame = None | ||
self.session_id = None | ||
self.min_value_raw = None | ||
self.max_value_raw = None | ||
self.originator = None | ||
self.limit_time = None | ||
|
||
@property | ||
def max_value(self): | ||
return Position.to_percent(self.max_value_raw) | ||
|
||
@property | ||
def min_value(self): | ||
return Position.to_percent(self.min_value_raw) | ||
|
||
async def handle_frame(self, frame): | ||
"""Handle incoming API frame, return True if this was the expected frame.""" | ||
if isinstance(frame, FrameGetLimitationStatusConfirmation): | ||
return False # Wait for Notification Frame | ||
if isinstance(frame, FrameGetLimitationStatusNotification): | ||
if frame.session_id == self.session_id: | ||
self.success = True | ||
self.min_value_raw = frame.min_value | ||
self.max_value_raw = frame.max_value | ||
self.originator = frame.limit_originator | ||
self.limit_time = frame.limit_time | ||
self.notification_frame = frame | ||
return True | ||
return False | ||
|
||
def request_frame(self): | ||
"""Construct initiating frame.""" | ||
self.session_id = get_new_session_id() | ||
return FrameGetLimitationStatus(node_ids=[self.node_id], session_id=self.session_id, | ||
limitation_type=self.limitation_type) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,38 @@ | ||
"""Unit tests for FrameGetLimitationStatusConfirmation.""" | ||
import unittest | ||
|
||
from pyvlx.api.frame_creation import frame_from_raw | ||
from pyvlx.api.frames.frame_get_limitation import ( | ||
FrameGetLimitationStatusConfirmation) | ||
|
||
|
||
class TestFrameGetLimitationStatusConfirmation(unittest.TestCase): | ||
"""Test class for FrameGetLimitationStatusConfirmation.""" | ||
|
||
# pylint: disable=too-many-public-methods,invalid-name | ||
|
||
def test_bytes(self): | ||
"""Test FrameGetLimitationStatusConfirmation bytes.""" | ||
frame = FrameGetLimitationStatusConfirmation(session_id=1, data=1) | ||
self.assertEqual(bytes(frame), b'\x00\x06\x03\x13\x00\x01\x01\x16') | ||
|
||
frame = FrameGetLimitationStatusConfirmation(session_id=2, data=0) | ||
self.assertEqual(bytes(frame), b'\x00\x06\x03\x13\x00\x02\x00\x14') | ||
|
||
def test_frame_from_raw(self): | ||
"""Test parse FrameGetLimitationStatusConfirmation from raw.""" | ||
frame = frame_from_raw(b'\x00\x06\x03\x13\x00\x01\x01\x16') | ||
self.assertTrue(isinstance(frame, FrameGetLimitationStatusConfirmation)) | ||
self.assertEqual(frame.session_id, 1) | ||
self.assertEqual(frame.data, 1) | ||
|
||
frame = frame_from_raw(b'\x00\x06\x03\x13\x00\x02\x00\x14') | ||
self.assertTrue(isinstance(frame, FrameGetLimitationStatusConfirmation)) | ||
self.assertEqual(frame.session_id, 2) | ||
self.assertEqual(frame.data, 0) | ||
|
||
def test_str(self): | ||
"""Test string representation of FrameGetLimitationStatusConfirmation.""" | ||
frame = FrameGetLimitationStatusConfirmation(session_id=1) | ||
self.assertEqual(str(frame), | ||
'<FrameGetLimitationStatusConfirmation session_id="1" status="None"/>') |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,46 @@ | ||
"""Unit tests for FrameGetLimitationStatusNotification.""" | ||
import unittest | ||
|
||
from pyvlx.api.frame_creation import frame_from_raw | ||
from pyvlx.api.frames.frame_get_limitation import ( | ||
FrameGetLimitationStatusNotification) | ||
from pyvlx.const import Originator | ||
|
||
|
||
class TestFrameGetLimitationStatusNotification(unittest.TestCase): | ||
"""Test class for TestFrameGetLimitationStatusNotification.""" | ||
|
||
# pylint: disable=too-many-public-methods,invalid-name | ||
|
||
def test_bytes(self): | ||
"""Test FrameGetLimitationStatusNotification bytes.""" | ||
|
||
frame = FrameGetLimitationStatusNotification() | ||
frame.session_id = 1 | ||
frame.node_id = 1 | ||
frame.parameter_id = 0 | ||
frame.min_value = 47668 | ||
frame.max_value = 63487 | ||
frame.limit_originator = Originator.USER.value | ||
frame.limit_time = 0 | ||
self.assertEqual(bytes(frame), b'\x00\r\x03\x14\x00\x01\x01\x00\xba4\xf7\xff\x01\x00\x9d') | ||
|
||
def test_frame_from_raw(self): | ||
"""Test parse FrameGetLimitationStatusNotification from raw.""" | ||
frame = frame_from_raw(b'\x00\r\x03\x14\x00\x01\x01\x00\xba4\xf7\xff\x01\x00\x9d') | ||
self.assertTrue(isinstance(frame, FrameGetLimitationStatusNotification)) | ||
self.assertEqual(frame.limit_originator, Originator.USER) | ||
self.assertEqual(frame.node_id, 1) | ||
self.assertEqual(frame.parameter_id, 0) | ||
self.assertEqual(frame.session_id, 1) | ||
self.assertEqual(frame.max_value, b'\xf7') | ||
self.assertEqual(frame.min_value, b'\xba') | ||
self.assertEqual(frame.limit_time, 0) | ||
|
||
def test_str(self): | ||
"""Test string representation of FrameGetLimitationStatusNotification.""" | ||
frame = FrameGetLimitationStatusNotification() | ||
self.assertEqual(str(frame), | ||
'<FrameGetLimitationStatusNotification node_id="0" ' | ||
'session_id="None" min_value="None" max_value="None" ' | ||
'originator="None" limit_time="None"/>') |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,33 @@ | ||
"""Unit tests for FrameGetLimitationStatus.""" | ||
import unittest | ||
|
||
from pyvlx.api.frame_creation import frame_from_raw | ||
from pyvlx.api.frames.frame_get_limitation import FrameGetLimitationStatus | ||
from pyvlx.const import LimitationType | ||
|
||
|
||
class TestFrameGetLimitationStatus(unittest.TestCase): | ||
"""Test class for FrameGetLimitationStatus.""" | ||
|
||
# pylint: disable=too-many-public-methods,invalid-name | ||
|
||
def test_bytes(self): | ||
"""Test FrameGetLimitationStatus bytes.""" | ||
frame = FrameGetLimitationStatus(node_ids=[1], session_id=1, limitation_type=LimitationType.MIN_LIMITATION) | ||
self.assertEqual(bytes(frame), b'\x00\x1c\x03\x12\x00\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' | ||
b'\x00\x00\x0c') | ||
|
||
frame = FrameGetLimitationStatus(node_ids=[1, 2], session_id=2, limitation_type=LimitationType.MAX_LIMITATION) | ||
self.assertEqual(bytes(frame), b'\x00\x1c\x03\x12\x00\x02\x02\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' | ||
b'\x00\x01\x0f') | ||
|
||
def test_frame_from_raw(self): | ||
"""Test parse FrameGetLimitationStatus from raw.""" | ||
frame = frame_from_raw(b'\x00\x1c\x03\x12\x00\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' | ||
b'\x0c') | ||
self.assertTrue(isinstance(frame, FrameGetLimitationStatus)) | ||
|
||
def test_str(self): | ||
"""Test string representation of FrameGetLimitationStatus.""" | ||
frame = FrameGetLimitationStatus(node_ids=[1], session_id=1, limitation_type=LimitationType.MIN_LIMITATION) | ||
self.assertEqual(str(frame), '<FrameGetLimitationStatus node_ids="[1]" session_id="1" originator="Originator.USER" />') |
Oops, something went wrong.