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