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)
