def main(): global args pilight_client = None try: parser = argparse.ArgumentParser(description='Test for 433Mhz sensors') parser.add_argument('--raw', help='show raw sensor readings', action="store_true") parser.add_argument('-S', '--server', help='Server to connect with pilight daemon', default='127.0.0.1') parser.add_argument('-P', '--port', help='Port to connect with pilight daemon', default=5000) parser.add_argument( '-p', '--protocol', help='show only sensor readings with this protocol') parser.add_argument( '-m', '--message-key', help='show only sensor readings containing this key in the message' ) parser.add_argument('-v', '--verbose', help='show verbose output', action="store_true") parser.add_argument('--blink', help='say anything on receiving', action="store_true") args = parser.parse_args() server433 = args.server port433 = args.port print "\n*** gw 433Mhz Testprogramm zum Sensorempfang ***" print "Verbinde zu pilight-daemon an {0} über Port {1}\n".format( server433, port433) # Create new pilight connection pilight_client = pilight.Client(host=server433, port=port433) # Set a data handle that is called on received data pilight_client.set_callback(handle_code) pilight_client.start() # Start the receiver print "Beginne Überwachung..\n" if args.raw: print "Zeige Rohdaten..\n" while True: time.sleep(5) except KeyboardInterrupt: print "\nAbbruch durch Benutzer Ctrl+C\n" except RuntimeError, e: print "RuntimeError {0}".format(e)
def test_invalid_identification(self): """Send an invalid identification and check for connection failure.""" recv_ident = {"action": "invalid"} with self.assertRaises(IOError): with pilight_daemon.PilightDaemon(send_codes=True): pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT, recv_ident=recv_ident)
def test_send_code(self): """Test for successfull code send.""" with pilight_daemon.PilightDaemon() as my_daemon: pilight_client = pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT) pilight_client.send_code(data={'protocol': 'daycom'}) time.sleep(1) self.assertEqual(my_daemon.get_data()['code'], {'protocol': 'daycom'})
def test_no_callback(self): """Test for no callback defined.""" with pilight_daemon.PilightDaemon(send_codes=True): pilight_client = pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT) pilight_client.start() time.sleep(1) # Give time to set thread status self.assertFalse(pilight_client.isAlive()) pilight_client.stop()
def __init__(self): super(PilightCKSkill, self).__init__(name="PilightCKSkill") # Initialize working variables used within the skill. self.data = { "protocol": ["intertechno_old"], "id": 1, "unit": 0, "off": 1 } pilight_client = pilight.Client(host='pick', port=5000)
def test_receive_code(self, mock): """Test for successfull code received.""" with pilight_daemon.PilightDaemon(send_codes=True): pilight_client = pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT) pilight_client.set_callback(_callback) pilight_client.start() time.sleep(2) pilight_client.stop() # Check if callback was called several times with expected data mock.assert_has_calls([call(pilight_daemon.FAKE_DATA)] * 10)
def test_send_code_fail(self): """Tests for failed code send.""" with pilight_daemon.PilightDaemon(): pilight_client = pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT) # Test 1: Use unknows protocol with self.assertRaises(IOError): pilight_client.send_code(data={'protocol': 'unknown'}) # Test 2: Do not send protocoll info, thus Value Error expected with self.assertRaises(ValueError): pilight_client.send_code(data={'no_protocol': 'test'})
def test_api(self): """Tests connection with different receiver filter and identification.""" recv_ident = { "action": "identify", "options": { "core": 1, # To get CPU load and RAM of pilight daemon "receiver": 1 # To receive the RF data received by pilight } } with pilight_daemon.PilightDaemon(send_codes=True): pilight_client = pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT, recv_ident=recv_ident, recv_codes_only=False) pilight_client.set_callback(_callback) pilight_client.start() time.sleep(1) pilight_client.stop()
def test_no_receive_filter(self, mock): """Test for successfull code received.""" with pilight_daemon.PilightDaemon(send_codes=True): pilight_client = pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT, veto_repeats=False) pilight_client.set_callback(_callback) pilight_client.start() time.sleep(2) pilight_client.stop() # Check if calls with repeats != 1 have been made calls = [] for i in range(10): fake_data = pilight_daemon.FAKE_DATA.copy() fake_data['repeats'] = i + 1 calls.append(call(fake_data)) mock.assert_has_calls(calls)
# Post data to REST API post_temperature_data({ 'sensor_id': sensor_id, 'binary_state': binary_state, 'source': 'raspberry' }) last_binary_sensor_message = code['message'] elif 'arctech' in code['protocol']: # ignore all other arctech entries (they are the same as artec_contact) pass else: print("--- !!!! Unknown protocl --- ") print(datetime.now(), code['protocol'], code) # pylint: disable=C0103 if __name__ == '__main__': # Create new pilight connection that runs on localhost with port 5000 pilight_client = pilight.Client(host='127.0.0.1', port=5000, veto_repeats=False) # Set a data handle that is called on received data pilight_client.set_callback(handle_code) pilight_client.start() # Start the receiver # You have 10 seconds to print all the data the pilight-daemon receives time.sleep(100000000) pilight_client.stop() # Stop the receiver
def setup(hass, config): """Setup the pilight component.""" from pilight import pilight try: pilight_client = pilight.Client(host=config[DOMAIN][CONF_HOST], port=config[DOMAIN][CONF_PORT]) except (socket.error, socket.timeout) as err: _LOGGER.error("Unable to connect to %s on port %s: %s", config[CONF_HOST], config[CONF_PORT], err) return False # Start / stop pilight-daemon connection with HA start/stop def start_pilight_client(_): """Called once when home assistant starts.""" pilight_client.start() hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_pilight_client) def stop_pilight_client(_): """Called once when home assistant stops.""" pilight_client.stop() hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_pilight_client) def send_code(call): """Send RF code to the pilight-daemon.""" message_data = call.data # Patch data because of bug: # https://github.com/pilight/pilight/issues/296 # Protocol has to be in a list otherwise segfault in pilight-daemon message_data["protocol"] = ensure_list(message_data["protocol"]) try: pilight_client.send_code(message_data) except IOError: _LOGGER.error('Pilight send failed for %s', str(message_data)) hass.services.register(DOMAIN, SERVICE_NAME, send_code, schema=RF_CODE_SCHEMA) # Publish received codes on the HA event bus # A whitelist of codes to be published in the event bus whitelist = config[DOMAIN].get('whitelist', False) def handle_received_code(data): """Called when RF codes are received.""" # Unravel dict of dicts to make event_data cut in automation rule # possible data = dict({ 'protocol': data['protocol'], 'uuid': data['uuid'] }, **data['message']) # No whitelist defined, put data on event bus if not whitelist: hass.bus.fire(EVENT, data) # Check if data matches the defined whitelist elif all(data[key] in whitelist[key] for key in whitelist): hass.bus.fire(EVENT, data) pilight_client.set_callback(handle_received_code) return True
"""Example how to to simply send RF commands. A running pilight-daemon is needed. """ from pilight import pilight # pylint: disable=C0103 if __name__ == '__main__': # Create new pilight connection that runs on localhost with port 5000 pilight_client = pilight.Client(host='127.0.0.1', port=5000) # Send a good code. It is checked to be acknoledged by the piligt-daemon. # Data from https://manual.pilight.org/en/api pilight_client.send_code(data={ "protocol": ["kaku_switch"], "id": 1, "unit": 0, "off": 1 }) # Send a wrong code that lead to an IO error since the pilight-daemon # rejects it. Data from https://manual.pilight.org/en/api pilight_client.send_code( data={ "protocol": ["kaku_switch"], "id": 0, # ID has to be > 0 "unit": 0, "off": 1 })
def test_client_connection_fail(self): """Test for failing pilight daemon connection.""" with pilight_daemon.PilightDaemon(): with self.assertRaises(IOError): pilight.Client(host='8.8.8.8', port=0)
def test_client_connection(self): """Test for successfull pilight daemon connection.""" with pilight_daemon.PilightDaemon(): pilight.Client(host=pilight_daemon.HOST, port=pilight_daemon.PORT)
values = {} for key, value in config["devices"].items(): if "id" in value and "id" in value["id"][0]: value["id"] = value["id"][0]["id"] if key in config["gui"]: name = config["gui"][key]["name"].replace(" und ", "&") else: name = key value["name"] = (name + 10 * " ")[:10] value["unit"] = "c" values[value["id"]] = value lcd_config = None for path in ("/etc/pilight", os.path.dirname("__file__")): if os.path.exists(os.path.join(path, "lcd-config.json")): lcd_config = os.path.join(path, "lcd-config.json") while True: connector = PilightConnector(values, lcd_config) print(values) # Create new pilight connection that runs on localhost with port 5000 pilight_client = pilight.Client(host='127.0.0.1', port=config.get("settings", {}).get("port", 5000)) # Set a data handle that is called on received data pilight_client.set_callback(connector.handle_code) pilight_client.start() # Start the receiver # restart every hour becuase sometimes the lcd connection breaks time.sleep(3600) pilight_client.stop() # Stop the receiver
if __name__ == '__main__': # Suscribe receiver to core info to have something to receive # asynchrounosly. With std. settings the receiver calls the # data handle only on received codes! recv_ident = { "action": "identify", "options": { "core": 1, # To get CPU load and RAM of pilight daemon "receiver": 1 # To receive the RF data received by pilight } } # Create new pilight connection that runs on localhost with port 5000 # Turn off to print core info and send info of the pilight-daemon pilight_client = pilight.Client(host='127.0.0.1', port=5000, recv_ident=recv_ident, recv_codes_only=False) # Set a data handle that is called on received data pilight_client.set_callback(handle_code) pilight_client.start() # Start the receiver # While the received data is handled you can also send commands # Data from https://manual.pilight.org/en/api data = {"protocol": ["kaku_switch"], "id": 1, "unit": 0, "off": 1} for i in range(5): data['id'] = i + 1 # ID > 0 for the kaku_switch protocoll
def setup(hass, config): """Set up the Pilight component.""" from pilight import pilight host = config[DOMAIN][CONF_HOST] port = config[DOMAIN][CONF_PORT] send_throttler = CallRateDelayThrottle(hass, config[DOMAIN][CONF_SEND_DELAY]) try: pilight_client = pilight.Client(host=host, port=port) except (socket.error, socket.timeout) as err: _LOGGER.error("Unable to connect to %s on port %s: %s", host, port, err) return False def start_pilight_client(_): """Run when Home Assistant starts.""" pilight_client.start() hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_pilight_client) def stop_pilight_client(_): """Run once when Home Assistant stops.""" pilight_client.stop() hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_pilight_client) @send_throttler.limited def send_code(call): """Send RF code to the pilight-daemon.""" # Change type to dict from mappingproxy since data has to be JSON # serializable message_data = dict(call.data) try: pilight_client.send_code(message_data) except OSError: _LOGGER.error("Pilight send failed for %s", str(message_data)) hass.services.register(DOMAIN, SERVICE_NAME, send_code, schema=RF_CODE_SCHEMA) # Publish received codes on the HA event bus # A whitelist of codes to be published in the event bus whitelist = config[DOMAIN].get(CONF_WHITELIST) def handle_received_code(data): """Run when RF codes are received.""" # Unravel dict of dicts to make event_data cut in automation rule # possible data = dict({ "protocol": data["protocol"], "uuid": data["uuid"] }, **data["message"]) # No whitelist defined, put data on event bus if not whitelist: hass.bus.fire(EVENT, data) # Check if data matches the defined whitelist elif all(str(data[key]) in whitelist[key] for key in whitelist): hass.bus.fire(EVENT, data) pilight_client.set_callback(handle_received_code) return True
def pilight_send(command): pilight_connection = pilight.Client(host=PILIGHT_HOST) print('Send command {}'.format(command)) return pilight_connection.send_code(data=command)