JC3248W535 AXS15231B QSPI

[straga]

Driver for QSPI LCD

• driver repo: https://github.com/straga/micropython_lcd/tree/master/device/JC3248W535/driver/axs15231b

info

http://pan.jczn1688.com/directlink/1/HMI%20display/JC3248W535EN.zip
https://components.espressif.com/components/espressif/esp_lcd_axs15231b

AXS15231B_Datasheet_V0.5_20230306.pdf

Micropython LVGL - Test

pinout

## Panel
LCD_QSPI_HOST           (SPI2_HOST)

PIN_NUM_QSPI_CS         (GPIO_NUM_45)
PIN_NUM_QSPI_PCLK       (GPIO_NUM_47)
PIN_NUM_QSPI_DATA0      (GPIO_NUM_21)
PIN_NUM_QSPI_DATA1      (GPIO_NUM_48)
PIN_NUM_QSPI_DATA2      (GPIO_NUM_40)
PIN_NUM_QSPI_DATA3      (GPIO_NUM_39)
PIN_NUM_QSPI_RST        (GPIO_NUM_NC)
PIN_NUM_QSPI_DC         (GPIO_NUM_8)
PIN_NUM_QSPI_TE         (GPIO_NUM_38)
PIN_NUM_QSPI_BL         (GPIO_NUM_1)

## Touch
I2C_NUM                     (I2C_NUM_0)
I2C_CLK_SPEED_HZ            400000

PIN_NUM_QSPI_TOUCH_SCL  (GPIO_NUM_8)
PIN_NUM_QSPI_TOUCH_SDA  (GPIO_NUM_4)
PIN_NUM_QSPI_TOUCH_RST  (-1)
PIN_NUM_QSPI_TOUCH_INT  (-1)

[picpic020960]

Bonjour ,
ESP32-s3 on the board ?

[straga]

@picpic020960 yes

Now work only on the first update display.
Next update I have the artifact - line wrong position

[straga]

Test: by moving lines over the screen.

test_1.mp4

test_lvgl.mp4

[kdschlosser]

do you have the buffers being creates as the full size of the display? If you that that is more than likely what is causing the problem because the number of buffers and the size of them that have to get created in internal memory in order to transmit the data is too much.

[kdschlosser]

I know what the problem is...

[straga]

@kdschlosser
WIDTH = const(320)
HEIGHT = const(480)
BUFFER_SIZE = int(WIDTH * HEIGHT) * 2
fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)

I create one buffer
frame_buffer1=fb1,

[kdschlosser]

give it a try with this code.

With the quad SPI it looks like you have to do full refreshes

import display_driver_framework
from micropython import const  # NOQA
import time

import lvgl as lv  # NOQA


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

_WRITE_CMD = const(0x02)
_READ_CMD = const(0x0B)

_RASET = const(0x2B)
_CASET = const(0x2A)
_RAMWR = const(0x32002C00)
_RAMWRC = const(0x32003C00)

_MADCTL_MV = const(0x20)  # 0=Normal, 1=Row/column exchange
_MADCTL_MX = const(0x40)  # 0=Left to Right, 1=Right to Left
_MADCTL_MY = const(0x80)  # 0=Top to Bottom, 1=Bottom to Top


class AXS15231B(display_driver_framework.DisplayDriver):
    _ORIENTATION_TABLE = (
        0,
        _MADCTL_MV,
        _MADCTL_MX | _MADCTL_MY,
        _MADCTL_MV | _MADCTL_MX | _MADCTL_MY
    )

    def __init__(
        self,
        data_bus,
        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,
    ):

        super().__init__(
            data_bus,
            display_width,
            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,  # NOQA
            rgb565_byte_swap=rgb565_byte_swap,
            _param_bits=8,
            _cmd_bits=32
        )

    def set_params(self, cmd, params=None):
        cmd = cmd & 0xff
        cmd <<= 8
        cmd |= _WRITE_CMD << 24
        self._data_bus.tx_param(cmd, params)

    def _dummy_set_memory_location(*_, **__):
        return _RAMWRC

    def _set_memory_location(self, x1: int, y1: int, x2: int, y2: int):

        # Column addresses
        param_buf = self._param_buf  # NOQA

        param_buf[0] = (x1 >> 8) & 0xFF
        param_buf[1] = x1 & 0xFF
        param_buf[2] = (x2 >> 8) & 0xFF
        param_buf[3] = x2 & 0xFF
        self.set_params(_CASET, self._param_mv)

        # Page addresses
        # param_buf[0] = (y1 >> 8) & 0xFF
        # param_buf[1] = y1 & 0xFF
        # param_buf[2] = (y2 >> 8) & 0xFF
        # param_buf[3] = y2 & 0xFF
        # self.set_params(_RASET, self._param_mv)

        if y1 == 0:
            return _RAMWR

        return _RAMWRC


# The code below needs to be in your init file

import time
from micropython import const  # NOQA

import lvgl as lv

_SLPOUT = const(0x11)
_COLMOD = const(0x3A)
_MADCTL = const(0x36)


def init(self):
    param_buf = bytearray(31)
    param_mv = memoryview(param_buf)

    self.set_params(_SLPOUT)
    time.sleep_ms(100)  # NOQA

    param_buf[0] = (
        self._madctl(
            self._color_byte_order,
            self._ORIENTATION_TABLE  # NOQA
        )
    )
    self.set_params(_MADCTL, param_mv[:1])

    color_size = lv.color_format_get_size(self._color_space)
    if color_size == 2:
        pixel_format = 0x55
    else:
        pixel_format = 0x66

    param_buf[0] = pixel_format
    self.set_params(_COLMOD, param_mv[:1])

    param_buf[:8] = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0xA5])
    self.set_params(0xBB, param_mv[:8])

    param_buf[:17] = bytearray([
        0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x64, 0x3F, 0x20, 
        0x05, 0x3F, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00])
    self.set_params(0xA0, param_mv[:17])

    param_buf[:31] = bytearray([
        0x30, 0x04, 0x0A, 0x3C, 0xEC, 0x54, 0xC4, 0x30, 0xAC, 0x28, 0x7F, 
        0x7F, 0x7F, 0x20, 0xF8, 0x10, 0x02, 0xFF, 0xFF, 0xF0, 0x90, 0x01, 
        0x32, 0xA0, 0x91, 0xC0, 0x20, 0x7F, 0xFF, 0x00, 0x54])
    self.set_params(0xA2, param_mv[:31])

    param_buf[:30] = bytearray([
        0x30, 0xAC, 0x21, 0x24, 0x08, 0x09, 0x10, 0x01, 0xAA, 0x14, 
        0xC2, 0x00, 0x22, 0x22, 0xAA, 0x03, 0x10, 0x12, 0x40, 0x14, 
        0x1E, 0x51, 0x15, 0x00, 0x40, 0x10, 0x00, 0x03, 0x3D, 0x12])
    self.set_params(0xD0, param_mv[:30])

    param_buf[:22] = bytearray([
        0xA0, 0x06, 0xAA, 0x08, 0x08, 0x02, 0x0A, 0x04, 0x04, 0x04, 0x04, 
        0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x55, 0x55])
    self.set_params(0xA3, param_mv[:22])

    param_buf[:30] = bytearray([
        0x33, 0x04, 0x02, 0x02, 0x71, 0x05, 0x24, 0x55, 0x02, 0x00, 
        0x41, 0x00, 0x53, 0xFF, 0xFF, 0xFF, 0x4F, 0x52, 0x00, 0x4F, 
        0x52, 0x00, 0x45, 0x3B, 0x0B, 0x02, 0x0D, 0x00, 0xFF, 0x40])
    self.set_params(0xC1, param_mv[:30])

    param_buf[:11] = bytearray([
        0x00, 0x00, 0x00, 0x50, 0x03, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01])
    self.set_params(0xC3, param_mv[:11])

    param_buf[:29] = bytearray([
        0x00, 0x24, 0x33, 0x90, 0x50, 0xEA, 0x64, 0x32, 0xC8, 0x64, 
        0xC8, 0x32, 0x90, 0x90, 0x11, 0x06, 0xDC, 0xFA, 0x04, 0x03, 
        0x80, 0xFE, 0x10, 0x10, 0x00, 0x0A, 0x0A, 0x44, 0x50])
    self.set_params(0xC4, param_mv[:29])

    param_buf[:23] = bytearray([
        0x18, 0x00, 0x00, 0x03, 0xFE, 0x78, 0x33, 0x20, 0x30, 0x10, 0x88, 0xDE,
        0x0D, 0x08, 0x0F, 0x0F, 0x01, 0x78, 0x33, 0x20, 0x10, 0x10, 0x80])
    self.set_params(0xC5, param_mv[:23])

    param_buf[:20] = bytearray([
        0x05, 0x0A, 0x05, 0x0A, 0x00, 0xE0, 0x2E, 0x0B, 0x12, 0x22, 
        0x12, 0x22, 0x01, 0x00, 0x00, 0x3F, 0x6A, 0x18, 0xC8, 0x22])
    self.set_params(0xC6, param_mv[:20])

    param_buf[:20] = bytearray([
        0x50, 0x32, 0x28, 0x00, 0xA2, 0x80, 0x8F, 0x00, 0x80, 0xFF, 
        0x07, 0x11, 0x9F, 0x6F, 0xFF, 0x26, 0x0C, 0x0D, 0x0E, 0x0F])
    self.set_params(0xC7, param_mv[:20])

    param_buf[:4] = bytearray([0x33, 0x44, 0x44, 0x01])
    self.set_params(0xC9, param_mv[:4])

    param_buf[:27] = bytearray([
        0x34, 0x1E, 0x88, 0x58, 0x13, 0x18, 0x56, 0x18, 0x1E, 
        0x68, 0xF7, 0x00, 0x65, 0x0C, 0x22, 0xC4, 0x0C, 0x77, 
        0x22, 0x44, 0xAA, 0x55, 0x04, 0x04, 0x12, 0xA0, 0x08])
    self.set_params(0xCF, param_mv[:27])

    param_buf[:30] = bytearray([
        0x3E, 0x3E, 0x88, 0x00, 0x44, 0x04, 0x78, 0x33, 0x20, 0x78, 
        0x33, 0x20, 0x04, 0x28, 0xD3, 0x47, 0x03, 0x03, 0x03, 0x03, 
        0x86, 0x00, 0x00, 0x00, 0x30, 0x52, 0x3F, 0x40, 0x40, 0x96])
    self.set_params(0xD5, param_mv[:30])

    param_buf[:30] = bytearray([
        0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, 0x95, 0x00, 
        0x01, 0x83, 0x75, 0x36, 0x20, 0x75, 0x36, 0x20, 0x3F, 0x03, 
        0x03, 0x03, 0x10, 0x10, 0x00, 0x04, 0x51, 0x20, 0x01, 0x00])
    self.set_params(0xD6, param_mv[:30])

    param_buf[:19] = bytearray([
        0x0A, 0x08, 0x0E, 0x0C, 0x1E, 0x18, 0x19, 0x1F, 0x00, 0x1F, 
        0x1A, 0x1F, 0x3E, 0x3E, 0x04, 0x00, 0x1F, 0x1F, 0x1F])
    self.set_params(0xD7, param_mv[:19])

    param_buf[:12] = bytearray([
        0x0B, 0x09, 0x0F, 0x0D, 0x1E, 0x18, 0x19, 0x1F, 0x01, 0x1F, 0x1A, 0x1F])
    self.set_params(0xD8, param_mv[:12])

    param_buf[:13] = bytearray([
        0x00, 0x0D, 0x0F, 0x09, 0x0B, 0x1F, 0x18, 
        0x19, 0x1F, 0x01, 0x1E, 0x1A, 0x1F])
    self.set_params(0xD9, param_mv[:13])

    param_buf[:12] = bytearray([
        0x0C, 0x0E, 0x08, 0x0A, 0x1F, 0x18, 0x19, 0x1F, 0x00, 0x1E, 0x1A, 0x1F])
    self.set_params(0xDD, param_mv[:12])

    param_buf[:8] = bytearray([0x44, 0x73, 0x4B, 0x69, 0x00, 0x0A, 0x02, 0x90])
    self.set_params(0xDF, param_mv[:8])

    param_buf[:17] = bytearray([
        0x19, 0x20, 0x0A, 0x13, 0x0E, 0x09, 0x12, 0x28, 0xD4, 
        0x24, 0x0C, 0x35, 0x13, 0x31, 0x36, 0x2F, 0x03])
    self.set_params(0xE0, param_mv[:17])

    param_buf[:17] = bytearray([
        0x38, 0x20, 0x09, 0x12, 0x0E, 0x08, 0x12, 0x28, 0xC5, 
        0x24, 0x0C, 0x34, 0x12, 0x31, 0x36, 0x2F, 0x27])
    self.set_params(0xE1, param_mv[:17])

    param_buf[:17] = bytearray([
        0x19, 0x20, 0x0A, 0x11, 0x09, 0x06, 0x11, 0x25, 0xD4, 
        0x22, 0x0B, 0x33, 0x12, 0x2D, 0x32, 0x2F, 0x03])
    self.set_params(0xE2, param_mv[:17])

    param_buf[:17] = bytearray([
        0x38, 0x20, 0x0A, 0x11, 0x09, 0x06, 0x11, 0x25, 0xC4, 
        0x21, 0x0A, 0x32, 0x11, 0x2C, 0x32, 0x2F, 0x27])
    self.set_params(0xE3, param_mv[:17])

    param_buf[:17] = bytearray([
        0x19, 0x20, 0x0D, 0x14, 0x0D, 0x08, 0x12, 0x2A, 0xD4, 
        0x26, 0x0E, 0x35, 0x13, 0x34, 0x39, 0x2F, 0x03])
    self.set_params(0xE4, param_mv[:17])

    param_buf[:17] = bytearray([
        0x38, 0x20, 0x0D, 0x13, 0x0D, 0x07, 0x12, 0x29, 0xC4, 
        0x25, 0x0D, 0x35, 0x12, 0x33, 0x39, 0x2F, 0x27])
    self.set_params(0xE5, param_mv[:17])

    param_buf[:8] = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
    self.set_params(0xBB, param_mv[:8])

    self.set_params(0x13)
    self.set_params(0x11)
    time.sleep_ms(200)  # NOQA

    self.set_params(0x29)
    time.sleep_ms(200)  # NOQA

    param_buf[:4] = bytearray([0x00, 0x00, 0x00, 0x00])
    self.set_params(0x2C, param_mv[:4])

    self.set_params(0x22)
    time.sleep_ms(200)  # NOQA

[straga]

@kdschlosser has a black screen with only a backlight. I tried that init before, but some commands don’t have documentation. Maybe that will work if I use a full-screen update.
But I can't set a full size buffer.

flush_cb
x1: 0, y1: 0, x2: 319, y2: 47 , width: 320, height: 48, size: 30720
x1: 0, y1: 48, x2: 319, y2: 95 , width: 320, height: 48, size: 30720
x1: 0, y1: 96, x2: 319, y2: 143 , width: 320, height: 48, size: 30720
x1: 0, y1: 144, x2: 319, y2: 191 , width: 320, height: 48, size: 30720
x1: 0, y1: 192, x2: 319, y2: 239 , width: 320, height: 48, size: 30720
x1: 0, y1: 240, x2: 319, y2: 287 , width: 320, height: 48, size: 30720
x1: 0, y1: 288, x2: 319, y2: 335 , width: 320, height: 48, size: 30720
x1: 0, y1: 336, x2: 319, y2: 383 , width: 320, height: 48, size: 30720
x1: 0, y1: 384, x2: 319, y2: 431 , width: 320, height: 48, size: 30720
x1: 0, y1: 432, x2: 319, y2: 479 , width: 320, height: 48, size: 30720

[straga]

@kdschlosser
That for my first code.
I change the screen size to:

WIDTH = const(120)
HEIGHT = const(160)

Try with an auto buffer set.

LVGL: Partial screen

static:

slide move: broken pixel exist

LVGL: Full screen

WIDTH = const(120)
HEIGHT = const(160)
BUFFER_SIZE = int(WIDTH * HEIGHT) * 2

• fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)
  or
• fb1 = display_bus.allocate_framebuffer(BUFFER_SIZE, lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)

frame_buffer1=fb1

x1: 0, y1: 0, x2: 119, y2: 159 , width: 120, height: 160, size: 38400

[kdschlosser]

try this code...

import display_driver_framework
from micropython import const  # NOQA
import time

import lvgl as lv  # NOQA


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

_WRITE_CMD = const(0x02)
_READ_CMD = const(0x0B)

_RASET = const(0x2B)
_CASET = const(0x2A)
_RAMWR = const(0x32002C00)
_RAMWRC = const(0x32003C00)

_MADCTL_MV = const(0x20)  # 0=Normal, 1=Row/column exchange
_MADCTL_MX = const(0x40)  # 0=Left to Right, 1=Right to Left
_MADCTL_MY = const(0x80)  # 0=Top to Bottom, 1=Bottom to Top


class AXS15231B(display_driver_framework.DisplayDriver):
    _ORIENTATION_TABLE = (
        0,
        _MADCTL_MV,
        _MADCTL_MX | _MADCTL_MY,
        _MADCTL_MV | _MADCTL_MX | _MADCTL_MY
    )

    def __init__(
        self,
        data_bus,
        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,
    ):

        super().__init__(
            data_bus,
            display_width,
            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,  # NOQA
            rgb565_byte_swap=rgb565_byte_swap,
            _param_bits=8,
            _cmd_bits=32
        )

    def set_params(self, cmd, params=None):
        cmd = cmd & 0xff
        cmd <<= 8
        cmd |= _WRITE_CMD << 24
        self._data_bus.tx_param(cmd, params)

    def _dummy_set_memory_location(*_, **__):
        return _RAMWR

    def _set_memory_location(self, x1: int, y1: int, x2: int, y2: int):

        # Column addresses
        param_buf = self._param_buf  # NOQA

        param_buf[0] = (x1 >> 8) & 0xFF
        param_buf[1] = x1 & 0xFF
        param_buf[2] = (x2 >> 8) & 0xFF
        param_buf[3] = x2 & 0xFF
        self.set_params(_CASET, self._param_mv)

        # Page addresses
        param_buf[0] = (y1 >> 8) & 0xFF
        param_buf[1] = y1 & 0xFF
        param_buf[2] = (y2 >> 8) & 0xFF
        param_buf[3] = y2 & 0xFF
        self.set_params(_RASET, self._param_mv)

        if y1 == 0:
            return _RAMWR

        return _RAMWRC

[kdschlosser]

If that doesn't work then I am going to have to spend a lot of time going over the datasheet for the display to read up on it.

[straga]

@kdschlosser The Datasheet is not full, as I understand it. If you don't have time, don't worry. I am buying that LCD to try adding to Micropython LVGL to populate your integration display drivers for Micropython.

Anyway, thanks for your help.

    self.set_params(0xBB, bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0xA5]))
    time.sleep_ms(10)

    self.set_params(0xC1, bytearray([0x33]))
    time.sleep_ms(10)

    self.set_params(0xBB, bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
    time.sleep_ms(10) 

That gets from some files:

0xBB - how I understand open special functionality.
0xC1 - set some val 0x33
0xBB - close special functionality

If that does my code renders images on all LCD.

If don't do.
Only part:

In that Arduino demo

[straga]

log:

without special 0XBB command.

    def _set_memory_location(self, x1: int, y1: int, x2: int, y2: int):

        # Column addresses
        param_buf = self._param_buf  # NOQA

        param_buf[0] = (x1 >> 8) & 0xFF
        param_buf[1] = x1 & 0xFF
        param_buf[2] = (x2 >> 8) & 0xFF
        param_buf[3] = x2 & 0xFF
        self.set_params(_CASET, self._param_mv)

        # Page addresses
        param_buf[0] = (y1 >> 8) & 0xFF
        param_buf[1] = y1 & 0xFF
        param_buf[2] = (y2 >> 8) & 0xFF
        param_buf[3] = y2 & 0xFF
        self.set_params(_RASET, self._param_mv)

        if y1 == 0:
            return _RAMWR
        return _RAMWRC

init code:

    # Color and Orientation
    param_buf[0] = (
        self._madctl(
            self._color_byte_order,
            self._ORIENTATION_TABLE  # NOQA
        )
    )
    self.set_params(AXS_LCD_MADCTL, param_mv[:1])

    # Pixel size
    color_size = lv.color_format_get_size(self._color_space)
    if color_size == 2:
        pixel_format = 0x55
    else:
        pixel_format = 0x66

    param_buf[0] = pixel_format
    self.set_params(AXS_LCD_IPF, param_mv[:1])

    # 0xD0 BRIGHTNESS
    param_buf[0] = 0xD0
    self.set_params(AXS_LCD_WRDISBV, param_mv[:1])

    # Disable Partial Display Mode (return to Normal Display Mode)
    param_buf[0] = 0x00
    self.set_params(AXS_LCD_NORON, param_mv[:1])
    time.sleep_ms(10)

    #  AXS_LCD_SLPOUT
    param_buf[0] = 0x00
    self.set_params(AXS_LCD_SLPOUT, param_mv[:1])
    time.sleep_ms(150)

    #  AXS_LCD_DISPON
    param_buf[0] = 0x00
    self.set_params(AXS_LCD_DISPON, param_mv[:1])
    time.sleep_ms(150)

x1:   0, y1:   0, x2: 319, y2:  47 , width: 320, height:  48, size: 30720
x1:   0, y1:  48, x2: 319, y2:  95 , width: 320, height:  48, size: 30720
x1:   0, y1:  96, x2: 319, y2: 143 , width: 320, height:  48, size: 30720
x1:   0, y1: 144, x2: 319, y2: 191 , width: 320, height:  48, size: 30720
x1:   0, y1: 192, x2: 319, y2: 239 , width: 320, height:  48, size: 30720
x1:   0, y1: 240, x2: 319, y2: 287 , width: 320, height:  48, size: 30720
x1:   0, y1: 288, x2: 319, y2: 335 , width: 320, height:  48, size: 30720
x1:   0, y1: 336, x2: 319, y2: 383 , width: 320, height:  48, size: 30720
x1:   0, y1: 384, x2: 319, y2: 431 , width: 320, height:  48, size: 30720
x1:   0, y1: 432, x2: 319, y2: 479 , width: 320, height:  48, size: 30720

I have first image:

After try move slider, image change only after some data

x1:  33, y1: 193, x2: 287, y2: 252 , width: 255, height:  60, size: 30600
x1:  33, y1: 253, x2: 287, y2: 287 , width: 255, height:  35, size: 17850
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670
x1:  29, y1: 189, x2: 291, y2: 246 , width: 263, height:  58, size: 30508
x1:  29, y1: 247, x2: 291, y2: 291 , width: 263, height:  45, size: 23670

all data upper data sent but the image did not change.

In one moment change

[straga]

@kdschlosser Progress: Full Render Work.
_dummy_set_memory_location - comment what setattrr for set_memory_location.

use: for full render test and pixel right position

WIDTH = const(120)
HEIGHT = const(160)
BUFFER_SIZE = int(WIDTH * HEIGHT) * 2
fb1 = lcd_bus.MEMORY_SPIRAM

Init display with any special cmd

  AXS_LCD_MADCTL
  AXS_LCD_IPF
  AXS_LCD_WRDISBV
  AXS_LCD_NORON
  AXS_LCD_SLPOUT
  AXS_LCD_DISPON

always _RAMWR for FULL Render

    def _set_memory_location(self, x1: int, y1: int, x2: int, y2: int):

        # Column addresses
        param_buf = self._param_buf  # NOQA

        param_buf[0] = (x1 >> 8) & 0xFF
        param_buf[1] = x1 & 0xFF
        param_buf[2] = (x2 >> 8) & 0xFF
        param_buf[3] = x2 & 0xFF
        self.set_params(_CASET, self._param_mv)

        # # Page addresses
        # param_buf[0] = (y1 >> 8) & 0xFF
        # param_buf[1] = y1 & 0xFF
        # param_buf[2] = (y2 >> 8) & 0xFF
        # param_buf[3] = y2 & 0xFF
        # self.set_params(_RASET, self._param_mv)

        # if y1 == 0:
        #     return _RAMWR
        # 
        # return _RAMWRC

        return _RAMWR

full_test.mp4

Try use full size buffer.

[straga]

@kdschlosser Full-size Full render: Works.

_dummy_set_memory_location - comment what setattrr for set_memory_location: display_driver_framework.py

Try to send data to panel_io_spi_tx_color by chunk.
Firs data send:

• RAMWR 0x2C - W Memory write

other to end buffer:

• RAMWRC 0x3C Memory write continue

The code looks like that.

  def _set_memory_location(self, x1: int, y1: int, x2: int, y2: int):

       # Column addresses
       param_buf = self._param_buf  # NOQA

       param_buf[0] = (x1 >> 8) & 0xFF
       param_buf[1] = x1 & 0xFF
       param_buf[2] = (x2 >> 8) & 0xFF
       param_buf[3] = x2 & 0xFF
       self.set_params(_CASET, self._param_mv)

       # # Page addresses
       # param_buf[0] = (y1 >> 8) & 0xFF
       # param_buf[1] = y1 & 0xFF
       # param_buf[2] = (y2 >> 8) & 0xFF
       # param_buf[3] = y2 & 0xFF
       # self.set_params(_RASET, self._param_mv)
       #
       # if y1 == 0:
       #     return _RAMWR
       #
       # return _RAMWRC

   def _flush_cb(self, _, area, color_p):

       """
       Flush callback for LVGL
       """

       x1 = area.x1 + self._offset_x
       x2 = area.x2 + self._offset_x

       y1 = area.y1 + self._offset_y
       y2 = area.y2 + self._offset_y

       cmd = self._set_memory_location(x1, y1, x2, y2)

       width = x2 - x1 + 1
       height = y2 - y1 + 1
       size = width * height * lv.color_format_get_size(self._color_space)

       #print(f"x1: {x1:3d}, y1: {y1:3d}, x2: {x2:3d}, y2: {y2:3d} , width: {width:3d}, height: {height:3d}, size: {size:3d}")

       data_view = color_p.__dereference__(size)

       #print 10 fist byte data view in one line in hex
       # print(" ".join("{:02x}".format(x) for x in data_view[:10]))

       cmd_RAMWR = _RAMWR & 0xff
       cmd_RAMWR <<= 8
       cmd_RAMWR |= _WRITE_COLOR << 24

       cmd_RAMWRC = _RAMWRC & 0xff
       cmd_RAMWRC <<= 8
       cmd_RAMWRC |= _WRITE_COLOR << 24

       '''
       Display size: 320x480 pixels
       Color depth: 2 bytes per pixel (likely RGB565 format)
       Total buffer size: 320 * 480 * 2 = 307,200 bytes
       In KB: 307,200 / 1024 ≈ 300 KB
       '''

       chunk_size = 1024 * 50
       for i in range(0, size, chunk_size):
           chunk = data_view[i:i + chunk_size]
           if i == 0:
               # 1 _RAMWR
               self._data_bus.tx_color(cmd_RAMWR, chunk, x1, y1, x2, y2)
           else:
               # other _RAMWRC
               self._data_bus.tx_color(cmd_RAMWRC, chunk, x1, y1, x2, y2)

full_size_1.mp4

full_size_2.mp4

[straga]

Update repo:

• https://github.com/straga/micropython_lcd

[kdschlosser]

I added a driver to the project for it.give it a test to see if it works.

[Villaden74]

Hi starga,
you did a great work!!!!
I'm struggling (in C) with I2C touch screen.
Could you be so kind to show me where you found the infoes for communications (i2c address, registers mapping...) you had for your python driver?
Actually, I have the axs15231B datasheet but I found only infoes about display and nothing to care about touch IC (only few about electrical).
Thank you and best regards.
Davide.

[straga]

@Villaden74 You can scan i2c bus for address.
look http://pan.jczn1688.com/directlink/1/HMI%20display/JC3248W535EN.zip and touch axs15231B in esphome. From the manufacture datasheet, not all info.

@kdschlosser Already added ?

[straga]

@kdschlosser I am tested with driver nv3041aG.py
https://github.com/straga/micropython_lcd/tree/master/device/JC3248W535 - work firmware from the box with ned drivers.

[straga]

Need to do some test more, but rotation 90.

[straga]

#451 - can try and test