LVGL_Micropython - driver for ST7701

[marilantagliari]

Is it relevant to write a driver for ST7701 ?

If the SPI is just used in initialization LCD, will be possible to write a command initialization and then use parallel RGB driver?

https://focuslcds.com/journals/application-notes/3-wire-spi-parallel-rgb-interface/
The 3-wire Serial Peripheral Interface (SPI) and the 16/18/24-bit RGB parallel interface are used in a sequence to communicate data to the display. The SPI interface is first used to initialize the display parameters through command registers. Once initialized, the display can receive data over the RGB parallel interface at a higher speed. This data can be sent in segments of 16, 18 or 24-bit lengths depending on what is specified by the SPI initialization commands.

[kdschlosser]

The SPI that is used for the configuration is a bit different. It is at an extremely low speed and it needs to he handled by a special driver and not your typical SPI that is available for an MCU. I have not added the special driver yet that is needed to handle the config. You do have the ability to write your own bit bang driver in python to handle turning the pins on and off when they need to be turned on and off using the viper code emitter for MicroPython.

RGB bus is going to be limited to 16 lanes for the ESP32. This is a limitation that is set by the ESP SDK. That means the maximum you can set the color depth to is going to be 16 bit which is RGB565.... Instead of using extra pins for the config SPI you can share the pins with some of the lanes for the RGB. You would have to run the config settings and then set up the bus driver and display driver. You will not be able to send any config settings while the display is active if you do this.

[kdschlosser]

HEY!!!! I wanted to let you know that I wrote in the handling of that funky SPI config IC. I am going to key up a display driver for it right now for your display....

It shouldn't take me that long to put together for ya. Maybe 20 minutes or so.

[marilantagliari]

WOWWWW.... I saw that updated in GitHub,.... nice... I'm testing right now

[kdschlosser]

1. I added the driver for this display. You just have to test it to see if it works. Let me know when you are ready to do that and I will tell you how to use it.

[marilantagliari]

ok Kevin, I changed to '480 x 480 x 2' allocated in MEMORY_SPIRAM, its OK.

But when start de app the backlight turn on, but I lost the connection in ThonnyIDE and nothing on the screen.

is it correct my display_bus using lcd_bus.RGBBus(...) ??

[kdschlosser]

don't use thonny. It is known to cause problems because of how it resets the ESP32. Always use the reset button on the ESP32 and use a terminal program like putty to connect using serial. You can use thonny to transfer files but make sure to press the reset button after you disconnect thonny

[kdschlosser]

You are correct to use the RGB Bus. I don't know if your pin assignments are correct or not. I would need a link to the data sheets for the board you are using to determine that.

[marilantagliari]

I thinks the pins are ok, because I test it with Arduino GFX and works fine.

I'm using putty to monitor serial and I'm trying with Thonny WebRepl but the screen is black, just the backlight power on, but de button test does not show in the LCD.

`from micropython import const # NOQA
from machine import sleep

_WIDTH = const(480)
_HEIGHT = const(480)

_BUFFER_SIZE = int(_WIDTH * _HEIGHT * 2)

import lcd_bus # NOQA

spi3wire = lcd_bus.SPI3Wire(
sclk=48,
mosi=47,
cs=39,
use_dc_bit=True,
dc_zero_on_data=False,
lsb_first=False,
cs_high_active=False,
keep_cs_inactive=True
)

display_bus = lcd_bus.RGBBus(
hsync=16,
vsync=17,
de=18,
disp=-1,
pclk=21,
data0=11,
data1=12,
data2=13,
data3=14,
data4=0,
data5=8,
data6=3,
data7=46,
data8=9,
data9=10,
data10=20,
data11=4,
data12=5,
data13=6,
data14=7,
data15=15,
freq=12000000
)

import st7701
import lvgl as lv # NOQA

lcd_bus.MEMORY_SPIRAM

fb1 = display_bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)#lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)
fb2 = display_bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)#lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)

display = st7701.ST7701(
display_bus,
_WIDTH,
_HEIGHT,
frame_buffer1=fb1,
frame_buffer2=fb2,
backlight_pin=38,
color_space=lv.COLOR_FORMAT.RGB565,
spi_3wire=spi3wire,
# this is if you are sharing the rgb data lines with the 3wire
bus_shared_pins=False
)

print('olaaa')

display.set_power(True)
display.init()
display.set_backlight(100)

import i2c
import gt911

i2c_bus = i2c.I2CBus(scl=45, sda=19, use_locks=False)

indev = gt911.GT911(i2c_bus)

lv.init()

scrn = lv.screen_active()
scrn.set_style_bg_color(lv.color_hex(0x000000), 0)

slider = lv.slider(scrn)
slider.set_size(300, 50)
slider.center()

label = lv.label(scrn)
label.set_text('HELLO WORLD!')
label.align(lv.ALIGN.CENTER, 0, -50)

import task_handler
th = task_handler.TaskHandler()

`

[jd3096-mpy]

I have the same problem,and I am sure that it's beacuse the SPI doesn't init correctly.
Use Arduino GFX use demo,then flash micropython fireware, it works.

[straga]

Hello. Driver for ST7701 now work or not ? I can do some test.

[kdschlosser]

need some testing on the 3wire SPI interface portion of the driver. That is what is not working properly.

[straga]

I received https://homeding.github.io/boards/esp32s3/panel-4848S040.htm that panel. Build firmware and flash on device. Now work only backlight.

may be some new info https://components.espressif.com/components/espressif/esp_lcd_st7701

[jd3096-mpy]

Hello. Driver for ST7701 now work or not ? I can do some test.

https://github.com/jd3096-mpy/micropython-3-wire-spi-soft
Here is a temporary MicroPython 3-line SPI initialization method I wrote. Of course, you need to modify the initialization command according to your screen.

https://github.com/jd3096-mpy/micropython-3-wire-spi-soft

[kdschlosser]

would it be OMK if I encoporate that into the binding? I would make sure to long to where the code came from and also give a TY to you fro writing it. This would be done in comments in the source file.

[straga]

Also infor from ESPHOME https://devices.esphome.io/devices/Guition-ESP32-S3-4848S040
After Repo update (just need fix set_params) we have config like that. ? Still only with backlight.

from micropython import const # NOQA

WIDTH = const(480)
HEIGHT = const(480)

BUFFER_SIZE = int(WIDTH * HEIGHT * 2)

import lcd_bus # NOQA

display_bus = lcd_bus.RGBBus(
    hsync=16,
    vsync=17,
    de=18,

    disp=-1,
    pclk=21,

    # R
    data0=11,
    data1=12,
    data2=13,
    data3=14,
    data4=0,

    # G
    data5=8,
    data6=20,
    data7=3,
    data8=46,
    data9=9,
    data10=10,

    # B
    data11=4,
    data12=5,
    data13=6,
    data14=7,
    data15=15,


    freq=12000000,

    hsync_pulse_width = 8,
    hsync_front_porch = 10,
    hsync_back_porch = 20,
    vsync_pulse_width=  8,
    vsync_front_porch = 10,
    vsync_back_porch = 10

)

from spi3wire import LOW_SPEED_SPI
spi3wire = LOW_SPEED_SPI(miso=47, sck=48, cs=39)

import st7701
import lvgl as lv # NOQA

lcd_bus.MEMORY_SPIRAM
fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM) #lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)
fb2 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM) #lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)

display = st7701.ST7701(
    display_bus,
    spi3wire,
    WIDTH,
    HEIGHT,
    frame_buffer1=fb1,
    frame_buffer2=fb2,
    backlight_pin=38,
    color_space=lv.COLOR_FORMAT.RGB565,
    # this is if you are sharing the rgb data lines with the 3wire
    bus_shared_pins=False
)

print('olaaa')

display.set_power(True)
display.init()
display.set_backlight(100)

scrn = lv.screen_active()
scrn.set_style_bg_color(lv.color_hex(0xffb6c1), 0)

slider = lv.slider(scrn)
slider.set_size(300, 50)
slider.center()

label = lv.label(scrn)
label.set_text('HELLO WORLD!')
label.align(lv.ALIGN.CENTER, 0, -50)

import task_handler
th = task_handler.TaskHandler()

[kdschlosser]

try using the version that @jd3096-mpy posted and use it with the rgb_display driver. Run the 3wire prior to building the display driver and see if it works. The one that I added last night was a test to see if it would work. The reason why I went that route is I need to be able to disable the 3wire spi if the pins are shared with the display bus.

[kdschlosser]

There are a couple of things that I know I need to change in my version which is the reason why I didn't tell anyone that I had added it. One of the things is I need to change how it is handling rotation which the st7701 doesn't support.

[straga]

Need some change also. Now I am tested with https://devices.esphome.io/devices/Guition-ESP32-S3-4848S040 - that works.
Now need refresh again to micropython and try more.

[straga]

I did that for 480x480 square (86 Box) GUITION ESP32-4848S040

[straga]

Code:

lcd_9bit_spi.py

from machine import Pin
import time

class LOW_SPEED_SPI:
    def __init__(self,cs_pin,clk_pin,miso_pin):
        self.clk=Pin(clk_pin,Pin.OUT)
        self.miso=Pin(miso_pin,Pin.OUT)
        self.cs=Pin(cs_pin,Pin.OUT)

    def delay(self,t):
        time.sleep_us(t)

    def senddata(self,data):
        for i in range(0,8):
            if (data&0x80):
                self.miso.value(1)
            else:
                self.miso.value(0)
            data=data<<1

            self.clk.value(0)
            self.delay(1)
            self.clk.value(1)
            self.delay(1)

    def write_cmd(self,data):   #9bit
        self.cs.value(0)

        self.miso.value(0)
        self.clk.value(0)
        self.delay(1)
        self.clk.value(1)
        self.delay(1)

        self.senddata(data)

        self.cs.value(1)

    def write_data(self,data):
        self.cs.value(0)
        self.miso.value(1)
        self.clk.value(0)
        self.delay(1)
        self.clk.value(1)
        self.delay(1)

        self.senddata(data)
        self.cs.value(1)

    def tx_param(self, cmd, data=None):
        self.write_cmd(cmd)

        if data is not None:
            for i in range(len(data)):
                self.write_data(data[i])

    def cmd(self, *data):
        # 0 - command
        # n ...  - data

        self.write_cmd(data[0])
        for i in range(1, len(data)):
            self.write_data(data[i])



    def init_st7701_spi(self):
        cmd = self.cmd

        cmd(0x01) #Software Reset
        cmd(0xFF, 0x77, 0x01, 0x00, 0x00, 0x10) #Software Reset
        cmd(0xC0, 0x3B, 0x00)
        cmd(0xC1, 0x0D, 0x02)
        cmd(0xC2, 0x31, 0x05)
        cmd(0xCD, 0x08)
        cmd(
            0xB0,
            0x00,
            0x11,
            0x18,
            0x0E,
            0x11,
            0x06,
            0x07,
            0x08,
            0x07,
            0x22,
            0x04,
            0x12,
            0x0F,
            0xAA,
            0x31,
            0x18,
        )
        cmd(
            0xB1,
            0x00,
            0x11,
            0x19,
            0x0E,
            0x12,
            0x07,
            0x08,
            0x08,
            0x08,
            0x22,
            0x04,
            0x11,
            0x11,
            0xA9,
            0x32,
            0x18,
        )
        cmd(0xFF, 0x77, 0x01, 0x00, 0x00, 0x11)
        cmd(0xB0, 0x60)
        cmd(0xB1, 0x32)
        cmd(0xB2, 0x07)
        cmd(0xB3, 0x80)
        cmd(0xB5, 0x49)
        cmd(0xB7, 0x85)
        cmd(0xB8, 0x21)
        cmd(0xC1, 0x78)
        cmd(0xC2, 0x78)
        cmd(0xE0, 0x00, 0x1B, 0x02)
        cmd(0xE1, 0x08, 0xA0, 0x00, 0x00, 0x07, 0xA0, 0x00, 0x00, 0x00, 0x44, 0x44)
        cmd(0xE2, 0x11, 0x11, 0x44, 0x44, 0xED, 0xA0, 0x00, 0x00, 0xEC, 0xA0, 0x00, 0x00)
        cmd(0xE3, 0x00, 0x00, 0x11, 0x11)
        cmd(0xE4, 0x44, 0x44)
        cmd(
            0xE5,
            0x0A,
            0xE9,
            0xD8,
            0xA0,
            0x0C,
            0xEB,
            0xD8,
            0xA0,
            0x0E,
            0xED,
            0xD8,
            0xA0,
            0x10,
            0xEF,
            0xD8,
            0xA0,
        )
        cmd(0xE6, 0x00, 0x00, 0x11, 0x11)
        cmd(0xE7, 0x44, 0x44)
        cmd(
            0xE8,
            0x09,
            0xE8,
            0xD8,
            0xA0,
            0x0B,
            0xEA,
            0xD8,
            0xA0,
            0x0D,
            0xEC,
            0xD8,
            0xA0,
            0x0F,
            0xEE,
            0xD8,
            0xA0,
        )
        cmd(0xEB, 0x02, 0x00, 0xE4, 0xE4, 0x88, 0x00, 0x40)
        cmd(0xEC, 0x3C, 0x00)
        cmd(
            0xED,
            0xAB,
            0x89,
            0x76,
            0x54,
            0x02,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0x20,
            0x45,
            0x67,
            0x98,
            0xBA,
        )
        cmd(0xFF, 0x77, 0x01, 0x00, 0x00, 0x13)
        cmd(0xE5, 0xE4)
        cmd(0x3A, 0x60)
        # end of ST7701 initialization from esphome

        # ?
        cmd(0xCD, 0x00)  # disable MDT flag

        # from esphome cp file.
        # st7701 does not appear to support axis swapping
        cmd(0xFF, 0x77, 0x01, 0x00, 0x00, 0x10)

        cmd(0xC7, 0x00) # mirror_x false
        cmd(0x36, 0x08)  # color order COLOR_ORDER_BGR 0x08 -  # RGB 0x00
        cmd(0x20) # display inversion off INVERT_OFF

        cmd(0x11) # SLEEP_OUT
        cmd(0x29) # DISPLAY ON

lcd.py

from micropython import const # NOQA

WIDTH = const(480)
HEIGHT = const(480)

BUFFER_SIZE = int(WIDTH * HEIGHT * 2)

import lcd_bus # NOQA

display_bus = lcd_bus.RGBBus(
    hsync=16,
    vsync=17,
    de=18,

    disp=-1,
    pclk=21,

    # R
    data0=11,
    data1=12,
    data2=13,
    data3=14,
    data4=0,

    # G
    data5=8,
    data6=20,
    data7=3,
    data8=46,
    data9=9,
    data10=10,

    # B
    data11=4,
    data12=5,
    data13=6,
    data14=7,
    data15=15,


    freq=12000000,

    hsync_pulse_width = 8,
    hsync_front_porch = 10,
    hsync_back_porch = 20,
    vsync_pulse_width=  8,
    vsync_front_porch = 10,
    vsync_back_porch = 10

)

# from spi3wire import Spi3Wire
# spi3wire = Spi3Wire(miso=47, sck=48, cs=39)

from lcd_9bit_spi import LOW_SPEED_SPI
spi3wire=LOW_SPEED_SPI(cs_pin=39, clk_pin=48, miso_pin=47)
spi3wire.init_st7701_spi()

import st7701
import lvgl as lv # NOQA

lcd_bus.MEMORY_SPIRAM
fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM) #lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)
fb2 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM) #lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)

display = st7701.ST7701(
    display_bus,
    spi3wire,
    WIDTH,
    HEIGHT,
    frame_buffer1=fb1,
    frame_buffer2=fb2,
    backlight_pin=38,
    color_space=lv.COLOR_FORMAT.RGB565,
    # this is if you are sharing the rgb data lines with the 3wire
    bus_shared_pins=False
)

print('olaaa')

display.set_power(True)
display.init(9)
display.set_backlight(100)

scrn = lv.screen_active()

scrn.set_style_bg_color(lv.color_hex(0xffb6c1), 0)

slider = lv.slider(scrn)
slider.set_size(300, 50)
slider.center()

label = lv.label(scrn)
label.set_text('HELLO WORLD!')
label.align(lv.ALIGN.CENTER, 0, -50)

import task_handler
th = task_handler.TaskHandler()

st7701.py

from micropython import const  # NOQA

import lvgl as lv  # NOQA
import lcd_bus  # NOQA
import display_driver_framework


STATE_HIGH = display_driver_framework.STATE_HIGH
STATE_LOW = display_driver_framework.STATE_LOW
STATE_PWM = display_driver_framework.STATE_PWM

BYTE_ORDER_RGB = display_driver_framework.BYTE_ORDER_RGB
BYTE_ORDER_BGR = display_driver_framework.BYTE_ORDER_BGR

# SET _CND2BKxSEL TO 0X00
_Command1 = const(0x00)

_SWRESET = const(0x01)  # Software Reset
_SLPIN = const(0x10)  # Sleep On
_SLPOUT = const(0x11)  # Sleep Off
_PTLON = const(0x12)  # Partial Display Mode On
_NORON = const(0x13)  # Normal Display Mode On
_ALLPOFF = const(0x22)  # All Pixel Off
_ALLPON = const(0x23)  # All Pixel On
_GAMSET = const(0x26)  # Gamma Set
_DISPOFF = const(0x28)  # Display Off
_DISPON = const(0x29)  # Display On
_TEOFF = const(0x34)  # Tearing Effect Line Off
_TEON = const(0x35)  # Tearing Effect Line On
_MADCTL = const(0x36)  # Display data access control
_IDMOFF = const(0x38)  # Idle Mode Off
_IDMON = const(0x39)  # Idle Mode On
_COLMOD = const(0x3A)  # Interface Pixel Format
_WRDISBV = const(0x51)  # Display Brightness Value
_WRCTRLD = const(0x53)  # CTRL Display
_WRCACE = const(0x55)  # Adaptive Brightness Control and Color Enhancement
_WRCABCMB = const(0x5E)  # CABC Minimum Brightness


_CND2BKxSEL = const(0xFF)

# Command2_BK0
# SET _CND2BKxSEL TO 0x10
_Command2_BK0 = const(0x10)

_PVGAMCTRL = const(0xB0)  # Positive Voltage Gamma Control
_NVGAMCTRL = const(0xB1)  # Negative Voltage Gamma Control
_DGMEN = const(0xB8)  # Digital Gamma Enable    0x00 = Off, 0x10 = On   1 byte
_DGMLUTR = const(0xB9)  # Digital Gamma Look-up Table for Redm    16 bytes
_DGMLUTB = const(0xBA)  # Digital Gamma Look-up Table for Blue   16 bytes
_PWM_CLK = const(0xBC)
_LNESET = const(0xC0)  # Display Line Setting

# Porch Control  2 bytes
# byte 1: Back-Porch Vertical line setting for display.  0x02 default
# byte 2: Front-Porch Vertical line setting for display. 0x04 default
_PORCTRL = const(0xC1)

# Inversion selection & Frame Rate Control   2 bytes
# byte 1: inversion selection
#         0x30: 1 dot
#         0x32: 2 dot
#         0x37: column
# default: 0x30

# byte 2: minimum number of pclk in each line
#         min value: 0x00
#         max value: 0x1F
#         value = (PCLK - 512) / 16
# default: 0x10 (768)
_INVSET = const(0xC2)

# RGB Control   3 bytes
# byte 1:
#         bit 7: RGB Mode Selection 1: HV mode, 0: DE mode
#         bit 3: VSYNC Polarity 1: high, 0: low (default: 1)
#         bit 2: HSYNC Polarity 1: high, 0: low (default: 0)
#         bit 1: DOTCLK Polarity 1: high, 0: low (default: 0)
#         bit 0: ENABLE Polarity 1: high, 0: low (default: 0)
#
# bytes 2 and 3: RGB interface Vsync back porch setting for HV mode
#                min value: 0x02
#                default: 0x1000
_RGBCTRL = const(0xC3)

# Partial Mode Control  4 bytes
# byte 1 & 2: start line address, max value 0x03FF (1023)
# byte 3 & 4: end line address,  max value 0x03FF (1023)
_PARCTRL = const(0xC5)

# X-direction Control  1 byte
# 0x00: source form 0 to 479
# 0x04: source form 479 to 0
# default: 0x00
_SDIR = const(0xC7)

_PDOSET = const(0xC8)  # Pseudo-Dot inversion diving setting
_PROMACT = const(0xCC)
_COLCTRL = const(0xCD)  # Color Control
_SSCTRL = const(0xCE)  # Sunlight Readable Enhancememnt


# Command2_BK1
# SET _CND2BKxSEL TO 0x11
_Command2_BK1 = const(0x11)
_VRHS = const(0xB0)  # VOP Amplitude setting
_VCOMS = const(0xB1)  # VCOM amplitude setting
_VGHSS = const(0xB2)  # VGH Voltage setting
_TESTCMD = const(0xB3)  # TEST Command Setting
_VGLS = const(0xB5)  # VGL Voltage setting
_VRHDV = const(0xB6)
_PWCTRL1 = const(0xB7)  # Power Control 1
_PWCTRL2 = const(0xB8)  # Power Control 2
_PWCTRL3 = const(0xB9)  # Power Control 3
_PCLKS1 = const(0xBA)  # Power pumping clk selection 1
_PCLKS2 = const(0xBB)  # Power pumping clk selection 2
_PCLKS3 = const(0xBC)  # Power pumping clk selection 3
_PDR1 = const(0xC1)  # Source pre_drive timing set1  SPD1??
_PDR2 = const(0xC2)  # Source EQ2 Setting  SPD2??
_MIPISET1 = const(0xD0)  # MIPI Setting 1
_MIPISET2 = const(0xD1)  # MIPI Setting 2
_MIPISET3 = const(0xD2)  # MIPI Setting 3
_MIPISET4 = const(0xD3)  # MIPI Setting 4
_SRCTRL = const(0xE0)
_NRCTRL = const(0xE1)  # Noise Reduce Control  **
_SECTRL = const(0xE2)  # Sharpness Control  **
_CCCTRL = const(0xE3)  # Color Calibration Control  **
_SKCTRL = const(0xE4)  # Skin Tone Preservation Control  **
_NVMSETE = const(0xEA)  # NVM Address Setting Enable  **
_CABCCTRL = const(0xEE)  # CABC Control **

# Command2_BK3
# SET _CND2BKxSEL TO 0x13
_Command2_BK3 = const(0x13)
_NVMEN = const(0xC8)
_NVMSET = const(0xCA)


COLOR_ENHANCE_OFF = 0x00
COLOR_ENHANCE_LOW = 0x01
COLOR_ENHANCE_MED = 0x02
COLOR_ENHANCE_HI = 0x04


ADAPT_IMAGE_MODE_OFF = 0x00
ADAPT_IMAGE_MODE_USER = 0x01
ADAPT_IMAGE_MODE_PICTURE = 0x02
ADAPT_IMAGE_MODE_VIDEO = 0x03


TYPE_TL021WVC02 = 10
TYPE_TL034WVS05_B1477A = 11
TYPE_TL032FWV01_I1440A = 12
TYPE_TL040WVS03 = 13
TYPE_TL028WVC01 = 14
TYPE_HD371001C40 = 15
TYPE_HD458002C40 = 16


class ST7701(display_driver_framework.DisplayDriver):
    _INVOFF = 0x20  # Color Inversion Off
    _INVON = 0x21  # Color Inversion On

    def __init__(
        self,
        data_bus,
        spi_3wire,
        display_width,
        display_height,
        frame_buffer1=None,
        frame_buffer2=None,
        reset_pin=None,
        reset_state=STATE_HIGH,
        power_pin=None,
        power_on_state=STATE_HIGH,
        backlight_pin=None,
        backlight_on_state=STATE_HIGH,
        offset_x=0,
        offset_y=0,
        color_byte_order=BYTE_ORDER_RGB,
        color_space=lv.COLOR_FORMAT.RGB888,  # NOQA
        rgb565_byte_swap=False,
        bus_shared_pins=False
    ):

        self._spi_3wire = spi_3wire
        self._bus_shared_pins = bus_shared_pins

        self._wrctrld = 0x00
        self._wrcace = 0x00

        super().__init__(
            data_bus=data_bus,
            display_width=display_width,
            display_height=display_height,
            frame_buffer1=frame_buffer1,
            frame_buffer2=frame_buffer2,
            reset_pin=reset_pin,
            reset_state=reset_state,
            power_pin=power_pin,
            power_on_state=power_on_state,
            backlight_pin=backlight_pin,
            backlight_on_state=backlight_on_state,
            offset_x=offset_x,
            offset_y=offset_y,
            color_byte_order=color_byte_order,
            color_space=color_space,
            rgb565_byte_swap=rgb565_byte_swap,
            _cmd_bits=8,
            _param_bits=8,
            _init_bus=False
        )

        self._disp_drv.sw_rotate = 1

    def set_params(self, cmd, params=None):

        print(f'set_params: {cmd}, {params}')

        if (
            not self._initilized or
            not self._bus_shared_pins
        ):
            self._spi_3wire.tx_param(cmd, params)

    def get_params(self, cmd, params):
        pass

    def _set_memory_location(self, x1, y1, x2, y2):  # NOQA
        return -1

    def init(self, type):  # NOQA
        # self._spi_3wire.init(8, 8)
        # if type < 1 or type > 16:
        #     raise RuntimeError('Invalid display type')
        #
        # mod_name = f'_st7701_type{type}'
        # mod = __import__(mod_name)
        # mod.init(self)
        #
        # if self._bus_shared_pins:
        #     # shut down the spi3wire prior to initilizing the data bus.
        #     # so we don't have a conflict between the bus and the 3wire
        #     self._spi_3wire.deinit()

        self._init_bus()  # NOQA

        display_driver_framework.DisplayDriver.init(self)

    def set_noise_reduction(self, value):
        if value:
            value -= 1
            if value > 0x03:
                raise ValueError('invalid noise reduction level')
            value |= 0x10

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command2_BK0])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

        self._param_buf[0] = value
        self.set_params(_NRCTRL, self._param_mv[:1])

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command1])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

    def set_skin_tone_enhancement(self, value):
        if value:
            value -= 1
            if value > 0x03:
                raise ValueError('invalid skin tone level')
            value |= 0x10

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command2_BK0])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

        self._param_buf[0] = value
        self.set_params(_SKCTRL, self._param_mv[:1])

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command1])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

    def set_sharpness(self, value):
        if value:
            value -= 1

            if value > 0x0F:
                raise ValueError('invalid sharpness level')

            value |= 0x10

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command2_BK0])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

        self._param_buf[0] = value
        self.set_params(_SECTRL, self._param_mv[:1])

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command1])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

    def set_sunlight_readable_enhancement(self, value):
        if value:
            value -= 1

            if value > 0x0F:
                raise ValueError('invalid sunlight enhancement level')

            value |= 0x10

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command2_BK0])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

        self._param_buf[0] = value
        self.set_params(_SECTRL, self._param_mv[:1])

        self._param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, _Command1])
        self.set_params(_CND2BKxSEL, self._param_mv[:5])

    def set_adaptive_image_mode(self, value):
        if value > 3:
            raise ValueError('invalid adaptive image mode')

        if self._wrcace & 0x01:
            self._wrcace ^= 0x01

        if self._wrcace & 0x02:
            self._wrcace ^= 0x02

        self._wrcace |= value

        self._param_buf[0] = self._wrcace
        self.set_params(_WRCACE, self._param_mv[:1])

    def set_color_enhancement(self, value):
        if value:
            if not self._wrcace & 0x80:
                self._wrcace |= 0x80

            value -= 1

            if value > 3 or value == 2:
                raise ValueError('invalid color enhance value')
            value <<= 4

            if self._wrcace & 0x10:
                self._wrcace ^= 0x10
            if self._wrcace & 0x20:
                self._wrcace ^= 0x20

            self._wrcace |= value
        else:
            if self._wrcace & 0x80:
                self._wrcace ^= 0x80

        self._param_buf[0] = self._wrcace
        self.set_params(_WRCACE, self._param_mv[:1])

    def set_auto_brightness(self, value):
        if int(bool(value)):
            self._wrctrld |= 0x20
        elif self._wrctrld & 0x20:
            self._wrctrld ^= 0x20

        self._param_buf[0] = self._wrctrld
        self.set_params(_WRCTRLD, self._param_mv[:1])

    def set_display_dimming(self, value):
        if int(bool(value)):
            self._wrctrld |= 0x08
        elif self._wrctrld & 0x08:
            self._wrctrld ^= 0x08

        self._param_buf[0] = self._wrctrld
        self.set_params(_WRCTRLD, self._param_mv[:1])

    def set_backlight_control(self, value):
        if int(bool(value)):
            self._wrctrld |= 0x04
        elif self._wrctrld & 0x04:
            self._wrctrld ^= 0x04

        self._param_buf[0] = self._wrctrld
        self.set_params(_WRCTRLD, self._param_mv[:1])

    def set_brightness(self, value):
        self._param_buf[0] = int((value / 100.0) * 255.0)
        self.set_params(_WRDISBV, self._param_mv[:1])

    def _madctl(self, *_, **__):
        raise NotImplementedError

[kdschlosser]

The problem is you guys are making it specific to just the st7701 display IC. There are many other display IC's that use a 3 wire low speed SPI and there needs to be settings that allow it to work across the board. Putting the init commands into the 3wire isn't the right thing to do. they need to be put in with the actual display and the commands should be passed from the display driver to the 3 wire driver.

[straga]

Absolutely right. But before that not work and not was understand problem in driver 3-wire or in setting. Now we have right setting. And can back to day ago and try use 3-wire SPI with right setting.

[straga]

st7701.zip

just update _st7701_type9.py
and use change version from @jd3096-mpy spi3wire for work with _st7701_type9.py

now work and color right (set RED background) and without artifact.

[straga]

for i2c touch

import gt911
import i2c

i2c_bus = i2c.I2C.Bus(host=1, scl=45, sda=19)
touch_i2c = i2c.I2C.Device(i2c_bus, gt911.I2C_ADDR, gt911.BITS)
indev = gt911.GT911(touch_i2c, debug=True)

for 19 pin, default use as USB-. Need reconfigure firmware.

sdkconfig.board

# Disable usb for i2c
CONFIG_USB_ENABLED=n
CONFIG_USB_CDC_ENABLED=n

CONFIG_TINYUSB_CDC_ENABLED=n
CONFIG_ESP_CONSOLE_USB_CDC=n
CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=n
CONFIG_USB_OTG_SUPPORTED=n

mpconfigboard.h
#define MICROPY_HW_USB_CDC (0)

[kdschlosser]

usb should be disabled by default. only when you supply --osb-otg as a build parameter does it turn on. I recommend not changing anything in the config files because the script looks for specific markers in the files to update them. If you change something and it is used as a marker it could cause problems.\ If the pin is still enabled as USB let me know and I will look into why it is not being free'd..

[kdschlosser]

Also any of the CONFIG_* parameters that are used in the ESP-IDF are able to be passed via the command line when you build the firmware. You do not have to edit any files to makes changes.

[kdschlosser]

The ST7701 display IC is a royal pain in the ass. It is very sensitive to the config settings that gets passed to it. They have to be just right otherwise it will not work. I added the config settings the way that I did so it doesn't gobble up a huge amount of memory so only one set of config settings gets loaded. I have to add in deleting the module from memory once it has finished running. haven't gotten to that yet. no need to chew up memory only to run once then done code. I am thinking about changing all of the init commands for all of the display drivers to be that way.

[straga]

If use own board config and with own micropython i just want use make with your code as user_module. It ok for me.

[straga]

# 0x70 RGB888, 0x60 RGB666, 0x50 RGB565
param_buf[0] = 0x60 # that need change from 0x50,
self.set_params(0x3A, param_mv[:1])

[straga]

working config: on today. Work with file from repo as is.

480x480 square (86 Box) GUITION ESP32-4848S040 display
https://www.aliexpress.us/item/3256806436494890.html

PWM frequency for backlight - 2000

display._backlight_pin.freq(2000)
display.set_backlight(50)

from micropython import const # NOQA

WIDTH = const(480)
HEIGHT = const(480)

BUFFER_SIZE = int(WIDTH * HEIGHT * 2)

import lcd_bus # NOQA

display_bus = lcd_bus.RGBBus(
    hsync=16,
    vsync=17,
    de=18,

    disp=-1,
    pclk=21,

    # B
    data0=4,
    data1=5,
    data2=6,
    data3=7,
    data4=15,

    # G
    data5=8,
    data6=20,
    data7=3,
    data8=46,
    data9=9,
    data10=10,

    # R
    data11=11,
    data12=12,
    data13=13,
    data14=14,
    data15=0,

    freq=12000000,

    hsync_pulse_width = 8,
    hsync_front_porch = 10,
    hsync_back_porch = 20,
    vsync_pulse_width=  8,
    vsync_front_porch = 10,
    vsync_back_porch = 10

)


# from spi3wire_9bit import Spi3Wire
# spi3wire=Spi3Wire(cs_pin=39, clk_pin=48, miso_pin=47)

from spi3wire import Spi3Wire
spi3wire=Spi3Wire(cs=39, sck=48, miso=47)


import st7701
import lvgl as lv # NOQA

lcd_bus.MEMORY_SPIRAM
fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM) #lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)
fb2 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM) #lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)

display = st7701.ST7701(
    display_bus,
    spi3wire,
    WIDTH,
    HEIGHT,
    frame_buffer1=fb1,
    frame_buffer2=fb2,
    backlight_pin=38,
    backlight_on_state=st7701.STATE_PWM,
    color_space=lv.COLOR_FORMAT.RGB565,
    # this is if you are sharing the rgb data lines with the 3wire
    bus_shared_pins=False
)

print('Hello LCD')

display.set_power(True)
# Init code for 480x480 square (86 Box) GUITION ESP32-4848S040 display
display.init(9)
# PWM frequency for backlight
display._backlight_pin.freq(2000)
display.set_backlight(50)


import gt911
import i2c

i2c_bus = i2c.I2C.Bus(host=1, scl=45, sda=19)
touch_i2c = i2c.I2C.Device(i2c_bus, gt911.I2C_ADDR, gt911.BITS)
indev = gt911.GT911(touch_i2c, debug=False)

[straga]

How it works.

2024-09-21.08.44.42.mp4

[kdschlosser]

OK so what did you have to do to get it to work? or is everything working properly now out of the box?

I did make it easier to extend the initialization commands. you need to create a python file named _st7701_init_type{X}.py where {X} is a number that is >= 17. and in that file you create a function named init that only has a single parameter of self. inside that function is where you place any initialization commands for the display you are using.

You pass that number as the type when calling the init method of the display driver. Then the display driver will function as it normally does.

[kdschlosser]

Looks like ya have to override the indev callback function in the touch driver to handle the display dimming a little bit better...

[straga]

OK so what did you have to do to get it to work? or is everything working properly now out of the box?

I did make it easier to extend the initialization commands. you need to create a python file named _st7701_init_type{X}.py where {X} is a number that is >= 17. and in that file you create a function named init that only has a single parameter of self. inside that function is where you place any initialization commands for the display you are using.

You pass that number as the type when calling the init method of the display driver. Then the display driver will function as it normally does.

Now work stock "display.init(9)" 9 type from the Box. I am don't change any.

[straga]

@kdschlosser what is the new setting for the latest driver?

Any questions: why need copy_puxel anyway if use rotation0?

Now I just back old method. That works for me.

    mp_lcd_err_t rgb_tx_color(mp_obj_t obj, int lcd_cmd, void *color, size_t color_size, int x_start, int y_start, int x_end, int y_end, uint8_t rotation, bool last_update)
    {
        //LCD_DEBUG_PRINT("rgb_tx_color(self, lcd_cmd=%d, color, color_size=%d, x_start=%d, y_start=%d, x_end=%d, y_end=%d)\n", lcd_cmd, color_size, x_start, y_start, x_end, y_end)
        //LCD_UNUSED(color_size);

        //mp_lcd_rgb_bus_obj_t *self = (mp_lcd_rgb_bus_obj_t *)obj;
        
        // rgb_bus_lock_acquire(&self->tx_color_lock, -1);

        // self->last_update = (uint8_t)last_update;
        // self->partial_buf = (uint8_t *)color;
        // self->x_start = x_start;
        // self->y_start = y_start;
        // self->x_end = x_end;
        // self->y_end = y_end;
        // self->rotation = rotation;

        // rgb_bus_lock_release(&self->copy_lock);

        LCD_DEBUG_PRINT("rgb_tx_color(self, lcd_cmd=%d, color, color_size=%d, x_start=%d, y_start=%d, x_end=%d, y_end=%d)\n", lcd_cmd, color_size, x_start, y_start, x_end, y_end)
        LCD_UNUSED(color_size);
        LCD_UNUSED(lcd_cmd);
        LCD_UNUSED(rotation);
        LCD_UNUSED(last_update);

        mp_lcd_rgb_bus_obj_t *self = (mp_lcd_rgb_bus_obj_t *)obj;

        esp_err_t ret = esp_lcd_panel_draw_bitmap(
            self->panel_handle,
            x_start,
            y_start,
            x_end + 1,
            y_end + 1,
            color
        );


       if (self->callback != mp_const_none) {
           mp_call_function_n_kw(self->callback, 0, 0, NULL);
       }

        return LCD_OK;
    }

[kdschlosser]

the reason why there is that copy task is to get better performance. It allows LVGL to render to a much smaller partial buffer instead of having to render the full sized frame buffer over and over again. The full sized frame buffers do still exist but they are hidden behind the scenes. The partial buffer gets copied to the large frame buffer on core 0 where as LVGL and MicroPython run on core 1. This speeds up the RGB driver by quite a bit because it allows LVGL and the users application to keep on doing it's thing. While the data is being sent to the display using DMA memory the full frame buffers are so large in size that it takes multiple interrupts to create a new transaction for the transmit. These interrupts no longer take place on the same core that LVGL and MicroPython are running on. Instead they take place on core 0. this once again helps to speed things up.

Core 0 on the ESP32 goes largely unused when using MicroPython. It is used to back end Bluetooth relates stuff and some other IO related tasks which don't use a lot of processor time. So why not put that additional processing core to some good use?

[straga]

@kdschlosser
I build latest driver:
python3 make.py esp32 BOARD=ESP32_GENERIC_S3 BOARD_VARIANT=SPIRAM_OCT --flash-size=16 DISPLAY=st7701 INDEV=gt911 --enable-jtag-repl=n

When the slider moves - lcd draws with artifacts.

from micropython import const # NOQA

# Full frame size for 4 inch display
WIDTH = const(480)
HEIGHT = const(480)

BUFFER_SIZE = int(WIDTH * HEIGHT * 2 // 20)  # 2 bytes per pixel for RGB565

import lcd_bus # NOQA

display_bus = lcd_bus.RGBBus(
    hsync=16,
    vsync=17,
    de=18,
    pclk=21,

    # B
    data0=4,
    data1=5,
    data2=6,
    data3=7,
    data4=15,

    # G
    data5=8,
    data6=20,
    data7=3,
    data8=46,
    data9=9,
    data10=10,

    # R
    data11=11,
    data12=12,
    data13=13,
    data14=14,
    data15=0,

    freq=12000000,

    hsync_pulse_width=8,
    hsync_back_porch=20,
    hsync_front_porch=10,
    vsync_pulse_width=8,
    vsync_back_porch=10,
    vsync_front_porch=10
)


from spi3wire import Spi3Wire
spi3wire = Spi3Wire(
    scl=48,   
    sda=47,  
    cs=39,    
    freq=500000 #76  Гц
    )

spi3wire.init(8, 8)  # cmd_bits=8, param_bits=8

import st7701
import lvgl as lv # NOQA

fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)  # Use PSRAM for LVGL buffer too

display = st7701.ST7701(
    display_bus,
    spi3wire,
    WIDTH,
    HEIGHT,
    frame_buffer1=fb1,
    frame_buffer2=None,
    backlight_pin=38,
    color_space=lv.COLOR_FORMAT.RGB565,
    rgb565_byte_swap=False,
    bus_shared_pins=False
)

print('Hello LCD')

display.set_power(True)
display.init(type=9)
display.set_backlight(100)

import gt911
import i2c
i2c_bus = i2c.I2C.Bus(host=1, scl=45, sda=19, freq=100000)
touch_i2c = i2c.I2C.Device(i2c_bus, gt911.I2C_ADDR, gt911.BITS)
indev = gt911.GT911(touch_i2c, debug=False)


scrn = lv.screen_active()

scrn.set_style_bg_color(lv.color_hex(0xFF0000), 0)

slider = lv.slider(scrn)
slider.set_size(300, 50)
slider.center()

label = lv.label(scrn)
label.set_text('HELLO WORLD!')
label.align(lv.ALIGN.CENTER, 0, -50)

import task_handler
th = task_handler.TaskHandler()

[kdschlosser]

OK cool. There are lots of changes I have recently made to the RGB driver to improve the performance of it. I more than likely need to adjust something. Do me a favor tho. can you adjust the buffer size to be 1/10th the size instead of being 1/20th the size. Also use 2 buffers instead of 1. This will give you better performance. The buffers do not need to be in DMA memory and they can also be placed in internal memory so LVGL will be able to render faster.

I want to confirm what I believe the problem is. I think I need to reduce the y axis by one or 2 lines.

Are you rotating the screen at all? or is this happening with zero rotation?

[kdschlosser]

IDK why I asked about the rotation. I am able to see it right in front of me that you are not using any rotation.

[straga]

The result is the same with DMA, without DMA, and with Internal or PSRAM. Only if the Fullframe buffer, works without artifacts.

[tmcadam]

I am testing with a Waveshare 4in 480x480 LCD w ST7701 and see the same behavior as @straga regarding the buffers. I'm using display.init(13) for this display.

https://www.waveshare.com/wiki/ESP32-S3-Touch-LCD-4

[kdschlosser]

OK so there is an issue I have to sort out with the RGB driver and a line being added I will look into it shortly. This would be easier if someone was able to test at the time I was making changes.

[tmcadam]

I am available to test.

[kdschlosser]

OK cool. Let me go and take a quick look see at it and i might be able to get it sorted out quickly. It looks like it is adding an extra line so I am going to shorten up the copy that takes place to the fill buffer..

If you can confirm one things for me. does it do it for all rotations, 90, 180 and 270 or only some of them?,,

[kdschlosser]

I made a change so you can test it if you like. could be a simple fix. we shall soon find out.

[tmcadam]

First update is without your changes I am not seeing the artifact with these settings

BUFFER_SIZE = int(WIDTH * HEIGHT * 2 // 10)
fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)  # Use PSRAM for LVGL buffer too
fb2 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)  # Use PSRAM for LVGL buffer too

Possibly from changing init(type=6) to init(type=13) , which fixed colors.

Rotation doesn't seem to work well

Doing display.set_rotation(0) no change
Doing display.set_rotation(90) makes everything chopped up
Doing display.set_rotation(180) no change , same as set_rotation(0)
Doing display.set_rotation(270) makes everything chopped up

[tmcadam]

With original (yesterday) build, I am still getting artifact at 1/20th
BUFFER_SIZE = int(WIDTH * HEIGHT * 2 // 20)

[tmcadam]

Tested the version with y_end+=1; commented out. Artifacts are still there with //20. Rotation 90 looks different, has these horizontal lines.