ELCROW CrowPanel –ESP32 Terminal with 3.5 inch parallel 480x320 TFT capacitive touch RGB display (DLC35010R)

[hemonu]

Board is based on ILI9488 plus FT6236. Display uses 16-bit parallel bus, which makes it really fast.
There is a variant available with an additional camera, which needs a totally different setup!

Link to supplier product page:
https://www.elecrow.com/esp-terminal-with-esp32-3-5-inch-parallel-480x320-tft-capacitive-touch-display-rgb-by-chip-ili9488.html

My setup code is in a separate module (tft_lvgl_dlc35010R.py):

import lcd_bus
from micropython import const
from machine import Pin
import i2c  
import ft6x36  
import time
import lvgl as lv 


# display settings
_WIDTH = const(320)
_HEIGHT = const(480)
_BL = const(46)
_RST = const(-1)
_DC = const(45)
_WR = const(18)
_RD = const(48)
_FREQ = const(40_000_000)
_DATA0 = const(47)
_DATA1 = const(21)
_DATA2 = const(14)
_DATA3 = const(13)
_DATA4 = const(12)
_DATA5 = const(11)
_DATA6 = const(10)
_DATA7 = const(9)
_DATA8 = const(3)
_DATA9 = const(8)
_DATA10 = const(16)
_DATA11 = const(15)
_DATA12 = const(7)
_DATA13 = const(6)
_DATA14 = const(5)
_DATA15 = const(4)

_BUFFER_SIZE = const(30720) # 1/10 of display size

#I2C settings for touch an external 
_SCL = const(39)
_SDA = const(38)
_TP_FREQ = const(100_000)


def init():

    #set read pin to 1
    rd = Pin(_RD, Pin.OUT, value=1)
    
    #create 16 bit i8080 bus
    display_bus = lcd_bus.I80Bus(
        dc=_DC,
        wr=_WR,
        freq=_FREQ,
        data0=_DATA0,
        data1=_DATA1,
        data2=_DATA2,
        data3=_DATA3,
        data4=_DATA4,
        data5=_DATA5,
        data6=_DATA6,
        data7=_DATA7,
        data8=_DATA8,
        data9=_DATA9,
        data10=_DATA10,
        data11=_DATA11,
        data12=_DATA12,
        data13=_DATA13,
        data14=_DATA14,
        data15=_DATA15
    )
    
    #create 2 buffers for DMA use
    fb1 = display_bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)
    fb2 = display_bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)


    import ili9488 

    tft = ili9488.ILI9488(
    data_bus=display_bus,
    frame_buffer1=fb1,
    frame_buffer2=fb2,
    display_width=_WIDTH,
    display_height=_HEIGHT,
    backlight_pin=_BL,
    color_space=lv.COLOR_FORMAT.RGB565,
    color_byte_order=ili9488.BYTE_ORDER_BGR,
    rgb565_byte_swap=False
    )
    
    tft.init()
    time.sleep(0.5)
    tft.set_rotation(lv.DISPLAY_ROTATION._0)
    tft.set_backlight(50)
    return tft

def deinit(tft):
    tft.reset
    time.sleep(1)
    tft.delete()
    
def touch_init():
    i2c_bus = i2c.I2C.Bus(1, scl=_SCL, sda=_SDA, freq=_TP_FREQ, use_locks=False)
    i2c_device = i2c.I2C.Device(i2c_bus, ft6x36.I2C_ADDR, ft6x36.BITS)
    indev = ft6x36.FT6x36(i2c_device)

[hemonu]

Here is a small test program, which demonstrates how to use the module:

import tft_lvgl_dlc35010R

import task_handler  # NOQA
import time  # NOQA

import lvgl as lv  # NOQA

lv.init()

display = tft_lvgl_dlc35010R.init()
tft_lvgl_dlc35010R.touch_init()

display.set_rotation(lv.DISPLAY_ROTATION._0)

display.set_backlight(80)

th = task_handler.TaskHandler()

scr = lv.screen_active()
scr.set_style_bg_color(lv.palette_lighten(lv.PALETTE.GREY, 1), 0)
scr.clean()

# Global Variable for Slider and Label
label = None
slider = None
# Event-Callback-Funktion für den Slider
def slider_event_cb(e):
    # Aktualisieren des Textes des Labels mit dem aktuellen Slider-Wert
    print('VALUE CHANGED: ', slider.get_value())
    label.set_text("{:d}%".format(slider.get_value()))

# Hauptfunktion zur Erstellung des Sliders und Labels
def lv_example_get_started_4():
    global label  # Wir verwenden das globale Label
    global slider

    # Erstellen eines Sliders in der Mitte des Bildschirms
    slider = lv.slider(scr)
    slider.set_width(200)  # Breite des Sliders festlegen
    slider.center()  # Zentrieren des Sliders auf dem Bildschirm
    slider.add_event_cb(slider_event_cb, lv.EVENT.VALUE_CHANGED, None)  # Ereignis-Callback hinzufügen

    # Erstellen eines Labels oberhalb des Sliders
    label = lv.label(scr)
    label.set_text("0")
    label.align_to(slider, lv.ALIGN.OUT_TOP_MID, 0, -35)  # Ausrichtung des Labels oben am Slider

# Beispiel aufrufen
lv_example_get_started_4()


# 4. Displays the contents of the screen object
lv.screen_load(scr)


# ------------------------------ Guard dog to restart ESP32 equipment --start------------------------
try:
    from machine import WDT
    wdt = WDT(timeout=2000)  # enable it with a timeout of 2s
    print("Hint: Press Ctrl+C to end the program")
    while True:
        wdt.feed()
        time.sleep(0.9)
except KeyboardInterrupt as ret:
    print("The program stopped running, ESP32 has restarted...")
    lv.deinit()
    time.sleep(10)
    tft.deinit()
    time.sleep(10)
# ------------------------------ Guard dog to restart ESP32 equipment --stop-------------------------

[kdschlosser]

There is a possible issue....

The init functions don't return the objects they created. While technically speaking you can get away with doing this because of the callback functions being registered in LVGL are what hold reference to the objects is what prevents them from being garbage collected it is technically not a great idea to do.

Use case example is if you redirect the indev to use a different callback for the purposes of displaying a screen saver. Once the callback gets changed to something that is not a method in the instance for the driver the driver is going to get GC'd resulting in a crash. The display driver and indev drivers really should be initialized at the module level. For code organization purposes you put the display driver code into it's own module name "display_driver_init" and the indev into one called "indev_init" and then you would simply import the module the initialize the driver.

This has the added benefit of being able to easily access the display driver or the indev driver from anywhere in your code by simply importing the init module and the driver will be available. When an import is done the code that is at the module level only runs a single time which is the first time it is imported any imports that are done doesn't run the code again, it imports the module in it's current state.

[kdschlosser]

I also suggest not blocking the REPL like you are doing. Having the main thread/task set to loop endlessly will block access to the REPL. If you want to have a Watchdog that will work without blocking the main thread/task and will work correctly this is what you should do.

from machine import WDT
import lvgl as lv
import task_handler

# initilize the task handler that updates lvgl
th = task_handler.TaskHander()

# initilize the watchdog with a timeout of 1 second. This is an ample 
# amount of time to know if the main thread has frozen for some reason.
wdt = WDT(timeout=1000)


def wdt_callback(*_):
    wdt.feed()


# we are able to use a timer in LVGL to make this callback because of how the 
# task_handler.TaskHandler class works. What it does is it creates a hardware
# timer that calls a callback every 33 milliseconds. The callback is made in 
# an ISR context and no memory is able to be allocated in that context so it 
# tells MicroPython to run the code located in a callback from the main 
# thread/task at it's earliest convience. The main thread then calls that 
# function and that function is what calls lv.task_handler which then in turn 
# will call the watchdog callback is 200 milliseconds has passed since it was 
# last called.
#
# by handling the watchdog in this manner it doesmn't tie up the main 
# thread/task in looping code where it is sleeping the majority of the time. 
# this allows the REPL to function as usual so when you connect over a serial
# connection you will get a prompt and you will be able to interact with the ESP
# without it causing any issues with the currently running code.
lv_wdt = lv.timer_create(200, wdt_callback)

# repeat without end
lv_wdt.set_repeat_count(-1)
lv_wdt.enable(True)


def deinit():
    # There is quite a bit involved to deinit and I am not going to go over
    # that here. Because the REPL is no longer being blocked there is no 
    # reason to deinit anything and there is nmo need to have the exception
    # catching for the keyboard interrupt. 
    pass

You will find that this is a much better way to handle using the watchdog timer.

[kdschlosser]

I do also want to mention one other thing for your knowledge.

    i2c_bus = i2c.I2C.Bus(1, scl=_SCL, sda=_SDA, freq=_TP_FREQ, use_locks=False)

the use_locks parameter is for use with MCU's that have threading support. This something that you would use if you have another device attached to the I2C bus that you want to poll to collect data from. You are able to set the use_locks to True and set up a thread to poll the second device without needing to worry about accessing the bus and having data collisions. The lock will only allow access to the bus in a FIFO order stalling other requests to access the bus without "spinning wheels" which would cause 100% CPU use. The main thread/task is what is used when polling the indev driver so if you use an lvgl timer to poll a second device you would not need to use locks because the timer callbacks also get executed in the main thread/task.