def show_phrase_length_selection(self):
self.screen = lv.obj()
self.recovery_phrase_length_screen_label = lv.label(self.screen)
self.recovery_phrase_length_screen_label.set_text(
"How many words are in\n your recovery phrase?")
self.recovery_phrase_length_screen_label.align(self.screen,
lv.ALIGN.CENTER, 0,
-300)
self.recovery_phrase_length_roller = lv.roller(self.screen)
recovery_phrase_length_options_str = "\n".join(
str(phrase_length)
for phrase_length in self.RECOVERY_PHRASE_LENGTHS)
self.recovery_phrase_length_roller.set_options(
recovery_phrase_length_options_str, 0)
self.recovery_phrase_length_roller.set_fix_width(True)
self.recovery_phrase_length_roller.set_selected(2, 0)
self.recovery_phrase_length_roller.set_size(200, 200)
self.recovery_phrase_length_roller.align(self.screen, lv.ALIGN.CENTER,
0, -75)
self.recovery_phrase_length_roller.set_visible_row_count(5)
self.confirm_phrase_length_button = lv.btn(self.screen)
self.confirm_phrase_length_button.set_size(125, 60)
self.confirm_phrase_length_button.align(self.screen, lv.ALIGN.CENTER,
0, 100)
self.confirm_phrase_length_button.set_event_cb(
self.handle_confirm_phrase_length_button)
self.confirm_phrase_length_button_label = lv.label(
self.confirm_phrase_length_button)
self.confirm_phrase_length_button_label.set_text("Ok")
lv.scr_load(self.screen)
def __init__(self):
self.mask_top_id = -1
self.mask_bottom_id = -1
#
# Add an fade mask to roller.
#
style = lv.style_t()
style.init()
style.set_bg_color(lv.color_black())
style.set_text_color(lv.color_white())
lv.scr_act().add_style(style, 0)
roller1 = lv.roller(lv.scr_act())
roller1.add_style(style, 0)
roller1.set_style_border_width(0, 0)
roller1.set_style_pad_all(0, 0)
roller1.set_style_bg_opa(lv.OPA.TRANSP, lv.PART.SELECTED)
#if LV_FONT_MONTSERRAT_22
# lv_obj_set_style_text_font(roller1, &lv_font_montserrat_22, LV_PART_SELECTED);
#endif
roller1.set_options(
"\n".join([
"January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"
]), lv.roller.MODE.NORMAL)
roller1.center()
roller1.set_visible_row_count(3)
roller1.add_event_cb(self.mask_event_cb, lv.EVENT.ALL, None)
def m4():
scr = lv.obj()
lv.scr_load(scr)
#container for drop and switch
cont = lv.cont(scr)
cont.set_auto_realign(True)
cont.set_fit2(lv.FIT.PARENT, lv.FIT.TIGHT)
cont.set_layout(lv.LAYOUT.PRETTY_MID)
cont.align(scr, lv.ALIGN.IN_TOP_MID, 0, 0)
#dropdown
drop = lv.dropdown(cont)
drop.set_style_local_border_post(lv.BORDER_SIDE.NONE, lv.BORDER_SIDE.NONE,
lv.BORDER_SIDE.NONE)
drop.set_options(
"Trigger 1\nTrigger 2\nTrigger 3\nTrigger 4\nTrigger 5\nTrigger 6\nTrigger 7\nTrigger 8\nTrigger 9\n Trigger 10"
)
#label
lbl1 = lv.label(cont)
lbl1.set_text("Arm?")
#switch
switch = lv.switch(cont)
#tabview
tab = lv.tabview(scr)
tab.align(cont, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
tab1 = tab.add_tab("Time")
tab2 = tab.add_tab("Auto")
tab3 = tab.add_tab("Switches")
#tab1
lbl2 = lv.label(tab1)
lbl2.set_text("Start time [h][m][s]")
lbl2.align(tab1, lv.ALIGN.IN_TOP_MID, 0, 0)
trig_btn = lv.btnmatrix(tab1)
trig_btn.set_height(200)
trig_btn.align(lbl2, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
def remap():
btn_map = [
lv.SYMBOL.UP, lv.SYMBOL.UP, lv.SYMBOL.UP, "\n",
str(trigger[0].bhour),
str(trigger[0].bminute),
str(trigger[0].bsecond), "\n", lv.SYMBOL.DOWN, lv.SYMBOL.DOWN,
lv.SYMBOL.DOWN, "\n", lv.SYMBOL.SAVE, "", ""
]
print('remapped called')
return btn_map
trig_btn.set_map(remap())
#trig_btn.set_style
def event_handler(obj, event):
if event == lv.EVENT.VALUE_CHANGED:
txt = obj.get_active_btn()
print("{} was pressed".format(txt))
if (txt == 0):
trigger[0].bhour += 1
if (txt == 1):
trigger[0].bminute += 1
if (txt == 2):
trigger[0].bsecond += 1
if (txt == 6):
trigger[0].bhour -= 1
if (txt == 7):
trigger[0].bminute -= 1
if (txt == 8):
trigger[0].bsecond -= 1
trig_btn.set_map(remap())
trig_btn.set_event_cb(event_handler)
#label set duration
lbl3 = lv.label(tab1)
lbl3.align(trig_btn, lv.ALIGN.OUT_BOTTOM_MID, -100, 0)
lbl3.set_text("Set trigger duration [h][m][s]")
roller = lv.roller(tab1)
def selectors_create(parent):
page = lv.page.__cast__(parent)
lv.page.set_scrl_layout(page, lv.LAYOUT.PRETTY_MID)
grid_h = page.get_height_grid(1, 1)
if disp_size <= lv.DISP_SIZE.SMALL:
grid_w = page.get_width_grid(1, 1)
else:
grid_w = page.get_width_grid(2, 1)
cal = lv.calendar(parent, None)
cal.set_drag_parent(True)
if disp_size > lv.DISP_SIZE.MEDIUM:
cal.set_size(min(grid_h, grid_w), min(grid_h, grid_w))
else:
cal.set_size(grid_w, grid_w)
if disp_size <= lv.DISP_SIZE.SMALL:
cal.set_style_local_text_font(lv.calendat.PART.BG,
lv.STATE.DEFAULT,
lv.theme_get_font_small())
hl = [{
"year": 2020,
"month": 1,
"day": 5
}, {
"year": 2020,
"month": 1,
"day": 9
}]
h = lv.cont(parent, None)
h.set_drag_parent(True)
if disp_size <= lv.DISP_SIZE.SMALL:
h.set_fit2(lv.FIT.NONE, lv.FIT.TIGHT)
h.set_width(lv.page.get_width_fit(page))
h.set_layout(lv.LAYOUT.COLUMN_MID)
elif disp_size <= lv.DISP_SIZE.MEDIUM:
h.set_size(lv.obj.get_width(lv.obj.__cast__(cal)),
lv.obj.get_height(lv.obj.__cast__(cal)))
h.set_layout(lv.LAYOUT.PRETTY_TOP)
else:
h.set_click(False)
h.set_style_local_bg_opa(lv.PART.MAIN, lv.STATE.DEFAULT, lv.OPA.TRANSP)
h.set_style_local_border_opa(lv.PART.MAIN, lv.STATE.DEFAULT,
lv.OPA.TRANSP)
h.set_style_local_pad_left(lv.cont.PART.MAIN, lv.STATE.DEFAULT, 0)
h.set_style_local_pad_right(lv.cont.PART.MAIN, lv.STATE.DEFAULT, 0)
h.set_style_local_pad_top(lv.cont.PART_MAIN, LV_STATE_DEFAULT, 0)
h.set_size(min(grid_h, grid_w), min(grid_h, grid_w))
h.set_layout(lv.LAYOUT.PRETTY_TOP)
roller = lv.roller(h, None)
roller.add_style(lv.cont.PART.MAIN, style_box)
roller.set_style_local_value_str(lv.cont.PART.MAIN, lv.STATE.DEFAULT,
"Roller")
roller.set_auto_fit(False)
roller.set_align(lv.label.ALIGN.CENTER)
roller.set_visible_row_count(4)
if disp_size <= lv.DISP_SIZE.SMALL:
roller.set_width(lv.cont.get_width_grid(h, 1, 1))
else:
roller.set_width(lv.cont.get_width_grid(h, 2, 1))
dd = lv.dropdown(h, None)
dd.add_style(lv.cont.PART.MAIN, style_box)
dd.set_style_local_value_str(lv.cont.PART.MAIN, lv.STATE.DEFAULT,
"Dropdown")
if disp_size <= lv.DISP_SIZE.SMALL:
dd.set_width(lv.cont.get_width_grid(h, 1, 1))
else:
dd.set_width(lv.cont.get_width_grid(h, 2, 1))
dd.set_options(
"Alpha\nBravo\nCharlie\nDelta\nEcho\nFoxtrot\nGolf\nHotel\nIndia\nJuliette\nKilo\nLima\nMike\nNovember\n"
"Oscar\nPapa\nQuebec\nRomeo\nSierra\nTango\nUniform\nVictor\nWhiskey\nXray\nYankee\nZulu"
)
list = lv.list(parent, None)
list.set_scroll_propagation(True)
list.set_size(grid_w, grid_h)
txts = [
lv.SYMBOL.SAVE, "Save", lv.SYMBOL.CUT, "Cut", lv.SYMBOL.COPY, "Copy",
lv.SYMBOL.OK, "This is a quite long text to scroll on the list",
lv.SYMBOL.EDIT, "Edit", lv.SYMBOL.WIFI, "Wifi", lv.SYMBOL.BLUETOOTH,
"Bluetooth", lv.SYMBOL.GPS, "GPS", lv.SYMBOL.USB, "USB",
lv.SYMBOL.SD_CARD, "SD card", lv.SYMBOL.CLOSE, "Close"
]
for i in range(0, len(txts) // 2, 2):
btn = list.add_btn(txts[i], txts[i + 1])
lv.btn.set_checkable(lv.btn.__cast__(btn), True)
# Make a button disabled
if i == 4:
btn.set_state(lv.btn.STATE.DISABLED)
cal.set_highlighted_dates(hl, 2)
lv.disp_drv_register(disp_drv)
indev_drv = lv.indev_drv_t()
lv.indev_drv_init (indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = lv_h.read
lv.indev_drv_register (indev_drv)
def event_handler(obj, event):
if event == lv.EVENT.VALUE_CHANGED:
option = " "*10
obj.get_selected_str(option, len(option))
print("Selected month: %s" % option.strip())
roller1 = lv.roller(lv.scr_act())
roller1.set_options("\n".join([
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"]), lv.roller.MODE.INIFINITE)
roller1.set_visible_row_count(6)
def gui_edit_trigger(num, flag):
#num is to call trigger[num]
#flag is to check 'new' or 'edit'
#changes are stored in temp_trigger_item
print('Printing Num : {}'.format(num))
temp_trigger_item = trigger
if flag == 'edit':
temp_trigger_item = trigger[num]
print('Btn Pressed : {}'.format(str(temp_trigger_item)))
elif flag == 'new':
print('Creating new Trigger')
#template should match with INITIAL TIMERS
temp_trigger_item = {
'name': 'New Trigger',
'hb': 0,
'mb': 0,
'sb': 5,
'dur': 5,
'pin': 5,
'timerno': 0,
'cardnum': 0,
'daysoweek': [0, 1, 2, 3, 4, 5, 6],
'sec_start': 0
}
def check_daysoweek(checkbox_array):
temp_daysoweek = []
for num, check in enumerate(checkbox_array, 0):
if check.get_state() == True:
temp_daysoweek.append(num)
print(temp_daysoweek)
return temp_daysoweek
def btn_event(task, params):
if params == 'cancel':
lv.scr_load(scr)
elif params['param'] == 'save' and params['flag'] == 'edit':
print(params)
temp_trigger_item['name'] = params['name']
temp_trigger_item['hb'] = params['hb']
temp_trigger_item['mb'] = params['mb']
temp_trigger_item['sb'] = params['sb']
temp_trigger_item['dur'] = params['dur']
temp_trigger_item['pin'] = params['pin']
temp_trigger_item['timerno'] = params['timerno']
temp_trigger_item['cardnum'] = params['cardnum']
temp_trigger_item['daysoweek'] = params['daysoweek']
temp_trigger_item['sec_start'] = params['sec_start']
print('Triger Edit : Settings saved')
lv.scr_load(scr)
elif params['param'] == 'save' and params['flag'] == 'new':
del params['param']
del params['flag']
trigger.append(params)
gui_main()
print('new key added : {}'.format(params))
global scr3
scr3 = lv.obj()
lv.scr_load(scr3)
btn1 = lv.btn(scr3)
btn1.set_size(150, 40)
btn1.set_style_bg_color(primary, 0)
btn1_label = lv.label(btn1)
btn1_label.set_text('Cancel')
btn1_label.center()
btn1.align_to(scr3, lv.ALIGN.TOP_LEFT, 0, 0)
btn1.add_event_cb(lambda task: btn_event(task, 'cancel'), lv.EVENT.CLICKED,
None)
btn2 = lv.btn(scr3)
btn2.set_size(150, 40)
btn2.set_style_bg_color(primary, 0)
btn2_label = lv.label(btn2)
btn2_label.set_text('Save')
btn2_label.center()
btn2.align_to(scr3, lv.ALIGN.TOP_RIGHT, 0, 0)
pinname = {'0': 21, '1': 19, '2': 18, '3': 5}
btn2.add_event_cb(
lambda task: btn_event(task,
params={
'param':
'save',
'flag':
flag,
'name':
ta_name.get_text(),
'hb':
r1.get_selected(),
'mb':
r2.get_selected(),
'sb':
r3.get_selected(),
'dur':
((r4.get_selected() * 60 * 60) +
(r5.get_selected() * 60) + r6.get_selected(
)),
'pin':
pinname[str(drpdwn.get_selected())],
'timerno':
0,
'cardnum':
0,
'daysoweek':
check_daysoweek(checkbox),
'sec_start':
0
}), lv.EVENT.CLICKED, None)
def refresh_label():
#label for activation time
label3.set_text(
'Set trigger activation time\n{:02} : {:02} : {:02}'.format(
r1.get_selected(), r2.get_selected(), r3.get_selected()))
#label for duration
durations = (r4.get_selected() * 60 * 60) + (r5.get_selected() *
60) + r6.get_selected()
label4.set_text(
'Set Duration for trigger\n{:,} in seconds'.format(durations))
label1 = lv.label(scr3)
if flag == 'edit':
label1.set_text('Edit Trigger Settings')
elif flag == 'new':
label1.set_text('New Trigger Settings')
label1.align_to(btn1, lv.ALIGN.OUT_BOTTOM_LEFT, 10, 10)
label2 = lv.label(scr3)
label2.set_text('Trigger Name')
label2.align_to(label1, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
def keyboard_event(task, kb, scr3):
event = task.get_code()
ta = task.get_target() #get ta object
if event == lv.EVENT.FOCUSED:
#enable keyboard
kb.set_textarea(ta)
kb.clear_flag(lv.obj.FLAG.HIDDEN)
#hide others
for i in range(6, scr3.get_child_cnt()):
scr3.get_child(i).add_flag(lv.obj.FLAG.HIDDEN)
if event == lv.EVENT.DEFOCUSED:
#disable keyboard and hide
kb.set_textarea(None)
kb.add_flag(lv.obj.FLAG.HIDDEN)
#show others
for i in range(6, scr3.get_child_cnt()):
scr3.get_child(i).clear_flag(lv.obj.FLAG.HIDDEN)
ta_name = lv.textarea(scr3)
ta_name.align_to(label2, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
ta_name.add_text(temp_trigger_item['name'])
ta_name.set_size(205, 40)
ta_name.add_state(lv.STATE.FOCUSED)
ta_name.add_event_cb(lambda task: keyboard_event(task, kb, scr3),
lv.EVENT.ALL, None)
kb = lv.keyboard(scr3)
kb.align_to(ta_name, lv.ALIGN.OUT_BOTTOM_LEFT, -10, 10)
kb.set_textarea(ta_name)
kb.add_flag(lv.obj.FLAG.HIDDEN)
label3 = lv.label(scr3)
label3.set_text('Set trigger activation time')
label3.align_to(ta_name, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
dump = []
for i in range(0, 24):
dump.append(str(i))
opts1 = "\n".join(dump)
del dump
dump = []
for i in range(0, 60):
dump.append(str(i))
opts2 = "\n".join(dump)
del dump
#Hour, Minute and Seconds to begin set using rollers
r1 = lv.roller(scr3)
r1.set_width(80)
r1.set_height(80)
r1.set_options(opts1, lv.roller.MODE.NORMAL)
r1.align_to(label3, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 35)
r2 = lv.roller(scr3)
r2.set_width(80)
r2.set_height(80)
r2.set_options(opts2, lv.roller.MODE.NORMAL)
r2.align_to(r1, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
r3 = lv.roller(scr3)
r3.set_width(80)
r3.set_height(80)
r3.set_options(opts2, lv.roller.MODE.NORMAL)
r3.align_to(r2, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
if flag == 'edit':
r1.set_selected(temp_trigger_item['hb'], lv.ANIM.ON)
r2.set_selected(temp_trigger_item['mb'], lv.ANIM.ON)
r3.set_selected(temp_trigger_item['sb'], lv.ANIM.ON)
r1_lbl = lv.label(scr3)
r1_lbl.set_text('Hour')
r1_lbl.align_to(r1, lv.ALIGN.OUT_TOP_MID, 0, 0)
r2_lbl = lv.label(scr3)
r2_lbl.set_text('Minute')
r2_lbl.align_to(r2, lv.ALIGN.OUT_TOP_MID, 0, 0)
r3_lbl = lv.label(scr3)
r3_lbl.set_text('Seconds')
r3_lbl.align_to(r3, lv.ALIGN.OUT_TOP_MID, 0, 0)
#Duration. Duration information is set in refresh_label()
label4 = lv.label(scr3)
label4.align_to(r1, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
r4 = lv.roller(scr3)
r4.set_width(80)
r4.set_height(80)
r4.set_options(opts1, lv.roller.MODE.NORMAL)
r4.align_to(label4, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 35)
r5 = lv.roller(scr3)
r5.set_width(80)
r5.set_height(80)
r5.set_options(opts2, lv.roller.MODE.NORMAL)
r5.align_to(r4, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
r6 = lv.roller(scr3)
r6.set_width(80)
r6.set_height(80)
r6.set_options(opts2, lv.roller.MODE.NORMAL)
r6.align_to(r5, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
def convert(seconds):
min, sec = divmod(seconds, 60)
hour, min = divmod(min, 60)
return [hour, min, sec]
if flag == 'edit':
convert(temp_trigger_item['dur'])
r4.set_selected(convert(temp_trigger_item['dur'])[0], lv.ANIM.ON)
r5.set_selected(convert(temp_trigger_item['dur'])[1], lv.ANIM.ON)
r6.set_selected(convert(temp_trigger_item['dur'])[2], lv.ANIM.ON)
r4_lbl = lv.label(scr3)
r4_lbl.set_text('Hour')
r4_lbl.align_to(r4, lv.ALIGN.OUT_TOP_MID, 0, 0)
r5_lbl = lv.label(scr3)
r5_lbl.set_text('Minute')
r5_lbl.align_to(r5, lv.ALIGN.OUT_TOP_MID, 0, 0)
r6_lbl = lv.label(scr3)
r6_lbl.set_text('Seconds')
r6_lbl.align_to(r6, lv.ALIGN.OUT_TOP_MID, 0, 0)
#Relay Setup
label5 = lv.label(scr3)
label5.set_text('Assign Relay to Trigger')
label5.align_to(r4, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
drpdwn = lv.dropdown(scr3)
drpdwn.align_to(label5, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
drpdwn.set_options("\n".join(['Relay 1', 'Relay 2', 'Relay 3', 'Relay 4']))
relayname = {21: '0', 19: '1', 18: '2', 5: '3'}
if flag == 'edit':
drpdwn.set_selected(int(relayname[temp_trigger_item['pin']]))
label6 = lv.label(scr3)
label6.set_text('Set days of week to turn trigger :')
label6.align_to(drpdwn, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
checkbox = []
checkbox_lbl = [
'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
'Saturday'
]
for i in range(0, 6):
checkbox.append(lv.checkbox(scr3))
if i == 0:
checkbox[i].align_to(label6, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
else:
checkbox[i].align_to(checkbox[i - 1], lv.ALIGN.OUT_BOTTOM_LEFT, 0,
10)
checkbox[i].set_text(checkbox_lbl[i])
if flag == 'edit':
if i in temp_trigger_item['daysoweek']:
checkbox[i].add_state(lv.STATE.CHECKED)
elif flag == 'new':
checkbox[i].add_state(lv.STATE.CHECKED)
if flag == 'edit':
del_btn = lv.btn(scr3)
del_btn_lbl = lv.label(del_btn)
del_btn_lbl.set_text('Delete This Trigger!')
del_btn.set_style_bg_color(red, 0)
del_btn.align_to(checkbox[5], lv.ALIGN.BOTTOM_MID, 80, 100)
lv.timer_create(lambda task: refresh_label(), 900, None)
def gui_time():
global scr2, calendar
selected_date_day = 0
selected_date_month = 0
selected_date_year = 0
def btn_event(event, params):
if params == 'cancel':
lv.scr_load(scr)
elif params['name'] == 'save':
set_time(params['year'], params['month'], params['day'], 0,
params['hour'], params['minute'], params['seconds'])
lv.scr_load(scr)
#implements set time
elif params['name'] == 'NTP':
if sta_if.isconnected():
ntptime.settime()
else:
print('Connect to WIFI')
def event_handler(task, params):
code = task.get_code()
if code == lv.EVENT.VALUE_CHANGED:
source = task.get_current_target()
date = lv.calendar_date_t()
if source.get_pressed_date(date) == lv.RES.OK:
calendar.set_today_date(date.year, date.month, date.day)
print("Clicked date: %02d.%02d.%02d" %
(date.day, date.month, date.year))
label1.set_text('Set Date : {} - {} - {}'.format(
date.year, date.month, date.day))
params['year'] = date.year
params['month'] = date.month
params['day'] = date.day
scr2 = lv.obj()
lv.scr_load(scr2)
#CANCEL
btn1 = lv.btn(scr2)
btn1.set_size(120, 40)
btn1.set_style_bg_color(primary, 0)
btn1_label = lv.label(btn1)
btn1_label.set_text('Cancel')
#btn1_label.set_style_text_font(lv.font_montserrat_28, 0)
btn1_label.center()
btn1.align_to(scr2, lv.ALIGN.TOP_LEFT, 0, 0)
btn1.add_event_cb(lambda task: btn_event(task, 'cancel'), lv.EVENT.CLICKED,
None)
#SAVE
btn2 = lv.btn(scr2)
btn2.set_size(120, 40)
btn2.set_style_bg_color(primary, 0)
btn2_label = lv.label(btn2)
btn2_label.set_text('Save')
#btn2_label.set_style_text_font(lv.font_montserrat_28, 0)
btn2_label.center()
btn2.align_to(scr2, lv.ALIGN.TOP_RIGHT, 0, 0)
btn2.add_event_cb(
lambda task: btn_event(
task, {
'name': 'save',
'hour': r1.get_selected(),
'minute': r2.get_selected(),
'seconds': r3.get_selected(),
'year': selected_date_year,
'month': selected_date_month,
'day': selected_date_day
}), lv.EVENT.CLICKED, None)
label1 = lv.label(scr2)
label1.set_text('Set Date : {} - {} - {}'.format(current_time()[0],
current_time()[1],
current_time()[2]))
def refresh_label():
label2.set_text('Set Time : {:02} : {:02} : {:02}'.format(
r1.get_selected(), r2.get_selected(), r3.get_selected()))
label1.align_to(btn1, lv.ALIGN.OUT_BOTTOM_LEFT, 10, 10)
calendar = lv.calendar(scr2)
calendar.set_size(240, 180)
calendar.align_to(label1, lv.ALIGN.OUT_BOTTOM_LEFT,
int((320 - 250) / 2) - 10, 60)
calendar.add_event_cb(
lambda task: event_handler(
task, {
'year': selected_date_year,
'month': selected_date_month,
'day': selected_date_day
}), lv.EVENT.ALL, None)
calendar.set_today_date(current_time()[0],
current_time()[1],
current_time()[2])
calendar.set_showed_date(current_time()[0], current_time()[1])
lv.calendar_header_dropdown(scr2, calendar)
label2 = lv.label(scr2)
label2.align_to(calendar, lv.ALIGN.OUT_BOTTOM_LEFT, -20, 10)
#generate values for rollers
dump = []
for i in range(0, 24):
dump.append(str(i))
opts1 = "\n".join(dump)
del dump
dump = []
for i in range(0, 60):
dump.append(str(i))
opts2 = "\n".join(dump)
del dump
r1 = lv.roller(scr2)
r1.set_width(80)
r1.set_height(60)
r1.align_to(label2, lv.ALIGN.OUT_BOTTOM_LEFT, 15, 20)
r1.set_options(opts1, lv.roller.MODE.NORMAL)
r1.set_selected(current_time()[4], lv.ANIM.ON)
r2 = lv.roller(scr2)
r2.set_width(80)
r2.set_height(60)
r2.align_to(r1, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
r2.set_options(opts2, lv.roller.MODE.NORMAL)
r2.set_selected(current_time()[5], lv.ANIM.ON)
r3 = lv.roller(scr2)
r3.set_width(80)
r3.set_height(60)
r3.align_to(r2, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
r3.set_options(opts2, lv.roller.MODE.NORMAL)
r3.set_selected(current_time()[6], lv.ANIM.ON)
r1_lbl = lv.label(scr2)
r1_lbl.set_text('Hour')
r1_lbl.align_to(r1, lv.ALIGN.OUT_TOP_MID, 0, 0)
r2_lbl = lv.label(scr2)
r2_lbl.set_text('Minute')
r2_lbl.align_to(r2, lv.ALIGN.OUT_TOP_MID, 0, 0)
r3_lbl = lv.label(scr2)
r3_lbl.set_text('Seconds')
r3_lbl.align_to(r3, lv.ALIGN.OUT_TOP_MID, 0, 0)
label3 = lv.label(scr2)
label3.set_text('Sync with online NTP Time Server')
label3.align_to(r1, lv.ALIGN.OUT_BOTTOM_LEFT, -20, 10)
btn3 = lv.btn(scr2)
btn3_lbl = lv.label(btn3)
btn3_lbl.set_text('Sync to NTP server')
btn3.align_to(label3, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
btn3.add_event_cb(lambda event: btn_event(event, {'name': 'NTP'}),
lv.EVENT.CLICKED, None)
#call refresh label
lv.timer_create(lambda task: refresh_label(), 900, None)
def __init__(self, parent, x_pos, y_pos, gui_ctrl):
super().__init__(parent)
self._gui_ctrl = gui_ctrl
btn_style = self.get_style(lv.tabview.STYLE.BTN_REL)
btn_style_or = lv.style_t()
lv.style_copy(btn_style_or, btn_style)
btn_style.body.padding.left = (parent.get_width() - x_pos) // 5 // 2
btn_style.body.padding.right = (parent.get_width() - x_pos) // 5 // 2
self.set_style(lv.tabview.STYLE.BTN_REL, btn_style)
self.set_size(parent.get_width() - x_pos, parent.get_height() - y_pos)
self.set_pos(x_pos, y_pos)
self.set_anim_time(0)
self.set_sliding(False)
self.set_btns_pos(lv.tabview.BTNS_POS.LEFT)
self.set_event_cb(self._tab_change_handler)
self._t_start = self.add_tab("New Session")
self._t_cal = self.add_tab("Calibration")
self._t_other = self.add_tab("Other")
self._t_done = self.add_tab("Done")
self.set_tab_act(3, lv.ANIM.OFF)
# Session screen
# Stat new session
self._new_sess = lv.cont(self._t_start)
self._new_sess.set_fit(lv.FIT.FLOOD)
self._new_sess.set_layout(lv.LAYOUT.PRETTY)
self._new_session_label = RealignLabel(
self._new_sess, "Set info, and start a new measuring session!",
False)
self._material_sel = lv.roller(self._new_sess)
self._material_sel.set_options(
"\n".join(material for material in MATERIAL_TYPE),
lv.roller.MODE.INIFINITE)
self._thickness_sel = lv.roller(self._new_sess)
self._thickness_sel.set_options(
"\n".join(thickness for thickness in THICKNESS_TYPE),
lv.roller.MODE.INIFINITE)
self._start_btn = TextBtn(self._new_sess, "Start", self._new_sess_cb)
self._start_btn.set_style(lv.btn.STYLE.REL, btn_style_or)
# Measuring Screen
self._session = lv.cont(self._t_start)
self._session.set_fit(lv.FIT.FLOOD)
self._session.set_layout(lv.LAYOUT.PRETTY)
self._session_label = RealignLabel(self._session, "\n\n\n", True)
self._start_measure_btn = TextBtn(self._session, "New Panel",
self._start_measure_cb)
self._start_measure_btn.set_style(lv.btn.STYLE.REL, btn_style_or)
self._done_measure_btn = TextBtn(self._session, "Finish",
self._done_measure_cb)
self._done_measure_btn.set_style(lv.btn.STYLE.REL, btn_style_or)
self._re_measure_btn = TextBtn(self._session, "Re-measure",
self._re_measure_cb)
self._re_measure_btn.set_style(lv.btn.STYLE.REL, btn_style_or)
self._chart = lv.chart(self._session)
self._chart.set_height(90)
self._chart.set_point_count(700)
self._chart.set_range(11000, 13000)
self._ser1 = self._chart.add_series(lv.color_hex(0x0000b3))
self._ser2 = self._chart.add_series(lv.color_hex(0xe60000))
self._ser3 = self._chart.add_series(lv.color_hex(0x00e600))
self._ser4 = self._chart.add_series(lv.color_hex(0xffffff))
self._session.set_hidden(True)
lv.page.glue_obj(self._new_sess, True)
lv.page.glue_obj(self._session, True)
self._preload_cont = lv.cont(self._t_start)
self._preload_cont.set_fit(lv.FIT.FLOOD)
self._preload_cont.set_layout(lv.LAYOUT.CENTER)
self._preload = lv.preload(self._preload_cont)
self._preload_cont.set_hidden(True)
# Calibration Screen
self._cal_label = RealignLabel(self._t_cal, "Output: \n", False)
self._cal_num_input = NumTextArea(self._t_cal, self.ta_test)
self._cal_num_input.set_auto_realign(True)
self._cal_num_input.align(self._cal_label, lv.ALIGN.OUT_BOTTOM_LEFT, 0,
0)
self._set_cal_1 = TextBtn(self._t_cal, "Set Amp 1", self._set_amp_1_cb)
self._set_cal_1.set_style(lv.btn.STYLE.REL, btn_style_or)
self._set_cal_1.align(self._cal_num_input, lv.ALIGN.OUT_RIGHT_MID, 0,
0)
self._set_cal_2 = TextBtn(self._t_cal, "Set Amp 2", self._set_amp_2_cb)
self._set_cal_2.set_style(lv.btn.STYLE.REL, btn_style_or)
self._set_cal_2.align(self._set_cal_1, lv.ALIGN.OUT_RIGHT_MID, 0, 0)
self._kb = lv.kb(self._t_cal)
self._kb.set_map(["1", "2", "3","\n","4","5", "6",\
"\n","7", "8", "9","\n","0",".","Bksp",""])
self._kb.set_height(180)
self._kb.set_y(85)
self._kb.set_ta(self._cal_num_input)
# Laser Off Screen
self._text = RealignLabel(self._t_done, "Laser Off", False)
# Other Screen
self._cal = lv.calendar(self._t_other)
return
def add_new():
'''button events'''
def btn_event(obj, param):
if param == "Cancel":
lv.scr_act().clean()
home()
if param == "Reset 1":
roller1.set_selected(0, lv.ANIM.ON)
roller2.set_selected(0, lv.ANIM.ON)
roller3.set_selected(0, lv.ANIM.ON)
if param == "Set AM 1":
roller1.set_selected(6, lv.ANIM.ON)
roller2.set_selected(0, lv.ANIM.ON)
roller3.set_selected(0, lv.ANIM.ON)
if param == "Set PM 1":
roller1.set_selected(13, lv.ANIM.ON)
roller2.set_selected(0, lv.ANIM.ON)
roller3.set_selected(0, lv.ANIM.ON)
if param == "Reset 2":
roller4.set_selected(0, lv.ANIM.ON)
roller5.set_selected(0, lv.ANIM.ON)
roller6.set_selected(0, lv.ANIM.ON)
if param == "Reset hour":
roller4.set_selected(0, lv.ANIM.ON)
if param == "Reset minute":
roller5.set_selected(0, lv.ANIM.ON)
if param == "Save":
'''storing settings in DB routine'''
print('Debug val')
#textarea cannot be empty
key = text_area.get_text()
if key == "":
print('Key cannot be empty')
lv.msgbox(lv.scr_act(), "Error", "Tigger name cannot be empty",
[], True)
#textare cannot be more than 8 char
if len(key) >= 8:
print('Trigger name too long')
lv.msgbox(lv.scr_act(), "Error", "Tigger name too long", [],
True)
print(text_area.get_text())
#beginhour
bhour = roller1.get_selected()
bminute = roller2.get_selected()
bsecs = roller3.get_selected()
begin_time = "{:02}{:02}{:02}".format(bhour, bminute, bsecs)
print(begin_time)
#duration
hdur = int(roller4.get_selected()) * 60 * 60
mdur = int(roller5.get_selected()) * 60
sdur = int(roller6.get_selected())
duration = str(hdur + mdur + sdur)
print(str(duration))
#enable flow sensor?
flow_enable_state = flow_sensor_switch.has_state(lv.STATE.CHECKED)
print(flow_enable_state)
#check flow sensor for 5 sec
flow_debounce_state = flow_debounce_checkbox.has_state(
lv.STATE.CHECKED)
print(flow_debounce_state)
#check min reading
flow_max_state = flow_debounce_checkbox.has_state(lv.STATE.CHECKED)
print(flow_max_state)
#max flow limit
flow_max_val = flow_max_spinbox.get_value()
flow_max_val = flow_max_spinbox.get_value()
print(flow_max_val)
#enable rain sensor
rain_sensor_enable_state = rain_sensor_switch.has_state(
lv.STATE.CHECKED)
print(rain_sensor_enable_state)
rain_debounce_state = rain_sensor_debounce.has_state(
lv.STATE.CHECKED)
print(rain_debounce_state)
#Generate keys to store in DB
'''create unique id'''
def new_id():
return random.randint(0, 9999)
temp_db_keys = []
for key in db:
temp_db_keys.append(eval(key))
temp_key = new_id()
if temp_key in temp_db_keys:
temp_key = new_id()
return temp_key
create_trigger(unique_id=temp_key,
name=key,
begin=begin_time,
duration=duration,
flow_enable_state=flow_enable_state,
flow_debounce_state=flow_debounce_state,
flow_max_state=flow_max_state,
flow_max_val=flow_max_val,
rain_enable_state=rain_sensor_enable_state,
rain_debounce_state=rain_debounce_state)
def ta_event_cb(e, keyboard):
code = e.get_code()
text_area = e.get_target()
if code == lv.EVENT.FOCUSED:
keyboard.set_textarea(text_area)
keyboard.clear_flag(lv.obj.FLAG.HIDDEN)
keyboard.move_foreground()
cont.add_flag(lv.obj.FLAG.HIDDEN)
if code == lv.EVENT.DEFOCUSED:
keyboard.set_textarea(None)
keyboard.add_flag(lv.obj.FLAG.HIDDEN)
cont.clear_flag(lv.obj.FLAG.HIDDEN)
'''main scr'''
scr = lv.obj()
scr.clean()
lv.scr_load(scr)
btn_cancel = lv.btn(scr)
btn_cancel.add_event_cb(lambda e: btn_event(e, "Cancel"), lv.EVENT.CLICKED,
None)
btn_cancel_text = lv.label(btn_cancel)
btn_cancel_text.set_text('Cancel')
btn_save = lv.btn(scr)
btn_save.align_to(btn_cancel, lv.ALIGN.OUT_RIGHT_TOP, 185, 0)
btn_save.add_event_cb(lambda e: btn_event(e, "Save"), lv.EVENT.CLICKED,
None)
btn_save_text = lv.label(btn_save)
btn_save_text.set_text('Save')
label = lv.label(scr)
label.set_text('Add New Trigger')
label.align_to(btn_cancel, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
label2 = lv.label(scr)
label2.set_text('Trigger Name (Max: 8 char)')
label2.align_to(label, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
text_area = lv.textarea(scr)
text_area.set_height(40)
text_area.align_to(label2, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
text_area.add_event_cb(lambda e: ta_event_cb(e, keyboard), lv.EVENT.ALL,
None)
keyboard = lv.keyboard(scr)
keyboard.align_to(scr, lv.ALIGN.BOTTOM_MID, 0, 0)
keyboard.set_textarea(text_area)
keyboard.add_flag(lv.obj.FLAG.HIDDEN)
label3 = lv.label(lv.scr_act())
label3.set_text("Set Time to begin Trigger")
label3.align_to(text_area, lv.ALIGN.OUT_BOTTOM_LEFT, 5, 10)
'''cont width'''
cont_width = 280
'''cont : Roller Time '''
cont = lv.obj(lv.scr_act())
cont.align_to(label3, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
cont.set_height(150)
cont.set_width(cont_width)
'''roller options'''
dump = []
for i in range(0, 24):
dump.append(str(i))
opts1 = "\n".join(dump)
del dump
dump = []
for i in range(0, 60):
dump.append(str(i))
opts2 = "\n".join(dump)
'''roller trigger time'''
roller1 = lv.roller(cont)
roller1.align_to(cont, lv.ALIGN.LEFT_MID, 0, 20)
roller1.set_width(50)
roller1.set_options(opts1, lv.roller.MODE.NORMAL)
roller1.set_visible_row_count(3)
roller1.set_selected(8, lv.ANIM.ON)
roller2 = lv.roller(cont)
roller2.align_to(roller1, lv.ALIGN.OUT_RIGHT_TOP, 5, 0)
roller2.set_width(50)
roller2.set_options(opts2, lv.roller.MODE.NORMAL)
roller2.set_visible_row_count(3)
roller2.set_selected(30, lv.ANIM.ON)
roller3 = lv.roller(cont)
roller3.align_to(roller2, lv.ALIGN.OUT_RIGHT_TOP, 5, 0)
roller3.set_width(50)
roller3.set_options(opts2, lv.roller.MODE.NORMAL)
roller3.set_visible_row_count(3)
roller3.set_selected(0, lv.ANIM.ON)
label4 = lv.label(cont)
label4.align_to(roller1, lv.ALIGN.OUT_TOP_MID, 0, 0)
label4.set_text('hour')
label5 = lv.label(cont)
label5.align_to(roller2, lv.ALIGN.OUT_TOP_MID, 0, 0)
label5.set_text('min')
label6 = lv.label(cont)
label6.align_to(roller3, lv.ALIGN.OUT_TOP_MID, 0, 0)
label6.set_text('sec')
'''reset button trigger'''
btn_reset = lv.btn(cont)
btn_reset.align_to(roller3, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
btn_reset.add_event_cb(lambda e: btn_event(e, "Reset 1"), lv.EVENT.CLICKED,
None)
btn_reset_lbl = lv.label(btn_reset)
btn_reset_lbl.set_text("RESET")
btn_am = lv.btn(cont)
btn_am.align_to(btn_reset, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
btn_am.add_event_cb(lambda e: btn_event(e, "Set AM 1"), lv.EVENT.CLICKED,
None)
btn_am_lbl = lv.label(btn_am)
btn_am_lbl.set_text('am')
btn_pm = lv.btn(cont)
btn_pm.align_to(btn_am, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
btn_pm.add_event_cb(lambda e: btn_event(e, "Set PM 1"), lv.EVENT.CLICKED,
None)
btn_pm_lbl = lv.label(btn_pm)
btn_pm_lbl.set_text('pm')
label7 = lv.label(scr)
label7.align_to(cont, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
label7.set_text('Set Duration')
'''cont 2 : Roller Duration'''
cont2 = lv.obj(scr)
cont2.align_to(label7, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
cont2.set_height(150)
cont2.set_width(cont_width)
'''roller duration'''
roller4 = lv.roller(cont2)
roller4.align_to(cont2, lv.ALIGN.LEFT_MID, 0, 20)
roller4.set_width(50)
roller4.set_options(opts1, lv.roller.MODE.NORMAL)
roller4.set_visible_row_count(3)
roller4.set_selected(0, lv.ANIM.ON)
roller5 = lv.roller(cont2)
roller5.align_to(roller4, lv.ALIGN.OUT_RIGHT_TOP, 5, 0)
roller5.set_width(50)
roller5.set_options(opts2, lv.roller.MODE.NORMAL)
roller5.set_visible_row_count(3)
roller5.set_selected(0, lv.ANIM.ON)
roller6 = lv.roller(cont2)
roller6.align_to(roller5, lv.ALIGN.OUT_RIGHT_TOP, 5, 0)
roller6.set_width(50)
roller6.set_options(opts2, lv.roller.MODE.NORMAL)
roller6.set_visible_row_count(3)
roller6.set_selected(30, lv.ANIM.ON)
label8 = lv.label(cont2)
label8.align_to(roller4, lv.ALIGN.OUT_TOP_MID, 0, 0)
label8.set_text('hour')
label9 = lv.label(cont2)
label9.align_to(roller5, lv.ALIGN.OUT_TOP_MID, 0, 0)
label9.set_text('min')
label10 = lv.label(cont2)
label10.align_to(roller6, lv.ALIGN.OUT_TOP_MID, 0, 0)
label10.set_text('sec')
'''reset button duration'''
btn_reset2 = lv.btn(cont2)
btn_reset2.align_to(roller6, lv.ALIGN.OUT_RIGHT_TOP, 10, 0)
btn_reset2.add_event_cb(lambda e: btn_event(e, "Reset 2"),
lv.EVENT.CLICKED, None)
btn_reset_lbl2 = lv.label(btn_reset2)
btn_reset_lbl2.set_text("RESET")
btn_am2 = lv.btn(cont2)
btn_am2.align_to(btn_reset2, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
btn_am2.add_event_cb(lambda e: btn_event(e, "Reset hour"),
lv.EVENT.CLICKED, None)
btn_am_lbl2 = lv.label(btn_am2)
btn_am_lbl2.set_text('hour')
btn_pm2 = lv.btn(cont2)
btn_pm2.align_to(btn_am2, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
btn_pm2.add_event_cb(lambda e: btn_event(e, "Reset minute"),
lv.EVENT.CLICKED, None)
btn_pm_lbl2 = lv.label(btn_pm2)
btn_pm_lbl2.set_text('minute')
label10 = lv.label(scr)
label10.align_to(cont2, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
label10.set_text('Set Automatic disable trigger settings')
'''cont 3 : Flow sensor'''
cont3 = lv.obj(scr)
cont3.align_to(label10, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
cont3.set_height(150)
cont3.set_width(cont_width)
flow_sensor_lbl = lv.label(cont3)
flow_sensor_lbl.align_to(cont3, lv.ALIGN.TOP_LEFT, 0, 5)
flow_sensor_lbl.set_text("Enable Flow Sensor")
flow_sensor_switch = lv.switch(cont3)
flow_sensor_switch.align_to(cont3, lv.ALIGN.TOP_RIGHT, 0, -5)
#label12 = lv.label(cont3)
#label12.align_to(label11, lv.ALIGN.OUT_BOTTOM_LEFT,0,0)
#label12.set_text('5 sec threshold')
flow_debounce_checkbox = lv.checkbox(cont3)
flow_debounce_checkbox.align_to(flow_sensor_lbl, lv.ALIGN.OUT_BOTTOM_LEFT,
5, 10)
flow_debounce_checkbox.set_text("Debounce protection")
flow_max_checkbox = lv.checkbox(cont3)
flow_max_checkbox.align_to(flow_debounce_checkbox,
lv.ALIGN.OUT_BOTTOM_LEFT, 0, 5)
flow_max_checkbox.set_text('Max flow protection')
flow_max_spinbox = lv.spinbox(cont3)
flow_max_spinbox.align_to(flow_max_checkbox, lv.ALIGN.OUT_BOTTOM_LEFT, 0,
0)
flow_max_spinbox.set_range(0, 9999)
h = flow_max_spinbox.get_height()
flow_max_spinbox_btn1 = lv.btn(cont3)
flow_max_spinbox_btn1.align_to(flow_max_spinbox, lv.ALIGN.OUT_RIGHT_TOP, 0,
0)
flow_max_spinbox_btn1.set_style_bg_img_src(lv.SYMBOL.PLUS, 0)
flow_max_spinbox_btn1.set_size(h, h)
flow_max_spinbox_btn2 = lv.btn(cont3)
flow_max_spinbox_btn2.align_to(flow_max_spinbox_btn1,
lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
flow_max_spinbox_btn2.set_style_bg_img_src(lv.SYMBOL.MINUS, 0)
flow_max_spinbox_btn2.set_size(h, h)
'''Cont 4: Rain sensor'''
cont4 = lv.obj(scr)
cont4.align_to(cont3, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cont4.set_height(90)
cont4.set_width(cont_width)
rain_sensor_lbl = lv.label(cont4)
rain_sensor_lbl.align_to(cont4, lv.ALIGN.TOP_LEFT, 0, 5)
rain_sensor_lbl.set_text("Enable Rain Sensor")
rain_sensor_switch = lv.switch(cont4)
rain_sensor_switch.align_to(cont4, lv.ALIGN.TOP_RIGHT, 0, -5)
rain_sensor_debounce = lv.checkbox(cont4)
rain_sensor_debounce.align_to(rain_sensor_lbl, lv.ALIGN.OUT_BOTTOM_LEFT, 5,
10)
rain_sensor_debounce.set_text("Debounce protection")
'''Calender'''
cont5 = lv.obj(scr)
cont5.align_to(cont4, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cont5.set_height(290)
cont5.set_width(cont_width)
label14 = lv.label(cont5)
label14.align_to(cont5, lv.ALIGN.TOP_LEFT, 0, 5)
label14.set_text("Enable days")
calendar_switch = lv.switch(cont5)
calendar_switch.align_to(cont5, lv.ALIGN.TOP_RIGHT, 0, -5)
cal_1_checkbox = lv.checkbox(cont5)
cal_1_checkbox.align_to(label14, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cal_1_checkbox.set_text("Monday")
cal_2_checkbox = lv.checkbox(cont5)
cal_2_checkbox.align_to(cal_1_checkbox, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cal_2_checkbox.set_text("Tuesday")
cal_3_checkbox = lv.checkbox(cont5)
cal_3_checkbox.align_to(cal_2_checkbox, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cal_3_checkbox.set_text("Wednesday")
cal_4_checkbox = lv.checkbox(cont5)
cal_4_checkbox.align_to(cal_3_checkbox, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cal_4_checkbox.set_text("Thursday")
cal_5_checkbox = lv.checkbox(cont5)
cal_5_checkbox.align_to(cal_4_checkbox, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cal_5_checkbox.set_text("Friday")
cal_6_checkbox = lv.checkbox(cont5)
cal_6_checkbox.align_to(cal_5_checkbox, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cal_6_checkbox.set_text("Saturday")
cal_7_checkbox = lv.checkbox(cont5)
cal_7_checkbox.align_to(cal_6_checkbox, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
cal_7_checkbox.set_text("Sunday")
def main_page(self, tile_num):
alarm_clock_main_tile = self.mainbar.get_tile_obj(tile_num)
alarm_clock_main_style = lv.style_t()
alarm_clock_main_style.copy(self.mainbar.get_style())
self.activated_cont = lv.obj(alarm_clock_main_tile, None)
self.activated_cont.set_width(lv.scr_act().get_disp().driver.hor_res)
self.activated_cont.set_height(30)
self.activated_cont.add_style(lv.label.PART.MAIN,
alarm_clock_main_style)
self.activated_label = lv.label(self.activated_cont, None)
self.activated_label.align(self.activated_cont, lv.ALIGN.IN_LEFT_MID,
10, 0) # align left
self.activated_label.set_text("Activated")
self.activated_label.add_style(lv.label.PART.MAIN,
alarm_clock_main_style)
# create the activate switch
self.activated_switch = lv.switch(self.activated_cont, None)
self.activated_switch.align(self.activated_cont, lv.ALIGN.IN_RIGHT_MID,
-10, 0)
self.day_cont_style = lv.style_t()
self.day_cont_style.copy(self.mainbar.get_style())
self.day_cont_style.set_pad_inner(lv.STATE.DEFAULT, 1)
self.day_cont_style.set_pad_left(lv.STATE.DEFAULT, 10)
self.day_cont_style.set_pad_top(lv.STATE.DEFAULT, 4)
self.day_cont = lv.cont(alarm_clock_main_tile, None)
self.day_cont.set_width(lv.scr_act().get_disp().driver.hor_res)
self.day_cont.set_layout(lv.LAYOUT.PRETTY_BOTTOM)
self.day_cont.set_fit(lv.FIT.NONE)
self.day_cont.align(self.activated_cont, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
self.day_cont.add_style(lv.cont.PART.MAIN, self.day_cont_style)
# create the day buttons
day_style = lv.style_t()
day_style.set_radius(lv.STATE.DEFAULT, 3)
for i in range(7):
# create the button
self.day_button[i] = lv.btn(self.day_cont, None)
self.day_button[i].set_checkable(True)
self.day_button[i].add_style(lv.btn.PART.MAIN, day_style)
self.day_button[i].set_size(30, 30)
self.day_label[i] = lv.label(self.day_button[i])
# print("Setting label %d text to: %s"%(i,self.weekDayTable_2[i]))
self.day_label[i].set_text(self.alarm_clock_week_day_2[i])
# create a roller for the hours
for i in range(23):
self.hours += (str(i) + "\n")
self.hours += str(23)
#print(self.hours)
self.hourRoller = lv.roller(alarm_clock_main_tile, None)
self.hourRoller.set_auto_fit(False)
self.hourRoller.set_width(60)
self.hourRoller.set_visible_row_count(4)
self.hourRoller.set_options(self.hours, lv.roller.MODE.INFINITE)
self.hourRoller.align(self.day_cont, lv.ALIGN.OUT_BOTTOM_LEFT, 50, 0)
for i in range(59):
# self.minutes += (str(i)+"\n")
self.minutes += "%02d\n" % i
self.minutes += str(59)
self.minuteRoller = lv.roller(alarm_clock_main_tile, None)
self.minuteRoller.set_auto_fit(False)
self.minuteRoller.set_width(60)
self.minuteRoller.set_visible_row_count(4)
self.minuteRoller.set_options(self.minutes, lv.roller.MODE.INFINITE)
self.minuteRoller.align(self.day_cont, lv.ALIGN.OUT_BOTTOM_RIGHT, -50,
0)
self.colon = lv.label(alarm_clock_main_tile, None)
self.colon.set_text(":")
self.colon.add_style(lv.label.PART.MAIN, self.day_cont_style)
self.colon.align(self.hourRoller, lv.ALIGN.OUT_RIGHT_MID, 0, 0)
exit_btn = lv.imgbtn(self.alarm_clock_main_tile, None)
exit_btn.set_src(lv.btn.STATE.RELEASED,
self.mainbar.get_exit_btn_dsc())
exit_btn.add_style(lv.imgbtn.PART.MAIN, alarm_clock_main_style)
exit_btn.align(self.alarm_clock_main_tile, lv.ALIGN.IN_BOTTOM_LEFT, 10,
-10)
self.log.debug("setting up exit callback")
exit_btn.set_event_cb(self.exit_alarm_clock_main_event_cb)
setup_btn = lv.imgbtn(self.alarm_clock_main_tile, None)
setup_btn.set_src(lv.btn.STATE.RELEASED,
self.mainbar.get_setup_btn_dsc())
setup_btn.add_style(lv.imgbtn.PART.MAIN, alarm_clock_main_style)
setup_btn.align(self.alarm_clock_main_tile, lv.ALIGN.IN_BOTTOM_RIGHT,
-10, -10)
self.log.debug("setting up setup callback")
#!/opt/bin/lv_micropython -i
import time
import lvgl as lv
import display_driver
def event_handler(source, evt):
if evt == lv.EVENT.VALUE_CHANGED:
month = " " * 10
roller.get_selected_str(month, len(month))
print("Selected month: ", month)
roller = lv.roller(lv.scr_act(), None)
roller.set_options(
"January\n"
"February\n"
"March\n"
"April\n"
"May\n"
"June\n"
"July\n"
"August\n"
"September\n"
"October\n"
"November\n"
"December", lv.roller.MODE.INFINITE)
roller.set_visible_row_count(4)
roller.align(None, lv.ALIGN.CENTER, 0, 0)
roller.set_event_cb(event_handler)
def m4():
position = 0
scr = lv.obj()
lv.scr_load(scr)
#container for drop and switch
cont = lv.cont(scr)
cont.set_auto_realign(True)
cont.set_fit2(lv.FIT.PARENT, lv.FIT.TIGHT)
cont.set_layout(lv.LAYOUT.PRETTY_MID)
cont.align(scr, lv.ALIGN.IN_TOP_MID, 0, 0)
cont.set_style_local_radius(0, 0, 0)
#dropdown - event
def drop_event(obj, event):
if event == lv.EVENT.VALUE_CHANGED:
position = drop.get_selected()
print("changing trigger position to {}".format(str(position)))
m4_1(position) #call to refresh roller position
#dropdown
drop = lv.dropdown(cont)
drop.set_style_local_border_post(lv.BORDER_SIDE.NONE, lv.BORDER_SIDE.NONE,
lv.BORDER_SIDE.NONE)
drop.set_options(
"Trigger 1\nTrigger 2\nTrigger 3\nTrigger 4\nTrigger 5\nTrigger 6\nTrigger 7\nTrigger 8\nTrigger 9\n Trigger 10"
)
drop.set_event_cb(drop_event)
#tabview
tab = lv.tabview(scr)
tab.align(cont, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
tab1 = tab.add_tab("Time")
tab2 = tab.add_tab("Auto")
tab3 = tab.add_tab("Switches")
tab4 = tab.add_tab("Desc")
####Tab 1
#label
lbl1 = lv.label(cont)
lbl1.set_text("Arm?")
#switch
switch = lv.switch(cont)
lbl2 = lv.label(tab1)
lbl2.set_text("Set time to begin trigger :")
lbl2.align(tab1, lv.ALIGN.IN_TOP_MID, 0, 10)
#contain - sort vert
cont2 = lv.cont(tab1)
cont2.align(lbl2, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
cont2.set_auto_realign(True)
cont2.set_layout(lv.LAYOUT.ROW_MID)
cont2.set_fit(lv.FIT.TIGHT)
roller_hour = lv.roller(cont2)
roller_hour.set_options(
"00\n01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23",
lv.roller.MODE.NORMAL)
roller_minute = lv.roller(cont2)
roller_minute.set_options(
"00\n01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59",
lv.roller.MODE.NORMAL)
roller_sec = lv.roller(cont2)
roller_sec.set_options(
"00\n01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59",
lv.roller.MODE.NORMAL)
btn = lv.btn(cont2)
lbl_btn = lv.label(btn)
lbl_btn.set_text("SET")
#duration
lbl3 = lv.label(tab1)
lbl3.set_text("Set duration for trigger : ")
lbl3.align(cont2, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
cont3 = lv.cont(tab1)
cont3.align(lbl3, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
cont3.set_auto_realign(True)
cont3.set_layout(lv.LAYOUT.ROW_MID)
cont3.set_fit(lv.FIT.TIGHT)
roller_hour_dur = lv.roller(cont3)
roller_hour_dur.set_options(
"00\n01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23",
lv.roller.MODE.NORMAL)
roller_minute_dur = lv.roller(cont3)
roller_minute_dur.set_options(
"00\n01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59",
lv.roller.MODE.NORMAL)
roller_sec_dur = lv.roller(cont3)
roller_sec_dur.set_options(
"00\n01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59",
lv.roller.MODE.NORMAL)
#button (set timer) - event
def btn_event(obj, event):
if obj == btn and event == lv.EVENT.CLICKED:
position = drop.get_selected()
trigger[position].bhour = roller_hour.get_selected()
trigger[position].bminute = roller_minute.get_selected()
trigger[position].bsecond = roller_sec.get_selected()
print("btn - event : position {}, bhour {}, bminute {}, bsec{}".
format(str(position), str(roller_hour.get_selected()),
str(roller_minute.get_selected()),
str(roller_sec.get_selected())))
if obj == btn2 and event == lv.EVENT.CLICKED:
position = drop.get_selected()
trigger[position].hourdur = roller_hour_dur.get_selected()
trigger[position].minutedur = roller_minute_dur.get_selected()
trigger[position].seconddur = roller_sec_dur.get_selected()
print("btn2 - event")
if obj == switch and event == lv.EVENT.VALUE_CHANGED:
position = drop.get_selected()
trigger[position].isArmed = switch.get_state()
print("Arming trigger {}".format(switch.get_state()))
if obj == btn_t4_1 and event == lv.EVENT.CLICKED:
m5()
btn2 = lv.btn(cont3)
lbl_btn2 = lv.label(btn2)
lbl_btn2.set_text("SET")
#button event call
btn.set_event_cb(btn_event)
btn2.set_event_cb(btn_event)
switch.set_event_cb(btn_event)
def m4_1(_position): #run after dropdown selected or pos 0 default
position = _position
print("M4_1() calling position {}".format(position))
roller_hour.set_selected(trigger[position].bhour, lv.ANIM.ON)
roller_minute.set_selected(trigger[position].bminute, lv.ANIM.ON)
roller_sec.set_selected(trigger[position].bsecond, lv.ANIM.ON)
roller_hour_dur.set_selected(trigger[position].hourdur, lv.ANIM.ON)
roller_minute_dur.set_selected(trigger[position].minutedur, lv.ANIM.ON)
roller_sec_dur.set_selected(trigger[position].seconddur, lv.ANIM.ON)
#set proper state of switch
if switch.get_state() != trigger[position].isArmed:
switch.toggle(lv.ANIM.ON)
m4_1(position)
#####Tab 2 - Automation
tab2.set_height(320)
lbl_t2 = lv.label(tab2)
lbl_t2.align(tab1, lv.ALIGN.IN_TOP_MID, 210, 10)
lbl_t2.set_text("Automatic trigger disable settings")
cont3 = lv.cont(tab2)
cont3.set_auto_realign(True)
cont3.set_layout(lv.LAYOUT.PRETTY_MID)
cont3.align(lbl_t2, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
cont3.set_fit2(lv.FIT.TIGHT, lv.FIT.TIGHT)
lbl_t2_2 = lv.label(cont3)
lbl_t2_2.set_text("Enable Flow Sensor")
switch_t2_1 = lv.switch(cont3)
lbl_t2_3 = lv.label(cont3)
lbl_t2_3.set_text("Enable Rain Sensor")
switch_t2_2 = lv.switch(cont3)
lbl_t2_4 = lv.label(cont3)
lbl_t2_4.set_text("Enable MET weather API")
switch_t2_3 = lv.switch(cont3)
lbl_t2_5 = lv.label(cont3)
lbl_t2_5.set_text("Enable Soil Sensor")
switch_t2_4 = lv.switch(cont3)
gauge_t2 = lv.gauge(tab2)
gauge_t2.align(cont3, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
####Tab 3 - Switches
tab3.set_height(320)
lbl_t3 = lv.label(tab3)
lbl_t3.align(tab3, lv.ALIGN.IN_TOP_MID, -80, 10)
lbl_t3.set_text("Assign Pin to be triggered")
#page4 = lv.page(tab3)
#page4.set_auto_realign(True)
#page4.align(lbl_t3, lv.ALIGN.OUT_BOTTOM_MID,0,10)
#page4.set_size(290,800)
btnmtx_t3 = lv.btnmatrix(tab3)
btnmtx_t3.align(lbl_t3, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
btnmtx_t3.set_width(250)
btnmtx_t3.set_height(600)
btn_map_t3 = [
"3.3v", "GND", "\n", "EN", "23", "\n", "36", "22", "\n", "39", "01",
"\n", "34", "03", "\n", "35", "21", "\n", "32", "GND", "\n", "33",
"19", "\n", "25", "18", "\n", "26", "05", "\n", "27", "17", "\n", "14",
"16", "\n", "12", "04", "\n", "GND", "00", "\n", "13", "02", "\n",
"09", "15", "\n", "10", "08", "\n", "11", "07", "\n", "VIN", "06", ""
]
btnmtx_t3.set_map(btn_map_t3)
btnmtx_t3.set_btn_ctrl_all(btnmtx_t3.CTRL.CHECKABLE)
btn_t3_save = lv.btn(tab3)
btn_t3_save.align(btnmtx_t3, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
lbl_btn_t3_save = lv.label(btn_t3_save)
lbl_btn_t3_save.set_text("Save Toggles")
#### Tab 4 Description
btn_t4_1 = lv.btn(tab4)
btn_t4_1.align(tab4, lv.ALIGN.CENTER, 0, 0)
btn_t4_1.set_event_cb(btn_event)
lbl_btn_t4_1 = lv.label(btn_t4_1)
lbl_btn_t4_1.set_text(lv.SYMBOL.HOME)
try:
style_sel.set_text_font(lv.font_montserrat_22)
except:
fs_drv = lv.fs_drv_t()
fs_driver.fs_register(fs_drv, 'S')
print(
"montserrat-22 not enabled in lv_conf.h, dynamically loading the font")
font_montserrat_22 = lv.font_load("S:" +
"../assets/font/montserrat-22.fnt")
style_sel.set_text_font(font_montserrat_22)
opts = "\n".join(["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"])
# A roller on the left with left aligned text, and custom width
roller = lv.roller(lv.scr_act())
roller.set_options(opts, lv.roller.MODE.NORMAL)
roller.set_visible_row_count(2)
roller.set_width(100)
roller.add_style(style_sel, lv.PART.SELECTED)
roller.set_style_text_align(lv.TEXT_ALIGN.LEFT, 0)
roller.align(lv.ALIGN.LEFT_MID, 10, 0)
roller.add_event_cb(event_handler, lv.EVENT.ALL, None)
roller.set_selected(2, lv.ANIM.OFF)
# A roller on the middle with center aligned text, and auto (default) width
roller = lv.roller(lv.scr_act())
roller.set_options(opts, lv.roller.MODE.NORMAL)
roller.set_visible_row_count(3)
roller.add_style(style_sel, lv.PART.SELECTED)
roller.align(lv.ALIGN.CENTER, 0, 0)