I'm lost and defeted and I need help

[cyrylts]

Hello gents,
At start I will just mention that whole reason that I ended up here was my aversion to spend 120-140$ for screen kit for my new pc case. So after week or so of research focusing on finding screen that will fit into it (for curious people my case is termaltake tr100, and in my country price is higher than on amazon) I found this. ESP32-S3 3.16 LCD 320x820. Sadly on their site they do not provide official documentation how to setup this device in micropython. After getting familiar what libraries are used to display cool stuff and playing with Arduino IDE, I decided to google if lvgl is ported to micropython and that's how I found this amazing piece of software.

I compiled binary the way that readme dictates choosing ST7701 library, after looking over codebase I see there are 16 types that you can use, and how happy I was that there is type 12 that is setup for this board. But now I'm confused, I understand that this specific board has RGB display bus, but you also require spi3wire to initialize this. At this point I'm not sure what I'm doing wrong, backlight works, but screen is dead. Display is setup correctly, I'm not sure about spi3wire or how this should be initialized properly. Over last 3 days I read through most of this project discussions and issues, and looking how some of them were started quite some time ago. I'm not sure if provided solutions were implemented or driver was adjusted to reflect those changes, 9bit_soft_spi would be great example. So now I would like some help to understand how I should properly initialize spi3wire for this ST7701 driver.
Kindest Regards

[kdschlosser]

ok the spi3wire is s very unique animal and how to use it greatly depends on how the pins are wired for both the display and the SPI3 wire. What the SPI3 wire does it is for the purpose of sending the initialization commands to the RGB to MIPI bridge IC that your display has. I have not coded in any bridge IC drivers so it would be up to you to do that portion of the work. I would have to take a look at the display IC you are using to see if the bridge IC is built into that or if it is a separate standalone IC. A lot of times it is a standalone IC.

If you have access to arduino code for running the display I can use that to see what is going on and I can then provide you with better instruction and examples to use..

[cyrylts]

@kdschlosser could you tell me what is correct size more or less of build bin file using this repo, each time I built it it 3mb, and I'm not sure if that's correct, on the other side this is packaged with lvgl which takes a lot of space.
I'm still trying to figure out driver issues, I think I will buy second board because I don't want to tear down my gloried and fulled by framebuf library image viewer :)

[cyrylts]

So after looking at the setting and getting myself more educated on the topic this is configuration that I found in demo for Arduino:

from micropython import const # NOQA
import gc

_WIDTH = const(320)
_HEIGHT = const(820)

_LCD_FREQ = const(12000000)
_BL = const(6)
_BUFFER_SIZE = const(_HEIGHT * _WIDTH * 2)



import lcd_bus



display_bus = lcd_bus.RGBBus(
    hsync=38,
    vsync=39,
    de=40,
    pclk=41,
    
    data0=17, data1=46, data2=3, data3=8, data4=18,
    data5=14, data6=13, data7=12, data8=11, data9=10, data10=9,
    data11=21, data12=1, data13=45, data14=48, data15=47,
    freq=_LCD_FREQ,
    
    hsync_pulse_width=6,
    hsync_back_porch=30,
    hsync_front_porch=30,
    vsync_pulse_width=40,
    vsync_back_porch=20,
    vsync_front_porch=20,
    
    )

from spi3wire import Spi3Wire
spi3wire=Spi3Wire(
    sda=1,
    scl=2,
    cs=0,
    freq=500000,
    spi_mode=2,
    use_dc_bit=True,
    dc_zero_on_data=True,
    lsb_first=True,
    cs_high_active=True,
#     sda_scl_idle_high=True,
#     scl_active_rising_edge=True,
    del_keep_cs_inactive = True,   
    )
spi3wire.init(9,8)

print("SPI WIRE DONE")

gc.collect()

import st7701
import lvgl as lv # NOQA
lv.init()

fb1 = display_bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)
fb2 = display_bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)
print("BUFFER ALLOCATED")

display = st7701.ST7701(
    data_bus = display_bus,
    spi_3wire = spi3wire,
    display_width=_WIDTH,
    display_height=_HEIGHT,
    frame_buffer1=fb1,
    frame_buffer2=fb2,
#     backlight_pin=6,
#     backlight_on_state=st7701.STATE_PWM,
    reset_pin = 16,
    color_space=lv.COLOR_FORMAT.RGB565,
    bus_shared_pins=False
    )
print("Hello Screen")

display.set_power(True)
display.init(type=18)
# display.set_backlight(20)
display.set_rotation(270)


import task_handler
th = task_handler.TaskHandler()



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

print("lv started")
label = lv.label(scrn)

label.set_text('HELLO WORLD!')

label.align(lv.ALIGN.CENTER, 0, 0)

In spi3wire I commented out 2 options that are not available in spi3wire that is implemented in repo, I'm not even sure if I'm doing this correctly, but @kdschlosser if you have any pointers what I could try to do please let me know.

[cyrylts]

and here is init sequence:

import time


# Waveshare 3.16 Inch 820h x 320w bar display
def init(self):
    param_buf = bytearray(16)
    param_mv = memoryview(param_buf)

    # Sleep Out
    ##param_buf[0] = 0x01 # Posible to remove
    ##self.set_params(0x11)
    ##time.sleep_ms(10)  # NOQA
    
    ##param_buf[0] = 0x00
    ##self.set_params(0x11)
    ##time.sleep_ms(120)  # NOQA
    
    ##param_buf[0] = 0x01 # Posible to remove
    ##self.set_params(0x11)
    ##time.sleep_ms(10)  # NOQA

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x13])
    self.set_params(0xFF, param_mv[:5])

    param_buf[0] = 0x08
    self.set_params(0xEF, param_mv[:1])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x10])
    self.set_params(0xFF, param_mv[:5])

    param_buf[:2] = bytearray([0xE5, 0x02])
    self.set_params(0xC0, param_mv[:2])

    # VBP
    param_buf[:2] = bytearray([0x15, 0x0A])
    self.set_params(0xC1, param_mv[:2])

    param_buf[:2] = bytearray([0x07, 0x02])
    self.set_params(0xC2, param_mv[:2])

    param_buf[0] = 0x10
    self.set_params(0xCC, param_mv[:1])
    ## Positive gamma
    param_buf[:16] = bytearray([
            0x00,0x08,0x51,0x0D,
            0xCE,0x06,0x00,0x08,
            0x08,0x24,0x05,0xD0,
            0x0F,0x6F,0x36,0x1F])
    self.set_params(0xB0, param_mv[:16])
    
    ## Negative gamma
    param_buf[:16] = bytearray([
            0x00,
            0x10,
            0x4F,
            0x0C,
            0x11,
            0x05,
            0x00,
            0x07,
            0x07,
            0x18,
            0x02,
            0xD3,
            0x11,
            0x6E,
            0x34,
            0x1F])
    self.set_params(0xB1, param_mv[:16])
    
    ##power settings
    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x11])
    self.set_params(0xFF, param_mv[:5])

    param_buf[0] = 0x4D
    self.set_params(0xB0, param_mv[:1])

    param_buf[0] = 0x37
    self.set_params(0xB1, param_mv[:1])

    param_buf[0] = 0x87
    self.set_params(0xB2, param_mv[:1])

    param_buf[0] = 0x80
    self.set_params(0xB3, param_mv[:1])

    param_buf[0] = 0x4A
    self.set_params(0xB5, param_mv[:1])

    param_buf[0] = 0x85
    self.set_params(0xB7, param_mv[:1])

    param_buf[0] = 0x21
    self.set_params(0xB8, param_mv[:1])

    param_buf[:2] = bytearray([0x00, 0x13])
    self.set_params(0xB9, param_mv[:2])

    param_buf[0] = 0x09
    self.set_params(0xC0, param_mv[:1])

    param_buf[0] = 0x78
    self.set_params(0xC1, param_mv[:1])

    param_buf[0] = 0x78
    self.set_params(0xC2, param_mv[:1])

    param_buf[0] = 0x88
    self.set_params(0xD0, param_mv[:1])

    param_buf[:3] = bytearray([0x80, 0x00, 0x02])
    self.set_params(0xE0, param_mv[:3])
    time.sleep_ms(100)  # NOQA

    param_buf[:11] = bytearray([
        0x0F, 0xA0, 0x00, 0x00,
        0x10, 0xA0, 0x00, 0x00,
        0x00, 0x60, 0x60])
    self.set_params(0xE1, param_mv[:11])

    param_buf[:13] = bytearray(
        [0x30, 0x30, 0x60, 0x60, 0x45, 0xA0, 0x00, 0x00, 0x46, 0xA0, 0x00, 0x00, 0x00]
    )
    self.set_params(0xE2, param_mv[:13])

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

    param_buf[:2] = bytearray([0x44, 0x44])
    self.set_params(0xE4, param_mv[:2])

    param_buf[:16] = bytearray(
        [
            0x0F,
            0x4A,
            0xA0,
            0xA0,
            0x11,
            0x4A,
            0xA0,
            0xA0,
            0x13,
            0x4A,
            0xA0,
            0xA0,
            0x15,
            0x4A,
            0xA0,
            0xA0
        ]
    )
    self.set_params(0xE5, param_mv[:16])

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

    param_buf[:2] = bytearray([0x44, 0x44])
    self.set_params(0xE7, param_mv[:2])

    param_buf[:16] = bytearray(
        [
            0x10,
            0x4A,
            0xA0,
            0xA0,
            0x12,
            0x4A,
            0xA0,
            0xA0,
            0x14,
            0x4A,
            0xA0,
            0xA0,
            0x16,
            0x4A,
            0xA0,
            0xA0,
        ]
    )
    self.set_params(0xE8, param_mv[:16])

    param_buf[:7] = bytearray([0x02, 0x00, 0x4E, 0x4E, 0xEE, 0x44, 0x00])
    self.set_params(0xEB, param_mv[:7])

    param_buf[:16] = bytearray(
        [
            0xFF,
            0xFF,
            0x04,
            0x56,
            0x72,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0x27,
            0x65,
            0x40,
            0xFF,
            0xFF,
        ]
    )
    self.set_params(0xED, param_mv[:16])

    param_buf[:6] = bytearray([0x08, 0x08, 0x08, 0x40, 0x3F, 0x64])
    self.set_params(0xEF, param_mv[:6])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x13])
    self.set_params(0xFF, param_mv[:5])

    param_buf[:2] = bytearray([0x00, 0x0E])
    self.set_params(0xE8, param_mv[:2])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x00])
    self.set_params(0xFF, param_mv[:5])

    param_buf[0] = 0x00
    self.set_params(0x11, param_mv[:1])
    time.sleep_ms(120)  # NOQA

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x13])
    self.set_params(0xFF, param_mv[:5])

    param_buf[:2] = bytearray([0x00, 0x0C])
    self.set_params(0xE8, param_mv[:2])
    time.sleep_ms(10)  # NOQA

    param_buf[:2] = bytearray([0x00, 0x00])
    self.set_params(0xE8, param_mv[:2])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x00])
    self.set_params(0xFF, param_mv[:5])

    param_buf[0] = 0x55
    self.set_params(0x3A, param_mv[:1])

    param_buf[0] = 0x00
    self.set_params(0x36, param_mv[:1])

    param_buf[0] = 0x00
    self.set_params(0x35, param_mv[:1])

    param_buf[0] = 0x00
    self.set_params(0x29, param_mv[:1])
    time.sleep_ms(20)  # NOQA
    

[cyrylts]

Thank you for response, for the code I just edited some demo stuff that was provided by Waveshare.
this is user_config.h file

#define USER_CONFIG_H
#include "driver/gpio.h"

// I2C
#define ESP32_SCL_NUM (GPIO_NUM_7)
#define ESP32_SDA_NUM (GPIO_NUM_15)


#define Backlight_Testing
#define EXAMPLE_Rotate_90 //软件实现旋转


#define EXAMPLE_LCD_H_RES 320
#define EXAMPLE_LCD_V_RES 820


#define EXAMPLE_LCD_IO_SPI_CS      (gpio_num_t)0
#define EXAMPLE_LCD_IO_SPI_SCK     (gpio_num_t)2
#define EXAMPLE_LCD_IO_SPI_SDO     (gpio_num_t)1

#define EXAMPLE_LCD_IO_RGB_DE      (gpio_num_t)40
#define EXAMPLE_LCD_IO_RGB_PCLK    (gpio_num_t)41
#define EXAMPLE_LCD_IO_RGB_VSYNC   (gpio_num_t)39
#define EXAMPLE_LCD_IO_RGB_HSYNC   (gpio_num_t)38
#define EXAMPLE_LCD_IO_RGB_DISP
#define EXAMPLE_LCD_IO_RGB_RESET   (gpio_num_t)16 

#define EXAMPLE_LCD_IO_RGB_R0      (gpio_num_t)17
#define EXAMPLE_LCD_IO_RGB_R1      (gpio_num_t)46
#define EXAMPLE_LCD_IO_RGB_R2      (gpio_num_t)3
#define EXAMPLE_LCD_IO_RGB_R3      (gpio_num_t)8
#define EXAMPLE_LCD_IO_RGB_R4      (gpio_num_t)18

#define EXAMPLE_LCD_IO_RGB_G0      (gpio_num_t)14
#define EXAMPLE_LCD_IO_RGB_G1      (gpio_num_t)13
#define EXAMPLE_LCD_IO_RGB_G2      (gpio_num_t)12
#define EXAMPLE_LCD_IO_RGB_G3      (gpio_num_t)11
#define EXAMPLE_LCD_IO_RGB_G4      (gpio_num_t)10
#define EXAMPLE_LCD_IO_RGB_G5      (gpio_num_t)9

#define EXAMPLE_LCD_IO_RGB_B0      (gpio_num_t)21
#define EXAMPLE_LCD_IO_RGB_B1      (gpio_num_t)5
#define EXAMPLE_LCD_IO_RGB_B2      (gpio_num_t)45
#define EXAMPLE_LCD_IO_RGB_B3      (gpio_num_t)48
#define EXAMPLE_LCD_IO_RGB_B4      (gpio_num_t)47


#define EXAMPLE_LVGL_TICK_PERIOD_MS    2
#define EXAMPLE_LVGL_TASK_MAX_DELAY_MS 500
#define EXAMPLE_LVGL_TASK_MIN_DELAY_MS 1
#define EXAMPLE_LVGL_TASK_STACK_SIZE   (8 * 1024)
#define EXAMPLE_LVGL_TASK_PRIORITY     5


#endif`

And here is esp_lcd_st7701_mipi file

/*
 * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#include "soc/soc_caps.h"

#if SOC_MIPI_DSI_SUPPORTED
#include <stdlib.h>
#include <sys/cdefs.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_lcd_panel_interface.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_commands.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_check.h"
#include "esp_lcd_st7701.h"
#include "esp_lcd_st7701_interface.h"

static const char *TAG = "st7701_mipi";

static esp_err_t panel_st7701_del(esp_lcd_panel_t *panel);
static esp_err_t panel_st7701_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_st7701_init(esp_lcd_panel_t *panel);
static esp_err_t panel_st7701_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_st7701_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_st7701_disp_on_off(esp_lcd_panel_t *panel, bool off);
static esp_err_t panel_st7701_sleep(esp_lcd_panel_t *panel, bool sleep);

typedef struct {
    esp_lcd_panel_io_handle_t io;
    int reset_gpio_num;
    uint8_t madctl_val; // save current value of LCD_CMD_MADCTL register
    uint8_t colmod_val; // save surrent value of LCD_CMD_COLMOD register
    const st7701_lcd_init_cmd_t *init_cmds;
    uint16_t init_cmds_size;
    struct {
        unsigned int reset_level: 1;
    } flags;
    // To save the original functions of MIPI DPI panel
    esp_err_t (*del)(esp_lcd_panel_t *panel);
    esp_err_t (*init)(esp_lcd_panel_t *panel);
} st7701_panel_t;

esp_err_t esp_lcd_new_panel_st7701_mipi(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel)
{
    ESP_RETURN_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
    st7701_vendor_config_t *vendor_config = (st7701_vendor_config_t *)panel_dev_config->vendor_config;
    ESP_RETURN_ON_FALSE(vendor_config && vendor_config->mipi_config.dpi_config && vendor_config->mipi_config.dsi_bus, ESP_ERR_INVALID_ARG, TAG,
                        "invalid vendor config");

    esp_err_t ret = ESP_OK;
    st7701_panel_t *st7701 = (st7701_panel_t *)calloc(1, sizeof(st7701_panel_t));
    ESP_RETURN_ON_FALSE(st7701, ESP_ERR_NO_MEM, TAG, "no mem for st7701 panel");

    if (panel_dev_config->reset_gpio_num >= 0) {
        gpio_config_t io_conf = {
            .mode = GPIO_MODE_OUTPUT,
            .pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num,
        };
        ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed");
    }

    switch (panel_dev_config->color_space) {
    case LCD_RGB_ELEMENT_ORDER_RGB:
        st7701->madctl_val = 0;
        break;
    case LCD_RGB_ELEMENT_ORDER_BGR:
        st7701->madctl_val |= LCD_CMD_BGR_BIT;
        break;
    default:
        ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported rgb element order");
        break;
    }

    switch (panel_dev_config->bits_per_pixel) {
    case 16: // RGB565
        st7701->colmod_val = 0x55;
        break;
    case 18: // RGB666
        st7701->colmod_val = 0x66;
        break;
    case 24: // RGB888
        st7701->colmod_val = 0x77;
        break;
    default:
        ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported pixel width");
        break;
    }

    st7701->io = io;
    st7701->init_cmds = vendor_config->init_cmds;
    st7701->init_cmds_size = vendor_config->init_cmds_size;
    st7701->reset_gpio_num = panel_dev_config->reset_gpio_num;
    st7701->flags.reset_level = panel_dev_config->flags.reset_active_high;

    // Create MIPI DPI panel
    esp_lcd_panel_handle_t panel_handle = NULL;
    ESP_GOTO_ON_ERROR(esp_lcd_new_panel_dpi(vendor_config->mipi_config.dsi_bus, vendor_config->mipi_config.dpi_config, &panel_handle), err, TAG,
                      "create MIPI DPI panel failed");
    ESP_LOGD(TAG, "new MIPI DPI panel @%p", panel_handle);

    // Save the original functions of MIPI DPI panel
    st7701->del = panel_handle->del;
    st7701->init = panel_handle->init;
    // Overwrite the functions of MIPI DPI panel
    panel_handle->del = panel_st7701_del;
    panel_handle->init = panel_st7701_init;
    panel_handle->reset = panel_st7701_reset;
    panel_handle->mirror = panel_st7701_mirror;
    panel_handle->invert_color = panel_st7701_invert_color;
    panel_handle->disp_on_off = panel_st7701_disp_on_off;
    panel_handle->disp_sleep = panel_st7701_sleep;
    panel_handle->user_data = st7701;
    *ret_panel = panel_handle;
    ESP_LOGD(TAG, "new st7701 panel @%p", st7701);

    return ESP_OK;
err:
    if (st7701) {
        if (panel_dev_config->reset_gpio_num >= 0) {
            gpio_reset_pin(panel_dev_config->reset_gpio_num);
        }
    }
    return ret;
}

static esp_err_t panel_st7701_del(esp_lcd_panel_t *panel)
{
    st7701_panel_t *st7701 = (st7701_panel_t *)panel->user_data;

    if (st7701->reset_gpio_num >= 0) {
        gpio_reset_pin(st7701->reset_gpio_num);
    }

    // Delete MIPI DPI panel
    st7701->del(panel);
    ESP_LOGD(TAG, "del st7701 panel @%p", st7701);
    free(st7701);

    return ESP_OK;
}

static esp_err_t panel_st7701_reset(esp_lcd_panel_t *panel)
{
    st7701_panel_t *st7701 = (st7701_panel_t *)panel->user_data;
    esp_lcd_panel_io_handle_t io = st7701->io;

    // perform hardware reset
    if (st7701->reset_gpio_num >= 0) {
        gpio_set_level(st7701->reset_gpio_num, st7701->flags.reset_level);
        vTaskDelay(pdMS_TO_TICKS(10));
        gpio_set_level(st7701->reset_gpio_num, !st7701->flags.reset_level);
        vTaskDelay(pdMS_TO_TICKS(10));
    } else if (io) { // perform software reset
        ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0), TAG, "send command failed");
        vTaskDelay(pdMS_TO_TICKS(20)); // spec, wait at least 5ms before sending new command
    }

    return ESP_OK;
}

static const st7701_lcd_init_cmd_t vendor_specific_init_default[] = {
    {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x13}, 5, 0},
    {0xEF, (uint8_t []){0x08}, 1, 0},
    {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x10}, 5, 0},
    {0xC0, (uint8_t []){0x2c, 0x00}, 2, 0},
    {0xC1, (uint8_t []){0x10, 0x0C}, 2, 0},
    {0xC2, (uint8_t []){0x21, 0x0A}, 2, 0},
    {0xCC, (uint8_t []){0x10}, 1, 0},
    {0xB0, (uint8_t []){0x00, 0x0B, 0x12, 0x0D, 0x10, 0x06, 0x02, 0x08, 0x07, 0x1F, 0x04, 0x11, 0x0F, 0x29, 0x31, 0x1E}, 16, 0},
    {0xB1, (uint8_t []){0x00, 0x0B, 0x13, 0x0D, 0x11, 0x06, 0x03, 0x08, 0x07, 0x20, 0x04, 0x12, 0x11, 0x29, 0x31, 0x1E}, 16, 0},
    {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x11}, 5, 0},
    {0xB0, (uint8_t []){0x5D}, 1, 0},
    {0xB1, (uint8_t []){0x72}, 1, 0},
    {0xB2, (uint8_t []){0x84}, 1, 0},
    {0xB3, (uint8_t []){0x80}, 1, 0},
    {0xB5, (uint8_t []){0x4D}, 1, 0},
    {0xB7, (uint8_t []){0x85}, 1, 0},
    {0xB8, (uint8_t []){0x20}, 1, 0},
    {0xC1, (uint8_t []){0x78}, 1, 0},
    {0xC2, (uint8_t []){0x78}, 1, 0},
    {0xD0, (uint8_t []){0x88}, 1, 0},
    {0xE0, (uint8_t []){0x80, 0x00, 0x02}, 3, 0},
    {0xE1, (uint8_t []){0x05, 0x00, 0x07, 0x00, 0x06, 0x00, 0x08, 0x00, 0x00, 0x33, 0x33}, 11, 0},
    {0xE2, (uint8_t []){0x00, 0x00, 0x30, 0x30, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00}, 12, 0},
    {0xE3, (uint8_t []){0x00, 0x00, 0x11, 0x11}, 4, 0},
    {0xE4, (uint8_t []){0x44, 0x44}, 2, 0},
    {0xE5, (uint8_t []){0x0C, 0x78, 0x00, 0xE0, 0x0E, 0x7A, 0x00, 0xE0, 0x08, 0x74, 0x00, 0xE0, 0x0A, 0x76, 0x00, 0xE0}, 16, 0},
    {0xE6, (uint8_t []){0x00, 0x00, 0x11, 0x11}, 4, 0},
    {0xE7, (uint8_t []){0x44, 0x44}, 2, 0},
    {0xE8, (uint8_t []){0x0D, 0x79, 0x00, 0xE0, 0x0F, 0x7B, 0x00, 0xE0, 0x09, 0x75, 0x00, 0xE0, 0x0B, 0x77, 0x00, 0xE0}, 16, 0},
    {0xE9, (uint8_t []){0x36, 0x00}, 2, 0},
    {0xEB, (uint8_t []){0x00, 0x01, 0xE4, 0xE4, 0x44, 0x88, 0x40}, 7, 0},
    {0xED, (uint8_t []){0xA1, 0xC2, 0xFB, 0x0F, 0x67, 0x45, 0xFF, 0xFF, 0xFF, 0xFF, 0x54, 0x76, 0xF0, 0xBF, 0x2C, 0x1A}, 16, 0},
    {0xEF, (uint8_t []){0x10, 0x0D, 0x04, 0x08, 0x3F, 0x1F}, 6, 0},
    {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x13}, 5, 0},
    {0xE8, (uint8_t []){0x00, 0x0E}, 2, 0},
    {0xE8, (uint8_t []){0x00, 0x0C}, 2, 20},
    {0xE8, (uint8_t []){0x00, 0x00}, 2, 0},
    {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x00}, 5, 0},
    {0x11, (uint8_t []){0x00}, 0, 120},
    {0x29, (uint8_t []){0x00}, 0, 0},

    // {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x12}, 5, 0}, /* This part of the parameters can be used for screen self-test */
    // {0xD1, (uint8_t []){0x81}, 1, 0},
    // {0xD2, (uint8_t []){0x08}, 1, 0},
};

static esp_err_t panel_st7701_init(esp_lcd_panel_t *panel)
{
    st7701_panel_t *st7701 = (st7701_panel_t *)panel->user_data;
    esp_lcd_panel_io_handle_t io = st7701->io;
    const st7701_lcd_init_cmd_t *init_cmds = NULL;
    uint16_t init_cmds_size = 0;
    bool is_command2_disable = true;
    bool is_cmd_overwritten = false;

    uint8_t ID[3];
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_rx_param(io, 0x04, ID, 3), TAG, "read ID failed");
    ESP_LOGI(TAG, "LCD ID: %02X %02X %02X", ID[0], ID[1], ID[2]);

    // back to CMD_Page 0
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, ST7701_CMD_CND2BKxSEL, (uint8_t []) {
        ST7701_CMD_BKxSEL_BYTE0, ST7701_CMD_BKxSEL_BYTE1, ST7701_CMD_BKxSEL_BYTE2, ST7701_CMD_BKxSEL_BYTE3, 0x00
    }, 5), TAG, "Write cmd failed");
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
        st7701->madctl_val,
    }, 1), TAG, "send command failed");
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD, (uint8_t[]) {
        st7701->colmod_val,
    }, 1), TAG, "send command failed");
    ESP_LOGI(TAG, " st7701->madctl_val: 0x%x, st7701->colmod_val: 0x%x",  st7701->madctl_val, st7701->colmod_val);

    // vendor specific initialization, it can be different between manufacturers
    // should consult the LCD supplier for initialization sequence code
    if (st7701->init_cmds) {
        init_cmds = st7701->init_cmds;
        init_cmds_size = st7701->init_cmds_size;
    } else {
        init_cmds = vendor_specific_init_default;
        init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(st7701_lcd_init_cmd_t);
    }

    for (int i = 0; i < init_cmds_size; i++) {
        // Check if the command has been used or conflicts with the internal only when command2 is disable
        if (is_command2_disable && (init_cmds[i].data_bytes > 0)) {
            switch (init_cmds[i].cmd) {
            case LCD_CMD_MADCTL:
                is_cmd_overwritten = true;
                st7701->madctl_val = ((uint8_t *)init_cmds[i].data)[0];
                break;
            case LCD_CMD_COLMOD:
                is_cmd_overwritten = true;
                st7701->colmod_val = ((uint8_t *)init_cmds[i].data)[0];
                break;
            default:
                is_cmd_overwritten = false;
                break;
            }

            if (is_cmd_overwritten) {
                is_cmd_overwritten = false;
                ESP_LOGW(TAG, "The %02Xh command has been used and will be overwritten by external initialization sequence",
                         init_cmds[i].cmd);
            }
        }

        // Send command
        ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, init_cmds[i].cmd, init_cmds[i].data, init_cmds[i].data_bytes),
                            TAG, "send command failed");
        vTaskDelay(pdMS_TO_TICKS(init_cmds[i].delay_ms));

        // Check if the current cmd is the command2 disable cmd
        if ((init_cmds[i].cmd == ST7701_CMD_CND2BKxSEL) && (init_cmds[i].data_bytes > 4)) {
            is_command2_disable = !(((uint8_t *)init_cmds[i].data)[4] & ST7701_CMD_CN2_BIT);
        }
    }
    ESP_LOGD(TAG, "send init commands success");

    ESP_RETURN_ON_ERROR(st7701->init(panel), TAG, "init MIPI DPI panel failed");

    return ESP_OK;
}

static esp_err_t panel_st7701_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
{
    st7701_panel_t *st7701 = (st7701_panel_t *)panel->user_data;
    esp_lcd_panel_io_handle_t io = st7701->io;
    int command = 0;
    if (invert_color_data) {
        command = LCD_CMD_INVON;
    } else {
        command = LCD_CMD_INVOFF;
    }
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
    return ESP_OK;
}

static esp_err_t panel_st7701_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
    st7701_panel_t *st7701 = (st7701_panel_t *)panel->user_data;
    esp_lcd_panel_io_handle_t io = st7701->io;
    uint8_t sdir_val = 0;

    ESP_RETURN_ON_FALSE(io, ESP_FAIL, TAG, "Panel IO is deleted, cannot send command");
    // Control mirror through LCD command
    if (mirror_x) {
        sdir_val = ST7701_CMD_SS_BIT;
    } else {
        sdir_val = 0;
    }
    if (mirror_y) {
        st7701->madctl_val |= LCD_CMD_ML_BIT;
    } else {
        st7701->madctl_val &= ~LCD_CMD_ML_BIT;
    }

    // Enable the Command2 BK0
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, ST7701_CMD_CND2BKxSEL, (uint8_t []) {
        ST7701_CMD_BKxSEL_BYTE0, ST7701_CMD_BKxSEL_BYTE1, ST7701_CMD_BKxSEL_BYTE2, ST7701_CMD_BKxSEL_BYTE3,
                                 ST7701_CMD_BKxSEL_BK0 | ST7701_CMD_CN2_BIT,
    }, 5), TAG, "send command failed");
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, ST7701_CMD_SDIR, (uint8_t[]) {
        sdir_val,
    }, 1), TAG, "send command failed");;

    // Disable Command2
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, ST7701_CMD_CND2BKxSEL, (uint8_t []) {
        ST7701_CMD_BKxSEL_BYTE0, ST7701_CMD_BKxSEL_BYTE1, ST7701_CMD_BKxSEL_BYTE2, ST7701_CMD_BKxSEL_BYTE3, 0,
    }, 5), TAG, "send command failed");
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
        st7701->madctl_val,
    }, 1), TAG, "send command failed");;

    return ESP_OK;
}

static esp_err_t panel_st7701_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
{
    st7701_panel_t *st7701 = (st7701_panel_t *)panel->user_data;
    esp_lcd_panel_io_handle_t io = st7701->io;
    int command = 0;

    if (on_off) {
        command = LCD_CMD_DISPON;
    } else {
        command = LCD_CMD_DISPOFF;
    }
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
    return ESP_OK;
}

static esp_err_t panel_st7701_sleep(esp_lcd_panel_t *panel, bool sleep)
{
    st7701_panel_t *st7701 = (st7701_panel_t *)panel->user_data;
    esp_lcd_panel_io_handle_t io = st7701->io;
    int command = 0;
    if (sleep) {
        command = LCD_CMD_SLPIN;
    } else {
        command = LCD_CMD_SLPOUT;
    }
    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG,
                        "io tx param failed");
    vTaskDelay(pdMS_TO_TICKS(100));

    return ESP_OK;
}
#endif

Init for spi3wire has the same values you setup for ST7701 type 12 driver, so more or less I just think that I'm doing something wrong with tools that you provided,

PS. I'm very sorry for bunch of edits but those files don't agree with code blocks.

[kdschlosser]

to do code block you wrap the code in triple back ticks

```

Code Here

```

Code Here

[kdschlosser]

This code you provided is not for your display. That code is if you have an MIPI DSI display that i attached. You have an RGB display. The only way that you could be using an MIPI display is if you are using an ESP32-P4

[cyrylts]

Thank you,
So I checked init sequence in screen_type 12 and there are differences, so I guess that is the issue with execution, I will create custom one for my screen, build that and then test. If I will still see the issues I will let you know.

Kindest Regards

[jedie]

Think i have a similar constrution area with #541 to get the 4 Inch 480x480 RGB Display running on the SQUiXL device by "Unexpected Maker".

It's a ST7701S and @kdschlosser mendiond that it should run with https://github.com/lvgl-micropython/lvgl_micropython/blob/main/api_drivers/common_api_drivers/display/st7701/st7701.py ... But it's needed a Spi3Wire instance. And i found the implementation here:

https://github.com/lvgl-micropython/lvgl_micropython/blob/main/api_drivers/common_api_drivers/frozen/other/spi3wire.py but there is the comment in there:

******* NOTICE ********
This module is no longer used.

What does really mean?!?

[cyrylts]

After some digging through whole project code, I think the answer to you question is simple. Python version of spi3wire is not used anymore, I think that @kdschlosser implemented c version for speed reasons, that you can find in ext_mod folder. I'm not sure if that version supports 9bit commands, or what exactly is supporting that in current st7701 driver.
Also are you passing correct driver type? Did you compare you init sequence to sequence used in software package provided by your board maker?

[kdschlosser]

the spi3wire was rewritten in C. It's still available that specific module you found is no longer used.

[cyrylts]

Not sure i still can make this work. For now I setup this type for my screen using configuration found in files that I got form arduino demo. but even with that there is no response from the screen, interesting enough I was able to find driver implementation that works with framebuf library, so I'm even more lost.

Kindest Regards

import time


# Waveshare 3.16 Inch 320 x 820 bar display
def init(self):
    param_buf = bytearray(16)
    param_mv = memoryview(param_buf)

    # Sleep Out
    self.set_params(0x11)

    time.sleep_ms(100)  # NOQA

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x13])
    self.set_params(0xFF, param_mv[:5])

    param_buf[0] = 0x08
    self.set_params(0xEF, param_mv[:1])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x10])
    self.set_params(0xFF, param_mv[:5])

    param_buf[:2] = bytearray([0xE5, 0x02])
    self.set_params(0xC0, param_mv[:2])

    # VBP
    param_buf[:2] = bytearray([0x15, 0x0A])
    self.set_params(0xC1, param_mv[:2])

    param_buf[:2] = bytearray([0x07, 0x02])
    self.set_params(0xC2, param_mv[:2])

    param_buf[0] = 0x10
    self.set_params(0xCC, param_mv[:1])

    param_buf[:16] = bytearray(
        [
            0x00,
            0x08,
            0x51,
            0x0D,
            0xCE,
            0x06,
            0x00,
            0x08,
            0x08,
            0x24,
            0x05,
            0xD0,
            0x0F,
            0x6F,
            0x36,
            0x1F,
        ]
    )
    self.set_params(0xB0, param_mv[:16])

    param_buf[:16] = bytearray(
        [
            0x00,
            0x10,
            0x4F,
            0x0C,
            0x11,
            0x05,
            0x00,
            0x07,
            0x07,
            0x18,
            0x02,
            0xD3,
            0x11,
            0x6E,
            0x34,
            0x1F,
        ]
    )
    self.set_params(0xB1, param_mv[:16])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x11])
    self.set_params(0xFF, param_mv[:5])

    param_buf[0] = 0x4D
    self.set_params(0xB0, param_mv[:1])

    param_buf[0] = 0x37
    self.set_params(0xB1, param_mv[:1])

    param_buf[0] = 0x87
    self.set_params(0xB2, param_mv[:1])

    param_buf[0] = 0x80
    self.set_params(0xB3, param_mv[:1])

    param_buf[0] = 0x4A
    self.set_params(0xB5, param_mv[:1])

    param_buf[0] = 0x85
    self.set_params(0xB7, param_mv[:1])

    param_buf[0] = 0x21
    self.set_params(0xB8, param_mv[:1])

    param_buf[:2] = bytearray([0x00, 0x13])
    self.set_params(0xB9, param_mv[:1])

    param_buf[0] = 0x09
    self.set_params(0xC0, param_mv[:1])

    param_buf[0] = 0x78
    self.set_params(0xC1, param_mv[:1])

    param_buf[0] = 0x78
    self.set_params(0xC2, param_mv[:1])

    param_buf[0] = 0x88
    self.set_params(0xD0, param_mv[:1])

    time.sleep_ms(100)  # NOQA

    param_buf[:3] = bytearray([0x80, 0x00, 0x02])
    self.set_params(0xE0, param_mv[:3])

    param_buf[:11] = bytearray(
        [0x0F, 0xA0, 0x00, 0x00, 0x10, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x60]
    )
    self.set_params(0xE1, param_mv[:11])

    param_buf[:13] = bytearray(
        [0x30, 0x30, 0x60, 0x60, 0x45, 0xA0, 0x00, 0x00, 0x46, 0xA0, 0x00, 0x00, 0x00]
    )
    self.set_params(0xE2, param_mv[:13])

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

    param_buf[:2] = bytearray([0x44, 0x44])
    self.set_params(0xE4, param_mv[:2])

    param_buf[:16] = bytearray(
        [
            0x0F,
            0x4A,
            0xA0,
            0xA0,
            0x11,
            0x4A,
            0xA0,
            0xA0,
            0x13,
            0x4A,
            0xA0,
            0xA0,
            0x15,
            0x4A,
            0xA0,
            0xA0,
        ]
    )
    self.set_params(0xE5, param_mv[:16])

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

    param_buf[:2] = bytearray([0x44, 0x44])
    self.set_params(0xE7, param_mv[:2])

    param_buf[:16] = bytearray(
        [
            0x10,
            0x4A,
            0xA0,
            0xA0,
            0x12,
            0x4A,
            0xA0,
            0xA0,
            0x14,
            0x4A,
            0xA0,
            0xA0,
            0x16,
            0x4A,
            0xA0,
            0xA0,
        ]
    )
    self.set_params(0xE8, param_mv[:16])

    param_buf[:7] = bytearray([0x02, 0x00, 0x4E, 0x4E, 0xEE, 0x44, 0x00])
    self.set_params(0xEB, param_mv[:7])

    param_buf[:16] = bytearray(
        [
            0xFF,
            0xFF,
            0x04,
            0x56,
            0x72,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
            0x27,
            0x65,
            0x40,
            0xFF,
            0xFF,
        ]
    )
    self.set_params(0xED, param_mv[:16])

    param_buf[:6] = bytearray([0x08, 0x08, 0x08, 0x40, 0x3F, 0x64])
    self.set_params(0xEF, param_mv[:6])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x13])
    self.set_params(0xFF, param_mv[:5])

    param_buf[:2] = bytearray([0x00, 0x0E])
    self.set_params(0xE8, param_mv[:2])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x00])
    self.set_params(0xFF, param_mv[:5])

    self.set_params(0x11)

    time.sleep_ms(120)  # NOQA

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x13])
    self.set_params(0xFF, param_mv[:5])

    param_buf[:2] = bytearray([0x00, 0x0C])
    self.set_params(0xE8, param_mv[:2])

    time.sleep_ms(10)  # NOQA

    param_buf[:2] = bytearray([0x00, 0x00])
    self.set_params(0xE8, param_mv[:2])

    param_buf[:5] = bytearray([0x77, 0x01, 0x00, 0x00, 0x00])
    self.set_params(0xFF, param_mv[:5])

    param_buf[0] = 0x55
    self.set_params(0x3A, param_mv[:1])

    param_buf[0] = 0x00
    self.set_params(0x36, param_mv[:1])

    param_buf[0] = 0x00
    self.set_params(0x35, param_mv[:1])

    #    self.set_params(0x11)

    #    time.sleep_ms(120)  # NOQA

    self.set_params(0x29)

    time.sleep_ms(20)  # NOQA

[kdschlosser]

ok so we need to slow down for 1 minute and make sure that everything is correct. give me some time to review what you have posted and I will write the startup code for you.

[kdschlosser]

OK so here we go...

I found several issues in your startup code. You had the SPI3Wire incorrectly setup . you were initializing the spi3wire when you shouldn't have been. The biggest one is you had the reset state for the display set so it was always going to be resetting. This display IC uses a negative to activate the reset not a positive so I had to add the parameter to flip that state.

Give this a go and see if it works for ya.

from micropython import const
_H_RES = const(320)
_V_RES = const(820)

# Wiring diagram says pin 42 so if it doesn't work then try changing the 0 to 42
_LCD_CS = const(0)  
_LCD_SDA = const(1)
_LCD_SCL = const(2)
_3WIRE_FREQ = const(500000)


_LCD_FREQ = const(12000000)
_BL = const(6)

_H_PULSE = const(6)
_V_PULSE = const(40)
_H_FRONT = const(30)
_H_BACK = const(30)
_V_FRONT = const(20)
_V_BACK = const(20)

_DE = const(40)
_PCLK = const(41)
_VSYNC = const(39)
_HSYNC = const(38)
_RESET = const(16)

_R0 = const(17)
_R1 = const(46)
_R2 = const(3)
_R3 = const(8)
_R4 = const(18)

_G0 = const(14)
_G1 = const(13)
_G2 = const(12)
_G3 = const(11)
_G4 = const(10)
_G5 = const(9)

_B0 = const(21)
_B1 = const(5)
_B2 = const(45)
_B3 = const(48)
_B4 = const(47)


import spi3wire


spi3wire_bus = spi3wire.Spi3Wire(
    sda=_LCD_SDA,
    scl=_LCD_SCL,
    cs=_LCD_CS,
    freq=_3WIRE_FREQ,
    spi_mode=1,   # This is supposed to be a 1
    use_dc_bit=True,
    cs_high_active=False,  # This should be False
    dc_zero_on_data=False,  # This should be False
    del_keep_cs_inactive=True
)

import lcd_bus

display_bus = lcd_bus.RGBBus(
    hsync=_HSYNC,
    vsync=_VSYNC,
    de=_DE,
    pclk=_PCLK,
    data0=_B0, data1=_B1, data2=_B2, data3=_B3, data4=_B4,
    data5=_G0, data6=_G1, data7=_G2, data8=_G3, data9=_G4, data10=_G5,
    data11=_R0, data12=_R1, data13=_R2, data14=_R3, data15=_R4,
    freq=_LCD_FREQ,
    hsync_pulse_width=_H_PULSE,
    hsync_back_porch=_H_BACK,
    hsync_front_porch=_H_FRONT,
    vsync_pulse_width=_V_PULSE,
    vsync_back_porch=_V_BACK,
    vsync_front_porch=_V_FRONT,

)

import st7701
import lvgl as lv  # NOQA

display = st7701.ST7701(
    data_bus=display_bus,
    spi_3wire=spi3wire_bus,
    display_width=_H_RES,
    display_height=_V_RES,
    backlight_pin=_BL,
    backlight_on_state=st7701.STATE_PWM,
    reset_pin=_RESET,
    reset_state=st7701.STATE_LOW,
    color_space=lv.COLOR_FORMAT.RGB565,
    bus_shared_pins=False
)


display.set_power(True)

# I am not sure what type you said was the closest. I thought it was 12 but in your code 18 is being used.
# Change this as needed or I can also do up a custom init if needed. 
display.init(type=18)

display.set_backlight(100)
display.set_rotation(270)

import task_handler


th = task_handler.TaskHandler()

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

label = lv.label(scrn)

label.set_text('HELLO WORLD!')

label.align(lv.ALIGN.CENTER, 0, 0)

[cyrylts]

I don't have heat sinks I would have to order some first, but now I'm working on v2 of case for this board. Current version don't have any ventilation holes so heat sink wouldn't help. Also I had some issues with building new firmware, due to partition limitation, but I was able to figure it out still there are some things in the output printed in terminal that don't look correct, so I need to investigate this more before I attempt overclocking.

[kdschlosser]

If you are running into issues with the partition sizing please lemme know what they are. the partitions should be automatically adjusting so if you see an error for that and then the build continues don't worry about it. That's normal. The only way the detection works is by compiling and it catches the fault and then resizes the partition and starts the build again. When it restarts the build it is a lot faster because it is able to pick up where the failure occurred.

if you build add > output.txt onto the end of the build command. It will dump the output to a file. While it does this it is not going to show anything on your screen so when it returns back to the prompt you will know it has finished the build.

[cyrylts]

I saw that ninja resized partition table, the issue was that after that all settings from board file were overwritten with some default values that were lowering my cpu from 240 to 120, memory type from octa to quad, memory clock from 80 to 40. I get that s3 chip is used in many configurations so whatever in esp32 is default setting was used.
But in the end I was able to resolve this and everything runs ok.

[kdschlosser]

That's because you didn't read the README.md file. It outlines everything you need to do to compile properly.

Your build command should be...

python3 make.py esp32 BOARD=ESP32_GENERIC_S3 BOARD_VARIANT=SPIRAM_OCT --flash-size=16 --octal-flash ----enable-uart-repl=y  --enable-cdc-repl=n --enable-jtag-repl=n --uart-repl-bitrate=115200 DISPLAY=st7701 INDEV=???

you may or may not need the --octal-flash build command.

That is what your build command should look look like. You need to fill in the INDEV with the model number of the touch IC.

That will set everything how it should be set and you do not need to alter or change any of the files. It will automatically set the partition size to maximize the space for the user partition and it will bake the drivers into the firmware when it compiles it.

[kdschlosser]

Ninja is used only to speed up the build process by using multiple cores on your CPU. If Ninja wasn't used only one file at a time would compile and it would take a whole lot longer. I set it up like that because I am able to compile the binding in around a minute because my machine has 64 cores. When I first started writing the library it drove me batty because of how long it was taking to compile. Adding Ninja was one of the first things I did.