def _create_rfx(config):
"""Construct a rfx object based on config."""
modes = config.get(CONF_PROTOCOLS)
if modes:
_LOGGER.debug("Using modes: %s", ",".join(modes))
else:
_LOGGER.debug("No modes defined, using device configuration")
if config[CONF_PORT] is not None:
# If port is set then we create a TCP connection
rfx = rfxtrxmod.Connect(
(config[CONF_HOST], config[CONF_PORT]),
None,
transport_protocol=rfxtrxmod.PyNetworkTransport,
modes=modes,
)
else:
rfx = rfxtrxmod.Connect(
config[CONF_DEVICE],
None,
modes=modes,
)
return rfx
def setup(hass, config):
"""Set up the RFXtrx component."""
# Declare the Handle event
def handle_receive(event):
"""Handle received messages from RFXtrx gateway."""
# Log RFXCOM event
if not event.device.id_string:
return
_LOGGER.debug(
"Receive RFXCOM event from "
"(Device_id: %s Class: %s Sub: %s, Pkt_id: %s)",
slugify(event.device.id_string.lower()),
event.device.__class__.__name__,
event.device.subtype,
"".join(f"{x:02x}" for x in event.data),
)
# Callback to HA registered components.
for subscriber in RECEIVED_EVT_SUBSCRIBERS:
subscriber(event)
device = config[DOMAIN].get(ATTR_DEVICE)
host = config[DOMAIN].get(CONF_HOST)
port = config[DOMAIN].get(CONF_PORT)
debug = config[DOMAIN][ATTR_DEBUG]
dummy_connection = config[DOMAIN][ATTR_DUMMY]
if dummy_connection:
rfx_object = rfxtrxmod.Connect(
device,
None,
debug=debug,
transport_protocol=rfxtrxmod.DummyTransport2,
)
elif port is not None:
# If port is set then we create a TCP connection
rfx_object = rfxtrxmod.Connect(
(host, port),
None,
debug=debug,
transport_protocol=rfxtrxmod.PyNetworkTransport,
)
else:
rfx_object = rfxtrxmod.Connect(device, None, debug=debug)
def _start_rfxtrx(event):
rfx_object.event_callback = handle_receive
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, _start_rfxtrx)
def _shutdown_rfxtrx(event):
"""Close connection with RFXtrx."""
rfx_object.close_connection()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown_rfxtrx)
hass.data[DATA_RFXOBJECT] = rfx_object
return True
def test_parse_bytes(self):
rfy = RFXtrx.lowlevel.parse(
bytearray(b'\x08\x1A\x00\x00\x0A\x00\x01\x01\x03'))
self.assertEqual(rfy.__repr__(),
"Rfy [subtype=0, seqnbr=0, id=0a0001:1, cmnd=Down]")
self.assertEqual(rfy.packetlength, 8)
self.assertEqual(rfy.subtype, 0)
self.assertEqual(rfy.type_string, "Rfy")
self.assertEqual(rfy.seqnbr, 0)
self.assertEqual(rfy.id_string, "0a0001:1")
self.assertEqual(rfy.cmnd, 3)
self.assertEqual(rfy.cmnd_string, "Down")
rfy = RFXtrx.lowlevel.Rfy()
rfy.set_transmit(0, 0, 0x0a0001, 1, 3)
self.assertEqual(rfy.__repr__(),
"Rfy [subtype=0, seqnbr=0, id=0a0001:1, cmnd=Down]")
self.assertEqual(rfy.packetlength, 8)
self.assertEqual(rfy.subtype, 0)
self.assertEqual(rfy.type_string, "Rfy")
self.assertEqual(rfy.seqnbr, 0)
self.assertEqual(rfy.id_string, "0a0001:1")
self.assertEqual(rfy.cmnd, 3)
self.assertEqual(rfy.cmnd_string, "Down")
rfy = RFXtrx.lowlevel.Rfy()
rfy.parse_id(0, "0a0001:2")
self.assertEqual(rfy.unitcode, 2)
self.assertRaises(ValueError, rfy.parse_id, 0, "AA")
rfy = RFXtrx.get_device(0x1A, 0, "0a0001:1")
self.assertEqual(
rfy.__str__(),
"<class 'RFXtrx.RfyDevice'> type='Rfy' id='0a0001:1'")
self.assertEqual(rfy.unitcode, 1)
rfy = RFXtrx.lowlevel.parse(
bytearray(b'\x08\x1A\x01\x00\x0A\x00\x01\x01\x05'))
self.assertEqual(rfy.cmnd_string, "Unknown command (0x05)")
self.assertEqual(rfy.type_string, "Rfy Extended")
rfy = RFXtrx.lowlevel.parse(
bytearray(b'\x08\x1A\x02\x00\x0A\x00\x01\x01\x05'))
self.assertEqual(rfy.cmnd_string, "Unknown command (0x05)")
self.assertEqual(rfy.type_string, "Unknown type (0x1a/0x02)")
rfy = RFXtrx.get_device(0x1A, 3, '0a0001:2')
self.assertEqual(rfy.subtype, 3)
self.assertEqual(
rfy.__str__(),
"<class 'RFXtrx.RfyDevice'> type='ASA' id='0a0001:2'")
def _create_rfx(config):
"""Construct a rfx object based on config."""
if config[CONF_PORT] is not None:
# If port is set then we create a TCP connection
rfx = rfxtrxmod.Connect(
(config[CONF_HOST], config[CONF_PORT]),
None,
transport_protocol=rfxtrxmod.PyNetworkTransport,
)
else:
rfx = rfxtrxmod.Connect(config[CONF_DEVICE], None)
return rfx
def setup(hass, config):
"""Set up the RFXtrx component."""
# Declare the Handle event
def handle_receive(event):
"""Handle received messages from RFXtrx gateway."""
# Log RFXCOM event
if not event.device.id_string:
return
_LOGGER.debug(
"Receive RFXCOM event from "
"(Device_id: %s Class: %s Sub: %s, Pkt_id: %s)",
slugify(event.device.id_string.lower()),
event.device.__class__.__name__, event.device.subtype,
"".join("{0:02x}".format(x) for x in event.data))
# Callback to HA registered components.
for subscriber in RECEIVED_EVT_SUBSCRIBERS:
subscriber(event)
# Try to load the RFXtrx module.
import RFXtrx as rfxtrxmod
device = config[DOMAIN][ATTR_DEVICE]
debug = config[DOMAIN][ATTR_DEBUG]
dummy_connection = config[DOMAIN][ATTR_DUMMY]
if dummy_connection:
rfx_object = rfxtrxmod.Connect(
device,
None,
debug=debug,
transport_protocol=rfxtrxmod.DummyTransport2)
else:
rfx_object = rfxtrxmod.Connect(device, None, debug=debug)
def _start_rfxtrx(event):
rfx_object.event_callback = handle_receive
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, _start_rfxtrx)
def _shutdown_rfxtrx(event):
"""Close connection with RFXtrx."""
rfx_object.close_connection()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown_rfxtrx)
hass.data[DATA_RFXOBJECT] = rfx_object
return True
def get_rfx_object(packetid):
"""Return the RFXObject with the packetid."""
import RFXtrx as rfxtrxmod
binarypacket = bytearray.fromhex(packetid)
pkt = rfxtrxmod.lowlevel.parse(binarypacket)
if pkt is None:
return None
if isinstance(pkt, rfxtrxmod.lowlevel.SensorPacket):
obj = rfxtrxmod.SensorEvent(pkt)
elif isinstance(pkt, rfxtrxmod.lowlevel.Status):
obj = rfxtrxmod.StatusEvent(pkt)
else:
obj = rfxtrxmod.ControlEvent(pkt)
return obj
def setup(hass, config):
"""Setup the RFXtrx component."""
# Declare the Handle event
def handle_receive(event):
"""Callback all subscribers for RFXtrx gateway."""
# Log RFXCOM event
if not event.device.id_string:
return
entity_id = slugify(event.device.id_string.lower())
packet_id = "".join("{0:02x}".format(x) for x in event.data)
entity_name = "%s : %s" % (entity_id, packet_id)
_LOGGER.info("Receive RFXCOM event from %s => %s", event.device,
entity_name)
# Callback to HA registered components.
for subscriber in RECEIVED_EVT_SUBSCRIBERS:
subscriber(event)
# Try to load the RFXtrx module.
import RFXtrx as rfxtrxmod
# Init the rfxtrx module.
global RFXOBJECT
if ATTR_DEVICE not in config[DOMAIN]:
_LOGGER.error(
"can not find device parameter in %s YAML configuration section",
DOMAIN)
return False
device = config[DOMAIN][ATTR_DEVICE]
debug = config[DOMAIN].get(ATTR_DEBUG, False)
dummy_connection = config[DOMAIN].get(ATTR_DUMMY, False)
if dummy_connection:
RFXOBJECT =\
rfxtrxmod.Core(device, handle_receive, debug=debug,
transport_protocol=rfxtrxmod.DummyTransport2)
else:
RFXOBJECT = rfxtrxmod.Core(device, handle_receive, debug=debug)
def _shutdown_rfxtrx(event):
RFXOBJECT.close_connection()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown_rfxtrx)
return True
def test_receive(self):
core = RFXtrx.Connect(self.path,
event_callback=_callback,
debug=False,
transport_protocol=RFXtrx.DummyTransport)
# Lighting1
bytes_array = bytearray(
[0x07, 0x10, 0x00, 0x2a, 0x45, 0x05, 0x01, 0x70])
event = core.transport.receive(bytes_array)
self.assertEquals(RFXtrx.ControlEvent, type(event))
self.assertEquals(
event.__str__(),
"<class 'RFXtrx.ControlEvent'> device=[<class 'RFXtrx.LightingDevice'> type='X10 lighting' id='E5'] values=[('Command', 'On'), ('Rssi numeric', 7)]"
)
#status
bytes_array = bytearray(b'\x0D\x01\x00\x01\x02\x53\x45'
b'\x10' # msg3: rsl
b'\x0C' # msg4: hideki lacrosse
b'\x2F' # msg5: x10 arc ac homeeasy oregon
b'\x01' # msg6: keeloq
b'\x01\x00\x00' # unused
)
event = core.transport.receive(bytes_array)
self.assertEquals(RFXtrx.StatusEvent, type(event))
self.assertEquals(
event.__str__(),
"<class 'RFXtrx.StatusEvent'> device=[Status [subtype=433.92MHz, firmware=69, output_power=0, devices=['ac', 'arc', 'hideki', 'homeeasy', 'keeloq', 'lacrosse', 'oregon', 'rsl', 'x10']]]"
)
core.close_connection()
def test_one_cover(self):
"""Test with 1 cover."""
assert setup_component(
self.hass, 'cover', {
'cover': {
'platform': 'rfxtrx',
'devices': {
'0b1400cd0213c7f210010f51': {
'name': 'Test'
}
}
}
})
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT =\
rfxtrxmod.Core("", transport_protocol=rfxtrxmod.DummyTransport)
assert 1 == len(rfxtrx_core.RFX_DEVICES)
for id in rfxtrx_core.RFX_DEVICES:
entity = rfxtrx_core.RFX_DEVICES[id]
assert entity.signal_repetitions == 1
assert not entity.should_fire_event
assert not entity.should_poll
entity.open_cover()
entity.close_cover()
entity.stop_cover()
def test_old_config(self):
"""Test with 1 switch."""
assert setup_component(
self.hass, 'switch', {
'switch': {
'platform': 'rfxtrx',
'devices': {
'123efab1': {
'name': 'Test',
'packetid': '0b1100cd0213c7f210010f51'
}
}
}
})
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT =\
rfxtrxmod.Core("", transport_protocol=rfxtrxmod.DummyTransport)
assert 1 == len(rfxtrx_core.RFX_DEVICES)
entity = rfxtrx_core.RFX_DEVICES['213c7f216']
assert 'Test' == entity.name
assert 'off' == entity.state
assert entity.assumed_state
assert entity.signal_repetitions == 1
assert not entity.should_fire_event
assert not entity.should_poll
assert not entity.is_on
entity.turn_on()
assert entity.is_on
entity.turn_off()
assert not entity.is_on
def test_one_cover(self):
"""Test with 1 cover."""
self.assertTrue(
_setup_component(
self.hass, 'cover', {
'cover': {
'platform': 'rfxtrx',
'devices': {
'0b1400cd0213c7f210010f51': {
'name': 'Test'
}
}
}
}))
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT =\
rfxtrxmod.Core("", transport_protocol=rfxtrxmod.DummyTransport)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
for id in rfxtrx_core.RFX_DEVICES:
entity = rfxtrx_core.RFX_DEVICES[id]
self.assertEqual(entity.signal_repetitions, 1)
self.assertFalse(entity.should_fire_event)
self.assertFalse(entity.should_poll)
entity.open_cover()
entity.close_cover()
entity.stop_cover()
def test_old_config(self):
"""Test with 1 switch."""
self.assertTrue(
_setup_component(
self.hass, 'switch', {
'switch': {
'platform': 'rfxtrx',
'devices': {
'123efab1': {
'name': 'Test',
'packetid': '0b1100cd0213c7f210010f51'
}
}
}
}))
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT =\
rfxtrxmod.Core("", transport_protocol=rfxtrxmod.DummyTransport)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
entity = rfxtrx_core.RFX_DEVICES['213c7f216']
self.assertEqual('Test', entity.name)
self.assertEqual('off', entity.state)
self.assertTrue(entity.assumed_state)
self.assertEqual(entity.signal_repetitions, 1)
self.assertFalse(entity.should_fire_event)
self.assertFalse(entity.should_poll)
self.assertFalse(entity.is_on)
entity.turn_on()
self.assertTrue(entity.is_on)
entity.turn_off()
self.assertFalse(entity.is_on)
def test_one_cover(self):
"""Test with 1 cover."""
assert setup_component(
self.hass,
"cover",
{
"cover": {
"platform": "rfxtrx",
"devices": {
"0b1400cd0213c7f210010f51": {
"name": "Test"
}
},
}
},
)
rfxtrx_core.RFXOBJECT = rfxtrxmod.Core(
"", transport_protocol=rfxtrxmod.DummyTransport)
assert 1 == len(rfxtrx_core.RFX_DEVICES)
for id in rfxtrx_core.RFX_DEVICES:
entity = rfxtrx_core.RFX_DEVICES[id]
assert entity.signal_repetitions == 1
assert not entity.should_fire_event
assert not entity.should_poll
entity.open_cover()
entity.close_cover()
entity.stop_cover()
def test_equal_device_check(self):
core = RFXtrx.Connect(self.path,
event_callback=_callback,
debug=False,
transport_protocol=RFXtrx.DummyTransport)
data1 = bytearray(b'\x11\x5A\x01\x00\x2E\xB2\x03\x00\x00'
b'\x02\xB4\x00\x00\x0C\x46\xA8\x11\x69')
energy = core.transport.receive(data1)
data2 = bytearray(b'\x0A\x14\x00\xAD\xF3\x94\xAB' b'\x01\x01\x00\x60')
light = core.transport.receive(data2)
light2 = core.transport.receive(data2)
data3 = bytearray(b'\x0A\x52\x02\x11\x70\x02\x00\xA7' b'\x2D\x00\x89')
temphum = core.transport.receive(data3)
bytes_array = bytearray(
b'\x0A\x14\x00\xAD\xF3\x94\xAB\x01\x10\x00\x60')
lighting5_subtype0 = core.transport.receive(bytes_array)
bytes_array = bytearray(
b'\x0A\x14\x01\xAD\xF3\x94\xAB\x01\x10\x00\x60')
lighting5_subtype1 = core.transport.receive(bytes_array)
self.assertFalse(light == light2)
self.assertFalse(light == energy)
self.assertFalse(temphum == energy)
self.assertTrue(light.device == light2.device)
self.assertFalse(light.device == energy.device)
self.assertFalse(temphum.device == energy.device)
self.assertFalse(
lighting5_subtype0.device == lighting5_subtype1.device)
core.close_connection()
async def test_one_cover(hass, rfxtrx):
"""Test with 1 cover."""
assert await async_setup_component(
hass,
"cover",
{
"cover": {
"platform": "rfxtrx",
"devices": {
"0b1400cd0213c7f210010f51": {
"name": "Test"
}
},
}
},
)
await hass.async_block_till_done()
hass.data[rfxtrx_core.DATA_RFXOBJECT] = rfxtrxmod.Core(
"", transport_protocol=rfxtrxmod.DummyTransport)
assert 1 == len(rfxtrx_core.RFX_DEVICES)
for id in rfxtrx_core.RFX_DEVICES:
entity = rfxtrx_core.RFX_DEVICES[id]
entity.hass = hass
assert entity.signal_repetitions == 1
assert not entity.should_fire_event
assert not entity.should_poll
entity.open_cover()
entity.close_cover()
entity.stop_cover()
def test_parse_bytes(self):
rfy = RFXtrx.lowlevel.parse(bytearray(b'\x08\x1A\x00\x00\x0A\x00\x01\x01\x03'))
self.assertEquals(rfy.__repr__(), "Rfy [subtype=0, seqnbr=0, id=0a0001:1, cmnd=Down]")
self.assertEquals(rfy.packetlength, 8)
self.assertEquals(rfy.subtype, 0)
self.assertEquals(rfy.type_string, "Rfy")
self.assertEquals(rfy.seqnbr, 0)
self.assertEquals(rfy.id_string, "0a0001:1")
self.assertEquals(rfy.cmnd, 3)
self.assertEquals(rfy.cmnd_string, "Down")
rfy = RFXtrx.lowlevel.Rfy()
rfy.set_transmit(0, 0, 0x0a0001, 1, 3)
self.assertEquals(rfy.__repr__(), "Rfy [subtype=0, seqnbr=0, id=0a0001:1, cmnd=Down]")
self.assertEquals(rfy.packetlength, 8)
self.assertEquals(rfy.subtype, 0)
self.assertEquals(rfy.type_string, "Rfy")
self.assertEquals(rfy.seqnbr, 0)
self.assertEquals(rfy.id_string, "0a0001:1")
self.assertEquals(rfy.cmnd, 3)
self.assertEquals(rfy.cmnd_string, "Down")
rfy = RFXtrx.lowlevel.Rfy()
rfy.parse_id(0, "0a0001:2")
self.assertEqual(rfy.unitcode, 2)
self.assertRaises(ValueError, rfy.parse_id, 0, "AA")
rfy = RFXtrx.get_device(0x1A, 0, "0a0001:1")
self.assertEquals(rfy.__str__(), "<class 'RFXtrx.RfyDevice'> type='Rfy' id='0a0001:1'")
self.assertEqual(rfy.unitcode, 1)
rfy = RFXtrx.lowlevel.parse(bytearray(b'\x08\x1A\x01\x00\x0A\x00\x01\x01\x05'))
self.assertEquals(rfy.cmnd_string, "Unknown command (0x05)")
self.assertEquals(rfy.type_string, "Unknown type (0x1a/0x01)")
def test_set_recmodes(self):
core = RFXtrx.Connect(self.path,
event_callback=_callback,
debug=False,
transport_protocol=RFXtrx.DummyTransport)
self.assertEquals(None, core._modes)
modes = [
'ac', 'arc', 'hideki', 'homeeasy', 'keeloq', 'lacrosse', 'oregon',
'rsl', 'x10'
]
bytes_array = bytearray(b'\x0D\x01\x00\x01\x02\x53\x45'
b'\x10' # msg3: rsl
b'\x0C' # msg4: hideki lacrosse
b'\x2F' # msg5: x10 arc ac homeeasy oregon
b'\x01' # msg6: keeloq
b'\x01\x00\x00' # unused
)
core._status = core.transport.receive(bytes_array)
core.set_recmodes(modes)
self.assertEquals(modes, core._modes)
# set an unknown mode
with self.assertRaises(ValueError):
core.set_recmodes(['arc', 'oregon', 'unknown-mode'])
def test_parse_bytes(self):
fan = RFXtrx.lowlevel.parse(bytearray(b'\x08\x17\x00\x00\x0A\x00\x01\x03\x00'))
self.assertEqual(fan.__repr__(), "Fan [subtype=0, seqnbr=0, id=0a0001, cmnd=Learn]")
self.assertEqual(fan.packetlength, 8)
self.assertEqual(fan.subtype, 0)
self.assertEqual(fan.type_string, "Siemens SF01")
self.assertEqual(fan.seqnbr, 0)
self.assertEqual(fan.id_string, "0a0001")
self.assertEqual(fan.cmnd, 3)
self.assertEqual(fan.cmnd_string, "Learn")
fan = RFXtrx.lowlevel.Fan()
fan.set_transmit(0, 0, 0x0a0001, 3)
self.assertEqual(fan.__repr__(), "Fan [subtype=0, seqnbr=0, id=0a0001, cmnd=Learn]")
self.assertEqual(fan.packetlength, 8)
self.assertEqual(fan.subtype, 0)
self.assertEqual(fan.type_string, "Siemens SF01")
self.assertEqual(fan.seqnbr, 0)
self.assertEqual(fan.id_string, "0a0001")
self.assertEqual(fan.cmnd, 3)
self.assertEqual(fan.cmnd_string, "Learn")
fan = RFXtrx.lowlevel.Fan()
fan.parse_id(0, "0a0001")
self.assertEqual(fan.id_string, "0a0001")
self.assertEqual(fan.id_combined, 0x0a0001)
self.assertRaises(ValueError, fan.parse_id, 0, "AA")
fan = RFXtrx.get_device(0x17, 0, "0a0001")
self.assertEqual(fan.__str__(), "<class 'RFXtrx.FanDevice'> type='Siemens SF01' id='0a0001'")
self.assertEqual(fan.id_combined, 0x0a0001)
fan = RFXtrx.lowlevel.parse(bytearray(b'\x08\x17\x02\x00\x0A\x00\x01\x06\x00'))
self.assertEqual(fan.cmnd_string, "Unknown command (0x06)")
self.assertEqual(fan.type_string, "Lucci Air AC")
fan = RFXtrx.lowlevel.parse(bytearray(b'\x08\x17\x0A\x00\x0A\x00\x01\x05\x00'))
self.assertEqual(fan.cmnd_string, "Unknown command (0x05)")
self.assertEqual(fan.type_string, "Unknown type (0x17/0x0a)")
fan = RFXtrx.get_device(0x17,3,'0a0001')
self.assertEqual(fan.subtype, 3)
self.assertEqual(fan.__str__(), "<class 'RFXtrx.FanDevice'> type='SEAV TXS4' id='0a0001'")
def test_constructor(self):
global num_calbacks
core = RFXtrx.Core(self.path, event_callback=_callback, transport_protocol=RFXtrx.DummyTransport2)
while num_calbacks < 6:
time.sleep(0.1)
self.assertEqual(len(core.sensors()),2)
self.assertTrue(core._thread.is_alive())
core.close_connection()
self.assertFalse(core._thread.is_alive())
def setup(hass, config):
"""Setup the RFXtrx component."""
# Declare the Handle event
def handle_receive(event):
"""Callback all subscribers for RFXtrx gateway."""
# Log RFXCOM event
if not event.device.id_string:
return
_LOGGER.info(
"Receive RFXCOM event from "
"(Device_id: %s Class: %s Sub: %s)",
slugify(event.device.id_string.lower()),
event.device.__class__.__name__, event.device.subtype)
# Callback to HA registered components.
for subscriber in RECEIVED_EVT_SUBSCRIBERS:
subscriber(event)
# Try to load the RFXtrx module.
import RFXtrx as rfxtrxmod
# Init the rfxtrx module.
global RFXOBJECT
device = config[DOMAIN][ATTR_DEVICE]
debug = config[DOMAIN][ATTR_DEBUG]
dummy_connection = config[DOMAIN][ATTR_DUMMY]
if dummy_connection:
RFXOBJECT =\
rfxtrxmod.Connect(device, handle_receive, debug=debug,
transport_protocol=rfxtrxmod.DummyTransport2)
else:
RFXOBJECT = rfxtrxmod.Connect(device, handle_receive, debug=debug)
def _shutdown_rfxtrx(event):
"""Close connection with RFXtrx."""
RFXOBJECT.close_connection()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown_rfxtrx)
return True
def get_rfx_object(packetid):
"""Return the RFXObject with the packetid."""
try:
binarypacket = bytearray.fromhex(packetid)
except ValueError:
return None
pkt = rfxtrxmod.lowlevel.parse(binarypacket)
if pkt is None:
return None
if isinstance(pkt, rfxtrxmod.lowlevel.SensorPacket):
obj = rfxtrxmod.SensorEvent(pkt)
elif isinstance(pkt, rfxtrxmod.lowlevel.Status):
obj = rfxtrxmod.StatusEvent(pkt)
else:
obj = rfxtrxmod.ControlEvent(pkt)
obj.data = binarypacket
return obj
def main():
if len(sys.argv) > 1:
rfxcom_device = sys.argv[1]
else:
rfxcom_device = '/dev/serial/by-id/usb-RFXCOM_RFXtrx433_A1Y0NJGR-if00-port0'
core = RFXtrx.Core(rfxcom_device, print_callback, debug=True)
while True:
print(core.sensors())
time.sleep(2)
def main():
if len(sys.argv) > 1:
rfxcom_device = sys.argv[1]
else:
rfxcom_device = '/dev/ttyUSB0'
core = RFXtrx.Core(rfxcom_device, print_callback, debug=True)
while True:
print(core.sensors())
time.sleep(2)
def main():
if len(sys.argv) >= 2:
rfxcom_device = sys.argv[1]
else:
rfxcom_device = '/dev/serial/by-id/usb-RFXCOM_RFXtrx433XL_DO2ZW4OB-if00-port0'
def on_message(client, userdata, message):
print('message topic=', message.topic)
if message.topic == '/seav_fan/t1':
fan.send_high(conn.transport)
elif message.topic == '/seav_fan/t2':
fan.send_medium(conn.transport)
elif message.topic == '/seav_fan/t3':
fan.send_low(conn.transport)
elif message.topic == '/seav_fan/t4':
fan.send_off(conn.transport)
time.sleep(3)
try:
conn = RFXtrx.Connect(rfxcom_device, print_callback, debug=True)
print(conn)
fan = RFXtrx.get_device(0x17, 0x03, "005545")
print('creating new mqtt client instance')
client = mqtt.Client("P1")
print('connecting to broker')
client.connect(broker_address)
print('subscribing to topics')
client.subscribe('/seav_fan/t1')
client.subscribe('/seav_fan/t2')
client.subscribe('/seav_fan/t3')
client.subscribe('/seav_fan/t4')
client.on_message = on_message
client.loop_forever()
finally:
conn.close_connection()
client.loop_stop()
def test_old_config(self):
"""Test with 1 light."""
assert setup_component(
self.hass,
"light",
{
"light": {
"platform": "rfxtrx",
"devices": {
"123efab1": {
"name": "Test",
"packetid": "0b1100cd0213c7f210010f51",
}
},
}
},
)
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT = rfxtrxmod.Core(
"", transport_protocol=rfxtrxmod.DummyTransport)
assert 1 == len(rfxtrx_core.RFX_DEVICES)
entity = rfxtrx_core.RFX_DEVICES["213c7f216"]
assert "Test" == entity.name
assert "off" == entity.state
assert entity.assumed_state
assert entity.signal_repetitions == 1
assert not entity.should_fire_event
assert not entity.should_poll
assert not entity.is_on
entity.turn_on()
assert entity.is_on
assert entity.brightness == 255
entity.turn_off()
assert not entity.is_on
assert entity.brightness == 0
entity.turn_on(brightness=100)
assert entity.is_on
assert entity.brightness == 100
entity.turn_on(brightness=10)
assert entity.is_on
assert entity.brightness == 10
entity.turn_on(brightness=255)
assert entity.is_on
assert entity.brightness == 255
def _test_transport(host, port, device):
"""Construct a rfx object based on config."""
if port is not None:
try:
conn = rfxtrxmod.PyNetworkTransport((host, port))
except OSError:
return False
conn.close()
else:
try:
conn = rfxtrxmod.PySerialTransport(device)
except serial.serialutil.SerialException:
return False
if conn.serial is None:
return False
conn.close()
return True
def get_rfx_object(packetid):
""" Return the RFXObject with the packetid. """
try:
import RFXtrx as rfxtrxmod
except ImportError:
_LOGGER.exception("Failed to import rfxtrx")
return False
binarypacket = bytearray.fromhex(packetid)
pkt = rfxtrxmod.lowlevel.parse(binarypacket)
if pkt is not None:
if isinstance(pkt, rfxtrxmod.lowlevel.SensorPacket):
obj = rfxtrxmod.SensorEvent(pkt)
elif isinstance(pkt, rfxtrxmod.lowlevel.Status):
obj = rfxtrxmod.StatusEvent(pkt)
else:
obj = rfxtrxmod.ControlEvent(pkt)
return obj
return None
def test_get_device(self):
core = RFXtrx.Connect(self.path, event_callback=_callback, debug=False, transport_protocol=RFXtrx.DummyTransport)
# Lighting1
bytes_array = bytearray([0x07, 0x10, 0x00, 0x2a, 0x45, 0x05, 0x01, 0x70])
event = core.transport.parse(bytes_array)
device = RFXtrx.get_device(event.device.packettype, event.device.subtype, event.device.id_string)
self.assertTrue(device==event.device)
# Lighting2
bytes_array =[0x0b, 0x11, 0x00, 0x2a, 0x01, 0x23, 0x45, 0x67, 0x05, 0x02, 0x07, 0x70]
event = core.transport.parse(bytes_array)
device = RFXtrx.get_device(event.device.packettype, event.device.subtype, event.device.id_string)
self.assertTrue(device==event.device)
# Lighting3
bytes_array = [0x08, 0x12, 0x00, 0x2a, 0x01, 0x34, 0x02, 0x15, 0x79]
event = core.transport.parse(bytes_array)
device = RFXtrx.get_device(event.device.packettype, event.device.subtype, event.device.id_string)
self.assertTrue(device==event.device)
# Lighting5
bytes_array = bytearray(b'\x0A\x14\x00\xAD\xF3\x94\xAB'
b'\x01\x01\x00\x60')
event = core.transport.parse(bytes_array)
device = RFXtrx.get_device(event.device.packettype, event.device.subtype, event.device.id_string)
self.assertTrue(device==event.device)
#Lighting 6
bytes_array = [0x0b, 0x15, 0x00, 0x2a, 0x12, 0x34, 0x41, 0x05, 0x03, 0x01, 0x00, 0x70]
event = core.transport.parse(bytes_array)
device = RFXtrx.get_device(event.device.packettype, event.device.subtype, event.device.id_string)
self.assertTrue(device==event.device)
#energy sensor
bytes_array = bytearray(b'\x11\x5A\x01\x00\x2E\xB2\x03\x00\x00'
b'\x02\xB4\x00\x00\x0C\x46\xA8\x11\x69')
event = core.transport.parse(bytes_array)
self.assertRaises(ValueError, RFXtrx.get_device,event.device.packettype, event.device.subtype, event.device.id_string)
core.close_connection()
def setup_rfxtrx(config, loop, mqtt_client, debug):
def rfxtrx_event_callback(event):
asyncio.run_coroutine_threadsafe(handle_event(event, mqtt_client, config), loop)
try:
rfxtrx_device = config["rfxtrx"]["device"]
log.info(f"Using RFXtrx device '{rfxtrx_device}'")
# RFXtrx.Connect starts and runs its own thread
rfxtrx_conn = RFXtrx.Connect(rfxtrx_device, rfxtrx_event_callback, debug=debug)
return rfxtrx_conn
except Exception:
log.exception("Failed to setup RFXtrx device")
sys.exit(2)
def setup(hass, config):
"""Setup the RFXtrx component."""
# Declare the Handle event
def handle_receive(event):
"""Callback all subscribers for RFXtrx gateway."""
# Log RFXCOM event
if not event.device.id_string:
return
_LOGGER.info("Receive RFXCOM event from %s", event.device)
# Callback to HA registered components.
for subscriber in RECEIVED_EVT_SUBSCRIBERS:
subscriber(event)
# Try to load the RFXtrx module.
import RFXtrx as rfxtrxmod
# Init the rfxtrx module.
global RFXOBJECT
device = config[DOMAIN][ATTR_DEVICE]
debug = config[DOMAIN][ATTR_DEBUG]
dummy_connection = config[DOMAIN][ATTR_DUMMY]
if dummy_connection:
RFXOBJECT =\
rfxtrxmod.Core(device, handle_receive, debug=debug,
transport_protocol=rfxtrxmod.DummyTransport2)
else:
RFXOBJECT = rfxtrxmod.Core(device, handle_receive, debug=debug)
def _shutdown_rfxtrx(event):
RFXOBJECT.close_connection()
hass.bus.listen_once(EVENT_BLUMATE_STOP, _shutdown_rfxtrx)
return True
def test_one_light(self):
"""Test with 1 light."""
self.assertTrue(
_setup_component(
self.hass, 'light', {
'light': {
'platform': 'rfxtrx',
'devices': {
'0b1100cd0213c7f210010f51': {
'name': 'Test'
}
}
}
}))
import RFXtrx as rfxtrxmod
rfxtrx_core.RFXOBJECT =\
rfxtrxmod.Core("", transport_protocol=rfxtrxmod.DummyTransport)
self.assertEqual(1, len(rfxtrx_core.RFX_DEVICES))
entity = rfxtrx_core.RFX_DEVICES['213c7f216']
self.assertEqual('Test', entity.name)
self.assertEqual('off', entity.state)
self.assertTrue(entity.assumed_state)
self.assertEqual(entity.signal_repetitions, 1)
self.assertFalse(entity.should_fire_event)
self.assertFalse(entity.should_poll)
self.assertFalse(entity.is_on)
entity.turn_on()
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 255)
entity.turn_off()
self.assertFalse(entity.is_on)
self.assertEqual(entity.brightness, 0)
entity.turn_on(brightness=100)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 100)
entity.turn_on(brightness=10)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 10)
entity.turn_on(brightness=255)
self.assertTrue(entity.is_on)
self.assertEqual(entity.brightness, 255)
def test_parse_bytes(self):
rollertrol = RFXtrx.lowlevel.parse(
bytearray(b'\x09\x19\x00\x00\x00\x9b\xa8\x01\x01\x00'))
self.assertEquals(
rollertrol.__repr__(),
"RollerTrol [subtype=0, seqnbr=0, id=009ba8:1, cmnd=Down, rssi=0]")
self.assertEquals(rollertrol.packetlength, 9)
self.assertEquals(rollertrol.subtype, 0)
self.assertEquals(rollertrol.type_string, "RollerTrol")
self.assertEquals(rollertrol.seqnbr, 0)
self.assertEquals(rollertrol.id_string, "009ba8:1")
self.assertEquals(rollertrol.cmnd, 1)
self.assertEquals(rollertrol.cmnd_string, "Down")
self.assertEquals(rollertrol.rssi_byte, 0)
self.assertEquals(rollertrol.rssi, 0)
rollertrol = RFXtrx.lowlevel.RollerTrol()
rollertrol.set_transmit(0, 0, 0x009ba8, 1, 1)
self.assertEquals(
rollertrol.__repr__(),
"RollerTrol [subtype=0, seqnbr=0, id=009ba8:1, cmnd=Down, rssi=0]")
self.assertEquals(rollertrol.packetlength, 9)
self.assertEquals(rollertrol.subtype, 0)
self.assertEquals(rollertrol.type_string, "RollerTrol")
self.assertEquals(rollertrol.seqnbr, 0)
self.assertEquals(rollertrol.id_string, "009ba8:1")
self.assertEquals(rollertrol.cmnd, 1)
self.assertEquals(rollertrol.cmnd_string, "Down")
self.assertEquals(rollertrol.rssi_byte, 0)
self.assertEquals(rollertrol.rssi, 0)
rollertrol = RFXtrx.lowlevel.RollerTrol()
rollertrol.parse_id(0, "009ba8:2")
self.assertEqual(rollertrol.unitcode, 2)
self.assertRaises(ValueError, rollertrol.parse_id, 0, "AA")
rollertrol = RFXtrx.get_device(0x19, 0, "009ba8:1")
self.assertEquals(
rollertrol.__str__(),
"<class 'RFXtrx.RollerTrolDevice'> type='RollerTrol' id='009ba8:1'"
)
self.assertEqual(rollertrol.unitcode, 1)
rollertrol = RFXtrx.lowlevel.parse(
bytearray(b'\x09\x19\x02\x00\x00\x9b\xa8\x01\x05\x00'))
self.assertEquals(rollertrol.cmnd_string, "Unknown command (0x05)")
self.assertEquals(rollertrol.type_string, "Unknown type (0x19/0x02)")
