def __init__(self,
miso=5,
mosi=18,
clk=19,
cs=13,
dc=12,
rst=4,
backlight=2,
spihost=esp.enum.HSPI_HOST,
mhz=40,
factor=5):
# Make sure Micropython was built such that color won't require processing before DMA
if lv.color_t.SIZE != 2:
raise RuntimeError(
'ili9341 micropython driver requires defining LV_COLOR_DEPTH=16'
)
if not hasattr(lv.color_t().ch, 'green_l'):
raise RuntimeError(
'ili9341 micropython driver requires defining LV_COLOR_16_SWAP=1'
)
# Initializations
self.miso = miso
self.mosi = mosi
self.clk = clk
self.cs = cs
self.dc = dc
self.rst = rst
self.backlight = backlight
self.spihost = spihost
self.mhz = mhz
self.init()
# Register display driver
buf_size = (self.width * self.height * lv.color_t.SIZE) // factor
lv.disp_buf_init(self.disp_buf, bytearray(buf_size),
bytearray(buf_size), buf_size // lv.color_t.SIZE)
lv.disp_drv_init(self.disp_drv)
self.disp_drv.buffer = self.disp_buf
self.disp_drv.flush_cb = self.flush
self.disp_drv.monitor_cb = self.monitor
self.disp_drv.hor_res = self.width
self.disp_drv.ver_res = self.height
lv.disp_drv_register(self.disp_drv)
def __init__(self, miso=5, mosi=18, clk=19, cs=13, dc=12, rst=4, backlight=2, spihost=esp.enum.HSPI_HOST, mhz=40, factor=4, hybrid=True):
# Make sure Micropython was built such that color won't require processing before DMA
if lv.color_t.SIZE != 2:
raise RuntimeError('ili9341 micropython driver requires defining LV_COLOR_DEPTH=16')
if not hasattr(lv.color_t().ch, 'green_l'):
raise RuntimeError('ili9341 micropython driver requires defining LV_COLOR_16_SWAP=1')
# Initializations
self.miso = miso
self.mosi = mosi
self.clk = clk
self.cs = cs
self.dc = dc
self.rst = rst
self.backlight = backlight
self.spihost = spihost
self.mhz = mhz
self.factor = factor
self.hybrid = hybrid
self.buf_size = (self.width * self.height * lv.color_t.SIZE) // factor
self.init()
# Register display driver
self.buf1 = esp.heap_caps_malloc(self.buf_size, esp.CAP.DMA)
self.buf2 = esp.heap_caps_malloc(self.buf_size, esp.CAP.DMA)
if self.buf1 and self.buf2:
print("Double buffer")
elif self.buf1:
print("Single buffer")
else:
raise RuntimeError("Not enough DMA-able memory to allocate display buffer")
lv.disp_buf_init(self.disp_buf, self.buf1, self.buf2, self.buf_size // lv.color_t.SIZE)
lv.disp_drv_init(self.disp_drv)
self.disp_drv.user_data = {'dc': self.dc, 'spi': self.spi}
self.disp_drv.buffer = self.disp_buf
self.disp_drv.flush_cb = esp.ili9341_flush if self.hybrid and hasattr(esp, 'ili9341_flush') else self.flush
self.disp_drv.monitor_cb = self.monitor
self.disp_drv.hor_res = self.width
self.disp_drv.ver_res = self.height
lv.disp_drv_register(self.disp_drv)
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)))
COLOR_SIZE = lv.color_t.SIZE
COLOR_IS_SWAPPED = hasattr(lv.color_t().ch, 'green_h')
class lodepng_error(RuntimeError):
def __init__(self, err):
if type(err) is int:
super().__init__(png.error_text(err))
else:
super().__init__(err)
# Parse PNG file header
# Taken from https://github.com/shibukawa/imagesize_py/blob/ffef30c1a4715c5acf90e8945ceb77f4a2ed2d45/imagesize.py#L63-L85
def get_png_info(decoder, src, header):
#
# Create a transparent canvas with Chroma keying and indexed color format (palette).
#
# Create a button to better see the transparency
btn=lv.btn(lv.scr_act())
# Create a buffer for the canvas
cbuf= bytearray(LV_CANVAS_BUF_SIZE_INDEXED_1BIT(CANVAS_WIDTH, CANVAS_HEIGHT))
# Create a canvas and initialize its the palette
canvas = lv.canvas(lv.scr_act())
canvas.set_buffer(cbuf, CANVAS_WIDTH, CANVAS_HEIGHT, lv.img.CF.INDEXED_1BIT)
canvas.set_palette(0, LV_COLOR_CHROMA_KEY)
canvas.set_palette(1, lv.palette_main(lv.PALETTE.RED))
# Create colors with the indices of the palette
c0 = lv.color_t()
c1 = lv.color_t()
c0.full = 0
c1.full = 1
# Red background (There is no dedicated alpha channel in indexed images so LV_OPA_COVER is ignored)
canvas.fill_bg(c1, lv.OPA.COVER)
# Create hole on the canvas
for y in range(10,30):
for x in range(5,20):
canvas.set_px(x, y, c0)
def __init__(self,
miso=5,
mosi=18,
clk=19,
cs=13,
dc=12,
rst=4,
power=14,
backlight=15,
backlight_on=0,
power_on=0,
spihost=esp.HSPI_HOST,
mhz=40,
factor=4,
hybrid=True,
width=240,
height=320,
colormode=COLOR_MODE_BGR,
rot=PORTRAIT,
invert=False,
double_buffer=True):
# Make sure Micropython was built such that color won't require processing before DMA
if lv.color_t.SIZE != 2:
raise RuntimeError(
'ili9341 micropython driver requires defining LV_COLOR_DEPTH=16'
)
if colormode == COLOR_MODE_BGR and not hasattr(lv.color_t().ch,
'green_l'):
raise RuntimeError(
'ili9341 BGR color mode requires defining LV_COLOR_16_SWAP=1')
# Initializations
self.width = width
self.height = height
self.miso = miso
self.mosi = mosi
self.clk = clk
self.cs = cs
self.dc = dc
self.rst = rst
self.power = power
self.backlight = backlight
self.backlight_on = backlight_on
self.power_on = power_on
self.spihost = spihost
self.mhz = mhz
self.factor = factor
self.hybrid = hybrid
self.buf_size = (self.width * self.height * lv.color_t.SIZE) // factor
self.init_cmds = [
{
'cmd': 0xCF,
'data': bytes([0x00, 0x83, 0X30])
},
{
'cmd': 0xED,
'data': bytes([0x64, 0x03, 0X12, 0X81])
},
{
'cmd': 0xE8,
'data': bytes([0x85, 0x01, 0x79])
},
{
'cmd': 0xCB,
'data': bytes([0x39, 0x2C, 0x00, 0x34, 0x02])
},
{
'cmd': 0xF7,
'data': bytes([0x20])
},
{
'cmd': 0xEA,
'data': bytes([0x00, 0x00])
},
{
'cmd': 0xC0,
'data': bytes([0x26])
}, # Power control
{
'cmd': 0xC1,
'data': bytes([0x11])
}, # Power control
{
'cmd': 0xC5,
'data': bytes([0x35, 0x3E])
}, # VCOM control
{
'cmd': 0xC7,
'data': bytes([0xBE])
}, # VCOM control
{
'cmd': 0x36,
'data': bytes([rot | colormode])
}, # Memory Access Control
{
'cmd': 0x3A,
'data': bytes([0x55])
}, # Pixel Format Set
{
'cmd': 0xB1,
'data': bytes([0x00, 0x1B])
},
{
'cmd': 0xF2,
'data': bytes([0x08])
},
{
'cmd': 0x26,
'data': bytes([0x01])
},
{
'cmd':
0xE0,
'data':
bytes([
0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0X87, 0x32, 0x0A,
0x07, 0x02, 0x07, 0x05, 0x00
])
},
{
'cmd':
0XE1,
'data':
bytes([
0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05,
0x18, 0x0D, 0x38, 0x3A, 0x1F
])
},
{
'cmd': 0x2A,
'data': bytes([0x00, 0x00, 0x00, 0xEF])
},
{
'cmd': 0x2B,
'data': bytes([0x00, 0x00, 0x01, 0x3f])
},
{
'cmd': 0x2C,
'data': bytes([0])
},
{
'cmd': 0xB7,
'data': bytes([0x07])
},
{
'cmd': 0xB6,
'data': bytes([0x0A, 0x82, 0x27, 0x00])
},
{
'cmd': 0x11,
'data': bytes([0]),
'delay': 100
},
{
'cmd': 0x29,
'data': bytes([0]),
'delay': 100
}
]
if invert:
self.init_cmds.append({'cmd': 0x21})
self.init()
# Register display driver
self.buf1 = esp.heap_caps_malloc(self.buf_size, esp.MALLOC_CAP.DMA)
self.buf2 = esp.heap_caps_malloc(
self.buf_size, esp.MALLOC_CAP.DMA) if double_buffer else None
if self.buf1 and self.buf2:
print("Double buffer")
elif self.buf1:
print("Single buffer")
else:
raise RuntimeError(
"Not enough DMA-able memory to allocate display buffer")
self.disp_buf = lv.disp_buf_t()
self.disp_drv = lv.disp_drv_t()
lv.disp_buf_init(self.disp_buf, self.buf1, self.buf2,
self.buf_size // lv.color_t.SIZE)
lv.disp_drv_init(self.disp_drv)
self.disp_drv.user_data = {'dc': self.dc, 'spi': self.spi}
self.disp_drv.buffer = self.disp_buf
self.disp_drv.flush_cb = esp.ili9341_flush if self.hybrid and hasattr(
esp, 'ili9341_flush') else self.flush
self.disp_drv.monitor_cb = self.monitor
self.disp_drv.hor_res = self.width
self.disp_drv.ver_res = self.height
lv.disp_drv_register(self.disp_drv)
def __init__(
self,
m5stack,
miso=38,
mosi=23,
clk=18,
cs=5,
dc=15,
backlight_on=0,
power_on=0,
spihost=esp.HSPI_HOST,
mhz=40,
factor=4,
hybrid=True,
width=320,
height=240,
colormode=COLOR_MODE_BGR,
rot=LANDSCAPE,
invert=True,
double_buffer=True,
half_duplex=True,
debug=False,
):
# Make sure Micropython was built such that color won't require processing before DMA
if lv.color_t.SIZE != 2:
raise RuntimeError(
"ili9342 micropython driver requires defining LV_COLOR_DEPTH=16"
)
if colormode == COLOR_MODE_BGR and not hasattr(lv.color_t().ch,
"green_l"):
raise RuntimeError(
"ili9342 BGR color mode requires defining LV_COLOR_16_SWAP=1")
self.display_name = "ILI9342"
self.display_type = DISPLAY_TYPE_ILI9341
self.init_cmds = [
{
"cmd": 0xCF,
"data": bytes([0x00, 0x83, 0x30])
},
{
"cmd": 0xED,
"data": bytes([0x64, 0x03, 0x12, 0x81])
},
{
"cmd": 0xE8,
"data": bytes([0x85, 0x01, 0x79])
},
{
"cmd": 0xCB,
"data": bytes([0x39, 0x2C, 0x00, 0x34, 0x02])
},
{
"cmd": 0xF7,
"data": bytes([0x20])
},
{
"cmd": 0xEA,
"data": bytes([0x00, 0x00])
},
{
"cmd": 0xC0,
"data": bytes([0x12, 0x12])
}, # Power control
{
"cmd": 0xC1,
"data": bytes([0x03])
}, # Power control
{
"cmd": 0xC5,
"data": bytes([0xF0])
}, # VCOM control
{
"cmd": 0xC7,
"data": bytes([0xBE])
}, # VCOM control
# Memory Access Control
{
"cmd": 0x36,
"data": bytes([rot | colormode])
},
# Pixel Format Set
{
"cmd": 0x3A,
"data": bytes([0x55])
},
{
"cmd": 0xB1,
"data": bytes([0x00, 0x1B])
},
{
"cmd": 0xF2,
"data": bytes([0x08])
},
{
"cmd": 0x26,
"data": bytes([0x01])
},
{
"cmd":
0xE0,
"data":
bytes([
0x00,
0x0C,
0x11,
0x04,
0x11,
0x08,
0x37,
0x89,
0x4C,
0x06,
0x0C,
0x0A,
0x2E,
0x34,
0x0F,
]),
},
{
"cmd":
0xE1,
"data":
bytes([
0x00,
0x0B,
0x11,
0x05,
0x13,
0x09,
0x33,
0x67,
0x48,
0x07,
0x0E,
0x0B,
0x2E,
0x33,
0x0F,
]),
},
{
"cmd": 0x2A,
"data": bytes([0x00, 0x00, 0x00, 0xEF])
},
{
"cmd": 0x2B,
"data": bytes([0x00, 0x00, 0x01, 0x3F])
},
{
"cmd": 0x2C,
"data": bytes([0])
},
{
"cmd": 0xB7,
"data": bytes([0x07])
},
{
"cmd": 0xB6,
"data": bytes([0x0A, 0xE0, 0x1D, 0x04])
},
{
"cmd": 0x11,
"data": bytes([0]),
"delay": 100
},
{
"cmd": 0x29,
"data": bytes([0]),
"delay": 100
},
]
super().__init__(
m5stack,
miso,
mosi,
clk,
cs,
dc,
backlight_on,
power_on,
spihost,
mhz,
factor,
hybrid,
width,
height,
colormode,
rot,
invert,
double_buffer,
half_duplex,
debug,
)
def __init__(self,
miso=5,
mosi=18,
clk=19,
cs=13,
dc=12,
rst=4,
power=14,
backlight=15,
backlight_on=0,
power_on=0,
spihost=esp.HSPI_HOST,
mhz=40,
factor=4,
hybrid=True,
width=240,
height=320,
colormode=COLOR_MODE_BGR,
rot=PORTRAIT,
invert=False,
double_buffer=True,
half_duplex=True,
asynchronous=False,
initialize=True):
# Make sure Micropython was built such that color won't require processing before DMA
if lv.color_t.SIZE != 2:
raise RuntimeError(
'ili9341 micropython driver requires defining LV_COLOR_DEPTH=16'
)
if colormode == COLOR_MODE_BGR and not hasattr(lv.color_t().ch,
'green_l'):
raise RuntimeError(
'ili9341 BGR color mode requires defining LV_COLOR_16_SWAP=1')
self.display_name = 'ILI9341'
self.display_type = DISPLAY_TYPE_ILI9341
self.init_cmds = [
{
'cmd': 0xCF,
'data': bytes([0x00, 0x83, 0X30])
},
{
'cmd': 0xED,
'data': bytes([0x64, 0x03, 0X12, 0X81])
},
{
'cmd': 0xE8,
'data': bytes([0x85, 0x01, 0x79])
},
{
'cmd': 0xCB,
'data': bytes([0x39, 0x2C, 0x00, 0x34, 0x02])
},
{
'cmd': 0xF7,
'data': bytes([0x20])
},
{
'cmd': 0xEA,
'data': bytes([0x00, 0x00])
},
{
'cmd': 0xC0,
'data': bytes([0x26])
}, # Power control
{
'cmd': 0xC1,
'data': bytes([0x11])
}, # Power control
{
'cmd': 0xC5,
'data': bytes([0x35, 0x3E])
}, # VCOM control
{
'cmd': 0xC7,
'data': bytes([0xBE])
}, # VCOM control
{
'cmd': 0x36,
'data': bytes([rot | colormode])
}, # Memory Access Control
{
'cmd': 0x3A,
'data': bytes([0x55])
}, # Pixel Format Set
{
'cmd': 0xB1,
'data': bytes([0x00, 0x1B])
},
{
'cmd': 0xF2,
'data': bytes([0x08])
},
{
'cmd': 0x26,
'data': bytes([0x01])
},
{
'cmd':
0xE0,
'data':
bytes([
0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0X87, 0x32, 0x0A,
0x07, 0x02, 0x07, 0x05, 0x00
])
},
{
'cmd':
0XE1,
'data':
bytes([
0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05,
0x18, 0x0D, 0x38, 0x3A, 0x1F
])
},
{
'cmd': 0x2A,
'data': bytes([0x00, 0x00, 0x00, 0xEF])
},
{
'cmd': 0x2B,
'data': bytes([0x00, 0x00, 0x01, 0x3f])
},
{
'cmd': 0x2C,
'data': bytes([0])
},
{
'cmd': 0xB7,
'data': bytes([0x07])
},
{
'cmd': 0xB6,
'data': bytes([0x0A, 0x82, 0x27, 0x00])
},
{
'cmd': 0x11,
'data': bytes([0]),
'delay': 100
},
{
'cmd': 0x29,
'data': bytes([0]),
'delay': 100
}
]
super().__init__(miso,
mosi,
clk,
cs,
dc,
rst,
power,
backlight,
backlight_on,
power_on,
spihost,
mhz,
factor,
hybrid,
width,
height,
colormode,
rot,
invert,
double_buffer,
half_duplex,
asynchronous=asynchronous,
initialize=initialize)
def __init__(self,
m5stack=M5Stack(),
mosi=23,
miso=38,
clk=18,
dc=15,
cs=5,
backlight=100,
backlight_on=1,
power_on=0,
spihost=esp.HSPI_HOST,
mhz=40,
factor=4,
hybrid=True,
width=320,
height=240,
start_x=0,
start_y=0,
colormode=COLOR_MODE_BGR,
rot=0x10,
invert=True,
double_buffer=True,
half_duplex=True,
asynchronous=False,
initialize=True):
# Make sure Micropython was built such that color won't require processing before DMA
if lv.color_t.__SIZE__ != 2:
raise RuntimeError(
'ili9341 micropython driver requires defining LV_COLOR_DEPTH=16'
)
if colormode == COLOR_MODE_BGR and not hasattr(lv.color_t().ch,
'green_l'):
raise RuntimeError(
'ili9341 BGR color mode requires defining LV_COLOR_16_SWAP=1')
self.display_name = 'ILI9341'
self.init_cmds = [
{
'cmd': 0xCF,
'data': bytes([0x00, 0x83, 0X30])
},
{
'cmd': 0xED,
'data': bytes([0x64, 0x03, 0X12, 0X81])
},
{
'cmd': 0xE8,
'data': bytes([0x85, 0x01, 0x79])
},
{
'cmd': 0xCB,
'data': bytes([0x39, 0x2C, 0x00, 0x34, 0x02])
},
{
'cmd': 0xF7,
'data': bytes([0x20])
},
{
'cmd': 0xEA,
'data': bytes([0x00, 0x00])
},
{
'cmd': 0xC0,
'data': bytes([0x26])
}, # Power control
{
'cmd': 0xC1,
'data': bytes([0x11])
}, # Power control
{
'cmd': 0xC5,
'data': bytes([0x35, 0x3E])
}, # VCOM control
{
'cmd': 0xC7,
'data': bytes([0xBE])
}, # VCOM control
{
'cmd': 0x36,
'data': bytes([self.madctl(colormode, rot, ORIENTATION_TABLE)])
}, # MADCTL
{
'cmd': 0x3A,
'data': bytes([0x55])
}, # Pixel Format Set
{
'cmd': 0xB1,
'data': bytes([0x00, 0x1B])
},
{
'cmd': 0xF2,
'data': bytes([0x08])
},
{
'cmd': 0x26,
'data': bytes([0x01])
},
{
'cmd':
0xE0,
'data':
bytes([
0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0X87, 0x32, 0x0A,
0x07, 0x02, 0x07, 0x05, 0x00
])
},
{
'cmd':
0XE1,
'data':
bytes([
0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05,
0x18, 0x0D, 0x38, 0x3A, 0x1F
])
},
{
'cmd': 0x2A,
'data': bytes([0x00, 0x00, 0x00, 0xEF])
},
{
'cmd': 0x2B,
'data': bytes([0x00, 0x00, 0x01, 0x3f])
},
{
'cmd': 0x2C,
'data': bytes([0])
},
{
'cmd': 0xB7,
'data': bytes([0x07])
},
{
'cmd': 0xB6,
'data': bytes([0x0A, 0x82, 0x27, 0x00])
},
{
'cmd': 0x11,
'data': bytes([0]),
'delay': 100
},
{
'cmd': 0x29,
'data': bytes([0]),
'delay': 100
}
]
super().__init__(m5stack=m5stack,
miso=miso,
mosi=mosi,
clk=clk,
cs=cs,
dc=dc,
backlight=backlight,
backlight_on=backlight_on,
power_on=power_on,
spihost=spihost,
mhz=mhz,
factor=factor,
hybrid=hybrid,
width=width,
height=height,
start_x=start_x,
start_y=start_y,
invert=invert,
double_buffer=double_buffer,
half_duplex=half_duplex,
display_type=DISPLAY_TYPE_ILI9341,
asynchronous=asynchronous,
initialize=initialize)
