def init():
L.l.info('PiGpio initialising')
P.pwm = PwmIo(obj=m.Pwm)
if P.import_ok:
try:
if _try_connect():
P.pi = pigpio.pi()
# test if daemon is on
P.pi.get_current_tick()
# setup this to receive list of ports that must be set as "IN" and have callbacks defined
# dispatcher.connect(setup_in_ports, signal=Constant.SIGNAL_GPIO_INPUT_PORT_LIST, sender=dispatcher.Any)
P.initialised = True
# set alternate mqtt send topic to avoid message overload on low cpu devices
m.Pwm.add_upsert_listener(_pwm_upsert_listener)
thread_pool.add_interval_callable(thread_run, run_interval_second=30)
L.l.info('PiGpio initialised OK')
else:
L.l.info('Unable to initialise pigpio, cannot connect')
if Constant.HOST_NAME == 'netbook':
m.Pwm.add_upsert_listener(_pwm_upsert_listener)
except Exception as ex1:
L.l.info('Unable to initialise PiGpio, err={}'.format(ex1))
P.pi = None
P.initialised = False
else:
L.l.info('PiGpio NOT initialised, module unavailable on this system')
def init():
L.l.debug("GPIO initialising")
if Constant.IS_MACHINE_RASPBERRYPI or Constant.IS_MACHINE_ODROID:
pcf8574_gpio.init()
# piface.init()
rpi_gpio.init()
pigpio_gpio.init()
# if Constant.IS_MACHINE_BEAGLEBONE:
# bbb_io.init()
# std_gpio.init()
if Constant.is_os_windows():
pigpio_gpio.init()
# init last after RPI
piface.init()
# init IO Sensors
_init_io()
m.ZoneCustomRelay.add_upsert_listener(zone_custom_relay_upsert_listener)
thread_pool.add_interval_callable(thread_run, run_interval_second=1)
P.initialised = True
if False: # L.DEBUG_REMOTE:
try:
import ptvsd
ptvsd.enable_attach(address=('0.0.0.0', 5678),
redirect_output=True)
print(
'Enabled remote debugging, waiting 15 seconds for client to attach'
)
ptvsd.wait_for_attach(timeout=15)
except Exception as ex:
print("Error in remote debug: {}".format(ex))
def init():
L.l.info('Wemo module initialising')
global _pooler
# Set up our singleton for polling the sockets for data read
_pooler = poller()
# Set up our singleton listener for UPnP broadcasts
u = upnp_broadcast_responder()
u.init_socket()
# Add the UPnP broadcast listener to the poller so we can respond
# when a broadcast is received.
_pooler.add(u)
# NOTE: As of 2015-08-17, the Echo appears to have a hard-coded limit of
# 16 switches it can control. Only the first 16 elements of the FAUXMOS
# list will be used.
alexa_list = get_alexawemo_rules()
index = 0
for rule_entry in alexa_list.keys():
# a fixed port wasn't specified, use a dynamic one
dev_name = rule_entry.replace('_', ' ')
switch = fauxmo(dev_name=dev_name,
listener=u,
pooller=_pooler,
ip_address=None,
port=0,
index=index,
action_handler_on=alexa_list[rule_entry][0],
action_handler_off=alexa_list[rule_entry][1])
index += 1
thread_pool.add_interval_callable(_pooler.poll, run_interval_second=0.5)
def init():
from main import thread_pool
L.l.info('Transport initialising')
thread_pool.add_interval_callable(thread_run, run_interval_second=1)
mqtt_io.init()
global initialised
initialised = True
def init():
thread_pool.add_interval_callable(thread_run,
run_interval_second=P.interval,
long_running=True)
dispatcher.connect(_init_recovery,
signal=Constant.SIGNAL_USB_DEVICE_CHANGE,
sender=dispatcher.Any)
def init():
L.l.info('Heat module initialising')
dispatcher.connect(handle_event_heat,
signal=Constant.SIGNAL_HEAT,
sender=dispatcher.Any)
thread_pool.add_interval_callable(heat_loop.thread_run, 60)
global initialised
initialised = True
def init():
from main import thread_pool
L.l.info('Transport initialising')
thread_pool.add_interval_callable(thread_run_send, run_interval_second=0.1)
thread_pool.add_interval_callable(thread_run_recv, run_interval_second=0.1)
mqtt_io.init()
# utils.init_debug()
P.initialised = True
def init():
dispatcher.connect(handle_local_event_db_post,
signal=Constant.SIGNAL_UI_DB_POST,
sender=dispatcher.Any)
dispatcher.connect(handle_event_mqtt_received,
signal=Constant.SIGNAL_MQTT_RECEIVED,
sender=dispatcher.Any)
thread_pool.add_interval_callable(mqtt_thread_run, run_interval_second=0.5)
def init():
L.l.info('Sonoff module initialising')
P.sonoff_topic = str(get_json_param(Constant.P_MQTT_TOPIC_SONOFF_1))
# mqtt_io.P.mqtt_client.message_callback_add(P.sonoff_topic, mqtt_on_message)
mqtt_io.add_message_callback(P.sonoff_topic, mqtt_on_message)
_read_mac_files()
thread_pool.add_interval_callable(thread_run, P.check_period, long_running=True)
P.initialised = True
def init():
L.l.debug('Monitor module initialising')
health_monitor_loop.init()
thread_pool.add_interval_callable(func=health_monitor_loop.thread_run,
run_interval_second=10)
global initialised
# health_monitor_loop.thread_run()
initialised = True
def init():
L.l.info('Heat module initialising')
dispatcher.connect(_handle_presence,
signal=Constant.SIGNAL_PRESENCE,
sender=dispatcher.Any)
thread_pool.add_interval_callable(thread_run, 30)
P.initialised = True
m.ZoneHeatRelay.add_upsert_listener(_zoneheatrelay_upsert_listener)
m.ZoneThermostat.add_upsert_listener(_zonethermostat_upsert_listener)
def init():
L.l.info('Openhab module initialising')
rules.P.openhab_topic = str(model_helper.get_param(Constant.P_MQTT_TOPIC_OPENHAB_SEND))
P.mqtt_topic_receive = str(model_helper.get_param(Constant.P_MQTT_TOPIC_OPENHAB_RECEIVE))
P.mqtt_topic_receive_prefix = P.mqtt_topic_receive.replace('#', '')
mqtt_io.P.mqtt_client.message_callback_add(P.mqtt_topic_receive, mqtt_on_message)
__load_rules()
thread_pool.add_interval_callable(thread_run, run_interval_second=1)
dispatcher.connect(parse_rules, signal=Constant.SIGNAL_DB_CHANGE_FOR_RULES, sender=dispatcher.Any)
P.initialised = True
def init():
L.l.info('Beaglebone IO module initialising')
try:
dispatcher.connect(setup_in_ports,
signal=Constant.SIGNAL_GPIO_INPUT_PORT_LIST,
sender=dispatcher.Any)
thread_pool.add_interval_callable(thread_run, run_interval_second=10)
global initialised
initialised = True
except Exception, ex:
L.l.critical('Module io_bbb not initialised, err={}'.format(ex))
def init():
L.l.debug("GPIO initialising")
if Constant.IS_MACHINE_RASPBERRYPI:
piface.init()
# pigpio_gpio.init()
rpi_gpio.init()
if Constant.IS_MACHINE_BEAGLEBONE:
# bbb_io.init()
std_gpio.init()
thread_pool.add_interval_callable(thread_run, run_interval_second=1)
P.initialised = True
def init():
L.l.info('BMS module initialising')
thread_pool.add_interval_callable(thread_run, run_interval_second=90)
m.Bms.add_upsert_listener(bms_upsert_listener)
P.manager = gatt.DeviceManager(adapter_name='hci0')
P.bluetooth_manager = threading.Thread(target=bluetooth_manager_thread,
args=[
P.manager,
])
P.bluetooth_manager.start()
P.initialised = True
def init():
L.l.debug('Presence module initialising')
thread_pool.add_interval_callable(presence_wifi.thread_run,
run_interval_second=20)
dispatcher.connect(handle_event_presence_io,
signal=Constant.SIGNAL_GPIO,
sender=dispatcher.Any)
dispatcher.connect(handle_event_presence_cam,
signal=Constant.SIGNAL_CAMERA,
sender=dispatcher.Any)
global initialised
initialised = True
def init():
global initialised, __CLIENT_SECRETS_FILE, __youtube
try:
__CLIENT_SECRETS_FILE = utils.get_app_root_path() + model_helper.get_param(Constant.P_YOUTUBE_CREDENTIAL_FILE)
L.l.info('Initialising youtube with credential from {}'.format(__CLIENT_SECRETS_FILE))
__youtube = get_authenticated_service([])
dispatcher.connect(file_watcher_event, signal=Constant.SIGNAL_FILE_WATCH, sender=dispatcher.Any)
thread_pool.add_interval_callable(thread_run, run_interval_second=10)
initialised = True
# upload_file('c:\\temp\\01-20150512215655-alert.avi')
except Exception as ex:
L.l.warning('Unable to initialise youtube uploader, err={}'.format(ex))
def init():
try:
# https://stackoverflow.com/questions/11029717/how-do-i-disable-log-messages-from-the-requests-library
logging.getLogger("requests").setLevel(logging.WARNING)
dispatcher.connect(_store_record,
signal=Constant.SIGNAL_STORABLE_RECORD,
sender=dispatcher.Any)
thread_pool.add_interval_callable(thread_run, run_interval_second=60)
except Exception as ex:
L.l.warning(
"Unable to read config or init thingspeak, stack={}".format(
traceback.print_exc()))
def init():
L.l.debug('Newtifry module initialising')
global _source_key
_source_key = model_helper.get_param(Constant.P_NEWTIFY_KEY)
dispatcher.connect(send_message,
signal=Constant.SIGNAL_PUSH_NOTIFICATION,
sender=dispatcher.Any)
# send_message(title="Initialising", message="Module initialising", priority=1)
# send_message(title="Initialised", message="Module initialised")
# send_message(title="Initialised 2", message="Module initialised 2")
thread_pool.add_interval_callable(_send_queue, run_interval_second=60)
global initialised
initialised = True
def init():
L.l.info('Tesla module initialising')
thread_pool.add_interval_callable(thread_run, run_interval_second=300)
P.email = get_secure_general("tesla_account_email")
P.home_latitude = get_secure_general("home_latitude")
P.home_longitude = get_secure_general("home_longitude")
P.tesla = Tesla(
email=P.email,
cache_file="../private_config/.credentials/tesla_cache.json",
timeout=180)
P.vehicles = P.tesla.vehicle_list()
P.api_requests += 1
first_read_all_vehicles()
if len(P.vehicles) > 0:
P.initialised = True
def _get_bus_list(ohost, oport):
ow = pyownet.protocol.proxy(host=ohost, port=oport)
owitems = ow.dir('/', slash=False, bus=True)
for owitem in owitems:
if 'bus' in owitem:
ow_proxy = pyownet.protocol.proxy(
host=ohost, port=oport, flags=pyownet.protocol.FLG_UNCACHED)
P.ow_conn_list[owitem] = ow_proxy
func = _dynamic_thread_run(ow_conn=ow_proxy, ow_bus=owitem)
thread_pool.add_interval_callable(func, P.sampling_period_seconds)
P.func_list.append(func)
# start all threads sequentially to avoid peak cpu usage
time.sleep(P.sampling_period_seconds / len(owitems))
L.l.info("Found {} owfs busses and initialised threads".format(
len(P.ow_conn_list)))
def init():
L.l.info('Owntracks module initialising')
config_file = get_json_param(Constant.P_ALL_CREDENTIAL_FILE)
with open(config_file, 'r') as f:
config = json.load(f)
P.phonetrack_token = config['nextcloud_phonetrack_token']
P.phonetrack_url = get_json_param(
Constant.P_NEXTCLOUD_PHONETRACK_URL).replace('<token>',
P.phonetrack_token)
P.mqtt_topic_receive = get_json_param(
Constant.P_MQTT_TOPIC_OWNTRACKS_RECEIVE)
P.mqtt_topic_receive_prefix = P.mqtt_topic_receive.replace('#', '')
mqtt_io.P.mqtt_client.message_callback_add(P.mqtt_topic_receive,
mqtt_on_message)
mqtt_io.add_message_callback(P.mqtt_topic_receive, mqtt_on_message)
thread_pool.add_interval_callable(thread_run, run_interval_second=10)
P.initialised = True
def init():
global scheduler
L.l.info('Rules module initialising')
if scheduler:
from rule import electricity
P.rules_modules.append(rules_run)
P.rules_modules.append(electricity)
scheduler.remove_all_jobs()
add_rules_into_db(module=rules_run)
# __load_rules_from_db()
scheduler.start()
P.timestamp = _get_stamp()
rule_common.init()
else:
L.l.warning('Rules not initialised as scheduler is not available')
thread_pool.add_interval_callable(thread_run, run_interval_second=1)
thread_pool.add_interval_callable(reload_rules, run_interval_second=30)
# connect rules processor for all db chages trigger
dispatcher.connect(parse_rules, signal=Constant.SIGNAL_DB_CHANGE_FOR_RULES, sender=dispatcher.Any)
P.initialised = True
def init():
if P.module_imported:
thread_pool.add_interval_callable(thread_run,
run_interval_second=P.interval)
opath = '../openzwave/config'
if not os.path.isdir(opath):
L.l.info('Openzawave config directory does not exist, creating')
if not os.path.isdir('../openzwave'):
os.mkdir('../openzwave')
if not os.path.isdir(opath):
os.mkdir(opath)
if not os.path.isfile(opath + '/zwcfg.xsd'):
L.l.info('Openzawave config file does not exist, creating empty')
with open(opath + "/zwcfg.xsd", "w") as text_file:
print("", file=text_file)
if not os.path.isfile(opath + '/options.xml'):
L.l.info('Openzawave options file does not exist, creating empty')
with open(opath + "/options.xml", "w") as text_file:
print("", file=text_file)
dispatcher.connect(_init_recovery,
signal=Constant.SIGNAL_USB_DEVICE_CHANGE,
sender=dispatcher.Any)
def init():
L.l.info('Dashcam module initialising')
recorder.init()
gps.init()
_battery_init()
accel.init()
thread_pool.add_interval_callable(recorder.thread_run, run_interval_second=recorder.thread_tick)
thread_pool.add_interval_callable(thread_run, run_interval_second=10)
thread_pool.add_interval_callable(accel.thread_run, run_interval_second=0.5)
dispatcher.connect(_battery_stat, signal=Constant.SIGNAL_BATTERY_STAT, sender=dispatcher.Any)
#ui.init()
global initialised
initialised = True
def init():
L.l.info('Atrea Ventilation module initialising - DUPLEX RD5 380')
thread_pool.add_interval_callable(thread_run, run_interval_second=30)
m.Ventilation.add_upsert_listener(ventilation_upsert_listener)
P.initialised = True
def _init_recovery():
if not P.initialised:
thread_pool.add_interval_callable(thread_run,
run_interval_second=P.interval)
def init():
L.l.info('usb module initialising')
thread_pool.add_interval_callable(thread_run, run_interval_second=60)
P.initialised = True
def init():
thread_pool.add_interval_callable(thread_run,
run_interval_second=P.interval)
def init():
L.l.info('cron module initialising')
setup_tasks()
thread_pool.add_interval_callable(thread_run, run_interval_second=60)
global initialised
initialised = True
