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 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_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 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 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)
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("-")
