def test_set(self):
"""Test setting value."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3")
)
self.loop.run_until_complete(remote_value.set(10))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x0A,))),
),
)
self.loop.run_until_complete(remote_value.set(11))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x0B,))),
),
)
def test_to_process_error(self):
"""Test process errornous telegram."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3")
)
with self.assertRaises(CouldNotParseTelegram):
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(1)),
)
self.loop.run_until_complete(remote_value.process(telegram))
with self.assertRaises(CouldNotParseTelegram):
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(
DPTArray(
(
0x64,
0x65,
)
)
),
)
self.loop.run_until_complete(remote_value.process(telegram))
def test_to_knx_error(self):
"""Test to_knx function with wrong parametern."""
xknx = XKNX(loop=self.loop)
remote_value = RemoteValueDptValue1Ucount(xknx)
with self.assertRaises(ConversionError):
remote_value.to_knx(256)
with self.assertRaises(ConversionError):
remote_value.to_knx("256")
def test_process(self):
"""Test process telegram."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3"))
telegram = Telegram(group_address=GroupAddress("1/2/3"),
payload=DPTArray((0x0A, )))
self.loop.run_until_complete(remote_value.process(telegram))
self.assertEqual(remote_value.value, 10)
async def test_process(self):
"""Test process telegram."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3"))
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x0A, ))),
)
await remote_value.process(telegram)
assert remote_value.value == 10
def __init__(
self,
xknx: XKNX,
name: str,
group_address_speed: GroupAddressesType | None = None,
group_address_speed_state: GroupAddressesType | None = None,
group_address_oscillation: GroupAddressesType | None = None,
group_address_oscillation_state: GroupAddressesType | None = None,
sync_state: bool | int | float | str = True,
device_updated_cb: DeviceCallbackType | None = None,
max_step: int | None = None,
):
"""Initialize fan class."""
super().__init__(xknx, name, device_updated_cb)
self.speed: RemoteValueDptValue1Ucount | RemoteValueScaling
self.mode = FanSpeedMode.STEP if max_step else FanSpeedMode.PERCENT
self.max_step = max_step
if self.mode == FanSpeedMode.STEP:
self.speed = RemoteValueDptValue1Ucount(
xknx,
group_address_speed,
group_address_speed_state,
sync_state=sync_state,
device_name=self.name,
feature_name="Speed",
after_update_cb=self.after_update,
)
else:
self.speed = RemoteValueScaling(
xknx,
group_address_speed,
group_address_speed_state,
sync_state=sync_state,
device_name=self.name,
feature_name="Speed",
after_update_cb=self.after_update,
range_from=0,
range_to=100,
)
self.oscillation = RemoteValueSwitch(
xknx,
group_address_oscillation,
group_address_oscillation_state,
sync_state=sync_state,
device_name=self.name,
feature_name="Oscillation",
after_update_cb=self.after_update,
)
def __init__(
self,
xknx: "XKNX",
name: str,
group_address_speed: Optional["GroupAddressableType"] = None,
group_address_speed_state: Optional["GroupAddressableType"] = None,
group_address_oscillation: Optional["GroupAddressableType"] = None,
group_address_oscillation_state: Optional[
"GroupAddressableType"] = None,
device_updated_cb: Optional[DeviceCallbackType] = None,
max_step: Optional[int] = None,
):
"""Initialize fan class."""
# pylint: disable=too-many-arguments
super().__init__(xknx, name, device_updated_cb)
self.speed: Union[RemoteValueDptValue1Ucount, RemoteValueScaling]
self.mode = FanSpeedMode.Step if max_step is not None else FanSpeedMode.Percent
self.max_step = max_step
if self.mode == FanSpeedMode.Step:
self.speed = RemoteValueDptValue1Ucount(
xknx,
group_address_speed,
group_address_speed_state,
device_name=self.name,
feature_name="Speed",
after_update_cb=self.after_update,
)
else:
self.speed = RemoteValueScaling(
xknx,
group_address_speed,
group_address_speed_state,
device_name=self.name,
feature_name="Speed",
after_update_cb=self.after_update,
range_from=0,
range_to=100,
)
self.oscillation = RemoteValueSwitch(
xknx,
group_address_oscillation,
group_address_oscillation_state,
device_name=self.name,
feature_name="Oscillation",
after_update_cb=self.after_update,
)
def test_set(self):
"""Test setting value."""
xknx = XKNX(loop=self.loop)
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3"))
self.loop.run_until_complete(asyncio.Task(remote_value.set(10)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(GroupAddress('1/2/3'), payload=DPTArray((0x0A, ))))
self.loop.run_until_complete(asyncio.Task(remote_value.set(11)))
self.assertEqual(xknx.telegrams.qsize(), 1)
telegram = xknx.telegrams.get_nowait()
self.assertEqual(
telegram,
Telegram(GroupAddress('1/2/3'), payload=DPTArray((0x0B, ))))
async def test_to_process_error(self):
"""Test process errornous telegram."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3"))
with pytest.raises(CouldNotParseTelegram):
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(1)),
)
await remote_value.process(telegram)
with pytest.raises(CouldNotParseTelegram):
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x64, 0x65))),
)
await remote_value.process(telegram)
async def test_set(self):
"""Test setting value."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3"))
await remote_value.set(10)
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x0A, ))),
)
await remote_value.set(11)
assert xknx.telegrams.qsize() == 1
telegram = xknx.telegrams.get_nowait()
assert telegram == Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x0B, ))),
)
async def test_to_process_error(self):
"""Test process errornous telegram."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(
xknx, group_address=GroupAddress("1/2/3")
)
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTBinary(1)),
)
assert await remote_value.process(telegram) is False
telegram = Telegram(
destination_address=GroupAddress("1/2/3"),
payload=GroupValueWrite(DPTArray((0x64, 0x65))),
)
assert await remote_value.process(telegram) is False
assert remote_value.value is None
def test_from_knx(self):
"""Test from_knx function with normal operation."""
xknx = XKNX(loop=self.loop)
remote_value = RemoteValueDptValue1Ucount(xknx)
self.assertEqual(remote_value.from_knx(DPTArray((0x0A, ))), 10)
def test_to_knx(self):
"""Test to_knx function with normal operation."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(xknx)
self.assertEqual(remote_value.to_knx(10), DPTArray((0x0A, )))
def __init__(
self,
xknx: XKNX,
name: str,
group_address_speed: GroupAddressesType | None = None,
group_address_speed_state: GroupAddressesType | None = None,
group_address_oscillation: GroupAddressesType | None = None,
group_address_oscillation_state: GroupAddressesType | None = None,
group_address_switch: GroupAddressesType | None = None,
group_address_switch_state: GroupAddressesType | None = None,
sync_state: bool | int | float | str = True,
device_updated_cb: DeviceCallbackType[Fan] | None = None,
max_step: int | None = None,
):
"""Initialize fan class."""
super().__init__(xknx, name, device_updated_cb)
self.speed: RemoteValueDptValue1Ucount | RemoteValueScaling
self.mode = FanSpeedMode.STEP if max_step else FanSpeedMode.PERCENT
self.max_step = max_step
# If there is a dedicated switch GA, it controls the on/off behavior of the fan.
# Otherwise the speed GA of the fan implicitly controls the on/off behavior instead.
# `self.switch.initialized`` can be used to check which setup is used.
self.switch = RemoteValueSwitch(
xknx,
group_address_switch,
group_address_switch_state,
sync_state=sync_state,
device_name=self.name,
feature_name="Switch",
after_update_cb=self.after_update,
)
if self.mode == FanSpeedMode.STEP:
self.speed = RemoteValueDptValue1Ucount(
xknx,
group_address_speed,
group_address_speed_state,
sync_state=sync_state,
device_name=self.name,
feature_name="Speed",
after_update_cb=self.after_update,
)
else:
self.speed = RemoteValueScaling(
xknx,
group_address_speed,
group_address_speed_state,
sync_state=sync_state,
device_name=self.name,
feature_name="Speed",
after_update_cb=self.after_update,
range_from=0,
range_to=100,
)
self.oscillation = RemoteValueSwitch(
xknx,
group_address_oscillation,
group_address_oscillation_state,
sync_state=sync_state,
device_name=self.name,
feature_name="Oscillation",
after_update_cb=self.after_update,
)
def test_from_knx(self):
"""Test from_knx function with normal operation."""
xknx = XKNX()
remote_value = RemoteValueDptValue1Ucount(xknx)
assert remote_value.from_knx(DPTArray((0x0A,))) == 10