Add board: Waveshare S3 Touch LCD 1.47 (#328)

Touch isn't working yet.
Fixed a SPI lock issue.

.github/workflows/build-firmware.yml

@@ -189,3 +189,12 @@ jobs:
         with:
           board_id: waveshare-s3-touch-43
           arch: esp32s3
+  waveshare-s3-touch-lcd-147:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Build"
+        uses: ./.github/actions/build-firmware
+        with:
+          board_id: waveshare-s3-touch-lcd-147
+          arch: esp32s3

App/Kconfig

@@ -51,6 +51,8 @@ menu "Tactility App"
             bool "unPhone"
         config TT_BOARD_WAVESHARE_S3_TOUCH_43
             bool "Waveshare ESP32 S3 Touch LCD 4.3"
+        config TT_BOARD_WAVESHARE_S3_TOUCH_LCD_147
+            bool "Waveshare ESP32 S3 Touch LCD 1.47"
         help
             Select a board/hardware configuration.
             Use TT_BOARD_CUSTOM if you will manually configure the board in your project.

App/Source/Boards.h

@@ -65,6 +65,9 @@
 #elif defined(CONFIG_TT_BOARD_WAVESHARE_S3_TOUCH_43)
 #include "WaveshareS3Touch43.h"
 #define TT_BOARD_HARDWARE &waveshare_s3_touch_43
+#elif defined(CONFIG_TT_BOARD_WAVESHARE_S3_TOUCH_LCD_147)
+#include "WaveshareS3TouchLcd147.h"
+#define TT_BOARD_HARDWARE &waveshare_s3_touch_lcd_147
 #else
 #define TT_BOARD_HARDWARE NULL
 #error Replace TT_BOARD_HARDWARE in main.c with your own. Or copy one of the ./sdkconfig.board.* files into ./sdkconfig.

Boards/WaveshareS3TouchLcd147/CMakeLists.txt

@@ -0,0 +1,7 @@
+file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
+
+idf_component_register(
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS "Source"
+    REQUIRES Tactility esp_lvgl_port EspLcdCompat AXS5106 JD9853
+)

Boards/WaveshareS3TouchLcd147/Source/Init.cpp

@@ -0,0 +1,43 @@
+#include <Tactility/TactilityCore.h>
+#include <driver/ledc.h>
+
+constexpr auto* TAG = "Waveshare";
+
+constexpr auto LCD_BL_LEDC_TIMER = LEDC_TIMER_0;
+constexpr auto LCD_BL_LEDC_MODE = LEDC_LOW_SPEED_MODE;
+constexpr auto LCD_BL_LEDC_CHANNEL = LEDC_CHANNEL_0;
+constexpr auto LCD_BL_LEDC_DUTY_RES = LEDC_TIMER_10_BIT;
+constexpr auto LCD_BL_LEDC_DUTY = 1024;
+constexpr auto LCD_BL_LEDC_FREQUENCY = 10000;
+
+void setBacklightDuty(uint8_t level) {
+    uint32_t duty = (level * (LCD_BL_LEDC_DUTY - 1)) / 255;
+    ESP_ERROR_CHECK(ledc_set_duty(LCD_BL_LEDC_MODE, LCD_BL_LEDC_CHANNEL, duty));
+    ESP_ERROR_CHECK(ledc_update_duty(LCD_BL_LEDC_MODE, LCD_BL_LEDC_CHANNEL));
+}
+
+void initBacklight() {
+    ledc_timer_config_t timer_config = {
+        .speed_mode = LCD_BL_LEDC_MODE,
+        .duty_resolution = LCD_BL_LEDC_DUTY_RES,
+        .timer_num = LCD_BL_LEDC_TIMER,
+        .freq_hz = LCD_BL_LEDC_FREQUENCY,
+        .clk_cfg = LEDC_AUTO_CLK};
+    ESP_ERROR_CHECK(ledc_timer_config(&timer_config));
+
+    ledc_channel_config_t channel_config = {
+        .gpio_num = GPIO_NUM_46,
+        .speed_mode = LCD_BL_LEDC_MODE,
+        .channel = LCD_BL_LEDC_CHANNEL,
+        .intr_type = LEDC_INTR_DISABLE,
+        .timer_sel = LCD_BL_LEDC_TIMER,
+        .duty = 0, // Set duty to 0%
+        .hpoint = 0};
+    ESP_ERROR_CHECK(ledc_channel_config(&channel_config));
+}
+
+bool initBoot() {
+    ESP_LOGI(TAG, LOG_MESSAGE_POWER_ON_START);
+    initBacklight();
+    return true;
+}

Boards/WaveshareS3TouchLcd147/Source/WaveshareS3TouchLcd147.cpp

@@ -0,0 +1,91 @@
+#include <Tactility/hal/Configuration.h>
+#include <Tactility/lvgl/LvglSync.h>
+
+#include "devices/Display.h"
+#include "devices/Sdcard.h"
+
+#define SPI_TRANSFER_SIZE_LIMIT (172 * 320 * (LV_COLOR_DEPTH / 8))
+
+bool initBoot();
+
+using namespace tt::hal;
+
+static std::vector<std::shared_ptr<Device>> createDevices() {
+    return {
+        createDisplay(),
+        createSdCard()
+    };
+}
+
+extern const Configuration waveshare_s3_touch_lcd_147 = {
+    .initBoot = initBoot,
+    .createDevices = createDevices,
+    .i2c = {
+        i2c::Configuration {
+            .name = "Internal",
+            .port = I2C_NUM_0,
+            .initMode = i2c::InitMode::ByTactility,
+            .isMutable = false,
+            .config = (i2c_config_t) {
+                .mode = I2C_MODE_MASTER,
+                .sda_io_num = GPIO_NUM_42,
+                .scl_io_num = GPIO_NUM_41,
+                .sda_pullup_en = true,
+                .scl_pullup_en = true,
+                .master = {
+                    .clk_speed = 400000
+                },
+                .clk_flags = 0
+            }
+        }
+    },
+    .spi {
+        spi::Configuration {
+            .device = SPI2_HOST,
+            .dma = SPI_DMA_CH_AUTO,
+            .config = {
+                .mosi_io_num = GPIO_NUM_39,
+                .miso_io_num = GPIO_NUM_NC,
+                .sclk_io_num = GPIO_NUM_38,
+                .quadwp_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
+                .quadhd_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
+                .data4_io_num = GPIO_NUM_NC,
+                .data5_io_num = GPIO_NUM_NC,
+                .data6_io_num = GPIO_NUM_NC,
+                .data7_io_num = GPIO_NUM_NC,
+                .data_io_default_level = false,
+                .max_transfer_sz = SPI_TRANSFER_SIZE_LIMIT,
+                .flags = 0,
+                .isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
+                .intr_flags = 0
+            },
+            .initMode = spi::InitMode::ByTactility,
+            .isMutable = false,
+            .lock = tt::lvgl::getSyncLock() // esp_lvgl_port owns the lock for the display
+        },
+        spi::Configuration {
+            .device = SPI3_HOST,
+            .dma = SPI_DMA_CH_AUTO,
+            .config = {
+                .mosi_io_num = GPIO_NUM_15,
+                .miso_io_num = GPIO_NUM_17,
+                .sclk_io_num = GPIO_NUM_16,
+                .data2_io_num = GPIO_NUM_NC,
+                .data3_io_num = GPIO_NUM_NC,
+                .data4_io_num = GPIO_NUM_NC,
+                .data5_io_num = GPIO_NUM_NC,
+                .data6_io_num = GPIO_NUM_NC,
+                .data7_io_num = GPIO_NUM_NC,
+                .data_io_default_level = false,
+                .max_transfer_sz = SPI_TRANSFER_SIZE_LIMIT,
+                .flags = 0,
+                .isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
+                .intr_flags = 0
+            },
+            .initMode = spi::InitMode::ByTactility,
+            .isMutable = false,
+            .lock = nullptr
+        }
+    },
+    .uart {}
+};

Boards/WaveshareS3TouchLcd147/Source/WaveshareS3TouchLcd147.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <Tactility/hal/Configuration.h>
+
+extern const tt::hal::Configuration waveshare_s3_touch_lcd_147;

Boards/WaveshareS3TouchLcd147/Source/devices/Axs5106Touch.cpp

@@ -0,0 +1,37 @@
+#include "Axs5106Touch.h"
+
+#include <esp_lcd_touch_axs5106.h>
+#include <esp_err.h>
+
+constexpr auto* TAG = "AXS5106";
+
+bool Axs5106Touch::createIoHandle(esp_lcd_panel_io_handle_t& outHandle) {
+    esp_lcd_panel_io_i2c_config_t io_config = ESP_LCD_TOUCH_IO_I2C_AXS5106_CONFIG();
+    return esp_lcd_new_panel_io_i2c(configuration->port, &io_config, &outHandle) == ESP_OK;
+}
+
+bool Axs5106Touch::createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& panelHandle) {
+    return esp_lcd_touch_new_i2c_axs5106(ioHandle, &configuration, &panelHandle) == ESP_OK;
+}
+
+esp_lcd_touch_config_t Axs5106Touch::createEspLcdTouchConfig() {
+    return {
+        .x_max = configuration->xMax,
+        .y_max = configuration->yMax,
+        .rst_gpio_num = configuration->pinReset,
+        .int_gpio_num = configuration->pinInterrupt,
+        .levels = {
+            .reset = configuration->pinResetLevel,
+            .interrupt = configuration->pinInterruptLevel,
+        },
+        .flags = {
+            .swap_xy = configuration->swapXy,
+            .mirror_x = configuration->mirrorX,
+            .mirror_y = configuration->mirrorY,
+        },
+        .process_coordinates = nullptr,
+        .interrupt_callback = nullptr,
+        .user_data = nullptr,
+        .driver_data = nullptr
+    };
+}

Boards/WaveshareS3TouchLcd147/Source/devices/Axs5106Touch.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <Tactility/hal/touch/TouchDevice.h>
+#include <Tactility/TactilityCore.h>
+#include <driver/i2c.h>
+
+#include <EspLcdTouch.h>
+
+class Axs5106Touch final : public EspLcdTouch {
+
+public:
+
+    class Configuration {
+    public:
+
+        Configuration(
+            i2c_port_t port,
+            uint16_t xMax,
+            uint16_t yMax,
+            bool swapXy = false,
+            bool mirrorX = false,
+            bool mirrorY = false,
+            gpio_num_t pinReset = GPIO_NUM_NC,
+            gpio_num_t pinInterrupt = GPIO_NUM_NC,
+            unsigned int pinResetLevel = 0,
+            unsigned int pinInterruptLevel = 0
+        ) : port(port),
+            xMax(xMax),
+            yMax(yMax),
+            swapXy(swapXy),
+            mirrorX(mirrorX),
+            mirrorY(mirrorY),
+            pinReset(pinReset),
+            pinInterrupt(pinInterrupt),
+            pinResetLevel(pinResetLevel),
+            pinInterruptLevel(pinInterruptLevel)
+        {}
+
+        i2c_port_t port;
+        uint16_t xMax;
+        uint16_t yMax;
+        bool swapXy;
+        bool mirrorX;
+        bool mirrorY;
+        gpio_num_t pinReset;
+        gpio_num_t pinInterrupt;
+        unsigned int pinResetLevel;
+        unsigned int pinInterruptLevel;
+    };
+
+private:
+
+    std::unique_ptr<Configuration> configuration;
+
+    bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle) override;
+
+    bool createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& panelHandle) override;
+
+    esp_lcd_touch_config_t createEspLcdTouchConfig() override;
+
+public:
+
+    explicit Axs5106Touch(std::unique_ptr<Configuration> inConfiguration) : configuration(std::move(inConfiguration)) {
+        assert(configuration != nullptr);
+    }
+
+    std::string getName() const override { return "AXS5106"; }
+
+    std::string getDescription() const override { return "AXS5106 I2C touch driver"; }
+};

Boards/WaveshareS3TouchLcd147/Source/devices/Display.cpp

@@ -0,0 +1,52 @@
+#include "Display.h"
+#include "Jd9853Display.h"
+#include "Axs5106Touch.h"
+
+constexpr auto LCD_SPI_HOST = SPI2_HOST;
+constexpr auto LCD_PIN_CS = GPIO_NUM_21;
+constexpr auto LCD_PIN_DC = GPIO_NUM_45;
+constexpr auto LCD_PIN_RESET = GPIO_NUM_40;
+constexpr auto LCD_HORIZONTAL_RESOLUTION = 172;
+constexpr auto LCD_VERTICAL_RESOLUTION = 320;
+constexpr auto LCD_SPI_TRANSFER_HEIGHT = (LCD_VERTICAL_RESOLUTION / 10);
+
+void setBacklightDuty(uint8_t level);
+
+static std::shared_ptr<tt::hal::touch::TouchDevice> createTouch() {
+    // Note for future changes: Reset pin is 48 and interrupt pin is 47
+    auto configuration = std::make_unique<Axs5106Touch::Configuration>(
+        I2C_NUM_0,
+        172,
+        320,
+        false,
+        false,
+        false,
+        GPIO_NUM_47,
+        GPIO_NUM_48
+    );
+
+    return std::make_shared<Axs5106Touch>(std::move(configuration));
+}
+
+std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
+    auto touch = createTouch();
+
+    auto configuration = std::make_unique<Jd9853Display::Configuration>(
+        LCD_SPI_HOST,
+        LCD_PIN_CS,
+        LCD_PIN_DC,
+        LCD_PIN_RESET,
+        172,
+        320,
+        touch,
+        false,
+        false,
+        false,
+        true
+    );
+
+    configuration->backlightDutyFunction = setBacklightDuty;
+
+    auto display = std::make_shared<Jd9853Display>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
+}

Boards/WaveshareS3TouchLcd147/Source/devices/Display.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <Tactility/hal/display/DisplayDevice.h>
+
+std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/WaveshareS3TouchLcd147/Source/devices/Jd9853Display.cpp

@@ -0,0 +1,162 @@
+#include "Jd9853Display.h"
+
+#include <Tactility/Log.h>
+
+#include <esp_lcd_jd9853.h>
+#include <esp_lcd_panel_commands.h>
+#include <esp_lvgl_port.h>
+
+constexpr const char* TAG = "JD9853";
+
+bool Jd9853Display::createIoHandle(esp_lcd_panel_io_handle_t& outHandle) {
+    const esp_lcd_panel_io_spi_config_t panel_io_config = {
+        .cs_gpio_num = configuration->csPin,
+        .dc_gpio_num = configuration->dcPin,
+        .spi_mode = 0,
+        .pclk_hz = configuration->pixelClockFrequency,
+        .trans_queue_depth = configuration->transactionQueueDepth,
+        .on_color_trans_done = nullptr,
+        .user_ctx = nullptr,
+        .lcd_cmd_bits = 8,
+        .lcd_param_bits = 8,
+        .cs_ena_pretrans = 0,
+        .cs_ena_posttrans = 0,
+        .flags = {
+            .dc_high_on_cmd = 0,
+            .dc_low_on_data = 0,
+            .dc_low_on_param = 0,
+            .octal_mode = 0,
+            .quad_mode = 0,
+            .sio_mode = 0,
+            .lsb_first = 0,
+            .cs_high_active = 0
+        }
+    };
+
+    return esp_lcd_new_panel_io_spi(configuration->spiHostDevice, &panel_io_config, &outHandle) == ESP_OK;
+}
+
+bool Jd9853Display::createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) {
+    jd9853_vendor_config_t vendor_config = {
+        .init_cmds = nullptr,
+        .init_cmds_size = 0
+    };
+
+    const esp_lcd_panel_dev_config_t panel_config = {
+        .reset_gpio_num = configuration->resetPin,
+        .rgb_ele_order = configuration->rgbElementOrder,
+        .data_endian = LCD_RGB_DATA_ENDIAN_LITTLE,
+        .bits_per_pixel = 16,
+        .flags = {
+            .reset_active_high = false
+        },
+        .vendor_config = &vendor_config
+    };
+
+    if (esp_lcd_new_panel_jd9853(ioHandle, &panel_config, &panelHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to create panel");
+        return false;
+    }
+
+    if (esp_lcd_panel_reset(panelHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to reset panel");
+        return false;
+    }
+
+    if (esp_lcd_panel_init(panelHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to init panel");
+        return false;
+    }
+
+    if (esp_lcd_panel_swap_xy(panelHandle, configuration->swapXY) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to swap XY ");
+        return false;
+    }
+
+    if (esp_lcd_panel_mirror(panelHandle, configuration->mirrorX, configuration->mirrorY) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set panel to mirror");
+        return false;
+    }
+
+    if (esp_lcd_panel_invert_color(panelHandle, configuration->invertColor) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set panel to invert");
+        return false;
+    }
+
+    if (esp_lcd_panel_disp_on_off(panelHandle, true) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to turn display on");
+        return false;
+    }
+
+    if (esp_lcd_panel_set_gap(panelHandle, 34, 0) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set panel gap");
+        return false;
+    }
+
+    return true;
+}
+
+lvgl_port_display_cfg_t Jd9853Display::getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) {
+    return {
+        .io_handle = ioHandle,
+        .panel_handle = panelHandle,
+        .control_handle = nullptr,
+        .buffer_size = configuration->bufferSize,
+        .double_buffer = false,
+        .trans_size = 0,
+        .hres = configuration->horizontalResolution,
+        .vres = configuration->verticalResolution,
+        .monochrome = false,
+        .rotation = {
+            .swap_xy = configuration->swapXY,
+            .mirror_x = configuration->mirrorX,
+            .mirror_y = configuration->mirrorY,
+        },
+        .color_format = LV_COLOR_FORMAT_RGB565,
+        .flags = {
+            .buff_dma = true,
+            .buff_spiram = false,
+            .sw_rotate = false,
+            .swap_bytes = true,
+            .full_refresh = false,
+            .direct_mode = false
+        }
+    };
+}
+
+/**
+ * Note:
+ * The datasheet implies this should work, but it doesn't:
+ * https://www.digikey.com/htmldatasheets/production/1640716/0/0/1/ILI9341-Datasheet.pdf
+ *
+ * This repo claims it only has 1 curve:
+ * https://github.com/brucemack/hello-ili9341
+ *
+ * I'm leaving it in as I'm not sure if it's just my hardware that's problematic.
+ */
+void Jd9853Display::setGammaCurve(uint8_t index) {
+    uint8_t gamma_curve;
+    switch (index) {
+        case 0:
+            gamma_curve = 0x01;
+            break;
+        case 1:
+            gamma_curve = 0x04;
+            break;
+        case 2:
+            gamma_curve = 0x02;
+            break;
+        case 3:
+            gamma_curve = 0x08;
+            break;
+        default:
+            return;
+    }
+    const uint8_t param[] = {
+        gamma_curve
+    };
+
+    if (esp_lcd_panel_io_tx_param(getIoHandle() , LCD_CMD_GAMSET, param, 1) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set gamma");
+    }
+}

Boards/WaveshareS3TouchLcd147/Source/devices/Jd9853Display.h

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <Tactility/hal/display/DisplayDevice.h>
+#include <Tactility/hal/spi/Spi.h>
+
+#include <EspLcdDisplay.h>
+
+#include <driver/gpio.h>
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_types.h>
+#include <functional>
+#include <lvgl.h>
+
+class Jd9853Display final : public EspLcdDisplay {
+
+public:
+
+    class Configuration {
+
+    public:
+
+        Configuration(
+            spi_host_device_t spiHostDevice,
+            gpio_num_t csPin,
+            gpio_num_t dcPin,
+            gpio_num_t resetPin,
+            unsigned int horizontalResolution,
+            unsigned int verticalResolution,
+            std::shared_ptr<tt::hal::touch::TouchDevice> touch,
+            bool swapXY = false,
+            bool mirrorX = false,
+            bool mirrorY = false,
+            bool invertColor = false,
+            uint32_t bufferSize = 0, // Size in pixel count. 0 means default, which is 1/10 of the screen size,
+            lcd_rgb_element_order_t rgbElementOrder = LCD_RGB_ELEMENT_ORDER_RGB
+        ) : spiHostDevice(spiHostDevice),
+            csPin(csPin),
+            dcPin(dcPin),
+            resetPin(resetPin),
+            horizontalResolution(horizontalResolution),
+            verticalResolution(verticalResolution),
+            swapXY(swapXY),
+            mirrorX(mirrorX),
+            mirrorY(mirrorY),
+            invertColor(invertColor),
+            bufferSize(bufferSize),
+            rgbElementOrder(rgbElementOrder),
+            touch(std::move(touch)
+        ) {
+            if (this->bufferSize == 0) {
+                this->bufferSize = horizontalResolution * verticalResolution / 10;
+            }
+        }
+
+        spi_host_device_t spiHostDevice;
+        gpio_num_t csPin;
+        gpio_num_t dcPin;
+        gpio_num_t resetPin;
+        unsigned int pixelClockFrequency = 40'000'000; // Hertz
+        size_t transactionQueueDepth = 10;
+        unsigned int horizontalResolution;
+        unsigned int verticalResolution;
+        bool swapXY;
+        bool mirrorX;
+        bool mirrorY;
+        bool invertColor;
+        uint32_t bufferSize; // Size in pixel count. 0 means default, which is 1/10 of the screen size
+        lcd_rgb_element_order_t rgbElementOrder;
+        std::shared_ptr<tt::hal::touch::TouchDevice> touch;
+        std::function<void(uint8_t)> _Nullable backlightDutyFunction = nullptr;
+    };
+
+private:
+
+    std::unique_ptr<Configuration> configuration;
+
+    bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle) override;
+
+    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) override;
+
+    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) override;
+
+public:
+
+    explicit Jd9853Display(std::unique_ptr<Configuration> inConfiguration) :
+        EspLcdDisplay(tt::hal::spi::getLock(inConfiguration->spiHostDevice)),
+        configuration(std::move(inConfiguration)
+    ) {
+        assert(configuration != nullptr);
+    }
+
+    std::string getName() const override { return "JD9853"; }
+
+    std::string getDescription() const override { return "JD9853 display"; }
+
+    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable getTouchDevice() override { return configuration->touch; }
+
+    void setBacklightDuty(uint8_t backlightDuty) override {
+        if (configuration->backlightDutyFunction != nullptr) {
+            configuration->backlightDutyFunction(backlightDuty);
+        }
+    }
+
+    bool supportsBacklightDuty() const override { return configuration->backlightDutyFunction != nullptr; }
+
+    void setGammaCurve(uint8_t index) override;
+
+    uint8_t getGammaCurveCount() const override { return 4; };
+};

Boards/WaveshareS3TouchLcd147/Source/devices/Sdcard.cpp

@@ -0,0 +1,26 @@
+#include "Sdcard.h"
+
+#include <Tactility/lvgl/LvglSync.h>
+#include <Tactility/hal/sdcard/SpiSdCardDevice.h>
+
+using tt::hal::sdcard::SpiSdCardDevice;
+
+constexpr auto SDCARD_PIN_CS = GPIO_NUM_14;
+constexpr auto LCD_PIN_CS = GPIO_NUM_21;
+
+std::shared_ptr<SdCardDevice> createSdCard() {
+    auto configuration = std::make_unique<SpiSdCardDevice::Config>(
+        SDCARD_PIN_CS,
+        GPIO_NUM_NC,
+        GPIO_NUM_NC,
+        GPIO_NUM_NC,
+        SdCardDevice::MountBehaviour::AtBoot,
+        tt::hal::spi::getLock(SPI3_HOST),
+        std::vector { LCD_PIN_CS },
+        SPI3_HOST
+    );
+
+    return std::make_shared<SpiSdCardDevice>(
+        std::move(configuration)
+    );
+}

Boards/WaveshareS3TouchLcd147/Source/devices/Sdcard.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <Tactility/hal/sdcard/SdCardDevice.h>
+
+using tt::hal::sdcard::SdCardDevice;
+
+std::shared_ptr<SdCardDevice> createSdCard();

Buildscripts/board.cmake

@@ -61,6 +61,8 @@ function(INIT_TACTILITY_GLOBALS SDKCONFIG_FILE)
         set(TACTILITY_BOARD_PROJECT UnPhone)
     elseif (board_id STREQUAL "waveshare-s3-touch-43")
         set(TACTILITY_BOARD_PROJECT WaveshareS3Touch43)
+    elseif (board_id STREQUAL "waveshare-s3-touch-lcd-147")
+        set(TACTILITY_BOARD_PROJECT WaveshareS3TouchLcd147)
     else ()
         set(TACTILITY_BOARD_PROJECT "")
     endif ()

Buildscripts/build-and-release-all.sh

@@ -75,6 +75,9 @@ release m5stack-cores3
 build waveshare-s3-touch-43
 release waveshare-s3-touch-43
 
+build waveshare-s3-touch-lcd-147
+release waveshare-s3-touch-lcd-147
+
 build unphone
 release unphone
 

Documentation/ideas.md

@@ -16,6 +16,7 @@
 - CrowPanel Basic 3.5": check why System Info doesn't show storage info
 - Update to LVGL v9.3 stable
 - Files app: delete folder recursively
+- Create `app::getSettingsPath()` to get paths to properties files by first trying sd card and then trying `/data`
 
 ## Medium Priority
 
@@ -29,6 +30,7 @@
 
 ## Lower Priority
 
+- The boot button on some devices can be used as GPIO_NUM_0 at runtime
 - Localize all apps
 - Support hot-plugging SD card (note: this is not possible if they require the CS pin hack)
 - Explore LVGL9's FreeRTOS functionality

Drivers/AXS5106/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS "esp_lcd_touch_axs5106.c"
+                    INCLUDE_DIRS "include"
+                    REQUIRES "esp_lcd" "driver" "espressif__esp_lcd_touch")

Drivers/AXS5106/README.md

@@ -0,0 +1,7 @@
+# AXS5106
+
+I2C touch driver.
+
+Source: https://files.waveshare.com/wiki/1.47inch%20Touch%20LCD/1.47inch_Touch_LCD_Demo_ESP32.zip
+
+License: Apache 2.0

Drivers/AXS5106/esp_lcd_touch_axs5106.c

@@ -0,0 +1,260 @@
+#include <stdio.h>
+#include "esp_lcd_touch_axs5106.h"
+
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_check.h"
+#include "driver/gpio.h"
+#include "esp_lcd_panel_io.h"
+#include "esp_lcd_touch.h"
+
+static const char *TAG = "esp_lcd_touch_axs5106";
+
+#define TOUCH_AXS5106_TOUCH_POINTS_REG (0X01)
+#define TOUCH_AXS5106_TOUCH_P1_XH_REG (0x03)
+#define TOUCH_AXS5106_TOUCH_P1_XL_REG (0x04)
+#define TOUCH_AXS5106_TOUCH_P1_YH_REG (0x05)
+#define TOUCH_AXS5106_TOUCH_P1_YL_REG (0x06)
+
+#define TOUCH_AXS5106_TOUCH_ID_REG (0x08)
+#define TOUCH_AXS5106_TOUCH_P2_XH_REG (0x09)
+#define TOUCH_AXS5106_TOUCH_P2_XL_REG (0x0A)
+#define TOUCH_AXS5106_TOUCH_P2_YH_REG (0x0B)
+#define TOUCH_AXS5106_TOUCH_P2_YL_REG (0x0C)
+
+/*******************************************************************************
+ * Function definitions
+ *******************************************************************************/
+static esp_err_t esp_lcd_touch_axs5106_read_data(esp_lcd_touch_handle_t tp);
+static bool esp_lcd_touch_axs5106_get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
+static esp_err_t esp_lcd_touch_axs5106_del(esp_lcd_touch_handle_t tp);
+
+/* I2C read */
+static esp_err_t touch_axs5106_i2c_write(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t *data, uint8_t len);
+static esp_err_t touch_axs5106_i2c_read(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t *data, uint8_t len);
+
+/* AXS5106 init */
+static esp_err_t touch_axs5106_init(esp_lcd_touch_handle_t tp);
+/* AXS5106 reset */
+static esp_err_t touch_axs5106_reset(esp_lcd_touch_handle_t tp);
+
+esp_err_t esp_lcd_touch_new_i2c_axs5106(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *out_touch)
+{
+    esp_err_t ret = ESP_OK;
+    assert(io != NULL);
+    assert(config != NULL);
+    assert(out_touch != NULL);
+
+    /* Prepare main structure */
+    esp_lcd_touch_handle_t esp_lcd_touch_axs5106 = heap_caps_calloc(1, sizeof(esp_lcd_touch_t), MALLOC_CAP_DEFAULT);
+    ESP_GOTO_ON_FALSE(esp_lcd_touch_axs5106, ESP_ERR_NO_MEM, err, TAG, "no mem for AXS5106 controller");
+
+    /* Communication interface */
+    esp_lcd_touch_axs5106->io = io;
+
+    /* Only supported callbacks are set */
+    esp_lcd_touch_axs5106->read_data = esp_lcd_touch_axs5106_read_data;
+    esp_lcd_touch_axs5106->get_xy = esp_lcd_touch_axs5106_get_xy;
+    esp_lcd_touch_axs5106->del = esp_lcd_touch_axs5106_del;
+
+    /* Mutex */
+    esp_lcd_touch_axs5106->data.lock.owner = portMUX_FREE_VAL;
+
+    /* Save config */
+    memcpy(&esp_lcd_touch_axs5106->config, config, sizeof(esp_lcd_touch_config_t));
+
+    /* Prepare pin for touch interrupt */
+    if (esp_lcd_touch_axs5106->config.int_gpio_num != GPIO_NUM_NC)
+    {
+        const gpio_config_t int_gpio_config = {
+            .mode = GPIO_MODE_INPUT,
+            .intr_type = (esp_lcd_touch_axs5106->config.levels.interrupt ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE),
+            .pin_bit_mask = BIT64(esp_lcd_touch_axs5106->config.int_gpio_num)};
+        ret = gpio_config(&int_gpio_config);
+        ESP_GOTO_ON_ERROR(ret, err, TAG, "GPIO config failed");
+
+        /* Register interrupt callback */
+        if (esp_lcd_touch_axs5106->config.interrupt_callback)
+        {
+            esp_lcd_touch_register_interrupt_callback(esp_lcd_touch_axs5106, esp_lcd_touch_axs5106->config.interrupt_callback);
+        }
+    }
+
+    /* Prepare pin for touch controller reset */
+    if (esp_lcd_touch_axs5106->config.rst_gpio_num != GPIO_NUM_NC)
+    {
+        const gpio_config_t rst_gpio_config = {
+            .mode = GPIO_MODE_OUTPUT,
+            .pin_bit_mask = BIT64(esp_lcd_touch_axs5106->config.rst_gpio_num)};
+        ret = gpio_config(&rst_gpio_config);
+        ESP_GOTO_ON_ERROR(ret, err, TAG, "GPIO config failed");
+    }
+
+    /* Reset controller */
+    ret = touch_axs5106_reset(esp_lcd_touch_axs5106);
+    ESP_GOTO_ON_ERROR(ret, err, TAG, "AXS5106 reset failed");
+
+    /* Init controller */
+    ret = touch_axs5106_init(esp_lcd_touch_axs5106);
+    ESP_GOTO_ON_ERROR(ret, err, TAG, "AXS5106 init failed");
+
+    uint8_t data[3] = { 0 };
+    if (touch_axs5106_i2c_read(esp_lcd_touch_axs5106, TOUCH_AXS5106_TOUCH_ID_REG, data, 3) == ESP_OK) {
+        if (data[0] != 0x00) {
+            ESP_LOGI(TAG, "Read: %02x %02x %02x", data[0], data[1], data[2]);
+        } else {
+            ESP_LOGW(TAG, "Failed to read id: received zeroes");
+        }
+    } else {
+        ESP_LOGE(TAG, "Failed to read id: receive failed");
+    }
+
+err:
+    if (ret != ESP_OK)
+    {
+        ESP_LOGE(TAG, "Error (0x%x)! Touch controller AXS5106 initialization failed!", ret);
+        if (esp_lcd_touch_axs5106)
+        {
+            esp_lcd_touch_axs5106_del(esp_lcd_touch_axs5106);
+        }
+    }
+
+    *out_touch = esp_lcd_touch_axs5106;
+
+    return ret;
+}
+
+static esp_err_t esp_lcd_touch_axs5106_read_data(esp_lcd_touch_handle_t tp)
+{
+    uint8_t data[30] = {0};
+    size_t i = 0;
+
+    assert(tp != NULL);
+
+    esp_err_t err = touch_axs5106_i2c_read(tp, TOUCH_AXS5106_TOUCH_POINTS_REG, data, 14);
+    ESP_RETURN_ON_ERROR(err, TAG, "I2C read error: %s", esp_err_to_name(err));
+
+    uint8_t points = data[1];
+    points = points & 0x0F;
+
+    if (points == 0)
+    {
+        return ESP_OK;
+    }
+
+    /* Number of touched points */
+    points = (points > 2 ? 2 : points);
+
+    // err = touch_axs5106_i2c_read(tp, TOUCH_AXS5106_TOUCH_P1_XH_REG, data, 6 * points);
+    // ESP_RETURN_ON_ERROR(err, TAG, "I2C read error!");
+
+    portENTER_CRITICAL(&tp->data.lock);
+
+    /* Number of touched points */
+    tp->data.points = points;
+
+    /* Fill all coordinates */
+    for (i = 0; i < points; i++)
+    {
+        tp->data.coords[i].y = (((uint16_t)(data[4 + i * 6] & 0x0f)) << 8);
+        tp->data.coords[i].y |= data[5 + i * 6];
+        tp->data.coords[i].x = ((uint16_t)(data[2 + i * 6] & 0x0f)) << 8;
+        tp->data.coords[i].x |= data[3 + i * 6];
+    }
+    portEXIT_CRITICAL(&tp->data.lock);
+    return ESP_OK;
+}
+
+static bool esp_lcd_touch_axs5106_get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num)
+{
+    assert(tp != NULL);
+    assert(x != NULL);
+    assert(y != NULL);
+    assert(point_num != NULL);
+    assert(max_point_num > 0);
+
+    portENTER_CRITICAL(&tp->data.lock);
+
+    /* Count of points */
+    *point_num = (tp->data.points > max_point_num ? max_point_num : tp->data.points);
+
+    for (size_t i = 0; i < *point_num; i++)
+    {
+        x[i] = tp->data.coords[i].x;
+        y[i] = tp->data.coords[i].y;
+
+        if (strength)
+        {
+            strength[i] = tp->data.coords[i].strength;
+        }
+    }
+
+    /* Invalidate */
+    tp->data.points = 0;
+
+    portEXIT_CRITICAL(&tp->data.lock);
+
+    return (*point_num > 0);
+}
+
+static esp_err_t esp_lcd_touch_axs5106_del(esp_lcd_touch_handle_t tp)
+{
+    assert(tp != NULL);
+
+    /* Reset GPIO pin settings */
+    if (tp->config.int_gpio_num != GPIO_NUM_NC)
+    {
+        gpio_reset_pin(tp->config.int_gpio_num);
+        if (tp->config.interrupt_callback)
+        {
+            gpio_isr_handler_remove(tp->config.int_gpio_num);
+        }
+    }
+
+    /* Reset GPIO pin settings */
+    if (tp->config.rst_gpio_num != GPIO_NUM_NC)
+    {
+        gpio_reset_pin(tp->config.rst_gpio_num);
+    }
+
+    free(tp);
+
+    return ESP_OK;
+}
+
+static esp_err_t touch_axs5106_i2c_write(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t *data, uint8_t len)
+{
+    assert(tp != NULL);
+    return esp_lcd_panel_io_tx_param(tp->io, reg, data, len);
+}
+
+static esp_err_t touch_axs5106_i2c_read(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t *data, uint8_t len)
+{
+    assert(tp != NULL);
+    assert(data != NULL);
+    return esp_lcd_panel_io_rx_param(tp->io, reg, data, len);
+}
+
+static esp_err_t touch_axs5106_init(esp_lcd_touch_handle_t tp)
+{
+    return ESP_OK;
+}
+
+static esp_err_t touch_axs5106_reset(esp_lcd_touch_handle_t tp)
+{
+    assert(tp != NULL);
+
+    if (tp->config.rst_gpio_num != GPIO_NUM_NC)
+    {
+        ESP_RETURN_ON_ERROR(gpio_set_level(tp->config.rst_gpio_num, tp->config.levels.reset), TAG, "GPIO set level error!");
+        vTaskDelay(pdMS_TO_TICKS(10));
+        ESP_RETURN_ON_ERROR(gpio_set_level(tp->config.rst_gpio_num, !tp->config.levels.reset), TAG, "GPIO set level error!");
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+
+    return ESP_OK;
+}

Drivers/AXS5106/include/esp_lcd_touch_axs5106.h

@@ -0,0 +1,59 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file
+ * @brief ESP LCD touch: AXS5106
+ */
+
+#pragma once
+
+#include "esp_lcd_touch.h"
+#include "driver/i2c_master.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Create a new AXS5106 touch driver
+ *
+ * @note The I2C communication should be initialized before use this function.
+ *
+ * @param io LCD/Touch panel IO handle
+ * @param config: Touch configuration
+ * @param out_touch: Touch instance handle
+ * @return
+ *      - ESP_OK                    on success
+ *      - ESP_ERR_NO_MEM            if there is no memory for allocating main structure
+ */
+esp_err_t esp_lcd_touch_new_i2c_axs5106(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *out_touch);
+
+/**
+ * @brief I2C address of the AXS5106 controller
+ *
+ */
+#define ESP_LCD_TOUCH_IO_I2C_AXS5106_ADDRESS (0x63)
+
+/**
+ * @brief Touch IO configuration structure
+ *
+ */
+#define ESP_LCD_TOUCH_IO_I2C_AXS5106_CONFIG()           \
+    {                                       \
+        .dev_addr = ESP_LCD_TOUCH_IO_I2C_AXS5106_ADDRESS, \
+        .control_phase_bytes = 1,           \
+        .dc_bit_offset = 0,                 \
+        .lcd_cmd_bits = 8,                  \
+        .flags =                            \
+        {                                   \
+            .disable_control_phase = 1,     \
+        }                                   \
+    }
+
+
+#ifdef __cplusplus
+}
+#endif

Drivers/JD9853/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS "esp_lcd_jd9853.c"
+                    INCLUDE_DIRS "include"
+                    REQUIRES "esp_lcd" "driver")

Drivers/JD9853/README.md

@@ -0,0 +1,7 @@
+# JD9853
+
+SPI display driver.
+
+Source: https://files.waveshare.com/wiki/1.47inch%20Touch%20LCD/1.47inch_Touch_LCD_Demo_ESP32.zip
+
+License: Apache 2.0

Drivers/JD9853/esp_lcd_jd9853.c

@@ -0,0 +1,460 @@
+#include <stdio.h>
+#include "esp_lcd_jd9853.h"
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#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"
+
+static const char *TAG = "JD9853";
+
+static esp_err_t panel_jd9853_del(esp_lcd_panel_t *panel);
+static esp_err_t panel_jd9853_reset(esp_lcd_panel_t *panel);
+static esp_err_t panel_jd9853_init(esp_lcd_panel_t *panel);
+static esp_err_t panel_jd9853_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data);
+static esp_err_t panel_jd9853_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
+static esp_err_t panel_jd9853_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
+static esp_err_t panel_jd9853_swap_xy(esp_lcd_panel_t *panel, bool swap_axes);
+static esp_err_t panel_jd9853_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap);
+static esp_err_t panel_jd9853_disp_on_off(esp_lcd_panel_t *panel, bool off);
+
+typedef struct
+{
+    esp_lcd_panel_t base;
+    esp_lcd_panel_io_handle_t io;
+    int reset_gpio_num;
+    bool reset_level;
+    int x_gap;
+    int y_gap;
+    uint8_t fb_bits_per_pixel;
+    uint8_t madctl_val; // save current value of LCD_CMD_MADCTL register
+    uint8_t colmod_val; // save current value of LCD_CMD_COLMOD register
+    const jd9853_lcd_init_cmd_t *init_cmds;
+    uint16_t init_cmds_size;
+} jd9853_panel_t;
+
+esp_err_t esp_lcd_new_panel_jd9853(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_err_t ret = ESP_OK;
+    jd9853_panel_t *jd9853 = NULL;
+    gpio_config_t io_conf = {0};
+
+    ESP_GOTO_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    jd9853 = (jd9853_panel_t *)calloc(1, sizeof(jd9853_panel_t));
+    ESP_GOTO_ON_FALSE(jd9853, ESP_ERR_NO_MEM, err, TAG, "no mem for jd9853 panel");
+
+    if (panel_dev_config->reset_gpio_num >= 0)
+    {
+        io_conf.mode = GPIO_MODE_OUTPUT;
+        io_conf.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");
+    }
+
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
+    switch (panel_dev_config->color_space)
+    {
+    case ESP_LCD_COLOR_SPACE_RGB:
+        jd9853->madctl_val = 0;
+        break;
+    case ESP_LCD_COLOR_SPACE_BGR:
+        jd9853->madctl_val |= LCD_CMD_BGR_BIT;
+        break;
+    default:
+        ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported color space");
+        break;
+    }
+#else
+    switch (panel_dev_config->rgb_endian)
+    {
+    case LCD_RGB_ENDIAN_RGB:
+        jd9853->madctl_val = 0;
+        break;
+    case LCD_RGB_ENDIAN_BGR:
+        jd9853->madctl_val |= LCD_CMD_BGR_BIT;
+        break;
+    default:
+        ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported rgb endian");
+        break;
+    }
+#endif
+
+    switch (panel_dev_config->bits_per_pixel)
+    {
+    case 16: // RGB565
+        jd9853->colmod_val = 0x55;
+        jd9853->fb_bits_per_pixel = 16;
+        break;
+    case 18: // RGB666
+        jd9853->colmod_val = 0x66;
+        // each color component (R/G/B) should occupy the 6 high bits of a byte, which means 3 full bytes are required for a pixel
+        jd9853->fb_bits_per_pixel = 24;
+        break;
+    default:
+        ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported pixel width");
+        break;
+    }
+
+    jd9853->io = io;
+    jd9853->reset_gpio_num = panel_dev_config->reset_gpio_num;
+    jd9853->reset_level = panel_dev_config->flags.reset_active_high;
+    if (panel_dev_config->vendor_config)
+    {
+        jd9853->init_cmds = ((jd9853_vendor_config_t *)panel_dev_config->vendor_config)->init_cmds;
+        jd9853->init_cmds_size = ((jd9853_vendor_config_t *)panel_dev_config->vendor_config)->init_cmds_size;
+    }
+    jd9853->base.del = panel_jd9853_del;
+    jd9853->base.reset = panel_jd9853_reset;
+    jd9853->base.init = panel_jd9853_init;
+    jd9853->base.draw_bitmap = panel_jd9853_draw_bitmap;
+    jd9853->base.invert_color = panel_jd9853_invert_color;
+    jd9853->base.set_gap = panel_jd9853_set_gap;
+    jd9853->base.mirror = panel_jd9853_mirror;
+    jd9853->base.swap_xy = panel_jd9853_swap_xy;
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
+    jd9853->base.disp_off = panel_jd9853_disp_on_off;
+#else
+    jd9853->base.disp_on_off = panel_jd9853_disp_on_off;
+#endif
+    *ret_panel = &(jd9853->base);
+    ESP_LOGD(TAG, "new jd9853 panel @%p", jd9853);
+
+    // ESP_LOGI(TAG, "LCD panel create success, version: %d.%d.%d", ESP_LCD_jd9853_VER_MAJOR, ESP_LCD_jd9853_VER_MINOR,
+    //          ESP_LCD_jd9853_VER_PATCH);
+
+    return ESP_OK;
+
+err:
+    if (jd9853)
+    {
+        if (panel_dev_config->reset_gpio_num >= 0)
+        {
+            gpio_reset_pin(panel_dev_config->reset_gpio_num);
+        }
+        free(jd9853);
+    }
+    return ret;
+}
+
+static esp_err_t panel_jd9853_del(esp_lcd_panel_t *panel)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+
+    if (jd9853->reset_gpio_num >= 0)
+    {
+        gpio_reset_pin(jd9853->reset_gpio_num);
+    }
+    ESP_LOGD(TAG, "del jd9853 panel @%p", jd9853);
+    free(jd9853);
+    return ESP_OK;
+}
+
+static esp_err_t panel_jd9853_reset(esp_lcd_panel_t *panel)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    esp_lcd_panel_io_handle_t io = jd9853->io;
+
+    // perform hardware reset
+    if (jd9853->reset_gpio_num >= 0)
+    {
+        gpio_set_level(jd9853->reset_gpio_num, jd9853->reset_level);
+        vTaskDelay(pdMS_TO_TICKS(10));
+        gpio_set_level(jd9853->reset_gpio_num, !jd9853->reset_level);
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    else
+    { // 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;
+}
+
+typedef struct
+{
+    uint8_t cmd;
+    uint8_t data[16];
+    uint8_t data_bytes; // Length of data in above data array; 0xFF = end of cmds.
+} lcd_init_cmd_t;
+
+// static const jd9853_lcd_init_cmd_t vendor_specific_init_default[] = {
+// //  {cmd, { data }, data_size, delay_ms}
+//     /* Power contorl B, power control = 0, DC_ENA = 1 */
+//     {0xCF, (uint8_t []){0x00, 0xAA, 0XE0}, 3, 0},
+//     /* Power on sequence control,
+//      * cp1 keeps 1 frame, 1st frame enable
+//      * vcl = 0, ddvdh=3, vgh=1, vgl=2
+//      * DDVDH_ENH=1
+//      */
+//     {0xED, (uint8_t []){0x67, 0x03, 0X12, 0X81}, 4, 0},
+//     /* Driver timing control A,
+//      * non-overlap=default +1
+//      * EQ=default - 1, CR=default
+//      * pre-charge=default - 1
+//      */
+//     {0xE8, (uint8_t []){0x8A, 0x01, 0x78}, 3, 0},
+//     /* Power control A, Vcore=1.6V, DDVDH=5.6V */
+//     {0xCB, (uint8_t []){0x39, 0x2C, 0x00, 0x34, 0x02}, 5, 0},
+//     /* Pump ratio control, DDVDH=2xVCl */
+//     {0xF7, (uint8_t []){0x20}, 1, 0},
+
+//     {0xF7, (uint8_t []){0x20}, 1, 0},
+//     /* Driver timing control, all=0 unit */
+//     {0xEA, (uint8_t []){0x00, 0x00}, 2, 0},
+//     /* Power control 1, GVDD=4.75V */
+//     {0xC0, (uint8_t []){0x23}, 1, 0},
+//     /* Power control 2, DDVDH=VCl*2, VGH=VCl*7, VGL=-VCl*3 */
+//     {0xC1, (uint8_t []){0x11}, 1, 0},
+//     /* VCOM control 1, VCOMH=4.025V, VCOML=-0.950V */
+//     {0xC5, (uint8_t []){0x43, 0x4C}, 2, 0},
+//     /* VCOM control 2, VCOMH=VMH-2, VCOML=VML-2 */
+//     {0xC7, (uint8_t []){0xA0}, 1, 0},
+//     /* Frame rate control, f=fosc, 70Hz fps */
+//     {0xB1, (uint8_t []){0x00, 0x1B}, 2, 0},
+//     /* Enable 3G, disabled */
+//     {0xF2, (uint8_t []){0x00}, 1, 0},
+//     /* Gamma set, curve 1 */
+//     {0x26, (uint8_t []){0x01}, 1, 0},
+//     /* Positive gamma correction */
+//     {0xE0, (uint8_t []){0x1F, 0x36, 0x36, 0x3A, 0x0C, 0x05, 0x4F, 0X87, 0x3C, 0x08, 0x11, 0x35, 0x19, 0x13, 0x00}, 15, 0},
+//     /* Negative gamma correction */
+//     {0xE1, (uint8_t []){0x00, 0x09, 0x09, 0x05, 0x13, 0x0A, 0x30, 0x78, 0x43, 0x07, 0x0E, 0x0A, 0x26, 0x2C, 0x1F}, 15, 0},
+//     /* Entry mode set, Low vol detect disabled, normal display */
+//     {0xB7, (uint8_t []){0x07}, 1, 0},
+//     /* Display function control */
+//     {0xB6, (uint8_t []){0x08, 0x82, 0x27}, 3, 0},
+// };
+
+static const jd9853_lcd_init_cmd_t vendor_specific_init_default[] = {
+    {0x11, (uint8_t []){ 0x00 }, 0, 120},
+    {0xDF, (uint8_t[]){0x98, 0x53}, 2, 0},
+    {0xDF, (uint8_t[]){0x98, 0x53}, 2, 0},
+    {0xB2, (uint8_t[]){0x23}, 1, 0},
+    {0xB7, (uint8_t[]){0x00, 0x47, 0x00, 0x6F}, 4, 0},
+    {0xBB, (uint8_t[]){0x1C, 0x1A, 0x55, 0x73, 0x63, 0xF0}, 6, 0},
+    {0xC0, (uint8_t[]){0x44, 0xA4}, 2, 0},
+    {0xC1, (uint8_t[]){0x16}, 1, 0},
+    {0xC3, (uint8_t[]){0x7D, 0x07, 0x14, 0x06, 0xCF, 0x71, 0x72, 0x77}, 8, 0},
+    {0xC4, (uint8_t[]){0x00, 0x00, 0xA0, 0x79, 0x0B, 0x0A, 0x16, 0x79, 0x0B, 0x0A, 0x16, 0x82}, 12, 0},                                                                                                                         // 00=60Hz 06=57Hz 08=51Hz, LN=320 Line
+    {0xC8, (uint8_t[]){0x3F, 0x32, 0x29, 0x29, 0x27, 0x2B, 0x27, 0x28, 0x28, 0x26, 0x25, 0x17, 0x12, 0x0D, 0x04, 0x00, 0x3F, 0x32, 0x29, 0x29, 0x27, 0x2B, 0x27, 0x28, 0x28, 0x26, 0x25, 0x17, 0x12, 0x0D, 0x04, 0x00}, 32, 0}, // SET_R_GAMMA
+    {0xD0, (uint8_t[]){0x04, 0x06, 0x6B, 0x0F, 0x00}, 5, 0},
+    {0xD7, (uint8_t[]){0x00, 0x30}, 2, 0},
+    {0xE6, (uint8_t[]){0x14}, 1, 0},
+    {0xDE, (uint8_t[]){0x01}, 1, 0},
+    {0xB7, (uint8_t[]){0x03, 0x13, 0xEF, 0x35, 0x35}, 5, 0},
+    {0xC1, (uint8_t[]){0x14, 0x15, 0xC0}, 3, 0},
+    {0xC2, (uint8_t[]){0x06, 0x3A}, 2, 0},
+    {0xC4, (uint8_t[]){0x72, 0x12}, 2, 0},
+    {0xBE, (uint8_t[]){0x00}, 1, 0},
+    {0xDE, (uint8_t[]){0x02}, 1, 0},
+    {0xE5, (uint8_t[]){0x00, 0x02, 0x00}, 3, 0},
+    {0xE5, (uint8_t[]){0x01, 0x02, 0x00}, 3, 0},
+    {0xDE, (uint8_t[]){0x00}, 1, 0},
+    {0x35, (uint8_t[]){0x00}, 1, 0},
+    {0x3A, (uint8_t[]){0x05}, 1, 0},                   // 06=RGB666；05=RGB565
+    {0x2A, (uint8_t[]){0x00, 0x22, 0x00, 0xCD}, 4, 0}, // Start_X=34, End_X=205
+    {0x2B, (uint8_t[]){0x00, 0x00, 0x01, 0x3F}, 4, 0}, // Start_Y=0, End_Y=319
+    {0xDE, (uint8_t[]){0x02}, 1, 0},
+    {0xE5, (uint8_t[]){0x00, 0x02, 0x00}, 3, 0},
+    {0xDE, (uint8_t[]){0x00}, 1, 0},
+    {0x29, (uint8_t []){ 0x00 }, 0, 0},
+};
+
+static esp_err_t panel_jd9853_init(esp_lcd_panel_t *panel)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    esp_lcd_panel_io_handle_t io = jd9853->io;
+
+    // LCD goes into sleep mode and display will be turned off after power on reset, exit sleep mode first
+    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0), TAG, "send command failed");
+    vTaskDelay(pdMS_TO_TICKS(100));
+    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]){
+                                                                          jd9853->madctl_val,
+                                                                      },
+                                                  1),
+                        TAG, "send command failed");
+    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD, (uint8_t[]){
+                                                                          jd9853->colmod_val,
+                                                                      },
+                                                  1),
+                        TAG, "send command failed");
+
+    const jd9853_lcd_init_cmd_t *init_cmds = NULL;
+    uint16_t init_cmds_size = 0;
+    if (jd9853->init_cmds)
+    {
+        init_cmds = jd9853->init_cmds;
+        init_cmds_size = jd9853->init_cmds_size;
+    }
+    else
+    {
+        init_cmds = vendor_specific_init_default;
+        init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(jd9853_lcd_init_cmd_t);
+    }
+
+    bool is_cmd_overwritten = false;
+    for (int i = 0; i < init_cmds_size; i++)
+    {
+        // Check if the command has been used or conflicts with the internal
+        switch (init_cmds[i].cmd)
+        {
+        case LCD_CMD_MADCTL:
+            is_cmd_overwritten = true;
+            jd9853->madctl_val = ((uint8_t *)init_cmds[i].data)[0];
+            break;
+        case LCD_CMD_COLMOD:
+            is_cmd_overwritten = true;
+            jd9853->colmod_val = ((uint8_t *)init_cmds[i].data)[0];
+            break;
+        default:
+            is_cmd_overwritten = false;
+            break;
+        }
+
+        if (is_cmd_overwritten)
+        {
+            ESP_LOGW(TAG, "The %02Xh command has been used and will be overwritten by external initialization sequence", init_cmds[i].cmd);
+        }
+
+        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));
+    }
+    ESP_LOGD(TAG, "send init commands success");
+
+    return ESP_OK;
+}
+
+static esp_err_t panel_jd9853_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    assert((x_start < x_end) && (y_start < y_end) && "start position must be smaller than end position");
+    esp_lcd_panel_io_handle_t io = jd9853->io;
+
+    x_start += jd9853->x_gap;
+    x_end += jd9853->x_gap;
+    y_start += jd9853->y_gap;
+    y_end += jd9853->y_gap;
+
+    // define an area of frame memory where MCU can access
+    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_CASET, (uint8_t[]){
+                                                                         (x_start >> 8) & 0xFF,
+                                                                         x_start & 0xFF,
+                                                                         ((x_end - 1) >> 8) & 0xFF,
+                                                                         (x_end - 1) & 0xFF,
+                                                                     },
+                                                  4),
+                        TAG, "send command failed");
+    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_RASET, (uint8_t[]){
+                                                                         (y_start >> 8) & 0xFF,
+                                                                         y_start & 0xFF,
+                                                                         ((y_end - 1) >> 8) & 0xFF,
+                                                                         (y_end - 1) & 0xFF,
+                                                                     },
+                                                  4),
+                        TAG, "send command failed");
+    // transfer frame buffer
+    size_t len = (x_end - x_start) * (y_end - y_start) * jd9853->fb_bits_per_pixel / 8;
+    esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, color_data, len);
+
+    return ESP_OK;
+}
+
+static esp_err_t panel_jd9853_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    esp_lcd_panel_io_handle_t io = jd9853->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_jd9853_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    esp_lcd_panel_io_handle_t io = jd9853->io;
+    if (mirror_x)
+    {
+        jd9853->madctl_val |= LCD_CMD_MX_BIT;
+    }
+    else
+    {
+        jd9853->madctl_val &= ~LCD_CMD_MX_BIT;
+    }
+    if (mirror_y)
+    {
+        jd9853->madctl_val |= LCD_CMD_MY_BIT;
+    }
+    else
+    {
+        jd9853->madctl_val &= ~LCD_CMD_MY_BIT;
+    }
+    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]){jd9853->madctl_val}, 1), TAG, "send command failed");
+    return ESP_OK;
+}
+
+static esp_err_t panel_jd9853_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    esp_lcd_panel_io_handle_t io = jd9853->io;
+    if (swap_axes)
+    {
+        jd9853->madctl_val |= LCD_CMD_MV_BIT;
+    }
+    else
+    {
+        jd9853->madctl_val &= ~LCD_CMD_MV_BIT;
+    }
+    ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]){jd9853->madctl_val}, 1), TAG, "send command failed");
+    return ESP_OK;
+}
+
+static esp_err_t panel_jd9853_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    jd9853->x_gap = x_gap;
+    jd9853->y_gap = y_gap;
+    return ESP_OK;
+}
+
+static esp_err_t panel_jd9853_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
+{
+    jd9853_panel_t *jd9853 = __containerof(panel, jd9853_panel_t, base);
+    esp_lcd_panel_io_handle_t io = jd9853->io;
+    int command = 0;
+
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
+    on_off = !on_off;
+#endif
+
+    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;
+}

Drivers/JD9853/include/esp_lcd_jd9853.h

@@ -0,0 +1,102 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file
+ * @brief ESP LCD: jd9853
+ */
+
+#pragma once
+
+#include "hal/spi_ll.h"
+#include "esp_lcd_panel_vendor.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief LCD panel initialization commands.
+ *
+ */
+typedef struct {
+    int cmd;                /*<! The specific LCD command */
+    const void *data;       /*<! Buffer that holds the command specific data */
+    size_t data_bytes;      /*<! Size of `data` in memory, in bytes */
+    unsigned int delay_ms;  /*<! Delay in milliseconds after this command */
+} jd9853_lcd_init_cmd_t;
+
+/**
+ * @brief LCD panel vendor configuration.
+ *
+ * @note  This structure needs to be passed to the `vendor_config` field in `esp_lcd_panel_dev_config_t`.
+ *
+ */
+typedef struct {
+    const jd9853_lcd_init_cmd_t *init_cmds;     /*!< Pointer to initialization commands array. Set to NULL if using default commands.
+                                                 *   The array should be declared as `static const` and positioned outside the function.
+                                                 *   Please refer to `vendor_specific_init_default` in source file.
+                                                 */
+    uint16_t init_cmds_size;                    /*<! Number of commands in above array */
+} jd9853_vendor_config_t;
+
+/**
+ * @brief Create LCD panel for model jd9853
+ *
+ * @note  Vendor specific initialization can be different between manufacturers, should consult the LCD supplier for initialization sequence code.
+ *
+ * @param[in] io LCD panel IO handle
+ * @param[in] panel_dev_config general panel device configuration
+ * @param[out] ret_panel Returned LCD panel handle
+ * @return
+ *          - ESP_ERR_INVALID_ARG   if parameter is invalid
+ *          - ESP_ERR_NO_MEM        if out of memory
+ *          - ESP_OK                on success
+ */
+esp_err_t esp_lcd_new_panel_jd9853(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);
+
+/**
+ * @brief LCD panel bus configuration structure
+ *
+ * @param[in] sclk SPI clock pin number
+ * @param[in] mosi SPI MOSI pin number
+ * @param[in] max_trans_sz Maximum transfer size in bytes
+ *
+ */
+#define JD9853_PANEL_BUS_SPI_CONFIG(sclk, mosi, max_trans_sz)  \
+    {                                                           \
+        .sclk_io_num = sclk,                                    \
+        .mosi_io_num = mosi,                                    \
+        .miso_io_num = -1,                                      \
+        .quadhd_io_num = -1,                                    \
+        .quadwp_io_num = -1,                                    \
+        .max_transfer_sz = max_trans_sz,                        \
+    }
+
+/**
+ * @brief LCD panel IO configuration structure
+ *
+ * @param[in] cs SPI chip select pin number
+ * @param[in] dc SPI data/command pin number
+ * @param[in] cb Callback function when SPI transfer is done
+ * @param[in] cb_ctx Callback function context
+ *
+ */
+#define JD9853_PANEL_IO_SPI_CONFIG(cs, dc, callback, callback_ctx) \
+    {                                                               \
+        .cs_gpio_num = cs,                                          \
+        .dc_gpio_num = dc,                                          \
+        .spi_mode = 0,                                              \
+        .pclk_hz = 40 * 1000 * 1000,                                \
+        .trans_queue_depth = 10,                                    \
+        .on_color_trans_done = callback,                            \
+        .user_ctx = callback_ctx,                                   \
+        .lcd_cmd_bits = 8,                                          \
+        .lcd_param_bits = 8,                                        \
+    }
+
+#ifdef __cplusplus
+}
+#endif

Tactility/Include/Tactility/hal/spi/Spi.h

@@ -23,7 +23,7 @@ struct Configuration {
     InitMode initMode;
     /** Whether configuration can be changed. */
     bool isMutable;
-    /** Optional custom lock */
+    /** Optional custom lock - otherwise creates one internally */
     std::shared_ptr<Lock> _Nullable lock;
 };
 

Tactility/Source/hal/spi/Spi.cpp

@@ -2,10 +2,10 @@
 
 #include <Tactility/Mutex.h>
 
-#define TAG "spi"
-
 namespace tt::hal::spi {
 
+constexpr auto* TAG = "SPI";
+
 struct Data {
     std::shared_ptr<Lock> lock;
     bool isConfigured = false;
@@ -15,7 +15,7 @@ struct Data {
 
 static Data dataArray[SPI_HOST_MAX];
 
-bool init(const std::vector<spi::Configuration>& configurations) {
+bool init(const std::vector<Configuration>& configurations) {
     TT_LOG_I(TAG, "Init");
     for (const auto& configuration: configurations) {
         Data& data = dataArray[configuration.device];
@@ -24,7 +24,7 @@ bool init(const std::vector<spi::Configuration>& configurations) {
         if (configuration.lock != nullptr) {
             data.lock = configuration.lock;
         } else {
-            data.lock = std::make_shared<Mutex>();
+            data.lock = std::make_shared<Mutex>(Mutex::Type::Recursive);
         }
     }
 
@@ -76,7 +76,6 @@ bool start(spi_host_device_t device) {
 
 #ifdef ESP_PLATFORM
 
-    Configuration& config = data.configuration;
     auto result = spi_bus_initialize(device, &data.configuration.config, data.configuration.dma);
     if (result != ESP_OK) {
         TT_LOG_E(TAG, "(%d) Starting: Failed to initialize: %s", device, esp_err_to_name(result));

sdkconfig.board.waveshare-s3-touch-lcd-147

@@ -0,0 +1,59 @@
+# Software defaults
+# Increase stack size for WiFi (fixes crash after scan)
+CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=3072
+CONFIG_LV_FONT_MONTSERRAT_14=y
+CONFIG_LV_FONT_MONTSERRAT_18=y
+CONFIG_LV_USE_USER_DATA=y
+CONFIG_LV_USE_FS_STDIO=y
+CONFIG_LV_FS_STDIO_LETTER=65
+CONFIG_LV_FS_STDIO_PATH=""
+CONFIG_LV_FS_STDIO_CACHE_SIZE=4096
+CONFIG_LV_USE_LODEPNG=y
+CONFIG_LV_USE_BUILTIN_MALLOC=n
+CONFIG_LV_USE_CLIB_MALLOC=y
+CONFIG_LV_USE_MSGBOX=n
+CONFIG_LV_USE_SPINNER=n
+CONFIG_LV_USE_WIN=n
+CONFIG_LV_USE_SNAPSHOT=y
+CONFIG_FREERTOS_HZ=1000
+CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2
+CONFIG_FREERTOS_SMP=n
+CONFIG_FREERTOS_UNICORE=n
+CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=5120
+CONFIG_FREERTOS_USE_TRACE_FACILITY=y
+CONFIG_FATFS_LFN_HEAP=y
+CONFIG_FATFS_VOLUME_COUNT=3
+CONFIG_FATFS_SECTOR_512=y
+CONFIG_WL_SECTOR_SIZE_512=y
+CONFIG_WL_SECTOR_SIZE=512
+CONFIG_WL_SECTOR_MODE_SAFE=y
+CONFIG_WL_SECTOR_MODE=1
+
+# Hardware: Main
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions-16mb.csv"
+CONFIG_PARTITION_TABLE_FILENAME="partitions-16mb.csv"
+CONFIG_TT_BOARD_WAVESHARE_S3_TOUCH_LCD_147=y
+CONFIG_TT_BOARD_NAME="Waveshare ESP32 S3 Touch LCD 1.47"
+CONFIG_TT_BOARD_ID="waveshare-s3-touch-lcd-147"
+CONFIG_IDF_EXPERIMENTAL_FEATURES=y
+CONFIG_IDF_TARGET="esp32s3"
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
+CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
+CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y
+CONFIG_FLASHMODE_QIO=y
+# Hardware: SPI RAM
+CONFIG_ESP32S3_SPIRAM_SUPPORT=y
+CONFIG_SPIRAM_MODE_OCT=y
+CONFIG_SPIRAM_SPEED_120M=y
+CONFIG_SPIRAM_USE_MALLOC=y
+CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP=y
+# SPI Flash (can set back to 80MHz after ESP-IDF bug is resolved)
+CONFIG_ESPTOOLPY_FLASHFREQ_120M=y
+# LVGL
+CONFIG_LV_DPI_DEF=600
+CONFIG_LV_DISP_DEF_REFR_PERIOD=10
+CONFIG_LV_THEME_DEFAULT_DARK=y
+# USB
+CONFIG_TINYUSB_MSC_ENABLED=y
+CONFIG_TINYUSB_MSC_MOUNT_PATH="/sdcard"