def init_gui_stm32(self):
import rk043fn48h as lcd
import lvstm32
hres = 480
vres = 272
# Register display driver
tick = lvstm32.lvstm32()
lcd.init(w=hres, h=vres)
disp_buf1 = lv.disp_buf_t()
buf1_1 = lcd.framebuffer(1)
buf1_2 = lcd.framebuffer(2)
lv.disp_buf_init(disp_buf1, buf1_1, buf1_2, len(buf1_1) // lv.color_t.SIZE)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = lcd.flush
disp_drv.gpu_blend_cb = lcd.gpu_blend
disp_drv.gpu_fill_cb = lcd.gpu_fill
disp_drv.hor_res = hres
disp_drv.ver_res = vres
lv.disp_drv_register(disp_drv)
# Register touch sensor
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = lcd.ts_read
lv.indev_drv_register(indev_drv)
def init_gui_esp32(self):
import lvesp32
import ILI9341 as ili
# Initialize ILI9341 display
disp = ili.display(miso=5, mosi=18, clk=19, cs=13, dc=12, rst=4, backlight=2)
disp.init()
# Register display driver
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(480*10)
lv.disp_buf_init(disp_buf1,buf1_1, None, len(buf1_1)//4)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = disp.flush
disp_drv.hor_res = 240
disp_drv.ver_res = 320
lv.disp_drv_register(disp_drv)
# Register raw resistive touch driver
import rtch
touch = rtch.touch(xp = 32, yp = 33, xm = 25, ym = 26, touch_rail = 27, touch_sense = 33)
touch.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read_cb = touch.read;
lv.indev_drv_register(indev_drv);
def registerKeyDriver(self):
self._keydev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._keydev_drv)
self._keydev_drv.type = lv.INDEV_TYPE.KEYPAD
self._keydev_drv.read_cb = self.getKeyReader()
self._keyDriver = lv.indev_drv_register(self._keydev_drv)
return self._keyDriver
def init_gui_esp32(self):
import lvesp32
import ILI9341 as ili
# Initialize ILI9341 display
disp = ili.display(miso=5, mosi=18, clk=19, cs=13, dc=12, rst=4, backlight=2)
disp.init()
# Register display driver
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.disp_flush = disp.flush
disp_drv.disp_fill = disp.fill
lv.disp_drv_register(disp_drv)
# Register raw resistive touch driver
import rtch
touch = rtch.touch(xp = 32, yp = 33, xm = 25, ym = 26, touch_rail = 27, touch_sense = 33)
touch.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read = touch.read;
lv.indev_drv_register(indev_drv);
def init_gui_SDL(self):
import SDL
SDL.init()
# Register SDL display driver.
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(480 * 10)
lv.disp_buf_init(disp_buf1, buf1_1, None, len(buf1_1) // 4)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = SDL.monitor_flush
disp_drv.hor_res = 480
disp_drv.ver_res = 320
lv.disp_drv_register(disp_drv)
# Regsiter SDL mouse driver
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = SDL.mouse_read
lv.indev_drv_register(indev_drv)
def registerEncoderDriver(self):
self._encdev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._encdev_drv)
self._encdev_drv.type = lv.INDEV_TYPE.ENCODER
self._encdev_drv.read_cb = self.getEncoderReader()
self._encDriver = lv.indev_drv_register(self._encdev_drv)
return self._keyDriver
def _register_indev_drv(self):
# Register touch screen driver
self._indev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._indev_drv)
self._indev_drv.type = lv.INDEV_TYPE.POINTER
self._indev_drv.read_cb = self._tft.read
self._indev = lv.indev_drv_register(self._indev_drv)
return
def registerDriver(self):
self._indev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._indev_drv)
self._indev_drv.type = self._devType
self._indev_drv.read_cb = self.getReader()
self._driver = lv.indev_drv_register(self._indev_drv)
self.extraRegistration()
return self._driver
def init_gui(self):
import lvgl as lv
import lvgl_helper as lv_h
import lcd
import time
from machine import I2C
config_touchscreen_support = True
board_m1n = False
i2c = I2C(I2C.I2C0, freq=400000, scl=30, sda=31)
if not board_m1n:
lcd.init()
else:
lcd.init(type=2, freq=20000000)
if config_touchscreen_support:
import touchscreen as ts
ts.init(i2c)
lv.init()
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(320 * 10)
lv.disp_buf_init(disp_buf1, buf1_1, None, len(buf1_1) // 4)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = lv_h.flush
if board_m1n:
disp_drv.hor_res = 240
disp_drv.ver_res = 240
else:
disp_drv.hor_res = 320
disp_drv.ver_res = 240
lv.disp_drv_register(disp_drv)
if config_touchscreen_support:
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)
# lv.log_register_print_cb(lv_h.log)
lv.log_register_print_cb(lambda level, path, line, msg: print(
'%s(%d): %s' % (path, line, msg)))
# Create the main screen and load it.
self.screen_main = Screen_Main(self)
lv.scr_load(self.screen_main)
def __init__(self,
miso=-1,
mosi=-1,
clk=-1,
cs=25,
spihost=esp.HSPI_HOST,
mhz=5,
transpose=False,
touch_margin=100):
# Initializations
self.screen_width = lv.disp_get_hor_res(lv.disp_t.cast(None))
self.screen_height = lv.disp_get_ver_res(lv.disp_t.cast(None))
self.miso = miso
self.mosi = mosi
self.clk = clk
self.cs = cs
self.spihost = spihost
self.mhz = mhz
self.cal_x0 = None
self.transpose = transpose
self.touch_margin = touch_margin
self.touch_count = 0
self.touch_cycles = 0
self.spi_init()
# Prepare buffer with commands to send to device
nc = len(self.CMDS)
self.buflen = 2 * nc * REP + 1 # +1 for final CMD_OFF
self.txbuf = esp.heap_caps_malloc(self.buflen, esp.MALLOC_CAP.DMA)
txbuf = self.txbuf.__dereference__(self.buflen)
for c in range(nc):
for r in range(REP):
txbuf[(c * REP + r) * 2 +
0] = self.CMDS[c] # first byte is command, second is 0
txbuf[(c * REP + r) * 2 + 1] = 0
txbuf[2 * nc * REP] = CMD_OFF
# print("xpt2046 txbuf:", ["%02x" % v for v in txbuf])
self.rxbuf = esp.heap_caps_malloc(self.buflen, esp.MALLOC_CAP.DMA)
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = self.read
lv.indev_drv_register(indev_drv)
print("xpt2046 touch initialized")
def __init__(self):
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(390 * 32)
lv.disp_buf_init(disp_buf1, buf1_1, None, len(buf1_1) // 4)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = display.flush
disp_drv.hor_res = 390
disp_drv.ver_res = 390
lv.disp_drv_register(disp_drv)
touchscreen.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = touchscreen.touchscreen_read
lv.indev_drv_register(indev_drv)
def init():
"""
GUI initialization function.
Should be called once in the very beginning.
"""
# init the gui library
lv.init()
# init the hardware library
SDL.init()
# Register SDL display driver
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(HOR_RES*10)
lv.disp_buf_init(disp_buf1,buf1_1, None, len(buf1_1)//4)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = SDL.monitor_flush
disp_drv.hor_res = HOR_RES
disp_drv.ver_res = VER_RES
lv.disp_drv_register(disp_drv)
# Regsiter SDL mouse driver
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read_cb = SDL.mouse_read;
lv.indev_drv_register(indev_drv);
# Set up material theme
# First argument (210) is a hue - theme color shift,
# Second - default font to use. Builtin: roboto_16, roboto_28
th = lv.theme_material_init(210, lv.font_roboto_22)
lv.theme_set_current(th)
# Create a screen and load it
# To access active screen use lv.scr_act()
scr = lv.obj()
lv.scr_load(scr)
# Initialize the styles
styles["title"] = lv.style_t()
# Title style - just a default style with larger font
lv.style_copy(styles["title"], lv.style_plain)
styles["title"].text.font = lv.font_roboto_28
def __init__(self, encoder, group=None):
def input_callback(drv, data):
data.enc_diff = encoder.diff
if encoder.pressed:
data.state = lv.INDEV_STATE.PR
else:
data.state = lv.INDEV_STATE.REL
gc.collect()
return False
self.drv = lv.indev_drv_t()
self.encoder = encoder
lv.indev_drv_init(self.drv)
self.drv.type = lv.INDEV_TYPE.ENCODER
self.drv.read_cb = input_callback
self.win_drv = lv.indev_drv_register(self.drv)
self.group = group
def __init__(self,
miso=-1,
mosi=-1,
clk=-1,
cs=25,
spihost=esp.HSPI_HOST,
mhz=5,
max_cmds=16,
cal_x0=3783,
cal_y0=3948,
cal_x1=242,
cal_y1=423,
transpose=True,
samples=3):
# Initializations
self.screen_width = lv.disp_get_hor_res(lv.disp_t.cast(None))
self.screen_height = lv.disp_get_ver_res(lv.disp_t.cast(None))
self.miso = miso
self.mosi = mosi
self.clk = clk
self.cs = cs
self.spihost = spihost
self.mhz = mhz
self.max_cmds = max_cmds
self.cal_x0 = cal_x0
self.cal_y0 = cal_y0
self.cal_x1 = cal_x1
self.cal_y1 = cal_y1
self.transpose = transpose
self.samples = samples
self.touch_count = 0
self.touch_cycles = 0
self.spi_init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = self.read
lv.indev_drv_register(indev_drv)
def init_gui_esp32(self):
import lvesp32
# Initialize ILI9341 display
from ili9341 import ili9341
self.disp = ili9341()
# Register raw resistive touch driver
import rtch
self.touch = rtch.touch(xp = 32, yp = 33, xm = 25, ym = 26, touch_rail = 27, touch_sense = 33)
self.touch.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read_cb = self.touch.read;
lv.indev_drv_register(indev_drv);
def screen_init():
sda_pin = machine.Pin(23)
scl_pin = machine.Pin(32)
i2c = machine.I2C(id=1, scl=scl_pin, sda=sda_pin, speed=400000)
ts.init(i2c)
tft.init(tft.ST7789, width=240, invrot=3, rot=1, bgr=False, height=240, miso=2, mosi=19, clk=18, cs=5, dc=27,
speed=40000000, color_bits=tft.COLOR_BITS16, backl_pin=12, backl_on=1)
tft.clear(tft.RED)
time.sleep(1)
tft.clear(tft.GREEN)
time.sleep(1)
tft.clear(tft.BLUE)
time.sleep(1)
lv.init()
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytes(240 * 10)
lv.disp_buf_init(disp_buf1, buf1_1, None, len(buf1_1) // 4)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = lv_h.flush
disp_drv.hor_res = 240
disp_drv.ver_res = 240
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)
scr = lv.obj()
btn = lv.btn(scr)
btn.align(lv.scr_act(), lv.ALIGN.CENTER, 0, 0)
label = lv.label(btn)
label.set_text("Button")
lv.scr_load(scr)
def init_gui_SDL(self):
import SDL
SDL.init()
# Register SDL display driver.
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.disp_flush = SDL.monitor_flush
disp_drv.disp_fill = SDL.monitor_fill
disp_drv.disp_map = SDL.monitor_map
lv.disp_drv_register(disp_drv)
# Regsiter SDL mouse driver
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read = SDL.mouse_read;
lv.indev_drv_register(indev_drv);
def init(autoupdate=True):
import lvgl as lv
import SDL
HOR_RES = 480
VER_RES = 800
"""
GUI initialization function.
Should be called once in the very beginning.
"""
# init the gui library
lv.init()
# init the hardware library
SDL.init()
# Register SDL display driver
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(HOR_RES * 10)
lv.disp_buf_init(disp_buf1, buf1_1, None, len(buf1_1) // 4)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = SDL.monitor_flush
disp_drv.hor_res = HOR_RES
disp_drv.ver_res = VER_RES
lv.disp_drv_register(disp_drv)
# Regsiter SDL mouse driver
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = SDL.mouse_read
lv.indev_drv_register(indev_drv)
scr = lv.obj()
lv.scr_load(scr)
if autoupdate:
import SDL
SDL.enable_autoupdate()
def init_indev_drv(self, mouse_read):
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = mouse_read
lv.indev_drv_register(indev_drv)
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = lv_h.flush
if board_m1n:
disp_drv.hor_res = 240
disp_drv.ver_res = 240
else:
disp_drv.hor_res = 480
disp_drv.ver_res = 320
lv.disp_drv_register(disp_drv)
if config_touchscreen_support:
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = read_cb
lv.indev_drv_register(indev_drv)
lv.log_register_print_cb(lambda level,path,line,msg: print('%s(%d): %s' % (path, line, msg)))
def event_handler(obj, event):
global btn, box, bg
if event == lv.EVENT.CLICKED:
if obj == btn:
box.set_hidden(0)
bg.set_hidden(0)
elif obj == box:
box.set_hidden(1)
