def energy_monitor_loop(): global switch_state # Process any received messages from the real radio energenie.loop() time.sleep(APP_DELAY)
def main(): global mqtt_hostname global mqtt_port global mqtt_keepalive global mqtt_username global mqtt_password global mqtt_client_id global mqtt_clean_session global energenie_devices # Bind event receiver for inbound energenie messages print("Binding fsk_router.when_incoming to rx_energenie...") energenie.fsk_router.when_incoming(rx_energenie) # Start thread for processing received inbound energenie, then sending to mqtt print("Starting rx_energenie_process thread...") thread_rxEnergenie = threading.Thread(target=rx_energenie_process, name="rx_energenie_process") thread_rxEnergenie.daemon = True thread_rxEnergenie.start() # Start thread for processing received inbound energenie, then sending to mqtt print("Starting energenie_tx_mqtt thread...") thread_energenieTxMqtt = threading.Thread(target=energenie_tx_mqtt, name="energenie_tx_mqtt") thread_energenieTxMqtt.daemon = True thread_energenieTxMqtt.start() # Start thread for receiving inbound mqtt messages, which will queue them for the other thread print("Starting rxFromMqtt thread...") thread_rxFromMqtt = threading.Thread(target=rx_mqtt, name="rx_mqtt") thread_rxFromMqtt.daemon = True thread_rxFromMqtt.start() print("Iterating devices in registry so they bind to receive router, and adding to energenie_devices dict for future easy reference...") names = energenie.registry.names() for name in names: print( "...Binding device " + name + "...") device = energenie.registry.get(name) # Used by rx_energenie to have a handy device name and device object, since the registry does this oddly energenie_devices[device.get_device_id()] = { 'name': name, 'device': device } print("Starting main receiver loop...") # Main processing loop for the energenie radio; loop command checks receive threads while not programkiller.kill_now: energenie.loop() try: msg = q_rx_mqtt.get(block=False) except Queue.Empty as e: # Empty queue means do nothing, just keep trying to receive pass else: mqtt_tx_energenie(msg=msg) q_rx_mqtt.task_done() time.sleep(ENERGENIE_SLEEP_WAIT)
def do_mihome_discovery(): """Discover any mihome device when it sends reports""" print("Discovery mode, press Ctrl-C to stop") energenie.discovery_ask(energenie.ask) try: while True: energenie.loop() # Allow receive processing time.sleep(0.25) # tick fast enough to get messages in quite quickly except KeyboardInterrupt: print("Discovery stopped")
def sensor_monitor_loop(feeds, devices): d_plug, d_open, d_motion = devices f_monitor, f_open, f_motion = feeds # Process any received messages from the real radio energenie.loop() print("Checking device status d_plug") try: power = d_plug.get_real_power() print("Power: %s" % str(power)) share_dict = { u"timestamp": datetime.datetime.now().isoformat(), u"power": power } PPR.pprint(share_dict) f_monitor.share_async(share_dict) except Exception as e: # pylint: disable=broad-except print("failed to get power") print(e) print("Checking device status d_open") try: switch = d_open.get_switch_state() print("Open: %s" % str(switch)) if switch is not None: share_dict = { u"timestamp": datetime.datetime.now().isoformat(), u"open": switch } PPR.pprint(share_dict) f_open.share_async(share_dict) except Exception as e: # pylint: disable=broad-except print("failed to get switch state") print(e) print("Checking device status d_motion") try: switch = d_motion.get_switch_state() print("Motion: %s" % str(switch)) if switch is not None: share_dict = { u"timestamp": datetime.datetime.now().isoformat(), u"motion": switch } PPR.pprint(share_dict) f_motion.share_async(share_dict) except Exception as e: # pylint: disable=broad-except print("failed to get switch") print(e) sleep(APP_DELAY)
def do_mihome_discovery(): """Discover any mihome device when it sends reports""" print("Discovery mode, press Ctrl-C to stop") energenie.discovery_ask(energenie.ask) try: while True: energenie.loop() # Allow receive processing time.sleep( 0.25) # tick fast enough to get messages in quite quickly except KeyboardInterrupt: print("Discovery stopped")
def discover_mihome(): # Select your discovery behaviour from one of these: ##energenie.discovery_auto() energenie.discovery_ask(ask_fn) ##energenie.discovery_autojoin() ##energenie.discovery_askjoin(ask_fn) # Run the receive loop permanently, so that receive messages are processed try: print("Discovery running, Ctrl-C to stop") while True: energenie.loop() except KeyboardInterrupt: pass # user abort
def in_background(socket_runner): global NEW_DEVICE_IDS # pylint: disable=global-statement socket_runner.run(background=True) try: while True: logger.info('Calling Energenie Loop') NEW_DEVICE_IDS = [] energenie.loop() for productid, sensorid in NEW_DEVICE_IDS: logger.info("device_id: %s", sensorid) auto_name = "auto_%s_%s" % (str(hex(productid)), str(hex(sensorid))) socket_runner.new_socket(energenie.registry.get(auto_name)) sleep(2) except KeyboardInterrupt: pass finally: socket_runner.stop()
def in_background(socket_runner): global NEW_DEVICE_IDS # pylint: disable=global-statement socket_runner.run(background=True) try: while True: logger.info('Calling Energenie Loop') NEW_DEVICE_IDS = [] energenie.loop() for productid, sensorid in NEW_DEVICE_IDS: logger.info("device_id: %s", sensorid) auto_name = "auto_%s_%s" % (str( hex(productid)), str(hex(sensorid))) socket_runner.new_socket(energenie.registry.get(auto_name)) sleep(2) except KeyboardInterrupt: pass finally: socket_runner.stop()
def energy_monitor_loop(): global switch_state # Process any received messages from the real radio energenie.loop() # For all devices in the registry, if they have a switch, toggle it for d in energenie.registry.devices(): if d.has_switch(): d.set_switch(switch_state) switch_state = not switch_state # For all devices in the registry, print any readings print("Checking device status") for d in energenie.registry.devices(): readings = d.get_readings_summary() print("%s %s" % (str(d), readings)) time.sleep(APP_DELAY)
def do_watch_devices(): """Repeatedly show readings for all devices""" print("Watching devices, Ctrl-C to stop") try: while True: energenie.loop() # allow receive processing print('-' * 80) names = energenie.registry.names() for name in names: device = energenie.registry.get(name) readings = device.get_readings_summary() print("%s %s" % (name, readings)) print("") time.sleep(1) except KeyboardInterrupt: pass # user exit
def sensor_monitor_loop(feeds, devices): d_plug, d_open, d_motion = devices f_monitor, f_open, f_motion = feeds # Process any received messages from the real radio energenie.loop() print("Checking device status d_plug") try: power = d_plug.get_real_power() print("Power: %s" % str(power)) share_dict = {u"timestamp": datetime.datetime.now().isoformat(), u"power": power} PPR.pprint(share_dict) f_monitor.share_async(share_dict) except Exception as e: # pylint: disable=broad-except print("failed to get power") print(e) print("Checking device status d_open") try: switch = d_open.get_switch_state() print("Open: %s" % str(switch)) if switch is not None: share_dict = {u"timestamp": datetime.datetime.now().isoformat(), u"open": switch} PPR.pprint(share_dict) f_open.share_async(share_dict) except Exception as e: # pylint: disable=broad-except print("failed to get switch state") print(e) print("Checking device status d_motion") try: switch = d_motion.get_switch_state() print("Motion: %s" % str(switch)) if switch is not None: share_dict = {u"timestamp": datetime.datetime.now().isoformat(), u"motion": switch} PPR.pprint(share_dict) f_motion.share_async(share_dict) except Exception as e: # pylint: disable=broad-except print("failed to get switch") print(e) sleep(APP_DELAY)
def do_logging(): """Enter a mode where all communications are logged to screen and a file""" import Logger # provide a default incoming message handler for all fsk messages def incoming(address, message): print("\nIncoming from %s" % str(address)) print(message) Logger.logMessage(message) energenie.fsk_router.when_incoming(incoming) print("Logging enabled, Ctrl-C to stop") try: while True: energenie.loop() except KeyboardInterrupt: pass #user quit finally: energenie.fsk_router.when_incoming(None)
def energy_monitor_loop(): global switch_state # Process any received messages from the real radio energenie.loop() # For all devices in the registry, if they have a switch, toggle it for d in energenie.registry.devices(): if d.has_switch(): d.set_switch(switch_state) switch_state = not switch_state # For all devices in the registry, if they have a get_power(), call it print("Checking device status") for d in energenie.registry.devices(): print(d) try: p = d.get_power() print("Power: %s" % str(p)) except: pass # Ignore it if can't provide a power time.sleep(APP_DELAY)
#!/usr/bin/env python3 import time import energenie APP_DELAY = 1 energenie.init() mon1 = energenie.registry.get('mon1') mon2 = energenie.registry.get('mon2') mon3 = energenie.registry.get('mon3') mon4 = energenie.registry.get('mon4') mons = [mon1, mon2, mon3, mon4] print("======") while True: energenie.loop() time.sleep(1) print("") print("==========================") for mon in mons: r = mon.get_readings() print("%s v" % r.voltage) #print("%s A" % r.current) print("%s w (real)" % r.real_power) #print("%s w (apparent)" % r.apparent_power) print("%s w (reactive)" % r.reactive_power) print("%s Hz" % r.frequency) print("-")