def run(duration_s=15, debug=False): if debug: ulogging.getLogger('eng.sw.unetmangler').setLevel(ulogging.DEBUG) netif = network.WLAN(network.STA_IF) net = unetmangler.Net_Mangler('wlan', netif, wlan_configs) net.connect('run', duration_s * 1000) while True: net.step() utime.sleep_ms(100)
def connect(debug=False): if debug: ulogging.getLogger('eng.sw.unetmangler').setLevel(ulogging.DEBUG) netif = network.WLAN(network.STA_IF) net = unetmangler.Net_Mangler('wlan', netif, wlan_configs) net.connect('run', 60000) while not net.is_connected(): net.step() utime.sleep_ms(100)
def run(debug=False): if debug: ulogging.getLogger('eng.sw.utimemangler').setLevel(ulogging.DEBUG) ulogging.getLogger('eng.sw.netmangler').setLevel(ulogging.DEBUG) netif = network.WLAN(network.STA_IF) net = unetmangler.Net_Mangler('wlan', netif, wlan_configs) tm = utimemangler.Time_Mangler(net, tzone_name, timezonedb_apikey) while tm.state != tm.TIME_SET: net.step() tm.step() utime.sleep_ms(100)
def __init__(self, pin, name, led_n, init_color='whitesmoke'): self._pin = Pin(pin, Pin.OUT) self._name = name self._np = neopixel.NeoPixel(self._pin, led_n) self.log = logging.getLogger(self._name) self.log.debug('init LED strip: %s' % self._name) self._color = COLORS[init_color]
def __init__(self, mainbar): self.hours = "" self.minutes = "" self.day_button = [None] * 7 self.day_label = [None] * 7 try: import ulogging as logging except: import logging self.log = logging.getLogger("AlarmClockApp") self.log.setLevel(logging.DEBUG) self.mainbar = mainbar self.statusbar = mainbar.gui.statusbar self.app = mainbar.app self.main_tile_num = mainbar.add_app_tile(1, 2, "alarmclock app") self.setup_tile_num = self.main_tile_num + 1 self.log.debug("tile number for main tile: %d", self.main_tile_num) self.alarm_clock_main_tile = mainbar.get_tile_obj(self.main_tile_num) self.log.debug("registering alarm_clock app") app = self.app.register("alarm\nclock", "alarm_clock_64px", self.enter_alarm_clock_main_event_cb) # self.app.set_indicator(app,Icon.INDICATOR_OK) self.main_page(self.main_tile_num)
def __init__(self, ble): self._ble = BLEController(ble, name='PaperTesla') self._leds = set() self.log = logging.getLogger('papertesla') self.log.info("PaperTesla Booted!") self._ble.on_write = self._handle_write self._ble.advertise()
def begin(self, username, password, clientid, hostname='mqtt.mydevices.com', port=1883, logname=LOG_NAME, loglevel=logging.WARNING): self.rootTopic = "v1/%s/things/%s" % (username, clientid) print("root topic: %s" % self.rootTopic) global wlan wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.disconnect() # try to connect to wlan connect() print("Connecting to %s" % hostname) self.client = MQTTClient(clientid, hostname, 0, username, password) self.client.connect() self.connected = True self.log = logging.getLogger(logname) # if logname == LOG_NAME: # logging.basicConfig(stream=sys.stdout, format='%(message)s', level=loglevel) self.log.info("Connecting to %s:%s" % (hostname, port)) # subscribe to the cmd topic command_topic = self.getCommandTopic() self.client.set_callback(self.client_on_message) self.log.info("SUB %s" % command_topic) self.client.subscribe(command_topic)
def __init__(self): import ulogging as logging self.log = logging.getLogger("t-watch") self.log.setLevel(logging.DEBUG) self.log.debug("Starting LVGL") self.drv = driver(width=240, height=240) scr_style = lv.style_t() scr_style.set_bg_color(lv.STATE.DEFAULT, lv_colors.BLACK) lv.scr_act().add_style(lv.obj.PART.MAIN, scr_style) self.log.debug("starting splash screen") splash = Splashscreen() sleep(1) splash.set_label("Starting WiFi") try: from hardware.wifi import WiFi wifi = WiFi() wifi.connect() # # get CET time from NTP and set up the pcf8563 RTC # self.pcf8563 = self.drv.watch.rtc wifi.getTime() currentTime = wifi.cetTime() year = currentTime[0] month = currentTime[1] date = currentTime[2] hour = currentTime[3] minute = currentTime[4] second = currentTime[5] day = currentTime[6] month_short = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ] day_of_week_short = [ "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" ] self.log.debug( " Setting RTC to %s %d. %s %02d %02d:%02d:%02d" % (day_of_week_short[day], date, month_short[month - 1], year, hour, minute, second)) self.pcf8563.set_datetime(currentTime) except: pass self.log.debug("Starting the power manager") if hasattr(self.drv, "watch"): print("Running on the twatch") self.powermgr = PowerManager(self.drv) splash.deinit() self.gui = GUI(self.drv)
def __init__(self, dir_pin, step_pin, en_pin): self._pos = 0 self._state = 0 self._speed = 0 self._stepper = Stepper(dir_pin, step_pin, en_pin) self._stepper.MAX_ACCEL = self.MAX_ACCEL self._timer = Timer(1) self._timer.init(freq=self.TIMER_FREQ, callback=self._do_step) self.log = logging.getLogger("anneal8tor.motor") self._rehydate()
def run(num=5, interval=120, debug=False): if debug: ulogging.getLogger('eng.sw.forecast').setLevel(ulogging.DEBUG) ulogging.getLogger('eng.sw.unetmangler').setLevel(ulogging.DEBUG) wlan_configs = [('wodexitose', 'mirodefamehe')] netif = network.WLAN(network.STA_IF) net = unetmangler.Net_Mangler('network', netif, wlan_configs) fc = forecast.Forecaster('9%20Liverton%20Crescent%20Christchurch%20NZ', 'c795da7ea1fadbf5dccbf95d39ce7baa', net, forecast_types=['currently'], forecast_interval_s=interval) #pylint: disable=line-too-long,invalid-name fc_timestamp_ms = fc.forecast_timestamp_ms while True: net.step() fc.step() if fc.forecast_timestamp_ms != fc_timestamp_ms: fc_timestamp_ms = fc.forecast_timestamp_ms f = fc.forecast_data['currently'] #pylint: disable=invalid-name t_forecast_u = time_unix_to_upy(f['time']) t_forecast_s = utime.localtime(t_forecast_u) hour = t_forecast_s[3] minute = t_forecast_s[4] summary = f['summary'] temperature_C = f['temperature'] #pylint: disable=invalid-name pressure_hPa = f['pressure'] #pylint: disable=invalid-name wind_m_s = f['windSpeed'] wind_kn = wind_m_s * 1.94 gust_m_s = f['windGust'] gust_kn = gust_m_s * 1.94 direction_d = f['windBearing'] print('{}:{} {} {}'.format(hour, minute, temperature_C, summary)) num -= 1 if num == 0 and not net.is_connected(): break utime.sleep_ms(100)
def __init__(self,mainbar): self.log = logging.getLogger("battery settings") self.log.setLevel(logging.DEBUG) # get an app tile and copy mainstyle battery_settings_tile_num = mainbar.add_app_tile( 1, 2, "battery setup" ) self.log.debug("Battery settings tile number: %d"%battery_settings_tile_num) battery_settings_tile = parent.get_tile_obj( battery_settings_tile_num + 1 ); battery_settings_style = lv.style_t() battery_settings_style.copy(parent.get_style())
def __init__(self, ble, name='PaperTesla'): self._ble = ble self._ble.active(True) self._ble.irq(handler=self._irq_handler) self._connections = set() self.name = name self.log = logging.getLogger('ble') self._handler = self._register_services() self._buffer = bytearray() self._payload = None self.on_connect = None self.on_disconnect = None self.on_write = None
def __init__(self, drv): # create a logger self.log = logging.getLogger("PowerManager") self.log.setLevel(logging.DEBUG) self.read_config() self.print_config() self.power = drv.watch.pmu self.power.adc1Enable( AXP202_BATT_VOL_ADC1 | AXP202_BATT_CUR_ADC1 | AXP202_VBUS_VOL_ADC1 | AXP202_VBUS_CUR_ADC1, True) self.power.enableIRQ( AXP202_VBUS_REMOVED_IRQ | AXP202_VBUS_CONNECT_IRQ | AXP202_CHARGING_FINISHED_IRQ | AXP202_CHARGING_IRQ | AXP202_TIMER_TIMEOUT_IRQ, AXP202_ON) self.power.clearIRQ() # # enable Coulomb counter and set target voltage for charging # if self.power.EnableCoulombcounter(): self.log.error("enabling the Coulomb counter failed!") if self.config['high_charging_target_voltage']: self.log_info('set target voltage to 4.36V') if self.power.setChargingTargetVoltage(AXP202_TARGET_VOL_4_36V): self.log.error("target voltage 4.36V set failed!") else: self.log.info('set target voltage to 4.2V') if self.power.setChargingTargetVoltage(AXP202_TARGET_VOL_4_2V): self.log.error("target voltage 4.2V set failed!") if self.power.setChargeControlCur(300): self.log.error("charge current set failed!") if self.power.setAdcSamplingRate(AXP_ADC_SAMPLING_RATE_200HZ): self.log.error("adc sample set failed!") # # switch off unused power # self.log.debug("Switch off unused power") self.power.setPowerOutPut(AXP202_EXTEN, AXP202_OFF) self.power.setPowerOutPut(AXP202_DCDC2, AXP202_OFF) self.power.setPowerOutPut(AXP202_LDO4, AXP202_OFF) # # turn i2s DAC on # self.log.debug("Switch i2s DAC on") self.power.setLDO3Mode(AXP202_LDO3_MODE_DCIN) self.power.setPowerOutPut(AXP202_LDO3, AXP202_ON) # # register IRQ function and GPIO pin # self.pmu_int = Pin(self.AXP202_INT, Pin.IN, Pin.PULL_UP) self.pmu_int.irq(trigger=Pin.IRQ_FALLING, handler=self.pmu_irq_cb)
def __init__(self, motor, switch_pin=34, hall_pin=33, relay_pin=32): self.log = logging.getLogger("anneal8tor.black") self._slot_disp = 0 self._motor = motor self._switch = Pin(switch_pin, Pin.IN) self._hall = Pin(hall_pin, Pin.IN) self._relay = Pin(relay_pin, Pin.OUT, value=0) self._switch_count = 0 self._switch_irq_began = None self._found_home_at = None self._status = self.BOOTING self._error = None self._calibrating = False self._rehydate()
def __init__(self, github_repo, module='', main_dir='main', OTAupdateTextList=[]): self.http_client = HttpClient() self.github_repo = github_repo.rstrip('/').replace( 'https://github.com', 'https://api.github.com/repos') self.main_dir = main_dir self.module = module.rstrip('/') self.log = ulogging.getLogger("OTA updater") self.log.setLevel(ulogging.DEBUG) self.OTAupdateTextList = OTAupdateTextList
def __init__(self,mainbar): self.setup_table = [None]*Constants.MAX_SETUP_ICON self.setup_tiles = [] self.log = logging.getLogger("SetupTile") self.log.setLevel(logging.DEBUG) y = 1 for tile_no in range(Constants.MAX_SETUP_TILES): id = "setup tile %s"%(tile_no+1) tile_num = mainbar.add_tile(tile_no+1,y,id) self.setup_tiles.append(mainbar.get_tile_obj(tile_num)) self.style = lv.style_t() self.style.copy(mainbar.mainbar_style) # # create the setup_table # for i in range(Constants.MAX_SETUP_ICON): self.setup_table[i]=Icon() self.setup_table[i].active=False self.setup_table[i].x = Constants.SETUP_FIRST_X_POS+((i % Constants.MAX_SETUP_ICON_HORZ ) * (Constants.SETUP_ICON_X_SIZE + Constants.SETUP_ICON_X_CLEARENCE)) self.setup_table[i].y = Constants.SETUP_FIRST_Y_POS+(((i % (Constants.MAX_SETUP_ICON_VERT * Constants.MAX_SETUP_ICON_HORZ)) // Constants.MAX_SETUP_ICON_HORZ)* (Constants.SETUP_ICON_Y_SIZE + Constants.SETUP_ICON_Y_CLEARENCE)) # create app icon container self.setup_table[i].cont = mainbar.obj_create( self.setup_tiles[ i // ( Constants.MAX_SETUP_ICON_HORZ * Constants.MAX_SETUP_ICON_VERT)]) self.setup_table[i].cont.add_style(lv.obj.PART.MAIN,self.style ) self.setup_table[i].cont.set_size(Constants.SETUP_ICON_X_SIZE, Constants.SETUP_ICON_Y_SIZE ); self.setup_table[i].cont.align(self.setup_tiles[i // ( Constants.MAX_SETUP_ICON_HORZ * Constants.MAX_SETUP_ICON_VERT ) ], lv.ALIGN.IN_TOP_LEFT, self.setup_table[i].x, self.setup_table[i].y ); # create app label self.setup_table[i].label= lv.label(self.setup_tiles[i//(Constants.MAX_SETUP_ICON_HORZ * Constants.MAX_SETUP_ICON_VERT)],None) mainbar.add_slide_element(self.setup_table[i].label); self.setup_table[i].label.add_style(lv.obj.PART.MAIN,self.style) self.setup_table[i].label.set_size(Constants.SETUP_LABEL_X_SIZE, Constants.SETUP_LABEL_Y_SIZE) self.setup_table[i].label.align( self.setup_table[i].cont, lv.ALIGN.OUT_BOTTOM_MID, 0, 0 ) self.setup_table[i].cont.set_hidden(True) self.setup_table[i].label.set_hidden(True) self.log.debug("icon screen/x/y: %d/%d/%d"%(i // ( Constants.MAX_SETUP_ICON_HORZ * Constants.MAX_SETUP_ICON_VERT ), self.setup_table[i].x, self.setup_table[i].y))
def __init__(self, parent): self.main_tile = None self.note_tile = None self.gui = None self.pcf8563 = None self.log = logging.getLogger("mainbar") self.log.setLevel(logging.DEBUG) self.mainbar_style = lv.style_t() self.mainbar_style.init() self.mainbar_style.set_radius(lv.obj.PART.MAIN, 0) self.mainbar_style.set_bg_color(lv.obj.PART.MAIN, lv_colors.GRAY) self.mainbar_style.set_bg_opa(lv.obj.PART.MAIN, lv.OPA._0) self.mainbar_style.set_border_width(lv.obj.PART.MAIN, 0) self.mainbar_style.set_text_color(lv.obj.PART.MAIN, lv_colors.WHITE) self.mainbar_style.set_image_recolor(lv.obj.PART.MAIN, lv_colors.WHITE) self.mainbar_switch_style = lv.style_t() self.mainbar_switch_style.init() self.mainbar_switch_style.set_bg_color(lv.STATE.CHECKED, lv_colors.GREEN) self.mainbar_slider_style = lv.style_t() self.mainbar_slider_style.init() self.mainbar_slider_style.set_bg_color(lv.STATE.DEFAULT, lv_colors.GREEN) self.mainbar_button_style = lv.style_t() self.mainbar_button_style.init() self.mainbar_button_style.set_radius(lv.STATE.DEFAULT, 3) self.mainbar_button_style.set_border_color(lv.STATE.DEFAULT, lv_colors.WHITE) self.mainbar_button_style.set_border_opa(lv.STATE.DEFAULT, lv.OPA._70) self.mainbar_button_style.set_border_width(lv.STATE.DEFAULT, 2) self.mainbar = lv.tileview(parent, None) self.mainbar.set_edge_flash(False) self.mainbar.add_style(lv.obj.PART.MAIN, self.mainbar_style) lv.page.set_scrollbar_mode(lv.page.__cast__(self.mainbar), lv.SCROLLBAR_MODE.OFF) self.exit_icon_dsc = self.get_image_dsc('exit_32px') self.setup_icon_dsc = self.get_image_dsc('setup_32px') self.app = App(self)
def __init__(self, position, pins): self.log = ulogging.getLogger("segment%s" % position) self.position = str(int(position)) self.pins = pins try: self.load_pin_map() except: pins_map = {"0": {}, "1": {}, "invert": True} for k, v in enumerate(self.pins): if 0 <= k <= 6: pins_map["0"][k + 1] = v elif 7 <= k <= 13: pins_map["1"][k - 6] = v with open(self.calibration_file, "w") as f: json.dump(pins_map, f) self.load_pin_map() self.set("-")
def __init__(self): # create a logger self.log = logging.getLogger("Splashscreen") self.log.setLevel(logging.DEBUG) scr_style = lv.style_t() scr_style.set_bg_color(lv.STATE.DEFAULT, lv_colors.BLACK) lv.scr_act().add_style(lv.obj.PART.MAIN, scr_style) try: with open('images/hedgehog143x81_argb8888.bin', 'rb') as f: hedgehog_data = f.read() self.log.debug("hedgehog143x81_argb8888.bin successfully read") except: try: with open('images/hedgehog143x81_argb565.bin', 'rb') as f: hedgehog_data = f.read() self.log.debug( "hedgehog143x81_argb565.bin successfully read") except: self.log.error("Could not open hedgehog image file") sys.exit() self.image = lv.img(lv.scr_act(), None) img_dsc = lv.img_dsc_t({ "header": { "always_zero": 0, "w": 143, "h": 81, "cf": lv.img.CF.TRUE_COLOR_ALPHA }, "data_size": len(hedgehog_data), "data": hedgehog_data, }) self.image.set_src(img_dsc) self.image.align(None, lv.ALIGN.CENTER, 0, -20) self.text_style = lv.style_t() self.text_style.init() self.text_style.set_text_color(lv.STATE.DEFAULT, lv_colors.WHITE) self.label = lv.label(lv.scr_act(), None) self.label.add_style(lv.label.PART.MAIN, self.text_style) self.label.set_text("Starting up...") self.label.align(self.image, lv.ALIGN.IN_BOTTOM_MID, 0, 50)
def __init__( self, pumpOut: Dout, pwr: PowerMeter, settings: Settings, debug: int = 0, log: Optional[RootLogger] = None ): if log is None and debug >= 0: import ulogging log = ulogging.getLogger("pump") if debug > 0: log.setLevel(ulogging.DEBUG) self._log = log self._fsmFunction = { 'IDLE': self._idle, 'PUMPING': self._pumping, 'WAIT': self._wait, 'ERROR': self._error, } self._pump = pumpOut self._pwr = pwr self._cfg = settings # High when tank is full self._lowerFloat = DigitalInput(LOWER_FLOAT, 'LowerFloat', active_high = False, interval = 10) self._upperFloat = DigitalInput(UPPER_FLOAT, 'UpperFloat', active_high = False, interval = 10) # self._lowerUltra = HCSR04(TRIGGER_PIN, LOWER_ULTRA, 5000) # self._upperUltra = HCSR04(TRIGGER_PIN, UPPER_ULTRA, 9000) self._state = 'IDLE' self._stateChange = time.time() # Start the main task self.task = asyncio.create_task(self._run())
def __init__(self): self.name = self.__class__.__module__.split('.')[-1] self._asyncio_loop = asyncio.get_event_loop() self._state = 'stopped' self._task = self.main() self._asyncio_loop.create_task(self._task) type(self)._logger = logging.getLogger(self.name) # Inspect class to get methods and members type(self)._methods = [ x for x in dir(self.__class__) if eval('callable(%s.Service.%s)' % (self.name, x)) and not x.startswith('_') ] type(self)._vars = [ x for x in dir(self.__class__) if x not in self._methods and not x.startswith('_') ]
def run(self, host="127.0.0.1", port=8081, debug=False, lazy_init=False, log=None): if log is None and debug >= 0: import ulogging log = ulogging.getLogger("picoweb") if debug > 0: log.setLevel(ulogging.DEBUG) self.log = log gc.collect() self.debug = int(debug) self.init() if not lazy_init: for app in self.mounts: app.init() loop = asyncio.get_event_loop() if debug > 0: print("* Running on http://%s:%s/" % (host, port)) self.serve(loop, host, port) loop.close()
def run(self, host="127.0.0.1", port=8081, debug=False, lazy_init=False, log=None): if log is None and debug >= 0: import ulogging log = ulogging.getLogger("picoweb") if debug > 0: log.setLevel(ulogging.DEBUG) self.log = log gc.collect() self.debug = int(debug) self.init() if not lazy_init: for app in self.mounts: app.init() loop = asyncio.get_event_loop() if debug > 0: print("* Running on http://%s:%s/" % (host, port)) loop.create_task(asyncio.start_server(self._handle, host, port)) loop.run_forever() loop.close()
def __init__(self,mainbar): try: import ulogging as logging except: import logging self.log = logging.getLogger("CalculatorApp") self.log.setLevel(logging.DEBUG) self.mainbar=mainbar self.statusbar=mainbar.gui.statusbar self.app = mainbar.app self.tile_num = mainbar.add_app_tile( 1, 1, "calculator app" ) self.log.debug("tile number for main tile: %d",self.tile_num) self.log.debug("registering calculator app") app=self.app.register("calculator","calculator_64px",self.enter_calculator_app_event_cb) self.main_page(self.tile_num)
def __init__(self,mainbar): try: import ulogging as logging except: import logging self.log = logging.getLogger("App") self.log.setLevel(logging.DEBUG) self.app_icon_data = [None]*Constants.MAX_APPS_ICON self.app_icon_dsc = [None]*Constants.MAX_APPS_ICON self.indicator_icon_data = [None]*Icon.MAX_INDICATOR self.indicator_icon_dsc = [None]*Icon.MAX_INDICATOR self.indicator_filenames=["info_ok_16px","info_1_16px","info_2_16px","info_3_16px","info_n_16px", "info_fail_16px","info_update_16px"] self.mainbar = mainbar # read all the indicator image files for i in range(Icon.MAX_INDICATOR): self.get_indicator_image(self.indicator_filenames[i],i)
def __init__(self, mainbar): try: import ulogging as logging except: import logging self.log = logging.getLogger("AnalogueClockApp") self.log.setLevel(logging.DEBUG) self.mainbar = mainbar self.statusbar = mainbar.gui.statusbar self.app = mainbar.app self.tile_num = mainbar.add_app_tile(1, 1, "analogue clock app") self.log.debug("tile number for main tile: %d", self.tile_num) self.log.debug("registering analogue clock app") app = self.app.register("analogue\nclock", "mondaine_clock_64px", self.enter_aclock_app_event_cb) self.main_page(self.tile_num)
def __init__(self, drv): self.log = logging.getLogger("gui") self.log.setLevel(logging.DEBUG) # create wallpaper self.wallpaper = lv.img(lv.scr_act(), None) self.wallpaper.set_width(lv.scr_act().get_disp().driver.hor_res) self.wallpaper.set_height(lv.scr_act().get_disp().driver.ver_res) self.set_background_image(self.wallpaper_images[2]) self.wallpaper.align(None, lv.ALIGN.CENTER, 0, 0) self.mainbar = MainBar(lv.scr_act()) self.mainbar.gui = self if hasattr(drv, 'watch'): self.log.debug("watch exists in drv") self.mainbar.pcf8563 = drv.watch.rtc else: self.log.debug("could not pass drv to mainbar") self.statusbar = StatusBar(self.mainbar) # add the four mainbar screens self.main_tile = MainTile(self.mainbar) self.mainbar.main_tile = self.main_tile self.log.debug("Creating app tile") self.app_tile = AppTile(self.mainbar) self.log.debug("Creating Note tile") self.note_tile = NoteTile(self.mainbar) self.log.debug("Creating Setup tile") self.setup_tile = SetupTile(self.mainbar) self.widget = Widget(self.mainbar) self.mainbar.widget = self # add apps example_app = ExampleApp(self.mainbar) calculator_app = Calculator(self.mainbar) calendar_app = Calendar(self.mainbar) aclock = AnalogueClock(self.mainbar) alarm_clock = AlarmClock(self.mainbar) stopwatch_app = Stopwatch(self.mainbar) weather_app = WeatherApp(self.mainbar)
def __init__(self, siren: Dout, door: Door, perimeter: list[DigitalInput], access: list[DigitalInput], settings: Settings, debug: int = 0, log: Optional[RootLogger] = None): if log is None and debug >= 0: import ulogging log = ulogging.getLogger("alarm") if debug > 0: log.setLevel(ulogging.DEBUG) self._log = log self._fsmFunction = { 'DISARMED': self._disarmed, 'AWAY': self._away, 'NIGHT': self._night, 'WAIT_AWAY': self._wait_away, 'DELAY_AWAY': self._delay_away, 'DELAY_NIGHT': self._delay_night, 'DISARM_AWAY': self._disarm_away, 'DISARM_NIGHT': self._disarm_night, 'ERROR': self._error, } self._cfg = settings self._siren = siren self._door = door self._perimeter = perimeter self._access = access self._state = 'DISARMED' self._next_state = None self._cause = None self._stateChange = time.time() # Start the main task self.task = asyncio.create_task(self._run())
class Mydb: db = None f = None log = logging.getLogger("Mydb - Class") def __init__(self): self.connect() def connect(self): try: self.f = open("espdb", "r+b") except OSError: self.f = open("espdb", "w+b") self.db = btree.open(self.f) self.log.info("Database initiated with success") def setItem(self, key, value): try: self.db[key.encode()] = value.encode() self.log.info("Key stored with sucess: key: %s - value: %s", key, value) except Exception: self.log.error("Database error on save") def getItem(self, key): try: value = self.db[key.encode()] self.log.info("Key recovered with sucess: key: %s - value: %s", key, value.decode()) return value.decode() except Exception: self.log.error("Database error on get: %s", key.encode()) return None def close(self): self.db.close() self.f.close() self.log.info("Database closed")
def __init__(self, debug: int = 0, log: Optional[RootLogger] = None): if log is None and debug >= 0: import ulogging log = ulogging.getLogger("settings") if debug > 0: log.setLevel(ulogging.DEBUG) self._log = log # Load system settings try: with open("settings.json", 'r', encoding='utf-8') as f: self.settings = json.load(f) except Exception as err: self._log.error(err) # Set to default values self.settings = { 'PUMPING_MAX_TIME': 600, # Maximum continuous pump operation in seconds 'ALARM_DELAY': 5, # Delay before arming the alarm 'ALARM_DISARM_DELAY': 20, # Delay for introducing password } self.saveSettings()
def __init__(self,mainbar): try: import ulogging as logging except: import logging self.log = logging.getLogger("ExampleApp") self.log.setLevel(logging.DEBUG) self.mainbar=mainbar self.statusbar=mainbar.gui.statusbar self.app = mainbar.app self.main_tile_num = mainbar.add_app_tile( 1, 2, "example app" ) self.setup_tile_num = self.main_tile_num +1 self.log.debug("tile number for main tile: %d",self.main_tile_num) self.example_app_main_tile = mainbar.get_tile_obj(self.main_tile_num) self.log.debug("registering example app") app=self.app.register("myapp","myapp_64px",self.enter_example_app_event_cb) self.app.set_indicator(app,Icon.INDICATOR_OK) self.main_page(self.main_tile_num) self.setup_page(self.setup_tile_num)