C++ conversion (#80)

Converted project to C++

Boards/LilygoTdeck/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRC_DIRS "."
+    INCLUDE_DIRS "."
+    REQUIRES Tactility esp_lvgl_port esp_lcd esp_lcd_touch_gt911 driver vfs fatfs
+)

Boards/LilygoTdeck/bootstrap.cpp

@@ -0,0 +1,101 @@
+#include "config.h"
+#include "display_i.h"
+#include "driver/spi_common.h"
+#include "keyboard.h"
+#include "TactilityCore.h"
+
+#define TAG "tdeck_bootstrap"
+
+static bool tdeck_power_on() {
+    gpio_config_t device_power_signal_config = {
+        .pin_bit_mask = BIT64(TDECK_POWERON_GPIO),
+        .mode = GPIO_MODE_OUTPUT,
+        .pull_up_en = GPIO_PULLUP_DISABLE,
+        .pull_down_en = GPIO_PULLDOWN_DISABLE,
+        .intr_type = GPIO_INTR_DISABLE,
+    };
+
+    if (gpio_config(&device_power_signal_config) != ESP_OK) {
+        return false;
+    }
+
+    if (gpio_set_level(TDECK_POWERON_GPIO, 1) != ESP_OK) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool init_i2c() {
+    const i2c_config_t i2c_conf = {
+        .mode = I2C_MODE_MASTER,
+        .sda_io_num = GPIO_NUM_18,
+        .scl_io_num = GPIO_NUM_8,
+        .sda_pullup_en = GPIO_PULLUP_DISABLE,
+        .scl_pullup_en = GPIO_PULLUP_DISABLE,
+        .master = {
+            .clk_speed = 400000
+        }
+    };
+
+    return i2c_param_config(TDECK_I2C_BUS_HANDLE, &i2c_conf) == ESP_OK && i2c_driver_install(TDECK_I2C_BUS_HANDLE, i2c_conf.mode, 0, 0, 0) == ESP_OK;
+}
+
+static bool init_spi() {
+    spi_bus_config_t bus_config = {
+        .mosi_io_num = TDECK_SPI_PIN_MOSI,
+        .miso_io_num = TDECK_SPI_PIN_MISO,
+        .sclk_io_num = TDECK_SPI_PIN_SCLK,
+        .quadwp_io_num = -1, // Quad SPI LCD driver is not yet supported
+        .quadhd_io_num = -1, // Quad SPI LCD driver is not yet supported
+        .max_transfer_sz = TDECK_SPI_TRANSFER_SIZE_LIMIT,
+    };
+
+    if (spi_bus_initialize(TDECK_SPI_HOST, &bus_config, SPI_DMA_CH_AUTO) != ESP_OK) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool tdeck_bootstrap() {
+    ESP_LOGI(TAG, "Power on");
+    if (!tdeck_power_on()) {
+        TT_LOG_E(TAG, "Power on failed");
+    }
+
+    /**
+     * Without this delay, the touch driver randomly fails when the device is USB-powered:
+     *  > lcd_panel.io.i2c: panel_io_i2c_rx_buffer(135): i2c transaction failed
+     *  > GT911: touch_gt911_read_cfg(352): GT911 read error!
+     * This might not be a problem with a lipo, but I haven't been able to test that.
+     * I tried to solve it just like I did with the keyboard:
+     * By reading from I2C until it succeeds and to then init the driver.
+     * It doesn't work, because it never recovers from the error.
+     */
+    TT_LOG_I(TAG, "Waiting after power-on");
+    tt::delay_ms(TDECK_POWERON_DELAY);
+
+    TT_LOG_I(TAG, "Init I2C");
+    if (!init_i2c()) {
+        TT_LOG_E(TAG, "Init I2C failed");
+        return false;
+    }
+
+    TT_LOG_I(TAG, "Init SPI");
+    if (!init_spi()) {
+        TT_LOG_E(TAG, "Init SPI failed");
+        return false;
+    }
+
+    // Don't turn the backlight on yet - Tactility init will take care of it
+    TT_LOG_I(TAG, "Init backlight");
+    if (!tdeck_backlight_init()) {
+        TT_LOG_E(TAG, "Init backlight failed");
+        return false;
+    }
+
+    keyboard_wait_for_response();
+
+    return true;
+}

Boards/LilygoTdeck/config.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "driver/i2c.h"
+#include "driver/gpio.h"
+
+// Main bus, used by GT911 touch hardware and keyboard
+#define TDECK_I2C_BUS_HANDLE I2C_NUM_0
+
+// SPI
+#define TDECK_SPI_HOST SPI2_HOST
+#define TDECK_SPI_PIN_SCLK GPIO_NUM_40
+#define TDECK_SPI_PIN_MOSI GPIO_NUM_41
+#define TDECK_SPI_PIN_MISO GPIO_NUM_38
+#define TDECK_SPI_TRANSFER_SIZE_LIMIT (TDECK_LCD_HORIZONTAL_RESOLUTION * TDECK_LCD_SPI_TRANSFER_HEIGHT * (TDECK_LCD_BITS_PER_PIXEL / 8))
+
+// Power on
+#define TDECK_POWERON_GPIO GPIO_NUM_10
+#define TDECK_POWERON_DELAY 2000 // milliseconds - see bootstrap.c for explanation
+
+// Display
+#define TDECK_LCD_SPI_HOST SPI2_HOST
+#define TDECK_LCD_PIN_CS GPIO_NUM_12
+#define TDECK_LCD_PIN_DC GPIO_NUM_11 // RS
+#define TDECK_LCD_PIN_BACKLIGHT GPIO_NUM_42
+#define TDECK_LCD_SPI_FREQUENCY 40000000
+#define TDECK_LCD_HORIZONTAL_RESOLUTION 320
+#define TDECK_LCD_VERTICAL_RESOLUTION 240
+#define TDECK_LCD_BITS_PER_PIXEL 16
+#define TDECK_LCD_DRAW_BUFFER_HEIGHT (TDECK_LCD_VERTICAL_RESOLUTION / 10)
+#define TDECK_LCD_SPI_TRANSFER_HEIGHT (TDECK_LCD_VERTICAL_RESOLUTION / 10)
+
+// LVGL
+// The minimum task stack seems to be about 3500, but that crashes the wifi app in some scenarios
+// At 4000, it crashes when the fps renderer is available
+#define TDECK_LVGL_TASK_STACK_DEPTH 8192
+
+// Dipslay backlight (PWM)
+#define TDECK_LCD_BACKLIGHT_LEDC_TIMER LEDC_TIMER_0
+#define TDECK_LCD_BACKLIGHT_LEDC_MODE LEDC_LOW_SPEED_MODE
+#define TDECK_LCD_BACKLIGHT_LEDC_CHANNEL LEDC_CHANNEL_0
+#define TDECK_LCD_BACKLIGHT_LEDC_DUTY_RES LEDC_TIMER_8_BIT
+#define TDECK_LCD_BACKLIGHT_LEDC_FREQUENCY (4000)
+
+// Touch (GT911)
+#define TDECK_TOUCH_I2C_BUS_HANDLE TDECK_I2C_BUS_HANDLE
+#define TDECK_TOUCH_X_MAX 240
+#define TDECK_TOUCH_Y_MAX 320
+#define TDECK_TOUCH_PIN_INT GPIO_NUM_16
+
+// SD Card
+#define TDECK_SDCARD_SPI_HOST SPI2_HOST
+#define TDECK_SDCARD_PIN_CS GPIO_NUM_39
+#define TDECK_SDCARD_SPI_FREQUENCY 800000U
+#define TDECK_SDCARD_FORMAT_ON_MOUNT_FAILED false
+#define TDECK_SDCARD_MAX_OPEN_FILES 4
+#define TDECK_SDCARD_ALLOC_UNIT_SIZE (16 * 1024)
+#define TDECK_SDCARD_STATUS_CHECK_ENABLED false
+
+// Keyboard
+#define TDECK_KEYBOARD_I2C_BUS_HANDLE TDECK_I2C_BUS_HANDLE
+#define TDECK_KEYBOARD_SLAVE_ADDRESS 0x55
+
+// Lora (optional)
+#define TDECK_RADIO_PIN_CS GPIO_NUM_9

Boards/LilygoTdeck/display.cpp

@@ -0,0 +1,143 @@
+#include "config.h"
+#include "driver/ledc.h"
+#include "driver/spi_master.h"
+#include "esp_err.h"
+#include "esp_lcd_panel_ops.h"
+#include "esp_lcd_panel_vendor.h"
+#include "esp_lvgl_port.h"
+#include "Log.h"
+
+#define TAG "tdeck_display"
+
+bool tdeck_backlight_init() {
+    ledc_timer_config_t ledc_timer = {
+        .speed_mode = TDECK_LCD_BACKLIGHT_LEDC_MODE,
+        .duty_resolution = TDECK_LCD_BACKLIGHT_LEDC_DUTY_RES,
+        .timer_num = TDECK_LCD_BACKLIGHT_LEDC_TIMER,
+        .freq_hz = TDECK_LCD_BACKLIGHT_LEDC_FREQUENCY,
+        .clk_cfg = LEDC_AUTO_CLK
+    };
+
+    if (ledc_timer_config(&ledc_timer) != ESP_OK) {
+        TT_LOG_E(TAG, "Backlight led timer config failed");
+        return false;
+    }
+
+    return true;
+}
+
+void tdeck_backlight_set(uint8_t duty) {
+    ledc_channel_config_t ledc_channel = {
+        .gpio_num = TDECK_LCD_PIN_BACKLIGHT,
+        .speed_mode = TDECK_LCD_BACKLIGHT_LEDC_MODE,
+        .channel = TDECK_LCD_BACKLIGHT_LEDC_CHANNEL,
+        .intr_type = LEDC_INTR_DISABLE,
+        .timer_sel = TDECK_LCD_BACKLIGHT_LEDC_TIMER,
+        .duty = duty,
+        .hpoint = 0
+    };
+
+    // Setting the config in the timer init and then calling ledc_set_duty() doesn't work when
+    // the app is running. For an unknown reason we have to call this config method every time:
+    if (ledc_channel_config(&ledc_channel) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to configure display backlight");
+    }
+}
+
+lv_display_t* tdeck_display_init() {
+    const esp_lcd_panel_io_spi_config_t panel_io_config = {
+        .cs_gpio_num = TDECK_LCD_PIN_CS,
+        .dc_gpio_num = TDECK_LCD_PIN_DC,
+        .spi_mode = 0,
+        .pclk_hz = TDECK_LCD_SPI_FREQUENCY,
+        .trans_queue_depth = 10,
+        .on_color_trans_done = nullptr,
+        .user_ctx = nullptr,
+        .lcd_cmd_bits = 8,
+        .lcd_param_bits = 8,
+        .flags = {
+            .dc_low_on_data = 0,
+            .octal_mode = 0,
+            .quad_mode = 0,
+            .sio_mode = 1,
+            .lsb_first = 0,
+            .cs_high_active = 0,
+        }
+    };
+
+    esp_lcd_panel_io_handle_t io_handle;
+    if (esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)TDECK_LCD_SPI_HOST, &panel_io_config, &io_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to create panel IO");
+        return nullptr;
+    }
+
+    const esp_lcd_panel_dev_config_t panel_config = {
+        .reset_gpio_num = GPIO_NUM_NC,
+        .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
+        .data_endian = LCD_RGB_DATA_ENDIAN_BIG,
+        .bits_per_pixel = TDECK_LCD_BITS_PER_PIXEL,
+        .flags = {
+            .reset_active_high = 0
+        },
+        .vendor_config = nullptr
+    };
+
+    esp_lcd_panel_handle_t panel_handle;
+    if (esp_lcd_new_panel_st7789(io_handle, &panel_config, &panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to create panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_reset(panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to reset panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_init(panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to init panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_invert_color(panel_handle, true) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to init panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_swap_xy(panel_handle, true) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to init panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_mirror(panel_handle, true, false) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to init panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_disp_on_off(panel_handle, true) != ESP_OK) {
+        TT_LOG_E(TAG, "failed to turn display on");
+        return nullptr;
+    }
+
+    const lvgl_port_display_cfg_t disp_cfg = {
+        .io_handle = io_handle,
+        .panel_handle = panel_handle,
+        .buffer_size = TDECK_LCD_HORIZONTAL_RESOLUTION * TDECK_LCD_DRAW_BUFFER_HEIGHT * (TDECK_LCD_BITS_PER_PIXEL / 8),
+        .double_buffer = true, // Disable to free up SPIRAM
+        .hres = TDECK_LCD_HORIZONTAL_RESOLUTION,
+        .vres = TDECK_LCD_VERTICAL_RESOLUTION,
+        .monochrome = false,
+        .rotation = {
+            .swap_xy = true,
+            .mirror_x = true,
+            .mirror_y = false,
+        },
+        .flags = {
+            .buff_dma = false,
+            .buff_spiram = true,
+            .sw_rotate = false,
+            .swap_bytes = true
+        }
+    };
+
+    return lvgl_port_add_disp(&disp_cfg);
+}

Boards/LilygoTdeck/display_i.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "lvgl.h"
+
+lv_display_t* tdeck_display_init();
+
+bool tdeck_backlight_init();
+
+void tdeck_backlight_set(uint8_t duty);

Boards/LilygoTdeck/keyboard.cpp

@@ -0,0 +1,86 @@
+#include "keyboard.h"
+#include "config.h"
+#include "lvgl.h"
+#include "TactilityCore.h"
+#include "Ui/LvglKeypad.h"
+#include <driver/i2c.h>
+
+#define TAG "tdeck_keyboard"
+
+typedef struct {
+    lv_indev_t* device;
+} KeyboardData;
+
+static inline esp_err_t keyboard_i2c_read(uint8_t* output) {
+    return i2c_master_read_from_device(
+        TDECK_KEYBOARD_I2C_BUS_HANDLE,
+        TDECK_KEYBOARD_SLAVE_ADDRESS,
+        output,
+        1,
+        configTICK_RATE_HZ / 10
+    );
+}
+
+void keyboard_wait_for_response() {
+    TT_LOG_I(TAG, "Waiting for keyboard response...");
+    bool awake = false;
+    uint8_t read_buffer = 0x00;
+    do {
+        awake = keyboard_i2c_read(&read_buffer) == ESP_OK;
+        if (!awake) {
+            tt::delay_ms(100);
+        }
+    } while (!awake);
+    TT_LOG_I(TAG, "Keyboard responded");
+}
+
+/**
+ * The callback simulates press and release events, because the T-Deck
+ * keyboard only publishes press events on I2C.
+ * LVGL currently works without those extra release events, but they
+ * are implemented for correctness and future compatibility.
+ *
+ * @param indev_drv
+ * @param data
+ */
+static void keyboard_read_callback(TT_UNUSED lv_indev_t* indev, lv_indev_data_t* data) {
+    static uint8_t last_buffer = 0x00;
+    uint8_t read_buffer = 0x00;
+
+    // Defaults
+    data->key = 0;
+    data->state = LV_INDEV_STATE_RELEASED;
+
+    if (keyboard_i2c_read(&read_buffer) == ESP_OK) {
+        if (read_buffer == 0 && read_buffer != last_buffer) {
+            TT_LOG_I(TAG, "Released %d", last_buffer);
+            data->key = last_buffer;
+            data->state = LV_INDEV_STATE_RELEASED;
+        } else if (read_buffer != 0) {
+            TT_LOG_I(TAG, "Pressed %d", read_buffer);
+            data->key = read_buffer;
+            data->state = LV_INDEV_STATE_PRESSED;
+        }
+    }
+
+    last_buffer = read_buffer;
+}
+
+Keyboard keyboard_alloc(_Nullable lv_disp_t* display) {
+    auto* data = static_cast<KeyboardData*>(malloc(sizeof(KeyboardData)));
+
+    data->device = lv_indev_create();
+    lv_indev_set_type(data->device, LV_INDEV_TYPE_KEYPAD);
+    lv_indev_set_read_cb(data->device, &keyboard_read_callback);
+    lv_indev_set_display(data->device, display);
+
+    tt::lvgl::keypad_set_indev(data->device);
+
+    return data;
+}
+
+void keyboard_free(Keyboard keyboard) {
+    auto* data = static_cast<KeyboardData*>(keyboard);
+    lv_indev_delete(data->device);
+    free(data);
+}

Boards/LilygoTdeck/keyboard.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "lvgl.h"
+
+void keyboard_wait_for_response();
+
+typedef void* Keyboard;
+
+Keyboard keyboard_alloc(_Nullable lv_disp_t* display);
+void keyboard_free(Keyboard keyboard);

Boards/LilygoTdeck/lilygo_tdeck.cpp

@@ -0,0 +1,17 @@
+#include "lilygo_tdeck.h"
+#include "display_i.h"
+
+bool tdeck_bootstrap();
+bool tdeck_init_lvgl();
+
+extern const tt::hal::sdcard::SdCard tdeck_sdcard;
+
+extern const tt::hal::Configuration lilygo_tdeck = {
+    .bootstrap = &tdeck_bootstrap,
+    .init_graphics = &tdeck_init_lvgl,
+    .display = {
+        .set_backlight_duty = &tdeck_backlight_set
+    },
+    .sdcard = &tdeck_sdcard,
+    .power = nullptr
+};

Boards/LilygoTdeck/lilygo_tdeck.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "Hal/Configuration.h"
+
+extern const tt::hal::Configuration lilygo_tdeck;

Boards/LilygoTdeck/lvgl.cpp

@@ -0,0 +1,67 @@
+#include "config.h"
+#include "display_i.h"
+#include "esp_lvgl_port.h"
+#include "keyboard.h"
+#include "Log.h"
+#include "Ui/LvglSync.h"
+#include "Thread.h"
+
+#define TAG "tdeck_lvgl"
+
+bool tdeck_init_touch(esp_lcd_panel_io_handle_t* io_handle, esp_lcd_touch_handle_t* touch_handle);
+
+bool tdeck_init_lvgl() {
+    static lv_disp_t* display = nullptr;
+    static esp_lcd_panel_io_handle_t touch_io_handle;
+    static esp_lcd_touch_handle_t touch_handle;
+
+    const lvgl_port_cfg_t lvgl_cfg = {
+        .task_priority = tt::THREAD_PRIORITY_RENDER,
+        .task_stack = TDECK_LVGL_TASK_STACK_DEPTH,
+        .task_affinity = -1, // core pinning
+        .task_max_sleep_ms = 500,
+        .timer_period_ms = 5
+    };
+
+    TT_LOG_D(TAG, "LVGL port init");
+    if (lvgl_port_init(&lvgl_cfg) != ESP_OK) {
+        TT_LOG_E(TAG, "LVGL port init failed");
+        return false;
+    }
+
+    // Add display
+
+    TT_LOG_D(TAG, "Creating display");
+    display = tdeck_display_init();
+    if (display == nullptr) {
+        TT_LOG_E(TAG, "Creating display failed");
+        return false;
+    }
+
+    // Add touch
+
+    TT_LOG_D(TAG, "Creating touch");
+    if (!tdeck_init_touch(&touch_io_handle, &touch_handle)) {
+        TT_LOG_E(TAG, "Creating touch failed");
+        return false;
+    }
+
+    const lvgl_port_touch_cfg_t touch_cfg = {
+        .disp = display,
+        .handle = touch_handle,
+    };
+
+    TT_LOG_D(TAG, "Adding touch");
+    lv_indev_t _Nullable* touch_indev = lvgl_port_add_touch(&touch_cfg);
+    if (touch_indev == nullptr) {
+        TT_LOG_E(TAG, "Adding touch failed");
+        return false;
+    }
+
+    // Set syncing functions
+    tt::lvgl::sync_set(&lvgl_port_lock, &lvgl_port_unlock);
+
+    keyboard_alloc(display);
+
+    return true;
+}

Boards/LilygoTdeck/sdcard.cpp

@@ -0,0 +1,149 @@
+#include "Hal/Sdcard.h"
+#include "Check.h"
+#include "Log.h"
+#include "config.h"
+
+#include "esp_vfs_fat.h"
+#include "sdmmc_cmd.h"
+#include "Ui/LvglSync.h"
+
+#define TAG "tdeck_sdcard"
+
+typedef struct {
+    const char* mount_point;
+    sdmmc_card_t* card;
+} MountData;
+
+/**
+ * Before we can initialize the sdcard's SPI communications, we have to set all
+ * other SPI pins on the board high.
+ * See https://github.com/espressif/esp-idf/issues/1597
+ * See https://github.com/Xinyuan-LilyGO/T-Deck/blob/master/examples/UnitTest/UnitTest.ino
+ * @return success result
+ */
+static bool sdcard_init() {
+    TT_LOG_D(TAG, "init");
+
+    gpio_config_t config = {
+        .pin_bit_mask = BIT64(TDECK_SDCARD_PIN_CS) | BIT64(TDECK_RADIO_PIN_CS) | BIT64(TDECK_LCD_PIN_CS),
+        .mode = GPIO_MODE_OUTPUT,
+        .pull_up_en = GPIO_PULLUP_DISABLE,
+        .pull_down_en = GPIO_PULLDOWN_DISABLE,
+        .intr_type = GPIO_INTR_DISABLE,
+    };
+
+    if (gpio_config(&config) != ESP_OK) {
+        TT_LOG_E(TAG, "GPIO init failed");
+        return false;
+    }
+
+    if (gpio_set_level(TDECK_SDCARD_PIN_CS, 1) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set board CS pin high");
+        return false;
+    }
+
+    if (gpio_set_level(TDECK_RADIO_PIN_CS, 1) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set radio CS pin high");
+        return false;
+    }
+
+    if (gpio_set_level(TDECK_LCD_PIN_CS, 1) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set TFT CS pin high");
+        return false;
+    }
+
+    return true;
+}
+
+static void* _Nullable sdcard_mount(const char* mount_point) {
+    TT_LOG_I(TAG, "Mounting %s", mount_point);
+
+    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
+        .format_if_mount_failed = TDECK_SDCARD_FORMAT_ON_MOUNT_FAILED,
+        .max_files = TDECK_SDCARD_MAX_OPEN_FILES,
+        .allocation_unit_size = TDECK_SDCARD_ALLOC_UNIT_SIZE,
+        .disk_status_check_enable = TDECK_SDCARD_STATUS_CHECK_ENABLED
+    };
+
+    // Init without card detect (CD) and write protect (WD)
+    sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
+    slot_config.gpio_cs = TDECK_SDCARD_PIN_CS;
+    slot_config.host_id = TDECK_SDCARD_SPI_HOST;
+
+    sdmmc_host_t host = SDSPI_HOST_DEFAULT();
+    // The following value is from T-Deck repo's UnitTest.ino project:
+    // https://github.com/Xinyuan-LilyGO/T-Deck/blob/master/examples/UnitTest/UnitTest.ino
+    // Observation: Using this automatically sets the bus to 20MHz
+    host.max_freq_khz = TDECK_SDCARD_SPI_FREQUENCY;
+
+    sdmmc_card_t* card;
+    esp_err_t ret = esp_vfs_fat_sdspi_mount(mount_point, &host, &slot_config, &mount_config, &card);
+
+    if (ret != ESP_OK) {
+        if (ret == ESP_FAIL) {
+            TT_LOG_E(TAG, "Mounting failed. Ensure the card is formatted with FAT.");
+        } else {
+            TT_LOG_E(TAG, "Mounting failed (%s)", esp_err_to_name(ret));
+        }
+        return NULL;
+    }
+
+    auto* data = static_cast<MountData*>(malloc(sizeof(MountData)));
+    *data = (MountData) {
+        .mount_point = mount_point,
+        .card = card,
+    };
+
+    return data;
+}
+
+static void* sdcard_init_and_mount(const char* mount_point) {
+    if (!sdcard_init()) {
+        TT_LOG_E(TAG, "Failed to set SPI CS pins high. This is a pre-requisite for mounting.");
+        return NULL;
+    }
+    auto* data = static_cast<MountData*>(sdcard_mount(mount_point));
+    if (data == nullptr) {
+        TT_LOG_E(TAG, "Mount failed for %s", mount_point);
+        return nullptr;
+    }
+
+    sdmmc_card_print_info(stdout, data->card);
+
+    return data;
+}
+
+static void sdcard_unmount(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    TT_LOG_I(TAG, "Unmounting %s", data->mount_point);
+
+    tt_assert(data != nullptr);
+    if (esp_vfs_fat_sdcard_unmount(data->mount_point, data->card) != ESP_OK) {
+        TT_LOG_E(TAG, "Unmount failed for %s", data->mount_point);
+    }
+
+    free(data);
+}
+
+static bool sdcard_is_mounted(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    /**
+     * The SD card and the screen are on the same SPI bus.
+     * Writing and reading to the bus from 2 devices at the same time causes crashes.
+     * This work-around ensures that this check is only happening when LVGL isn't rendering.
+     */
+    if (tt::lvgl::lock(100)) {
+        bool result = (data != nullptr) && (sdmmc_get_status(data->card) == ESP_OK);
+        tt::lvgl::unlock();
+        return result;
+    } else {
+        return false;
+    }
+}
+
+extern const tt::hal::sdcard::SdCard tdeck_sdcard = {
+    .mount = &sdcard_init_and_mount,
+    .unmount = &sdcard_unmount,
+    .is_mounted = &sdcard_is_mounted,
+    .mount_behaviour = tt::hal::sdcard::MountBehaviourAtBoot
+};

Boards/LilygoTdeck/touch.cpp

@@ -0,0 +1,58 @@
+#include "config.h"
+#include "esp_err.h"
+#include "esp_lcd_panel_io_interface.h"
+#include "esp_lcd_touch_gt911.h"
+#include "Log.h"
+#include "Kernel.h"
+
+#define TAG "tdeck_touch"
+
+bool tdeck_init_touch(esp_lcd_panel_io_handle_t* io_handle, esp_lcd_touch_handle_t* touch_handle) {
+    const esp_lcd_panel_io_i2c_config_t touch_io_config = ESP_LCD_TOUCH_IO_I2C_GT911_CONFIG();
+
+    // TODO: Revert on new ESP-IDF version
+    static_assert(ESP_IDF_VERSION == ESP_IDF_VERSION_VAL(5, 3, 1));
+    esp_lcd_new_panel_io_i2c(
+        (esp_lcd_i2c_bus_handle_t)TDECK_TOUCH_I2C_BUS_HANDLE,
+        &touch_io_config,
+        io_handle
+    );
+    /*
+    if (
+        esp_lcd_new_panel_io_i2c(
+            (esp_lcd_i2c_bus_handle_t)TDECK_TOUCH_I2C_BUS_HANDLE,
+            &touch_io_config,
+            io_handle
+        ) != ESP_OK
+    ) {
+        TT_LOG_E(TAG, "touch io i2c creation failed");
+        return false;
+    }
+    */
+
+    esp_lcd_touch_config_t config = {
+        .x_max = TDECK_TOUCH_X_MAX,
+        .y_max = TDECK_TOUCH_Y_MAX,
+        .rst_gpio_num = GPIO_NUM_NC,
+        .int_gpio_num = TDECK_TOUCH_PIN_INT,
+        .levels = {
+            .reset = 0,
+            .interrupt = 0,
+        },
+        .flags = {
+            .swap_xy = 1,
+            .mirror_x = 1,
+            .mirror_y = 0,
+        },
+        .process_coordinates = nullptr,
+        .interrupt_callback = nullptr,
+        .user_data = nullptr
+    };
+
+    if (esp_lcd_touch_new_i2c_gt911(*io_handle, &config, touch_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "gt911 driver creation failed");
+        return false;
+    }
+
+    return true;
+}

Boards/M5stackCore2/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRC_DIRS "Source"
+    INCLUDE_DIRS "Source"
+    REQUIRES Tactility M5stackShared vfs fatfs M5Unified
+)

Boards/M5stackCore2/Source/M5stackCore2.cpp

@@ -0,0 +1,14 @@
+#include "M5stackCore2.h"
+#include "m5stack_shared.h"
+
+extern const tt::hal::sdcard::SdCard m5stack_core2_sdcard;
+
+extern const tt::hal::Configuration m5stack_core2 = {
+    .bootstrap = &m5stack_bootstrap,
+    .init_graphics = &m5stack_lvgl_init,
+    .display = {
+        .set_backlight_duty = nullptr
+    },
+    .sdcard = &m5stack_core2_sdcard,
+    .power = &m5stack_power
+};

Boards/M5stackCore2/Source/M5stackCore2.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "Hal/Configuration.h"
+
+extern const tt::hal::Configuration m5stack_core2;

Boards/M5stackCore2/Source/M5stackCore2Sdcard.cpp

@@ -0,0 +1,86 @@
+#include "Check.h"
+#include "Log.h"
+#include "Hal/Sdcard.h"
+
+#include "esp_vfs_fat.h"
+#include "sdmmc_cmd.h"
+
+#define TAG "m5stack_core2_sdcard"
+
+#define CORE2_SDCARD_SPI_HOST SPI2_HOST
+#define CORE2_SDCARD_PIN_CS GPIO_NUM_4
+#define CORE2_SDCARD_SPI_FREQUENCY 800000U
+#define CORE2_SDCARD_FORMAT_ON_MOUNT_FAILED false
+#define CORE2_SDCARD_MAX_OPEN_FILES 4
+#define CORE2_SDCARD_ALLOC_UNIT_SIZE (16 * 1024)
+#define CORE2_SDCARD_STATUS_CHECK_ENABLED false
+
+typedef struct {
+    const char* mount_point;
+    sdmmc_card_t* card;
+} MountData;
+
+static void* sdcard_mount(const char* mount_point) {
+    TT_LOG_I(TAG, "Mounting %s", mount_point);
+
+    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
+        .format_if_mount_failed = CORE2_SDCARD_FORMAT_ON_MOUNT_FAILED,
+        .max_files = CORE2_SDCARD_MAX_OPEN_FILES,
+        .allocation_unit_size = CORE2_SDCARD_ALLOC_UNIT_SIZE,
+        .disk_status_check_enable = CORE2_SDCARD_STATUS_CHECK_ENABLED
+    };
+
+    sdmmc_card_t* card;
+
+    // Init without card detect (CD) and write protect (WD)
+    sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
+    slot_config.gpio_cs = CORE2_SDCARD_PIN_CS;
+    slot_config.host_id = CORE2_SDCARD_SPI_HOST;
+
+    sdmmc_host_t host = SDSPI_HOST_DEFAULT();
+    host.max_freq_khz = CORE2_SDCARD_SPI_FREQUENCY;
+    esp_err_t ret = esp_vfs_fat_sdspi_mount(mount_point, &host, &slot_config, &mount_config, &card);
+
+    if (ret != ESP_OK) {
+        if (ret == ESP_FAIL) {
+            TT_LOG_E(TAG, "Mounting failed. Ensure the card is formatted with FAT.");
+        } else {
+            TT_LOG_E(TAG, "Mounting failed (%s)", esp_err_to_name(ret));
+        }
+        return nullptr;
+    }
+
+    auto* data = static_cast<MountData*>(malloc(sizeof(MountData)));
+    *data = (MountData) {
+        .mount_point = mount_point,
+        .card = card,
+    };
+
+    sdmmc_card_print_info(stdout, data->card);
+
+    return data;
+}
+
+static void sdcard_unmount(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    TT_LOG_I(TAG, "Unmounting %s", data->mount_point);
+
+    tt_assert(data != nullptr);
+    if (esp_vfs_fat_sdcard_unmount(data->mount_point, data->card) != ESP_OK) {
+        TT_LOG_E(TAG, "Unmount failed for %s", data->mount_point);
+    }
+
+    free(data);
+}
+
+static bool sdcard_is_mounted(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    return (data != nullptr) && (sdmmc_get_status(data->card) == ESP_OK);
+}
+
+extern const tt::hal::sdcard::SdCard m5stack_core2_sdcard = {
+    .mount = &sdcard_mount,
+    .unmount = &sdcard_unmount,
+    .is_mounted = &sdcard_is_mounted,
+    .mount_behaviour = tt::hal::sdcard::MountBehaviourAnytime
+};

Boards/M5stackCoreS3/CMakeLists.txt

@@ -0,0 +1,6 @@
+idf_component_register(
+    SRC_DIRS "Source"
+    INCLUDE_DIRS "Source"
+    PRIV_INCLUDE_DIRS "Private"
+    REQUIRES Tactility M5stackShared vfs fatfs M5Unified
+)

Boards/M5stackCoreS3/Private/config.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "driver/spi_common.h"
+#include "driver/gpio.h"
+
+// SD Card
+#define CORES3_SDCARD_SPI_HOST SPI2_HOST
+#define CORES3_SDCARD_PIN_CS GPIO_NUM_4
+#define CORES3_SDCARD_SPI_FREQUENCY 800000U
+#define CORES3_SDCARD_FORMAT_ON_MOUNT_FAILED false
+#define CORES3_SDCARD_MAX_OPEN_FILES 4
+#define CORES3_SDCARD_ALLOC_UNIT_SIZE (16 * 1024)
+#define CORES3_SDCARD_STATUS_CHECK_ENABLED false

Boards/M5stackCoreS3/Source/m5stack_cores3.cpp

@@ -0,0 +1,14 @@
+#include "m5stack_cores3.h"
+#include "m5stack_shared.h"
+
+extern const tt::hal::sdcard::SdCard m5stack_cores3_sdcard;
+
+const tt::hal::Configuration m5stack_cores3 = {
+    .bootstrap = &m5stack_bootstrap,
+    .init_graphics = &m5stack_lvgl_init,
+    .display = {
+        .set_backlight_duty = nullptr
+    },
+    .sdcard = &m5stack_cores3_sdcard,
+    .power = &m5stack_power
+};

Boards/M5stackCoreS3/Source/m5stack_cores3.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "Hal/Configuration.h"
+
+extern const tt::hal::Configuration m5stack_cores3;

Boards/M5stackCoreS3/Source/m5stack_cores3_sdcard.cpp

@@ -0,0 +1,79 @@
+#include "Hal/Sdcard.h"
+#include "Check.h"
+#include "Log.h"
+#include "config.h"
+
+#include "esp_vfs_fat.h"
+#include "sdmmc_cmd.h"
+
+#define TAG "m5stack_cores3_sdcard"
+
+typedef struct {
+    const char* mount_point;
+    sdmmc_card_t* card;
+} MountData;
+
+static void* sdcard_mount(const char* mount_point) {
+    TT_LOG_I(TAG, "Mounting %s", mount_point);
+
+    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
+        .format_if_mount_failed = CORES3_SDCARD_FORMAT_ON_MOUNT_FAILED,
+        .max_files = CORES3_SDCARD_MAX_OPEN_FILES,
+        .allocation_unit_size = CORES3_SDCARD_ALLOC_UNIT_SIZE,
+        .disk_status_check_enable = CORES3_SDCARD_STATUS_CHECK_ENABLED
+    };
+
+    sdmmc_card_t* card;
+
+    // Init without card detect (CD) and write protect (WD)
+    sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
+    slot_config.gpio_cs = CORES3_SDCARD_PIN_CS;
+    slot_config.host_id = CORES3_SDCARD_SPI_HOST;
+
+    sdmmc_host_t host = SDSPI_HOST_DEFAULT();
+    host.max_freq_khz = CORES3_SDCARD_SPI_FREQUENCY;
+    esp_err_t ret = esp_vfs_fat_sdspi_mount(mount_point, &host, &slot_config, &mount_config, &card);
+
+    if (ret != ESP_OK) {
+        if (ret == ESP_FAIL) {
+            TT_LOG_E(TAG, "Mounting failed. Ensure the card is formatted with FAT.");
+        } else {
+            TT_LOG_E(TAG, "Mounting failed (%s)", esp_err_to_name(ret));
+        }
+        return nullptr;
+    }
+
+    auto* data = static_cast<MountData*>(malloc(sizeof(MountData)));
+    *data = (MountData) {
+        .mount_point = mount_point,
+        .card = card
+    };
+
+    sdmmc_card_print_info(stdout, data->card);
+
+    return data;
+}
+
+static void sdcard_unmount(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    TT_LOG_I(TAG, "Unmounting %s", data->mount_point);
+
+    tt_assert(data != nullptr);
+    if (esp_vfs_fat_sdcard_unmount(data->mount_point, data->card) != ESP_OK) {
+        TT_LOG_E(TAG, "Unmount failed for %s", data->mount_point);
+    }
+
+    free(data);
+}
+
+static bool sdcard_is_mounted(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    return (data != nullptr) && (sdmmc_get_status(data->card) == ESP_OK);
+}
+
+extern const tt::hal::sdcard::SdCard m5stack_cores3_sdcard = {
+    .mount = &sdcard_mount,
+    .unmount = &sdcard_unmount,
+    .is_mounted = &sdcard_is_mounted,
+    .mount_behaviour = tt::hal::sdcard::MountBehaviourAnytime
+};

Boards/M5stackShared/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRC_DIRS "Source"
+    INCLUDE_DIRS "Source"
+    REQUIRES Tactility esp_lvgl_port M5Unified
+)

Boards/M5stackShared/Source/m5stack_bootstrap.cpp

@@ -0,0 +1,10 @@
+#include "M5Unified.hpp"
+#include "Log.h"
+
+#define TAG "m5stack_bootstrap"
+
+bool m5stack_bootstrap() {
+    TT_LOG_I(TAG, "Initializing M5Unified");
+    M5.begin();
+    return true;
+}

Boards/M5stackShared/Source/m5stack_lvgl.cpp

@@ -0,0 +1,46 @@
+#include "esp_lvgl_port.h"
+#include "Log.h"
+#include "Thread.h"
+#include "Ui/LvglSync.h"
+
+#define TAG "cores3_lvgl"
+
+_Nullable lv_disp_t* m5stack_lvgl_display(bool usePsram);
+_Nullable lv_indev_t* m5stack_lvgl_touch();
+
+bool m5stack_lvgl_init() {
+    static lv_display_t* display = nullptr;
+
+    const lvgl_port_cfg_t lvgl_cfg = {
+        .task_priority = tt::ThreadPriorityHigh,
+        .task_stack = 8096,
+        .task_affinity = -1, // core pinning
+        .task_max_sleep_ms = 500,
+        .timer_period_ms = 5
+    };
+
+    if (lvgl_port_init(&lvgl_cfg) != ESP_OK) {
+        TT_LOG_E(TAG, "lvgl_port_init failed");
+        return false;
+    }
+
+    // Add display
+    display = m5stack_lvgl_display(true);
+    if (display == nullptr) {
+        TT_LOG_E(TAG, "failed to add display");
+        return false;
+    }
+
+    // Add touch
+    lv_indev_t* touch_indev = m5stack_lvgl_touch();
+    if (touch_indev == nullptr) {
+        TT_LOG_E(TAG, "failed to add touch");
+        return false;
+    }
+    lv_indev_set_display(touch_indev, display);
+
+    // Set syncing functions
+    tt::lvgl::sync_set(&lvgl_port_lock, &lvgl_port_unlock);
+
+    return true;
+}

Boards/M5stackShared/Source/m5stack_lvgl_display.cpp

@@ -0,0 +1,61 @@
+#include "TactilityCore.h"
+
+#include "M5Unified.hpp"
+#include "esp_err.h"
+#include "esp_lvgl_port.h"
+
+static void flush_callback(lv_display_t* display, const lv_area_t* area, uint8_t* px_map) {
+    M5GFX& gfx = *(M5GFX*)lv_display_get_driver_data(display);
+
+    int32_t width = (area->x2 - area->x1 + 1);
+    int32_t height = (area->y2 - area->y1 + 1);
+
+    gfx.startWrite();
+    gfx.setAddrWindow(area->x1, area->y1, width, height);
+    gfx.writePixels((lgfx::rgb565_t*)px_map, width * height);
+    gfx.endWrite();
+
+    lv_display_flush_ready(display);
+}
+
+
+_Nullable lv_disp_t* m5stack_lvgl_display(bool usePsram) {
+    M5GFX& gfx = M5.Display;
+
+    static lv_display_t* display = lv_display_create(gfx.width(), gfx.height());
+    LV_ASSERT_MALLOC(display)
+    if (display == nullptr) {
+        return nullptr;
+    }
+
+    lv_display_set_driver_data(display, &gfx);
+    lv_display_set_flush_cb(display, flush_callback);
+
+    const size_t bytes_per_pixel = 2; // assume 16-bit color
+    const size_t buffer_size = gfx.width() * gfx.height() * bytes_per_pixel / 8;
+    if (usePsram) {
+        static auto* buffer1 = (uint8_t*)heap_caps_malloc(buffer_size, MALLOC_CAP_SPIRAM);
+        LV_ASSERT_MALLOC(buffer1)
+        static auto* buffer2 = (uint8_t*)heap_caps_malloc(buffer_size, MALLOC_CAP_SPIRAM);
+        LV_ASSERT_MALLOC(buffer2)
+        lv_display_set_buffers(
+            display,
+            (void*)buffer1,
+            (void*)buffer2,
+            buffer_size,
+            LV_DISPLAY_RENDER_MODE_PARTIAL
+        );
+    } else {
+        static auto* buffer = (uint8_t*)malloc(buffer_size);
+        LV_ASSERT_MALLOC(buffer)
+        lv_display_set_buffers(
+            display,
+            (void*)buffer,
+            nullptr,
+            buffer_size,
+            LV_DISPLAY_RENDER_MODE_PARTIAL
+        );
+    }
+
+    return display;
+}

Boards/M5stackShared/Source/m5stack_lvgl_touch.cpp

@@ -0,0 +1,29 @@
+#include "M5Unified.hpp"
+#include "lvgl.h"
+#include "TactilityCore.h"
+
+#define TAG "cores3_touch"
+
+static void touch_read_callback(TT_UNUSED lv_indev_t* indev, lv_indev_data_t* data) {
+    lgfx::touch_point_t point; // Making it static makes it unreliable
+    bool touched = M5.Lcd.getTouch(&point) > 0;
+    if (!touched) {
+        data->state = LV_INDEV_STATE_REL;
+    } else {
+        data->state = LV_INDEV_STATE_PR;
+        data->point.x = point.x;
+        data->point.y = point.y;
+    }
+}
+
+_Nullable lv_indev_t* m5stack_lvgl_touch() {
+    static lv_indev_t* indev = lv_indev_create();
+    LV_ASSERT_MALLOC(indev)
+    if (indev == nullptr) {
+        return nullptr;
+    }
+
+    lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
+    lv_indev_set_read_cb(indev, touch_read_callback);
+    return indev;
+}

Boards/M5stackShared/Source/m5stack_power.cpp

@@ -0,0 +1,38 @@
+#include "Hal/Power.h"
+#include "M5Unified.hpp"
+
+/**
+ * M5.Power by default doesn't have a check to see if charging is enabled.
+ * However, it's always enabled by default after boot, so we cover that here:
+ */
+static bool is_charging_enabled = true;
+
+static bool power_is_charging() {
+    return M5.Power.isCharging() == m5::Power_Class::is_charging;
+}
+
+static bool power_is_charging_enabled() {
+    return is_charging_enabled;
+}
+
+static void power_set_charging_enabled(bool enabled) {
+    is_charging_enabled = enabled; // Local shadow copy because M5 API doesn't provide a function for it
+    M5.Power.setBatteryCharge(enabled);
+}
+
+static uint8_t power_get_charge_level() {
+    uint16_t scaled = (uint16_t)M5.Power.getBatteryLevel() * 255 / 100;
+    return (uint8_t)scaled;
+}
+
+static int32_t power_get_current() {
+    return M5.Power.getBatteryCurrent();
+}
+
+extern const tt::hal::Power m5stack_power = {
+    .is_charging = &power_is_charging,
+    .is_charging_enabled = &power_is_charging_enabled,
+    .set_charging_enabled = &power_set_charging_enabled,
+    .get_charge_level = &power_get_charge_level,
+    .get_current = &power_get_current
+};

Boards/M5stackShared/Source/m5stack_shared.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "Hal/Power.h"
+#include "Hal/Sdcard.h"
+
+extern bool m5stack_lvgl_init();
+extern bool m5stack_bootstrap();
+
+extern const tt::hal::Power m5stack_power;

Boards/WaveshareS3Touch/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRC_DIRS "."
+    INCLUDE_DIRS "."
+    REQUIRES Tactility lvgl esp_lcd esp_lcd_touch_gt911
+)

Boards/WaveshareS3Touch/bootstrap.cpp

@@ -0,0 +1,39 @@
+#include "config.h"
+#include "TactilityCore.h"
+#include <driver/i2c.h>
+
+#define TAG "waveshare_bootstrap"
+
+#define WAVESHARE_I2C_MASTER_TX_BUF_DISABLE 0
+#define WAVESHARE_I2C_MASTER_RX_BUF_DISABLE 0
+
+static esp_err_t i2c_init() {
+    const i2c_config_t i2c_conf = {
+        .mode = I2C_MODE_MASTER,
+        .sda_io_num = GPIO_NUM_8,
+        .scl_io_num = GPIO_NUM_9,
+        .sda_pullup_en = GPIO_PULLUP_DISABLE,
+        .scl_pullup_en = GPIO_PULLUP_DISABLE,
+        .master = {
+            .clk_speed = 400000
+        }
+    };
+
+    i2c_param_config(WAVESHARE_TOUCH_I2C_PORT, &i2c_conf);
+
+    return i2c_driver_install(
+        WAVESHARE_TOUCH_I2C_PORT,
+        i2c_conf.mode,
+        WAVESHARE_I2C_MASTER_RX_BUF_DISABLE,
+        WAVESHARE_I2C_MASTER_TX_BUF_DISABLE,
+        0
+    ) == ESP_OK;
+}
+
+bool ws3t_bootstrap() {
+    if (!i2c_init()) {
+        TT_LOG_E(TAG, "I2C init failed");
+        return false;
+    }
+    return true;
+}

Boards/WaveshareS3Touch/bootstrap_i.h

@@ -0,0 +1,3 @@
+#pragma once
+
+bool ws3t_bootstrap();

Boards/WaveshareS3Touch/config.h

@@ -0,0 +1,38 @@
+/**
+* The WaveShare S3 Touch uses a panel with the ST7262 display driver.
+*/
+#pragma once
+
+#define WAVESHARE_LCD_HOR_RES 800
+#define WAVESHARE_LCD_VER_RES 480
+
+#define WAVESHARE_LCD_PIXEL_CLOCK_HZ (12 * 1000 * 1000) // NOTE: original was 14MHz, but we had to slow it down with PSRAM frame buffer
+#define WAVESHARE_LCD_PIN_NUM_HSYNC 46
+#define WAVESHARE_LCD_PIN_NUM_VSYNC 3
+#define WAVESHARE_LCD_PIN_NUM_DE 5
+#define WAVESHARE_LCD_PIN_NUM_PCLK 7
+#define WAVESHARE_LCD_PIN_NUM_DATA0 14  // B3
+#define WAVESHARE_LCD_PIN_NUM_DATA1 38  // B4
+#define WAVESHARE_LCD_PIN_NUM_DATA2 18  // B5
+#define WAVESHARE_LCD_PIN_NUM_DATA3 17  // B6
+#define WAVESHARE_LCD_PIN_NUM_DATA4 10  // B7
+#define WAVESHARE_LCD_PIN_NUM_DATA5 39  // G2
+#define WAVESHARE_LCD_PIN_NUM_DATA6 0   // G3
+#define WAVESHARE_LCD_PIN_NUM_DATA7 45  // G4
+#define WAVESHARE_LCD_PIN_NUM_DATA8 48  // G5
+#define WAVESHARE_LCD_PIN_NUM_DATA9 47  // G6
+#define WAVESHARE_LCD_PIN_NUM_DATA10 21 // G7
+#define WAVESHARE_LCD_PIN_NUM_DATA11 1  // R3
+#define WAVESHARE_LCD_PIN_NUM_DATA12 2  // R4
+#define WAVESHARE_LCD_PIN_NUM_DATA13 42 // R5
+#define WAVESHARE_LCD_PIN_NUM_DATA14 41 // R6
+#define WAVESHARE_LCD_PIN_NUM_DATA15 40 // R7
+#define WAVESHARE_LCD_PIN_NUM_DISP_EN (-1)
+#define WAVESHARE_LCD_BUFFER_HEIGHT (WAVESHARE_LCD_VER_RES / 3) // How many rows of pixels to buffer - 1/3rd is about 1MB
+
+#define WAVESHARE_LCD_USE_DOUBLE_FB true // Performance boost at the cost of about extra PSRAM(SPIRAM)
+
+#define WAVESHARE_LVGL_TICK_PERIOD_MS 2 // TODO: Setting it to 5 causes a crash - why?
+#define LVGL_MAX_SLEEP 500
+
+#define WAVESHARE_TOUCH_I2C_PORT I2C_NUM_0

Boards/WaveshareS3Touch/display.cpp

@@ -0,0 +1,208 @@
+#include "config.h"
+
+#include "lvgl.h"
+#include "TactilityCore.h"
+#include "Thread.h"
+
+#include "esp_err.h"
+#include "esp_lcd_panel_ops.h"
+#include <esp_lcd_panel_rgb.h>
+#include <esp_timer.h>
+#include <sys/cdefs.h>
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+
+#define TAG "waveshare_s3_touch_display"
+
+SemaphoreHandle_t sem_vsync_end = nullptr;
+SemaphoreHandle_t sem_gui_ready = nullptr;
+SemaphoreHandle_t lvgl_mux = nullptr;
+
+#if WAVESHARE_LCD_USE_DOUBLE_FB
+#define WAVESHARE_LCD_NUM_FB 2
+#else
+#define WAVESHARE_LCD_NUM_FB 1
+#endif
+
+static bool lvgl_is_running = false;
+
+bool ws3t_display_lock(uint32_t timeout_ms) {
+    assert(lvgl_mux && "lvgl_port_init must be called first");
+    const TickType_t timeout_ticks = (timeout_ms == 0) ? tt::TtWaitForever : pdMS_TO_TICKS(timeout_ms);
+    return xSemaphoreTakeRecursive(lvgl_mux, timeout_ticks) == pdTRUE;
+}
+
+void ws3t_display_unlock(void) {
+    assert(lvgl_mux && "lvgl_port_init must be called first");
+    xSemaphoreGiveRecursive(lvgl_mux);
+}
+
+// Display_task should have lower priority than lvgl_tick_task below
+static int32_t display_task(TT_UNUSED void* parameter) {
+    uint32_t task_delay_ms = LVGL_MAX_SLEEP;
+
+    ESP_LOGI(TAG, "Starting LVGL task");
+    lvgl_is_running = true;
+    while (lvgl_is_running) {
+        if (ws3t_display_lock(0)) {
+            task_delay_ms = lv_timer_handler();
+            ws3t_display_unlock();
+        }
+        if ((task_delay_ms > LVGL_MAX_SLEEP) || (1 == task_delay_ms)) {
+            task_delay_ms = LVGL_MAX_SLEEP;
+        } else if (task_delay_ms < 1) {
+            task_delay_ms = 1;
+        }
+        vTaskDelay(pdMS_TO_TICKS(task_delay_ms));
+    }
+
+    vTaskDelete(nullptr);
+    return 0;
+}
+
+static bool on_vsync_event(
+    TT_UNUSED esp_lcd_panel_handle_t panel,
+    TT_UNUSED const esp_lcd_rgb_panel_event_data_t* event_data,
+    TT_UNUSED void* user_data
+) {
+    BaseType_t high_task_awoken = pdFALSE;
+
+    if (xSemaphoreTakeFromISR(sem_gui_ready, &high_task_awoken) == pdTRUE) {
+        xSemaphoreGiveFromISR(sem_vsync_end, &high_task_awoken);
+    }
+
+    return high_task_awoken == pdTRUE;
+}
+
+static void lvgl_tick_task(TT_UNUSED void* arg) {
+    // Tell how much time has passed
+    lv_tick_inc(WAVESHARE_LVGL_TICK_PERIOD_MS);
+}
+
+static void display_flush_callback(lv_display_t* disp, const lv_area_t* area, uint8_t* px_map) {
+    auto panel_handle = static_cast<esp_lcd_panel_handle_t>(lv_display_get_user_data(disp));
+    int offsetx1 = area->x1;
+    int offsetx2 = area->x2;
+    int offsety1 = area->y1;
+    int offsety2 = area->y2;
+    xSemaphoreGive(sem_gui_ready);
+    xSemaphoreTake(sem_vsync_end, portMAX_DELAY);
+    // pass the draw buffer to the driver
+    esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, px_map);
+    lv_disp_flush_ready(disp);
+}
+
+lv_disp_t* ws3t_display_create() {
+    TT_LOG_I(TAG, "display init");
+
+    sem_vsync_end = xSemaphoreCreateBinary();
+    tt_assert(sem_vsync_end);
+    sem_gui_ready = xSemaphoreCreateBinary();
+    tt_assert(sem_gui_ready);
+
+    lvgl_mux = xSemaphoreCreateRecursiveMutex();
+    tt_assert(lvgl_mux);
+
+    tt::Thread* thread = tt::thread_alloc_ex("display_task", 8192, &display_task, nullptr);
+    tt::thread_set_priority(thread, tt::ThreadPriorityHigh); // TODO: try out THREAD_PRIORITY_RENDER
+    tt::thread_start(thread);
+
+    esp_lcd_panel_handle_t panel_handle = NULL;
+    esp_lcd_rgb_panel_config_t panel_config = {
+        .clk_src = LCD_CLK_SRC_DEFAULT,
+        .timings = {
+            .pclk_hz = WAVESHARE_LCD_PIXEL_CLOCK_HZ,
+            .h_res = WAVESHARE_LCD_HOR_RES,
+            .v_res = WAVESHARE_LCD_VER_RES,
+            .hsync_pulse_width = 10,
+            // The following parameters should refer to LCD spec
+            .hsync_back_porch = 10,
+            .hsync_front_porch = 20,
+            .vsync_pulse_width = 10,
+            .vsync_back_porch = 10,
+            .vsync_front_porch = 10,
+        },
+        .data_width = 16, // RGB565 in parallel mode, thus 16bit in width
+        .bits_per_pixel = 16,
+        .num_fbs = WAVESHARE_LCD_NUM_FB,
+        .bounce_buffer_size_px = 0,
+        .sram_trans_align = 0,
+        .psram_trans_align = 64,
+        .hsync_gpio_num = WAVESHARE_LCD_PIN_NUM_HSYNC,
+        .vsync_gpio_num = WAVESHARE_LCD_PIN_NUM_VSYNC,
+        .de_gpio_num = WAVESHARE_LCD_PIN_NUM_DE,
+        .pclk_gpio_num = WAVESHARE_LCD_PIN_NUM_PCLK,
+        .disp_gpio_num = WAVESHARE_LCD_PIN_NUM_DISP_EN,
+        .data_gpio_nums = {WAVESHARE_LCD_PIN_NUM_DATA0, WAVESHARE_LCD_PIN_NUM_DATA1, WAVESHARE_LCD_PIN_NUM_DATA2, WAVESHARE_LCD_PIN_NUM_DATA3, WAVESHARE_LCD_PIN_NUM_DATA4, WAVESHARE_LCD_PIN_NUM_DATA5, WAVESHARE_LCD_PIN_NUM_DATA6, WAVESHARE_LCD_PIN_NUM_DATA7, WAVESHARE_LCD_PIN_NUM_DATA8, WAVESHARE_LCD_PIN_NUM_DATA9, WAVESHARE_LCD_PIN_NUM_DATA10, WAVESHARE_LCD_PIN_NUM_DATA11, WAVESHARE_LCD_PIN_NUM_DATA12, WAVESHARE_LCD_PIN_NUM_DATA13, WAVESHARE_LCD_PIN_NUM_DATA14, WAVESHARE_LCD_PIN_NUM_DATA15},
+        .flags = {.disp_active_low = false, .refresh_on_demand = false, .fb_in_psram = true, .double_fb = WAVESHARE_LCD_USE_DOUBLE_FB, .no_fb = false, .bb_invalidate_cache = false}
+    };
+
+    if (esp_lcd_new_rgb_panel(&panel_config, &panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to create RGB panel");
+        return nullptr;
+    }
+
+    esp_lcd_rgb_panel_event_callbacks_t cbs = {
+        .on_vsync = on_vsync_event,
+        .on_bounce_empty = nullptr,
+        .on_bounce_frame_finish = nullptr
+    };
+    if (esp_lcd_rgb_panel_register_event_callbacks(panel_handle, &cbs, nullptr) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to register callbacks");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_reset(panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to reset panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_init(panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to init panel");
+        return nullptr;
+    }
+
+    lv_init();
+
+#if WAVESHARE_LCD_USE_DOUBLE_FB
+    // initialize LVGL draw buffers
+    lv_draw_buf_t* buffer1 = lv_draw_buf_create(WAVESHARE_LCD_HOR_RES, WAVESHARE_LCD_BUFFER_HEIGHT, LV_COLOR_FORMAT_RGB565, 0);
+    lv_draw_buf_t* buffer2 = lv_draw_buf_create(WAVESHARE_LCD_HOR_RES, WAVESHARE_LCD_BUFFER_HEIGHT, LV_COLOR_FORMAT_RGB565, 0);
+    tt_assert(buffer1);
+    tt_assert(buffer2);
+#else
+    lv_draw_buf_t* buffer1 = lv_draw_buf_create(WAVESHARE_LCD_HOR_RES, WAVESHARE_LCD_VER_RES, LV_COLOR_FORMAT_RGB565, 0);
+    lv_draw_buf_t* buffer2 = NULL;
+    tt_assert(buffer1);
+#endif // WAVESHARE_USE_DOUBLE_FB
+
+    lv_display_t* display = lv_display_create(WAVESHARE_LCD_HOR_RES, WAVESHARE_LCD_VER_RES);
+    lv_display_set_draw_buffers(display, buffer1, buffer2);
+    lv_display_set_flush_cb(display, &display_flush_callback);
+    lv_display_set_user_data(display, panel_handle);
+    lv_display_set_antialiasing(display, false);
+    lv_display_set_render_mode(display, LV_DISPLAY_RENDER_MODE_PARTIAL);
+
+    const esp_timer_create_args_t lvgl_tick_timer_args = {
+        .callback = &lvgl_tick_task,
+        .name = "lvgl_tick"
+    };
+    esp_timer_handle_t lvgl_tick_timer = nullptr;
+    ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));
+    ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer, WAVESHARE_LVGL_TICK_PERIOD_MS * 1000));
+
+    return display;
+}
+
+void ws3t_display_destroy() {
+    // TODO: de-init display, its buffer and touch, stop display tasks, stop timer
+    // TODO: see esp_lvlg_port.c for more info
+    if (lvgl_mux) {
+        vSemaphoreDelete(lvgl_mux);
+        lvgl_mux = nullptr;
+    }
+#if LV_ENABLE_GC || !LV_MEM_CUSTOM
+    lv_deinit();
+#endif
+}

Boards/WaveshareS3Touch/display_i.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "lvgl.h"
+#include <cstdint>
+
+bool ws3t_display_lock(uint32_t timeout_ms);
+void ws3t_display_unlock(void);
+
+lv_display_t* ws3t_display_create();
+void ws3t_display_destroy();

Boards/WaveshareS3Touch/lvgl.cpp

@@ -0,0 +1,18 @@
+#include "lvgl_i.h"
+
+#include "display_i.h"
+#include "touch_i.h"
+#include "Ui/LvglSync.h"
+
+bool ws3t_init_lvgl() {
+    tt::lvgl::sync_set(&ws3t_display_lock, &ws3t_display_unlock);
+
+    lv_display_t* display = ws3t_display_create();
+    if (display == nullptr) {
+        return false;
+    }
+
+    ws3t_touch_init(display);
+
+    return true;
+}

Boards/WaveshareS3Touch/lvgl_i.h

@@ -0,0 +1,3 @@
+#pragma once
+
+bool ws3t_init_lvgl();

Boards/WaveshareS3Touch/touch.cpp

@@ -0,0 +1,72 @@
+#include "config.h"
+
+#include "driver/i2c.h"
+#include "esp_err.h"
+#include "esp_lcd_touch_gt911.h"
+#include "esp_log.h"
+#include "lvgl.h"
+
+#define TAG "waveshare_s3_touch_i2c"
+
+static esp_lcd_touch_handle_t touch_init_internal() {
+    static esp_lcd_panel_io_handle_t tp_io_handle = nullptr;
+    static esp_lcd_panel_io_i2c_config_t tp_io_config = ESP_LCD_TOUCH_IO_I2C_GT911_CONFIG();
+    ESP_LOGI(TAG, "Initialize touch IO");
+
+    // TODO: Revert on new ESP-IDF version
+    static_assert(ESP_IDF_VERSION == ESP_IDF_VERSION_VAL(5, 3, 1));
+    //    ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)WAVESHARE_TOUCH_I2C_PORT, &tp_io_config, &tp_io_handle));
+    esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)WAVESHARE_TOUCH_I2C_PORT, &tp_io_config, &tp_io_handle);
+
+    esp_lcd_touch_config_t tp_cfg = {
+        .x_max = WAVESHARE_LCD_VER_RES,
+        .y_max = WAVESHARE_LCD_HOR_RES,
+        .rst_gpio_num = GPIO_NUM_NC,
+        .int_gpio_num = GPIO_NUM_NC,
+        .flags = {
+            .swap_xy = 0,
+            .mirror_x = 0,
+            .mirror_y = 0,
+        },
+    };
+    /* Initialize touch */
+    ESP_LOGI(TAG, "Initialize touch controller GT911");
+    esp_lcd_touch_handle_t tp = nullptr;
+    ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_gt911(tp_io_handle, &tp_cfg, &tp));
+
+    return tp;
+}
+
+static void touch_callback(lv_indev_t* indev, lv_indev_data_t* data) {
+    uint16_t touchpad_x[1] = {0};
+    uint16_t touchpad_y[1] = {0};
+    uint8_t touchpad_cnt = 0;
+
+    /* Read touch controller data */
+    auto touch_handle = static_cast<esp_lcd_touch_handle_t>(lv_indev_get_user_data(indev));
+    esp_lcd_touch_read_data(touch_handle);
+
+    /* Get coordinates */
+    bool touchpad_pressed = esp_lcd_touch_get_coordinates(touch_handle, touchpad_x, touchpad_y, nullptr, &touchpad_cnt, 1);
+
+    if (touchpad_pressed && touchpad_cnt > 0) {
+        data->point.x = touchpad_x[0];
+        data->point.y = touchpad_y[0];
+        data->state = LV_INDEV_STATE_PR;
+    } else {
+        data->state = LV_INDEV_STATE_REL;
+    }
+}
+
+void ws3t_touch_init(lv_display_t* display) {
+    esp_lcd_touch_handle_t touch_handle = touch_init_internal();
+
+    ESP_LOGI(TAG, "Register display indev to LVGL");
+
+    static lv_indev_t* device = nullptr;
+    device = lv_indev_create();
+    lv_indev_set_type(device, LV_INDEV_TYPE_POINTER);
+    lv_indev_set_read_cb(device, &touch_callback);
+    lv_indev_set_display(device, display);
+    lv_indev_set_user_data(device, touch_handle);
+}

Boards/WaveshareS3Touch/touch_i.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "lvgl.h"
+
+void ws3t_touch_init(lv_display_t* display);

Boards/WaveshareS3Touch/waveshare_s3_touch.cpp

@@ -0,0 +1,15 @@
+#include "waveshare_s3_touch.h"
+
+#include "lvgl_i.h"
+
+bool ws3t_bootstrap();
+
+extern const tt::hal::Configuration waveshare_s3_touch = {
+    .bootstrap = &ws3t_bootstrap,
+    .init_graphics = &ws3t_init_lvgl,
+    .display = {
+        .set_backlight_duty = nullptr // TODO: This requires implementing the CH422G IO expander
+    },
+    .sdcard = nullptr,
+    .power = nullptr
+};

Boards/WaveshareS3Touch/waveshare_s3_touch.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "Hal/Configuration.h"
+
+// Waveshare S3 Touch LCD 4.3
+extern const tt::hal::Configuration waveshare_s3_touch;

Boards/YellowBoard/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRC_DIRS "."
+    INCLUDE_DIRS "."
+    REQUIRES Tactility esp_lvgl_port esp_lcd_touch_cst816s esp_lcd_ili9341 driver vfs fatfs
+)

Boards/YellowBoard/bootstrap.cpp

@@ -0,0 +1,96 @@
+#include "config.h"
+#include "TactilityCore.h"
+#include "display_i.h"
+#include <driver/spi_common.h>
+
+#define TAG "twodotfour_bootstrap"
+
+static bool init_i2c() {
+    const i2c_config_t i2c_conf = {
+        .mode = I2C_MODE_MASTER,
+        .sda_io_num = GPIO_NUM_33,
+        .scl_io_num = GPIO_NUM_32,
+        .sda_pullup_en = GPIO_PULLUP_DISABLE,
+        .scl_pullup_en = GPIO_PULLUP_DISABLE,
+        .master = {
+            .clk_speed = 400000
+        }
+    };
+
+    if (i2c_param_config(TWODOTFOUR_TOUCH_I2C_PORT, &i2c_conf) != ESP_OK) {
+        TT_LOG_E(TAG, "i2c config failed");
+        return false;
+    }
+
+    if (i2c_driver_install(TWODOTFOUR_TOUCH_I2C_PORT, i2c_conf.mode, 0, 0, 0) != ESP_OK) {
+        TT_LOG_E(TAG, "i2c driver install failed");
+        return false;
+    }
+
+    return true;
+}
+
+static bool init_spi2() {
+     const spi_bus_config_t bus_config = {
+         .mosi_io_num = TWODOTFOUR_SPI2_PIN_MOSI,
+         .miso_io_num = GPIO_NUM_NC,
+         .sclk_io_num = TWODOTFOUR_SPI2_PIN_SCLK,
+         .quadwp_io_num = GPIO_NUM_NC,
+         .quadhd_io_num = GPIO_NUM_NC,
+         .max_transfer_sz = TWODOTFOUR_SPI2_TRANSACTION_LIMIT
+    };
+
+     if (spi_bus_initialize(SPI2_HOST, &bus_config, SPI_DMA_CH_AUTO) != ESP_OK) {
+         TT_LOG_E(TAG, "SPI bus init failed");
+         return false;
+     }
+
+     return true;
+}
+
+static bool init_spi3() {
+    const spi_bus_config_t bus_config = {
+        .mosi_io_num = TWODOTFOUR_SPI3_PIN_MOSI,
+        .miso_io_num = TWODOTFOUR_SPI3_PIN_MISO,
+        .sclk_io_num = TWODOTFOUR_SPI3_PIN_SCLK,
+        .quadwp_io_num = GPIO_NUM_NC,
+        .quadhd_io_num = GPIO_NUM_NC,
+        .max_transfer_sz = TWODOTFOUR_SPI3_TRANSACTION_LIMIT
+    };
+
+    if (spi_bus_initialize(SPI3_HOST, &bus_config, SPI_DMA_CH_AUTO) != ESP_OK) {
+        TT_LOG_E(TAG, "SPI bus init failed");
+        return false;
+    }
+
+    return true;
+}
+
+bool twodotfour_bootstrap() {
+    TT_LOG_I(TAG, "Init I2C");
+    if (!init_i2c()) {
+        TT_LOG_E(TAG, "Init I2C failed");
+        return false;
+    }
+
+    TT_LOG_I(TAG, "Init SPI2");
+    if (!init_spi2()) {
+        TT_LOG_E(TAG, "Init SPI2 failed");
+        return false;
+    }
+
+    TT_LOG_I(TAG, "Init SPI3");
+    if (!init_spi3()) {
+        TT_LOG_E(TAG, "Init SPI3 failed");
+        return false;
+    }
+
+    // Don't turn the backlight on yet - Tactility init will take care of it
+    TT_LOG_I(TAG, "Init backlight");
+    if (!twodotfour_backlight_init()) {
+        TT_LOG_E(TAG, "Init backlight failed");
+        return false;
+    }
+
+    return true;
+}

Boards/YellowBoard/config.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "driver/spi_common.h"
+#include "driver/i2c.h"
+#include "driver/gpio.h"
+
+// SPI 2 - display
+#define TWODOTFOUR_SPI2_PIN_SCLK GPIO_NUM_14
+#define TWODOTFOUR_SPI2_PIN_MOSI GPIO_NUM_13
+#define TWODOTFOUR_SPI2_TRANSACTION_LIMIT TWODOTFOUR_LCD_DRAW_BUFFER_SIZE
+
+// SPI 3 - sdcard
+#define TWODOTFOUR_SPI3_PIN_SCLK GPIO_NUM_18
+#define TWODOTFOUR_SPI3_PIN_MOSI GPIO_NUM_23
+#define TWODOTFOUR_SPI3_PIN_MISO GPIO_NUM_19
+#define TWODOTFOUR_SPI3_TRANSACTION_LIMIT 8192 // TODO: Determine proper limit
+
+// Display
+#define TWODOTFOUR_LCD_SPI_HOST SPI2_HOST
+#define TWODOTFOUR_LCD_HORIZONTAL_RESOLUTION 240
+#define TWODOTFOUR_LCD_VERTICAL_RESOLUTION 320
+#define TWODOTFOUR_LCD_BITS_PER_PIXEL 16
+#define TWODOTFOUR_LCD_DRAW_BUFFER_HEIGHT (TWODOTFOUR_LCD_VERTICAL_RESOLUTION / 10)
+#define TWODOTFOUR_LCD_DRAW_BUFFER_SIZE (TWODOTFOUR_LCD_HORIZONTAL_RESOLUTION * TWODOTFOUR_LCD_DRAW_BUFFER_HEIGHT * (TWODOTFOUR_LCD_BITS_PER_PIXEL / 8))
+#define TWODOTFOUR_LCD_PIN_CS GPIO_NUM_15
+#define TWODOTFOUR_LCD_PIN_DC GPIO_NUM_2
+#define TWODOTFOUR_LCD_PIN_BACKLIGHT GPIO_NUM_27
+
+// Touch
+#define TWODOTFOUR_TOUCH_I2C_PORT I2C_NUM_0
+
+// SD Card
+#define TWODOTFOUR_SDCARD_SPI_HOST SPI3_HOST
+#define TWODOTFOUR_SDCARD_PIN_CS GPIO_NUM_5
+#define TWODOTFOUR_SDCARD_SPI_FREQUENCY 800000U
+#define TWODOTFOUR_SDCARD_FORMAT_ON_MOUNT_FAILED false
+#define TWODOTFOUR_SDCARD_MAX_OPEN_FILES 4
+#define TWODOTFOUR_SDCARD_ALLOC_UNIT_SIZE (16 * 1024)
+#define TWODOTFOUR_SDCARD_STATUS_CHECK_ENABLED false

Boards/YellowBoard/display.cpp

@@ -0,0 +1,126 @@
+#include "config.h"
+#include "TactilityCore.h"
+
+#include "driver/gpio.h"
+#include "driver/ledc.h"
+#include "esp_err.h"
+#include "esp_lcd_ili9341.h"
+#include "esp_lcd_panel_io.h"
+#include "esp_lcd_panel_ops.h"
+#include "esp_lvgl_port.h"
+
+#define TAG "twodotfour_ili9341"
+
+// Dipslay backlight (PWM)
+#define TWODOTFOUR_LCD_BACKLIGHT_LEDC_TIMER LEDC_TIMER_0
+#define TWODOTFOUR_LCD_BACKLIGHT_LEDC_MODE LEDC_LOW_SPEED_MODE
+#define TWODOTFOUR_LCD_BACKLIGHT_LEDC_CHANNEL LEDC_CHANNEL_0
+#define TWODOTFOUR_LCD_BACKLIGHT_LEDC_DUTY_RES LEDC_TIMER_8_BIT
+#define TWODOTFOUR_LCD_BACKLIGHT_LEDC_FREQUENCY (1000)
+
+bool twodotfour_backlight_init() {
+    ledc_timer_config_t ledc_timer = {
+        .speed_mode = TWODOTFOUR_LCD_BACKLIGHT_LEDC_MODE,
+        .duty_resolution = TWODOTFOUR_LCD_BACKLIGHT_LEDC_DUTY_RES,
+        .timer_num = TWODOTFOUR_LCD_BACKLIGHT_LEDC_TIMER,
+        .freq_hz = TWODOTFOUR_LCD_BACKLIGHT_LEDC_FREQUENCY,
+        .clk_cfg = LEDC_AUTO_CLK
+    };
+
+    if (ledc_timer_config(&ledc_timer) != ESP_OK) {
+        TT_LOG_E(TAG, "Backlight led timer config failed");
+        return false;
+    }
+
+    return true;
+}
+
+void twodotfour_backlight_set(uint8_t duty) {
+    ledc_channel_config_t ledc_channel = {
+        .gpio_num = TWODOTFOUR_LCD_PIN_BACKLIGHT,
+        .speed_mode = TWODOTFOUR_LCD_BACKLIGHT_LEDC_MODE,
+        .channel = TWODOTFOUR_LCD_BACKLIGHT_LEDC_CHANNEL,
+        .intr_type = LEDC_INTR_DISABLE,
+        .timer_sel = TWODOTFOUR_LCD_BACKLIGHT_LEDC_TIMER,
+        .duty = duty,
+        .hpoint = 0
+    };
+
+    // Setting the config in the timer init and then calling ledc_set_duty() doesn't work when
+    // the app is running. For an unknown reason we have to call this config method every time:
+    if (ledc_channel_config(&ledc_channel) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to configure display backlight");
+    }
+}
+
+lv_disp_t* twodotfour_display_init() {
+    TT_LOG_I(TAG, "Display init");
+
+    const esp_lcd_panel_io_spi_config_t panel_io_config = ILI9341_PANEL_IO_SPI_CONFIG(
+        TWODOTFOUR_LCD_PIN_CS,
+        TWODOTFOUR_LCD_PIN_DC,
+        nullptr,
+        nullptr
+    );
+
+    esp_lcd_panel_io_handle_t io_handle;
+    if (esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)TWODOTFOUR_LCD_SPI_HOST, &panel_io_config, &io_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to create panel");
+        return nullptr;
+    }
+
+    const esp_lcd_panel_dev_config_t panel_config = {
+        .reset_gpio_num = GPIO_NUM_NC,
+        .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_BGR,
+        .bits_per_pixel = TWODOTFOUR_LCD_BITS_PER_PIXEL,
+    };
+
+    esp_lcd_panel_handle_t panel_handle;
+    if (esp_lcd_new_panel_ili9341(io_handle, &panel_config, &panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to create ili9341");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_reset(panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to reset panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_init(panel_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to init panel");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_mirror(panel_handle, true, false) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set panel to mirror");
+        return nullptr;
+    }
+
+    if (esp_lcd_panel_disp_on_off(panel_handle, true) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to turn display on");
+        return nullptr;
+    }
+
+    const lvgl_port_display_cfg_t disp_cfg = {
+        .io_handle = io_handle,
+        .panel_handle = panel_handle,
+        .buffer_size = TWODOTFOUR_LCD_DRAW_BUFFER_SIZE,
+        .double_buffer = false,
+        .hres = TWODOTFOUR_LCD_HORIZONTAL_RESOLUTION,
+        .vres = TWODOTFOUR_LCD_VERTICAL_RESOLUTION,
+        .monochrome = false,
+        .rotation = {
+            .swap_xy = false,
+            .mirror_x = true,
+            .mirror_y = false,
+        },
+        .flags = {
+            .buff_dma = true,
+            .buff_spiram = false,
+            .sw_rotate = false,
+            .swap_bytes = true
+        }
+    };
+
+    return lvgl_port_add_disp(&disp_cfg);
+}

Boards/YellowBoard/display_i.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <cstdint>
+
+bool twodotfour_backlight_init();
+void twodotfour_backlight_set(uint8_t duty);

Boards/YellowBoard/lvgl.cpp

@@ -0,0 +1,56 @@
+#include "esp_lvgl_port.h"
+#include "Log.h"
+#include "Ui/LvglSync.h"
+#include "Thread.h"
+
+#define TAG "twodotfour_lvgl"
+
+lv_display_t* twodotfour_display_init();
+bool twodotfour_touch_init(esp_lcd_panel_io_handle_t* io_handle, esp_lcd_touch_handle_t* touch_handle);
+
+bool twodotfour_lvgl_init() {
+    static lv_display_t* display = nullptr;
+    static esp_lcd_panel_io_handle_t touch_io_handle;
+    static esp_lcd_touch_handle_t touch_handle;
+
+    const lvgl_port_cfg_t lvgl_cfg = {
+        .task_priority = tt::ThreadPriorityHigh,
+        .task_stack = 8096,
+        .task_affinity = -1, // core pinning
+        .task_max_sleep_ms = 500,
+        .timer_period_ms = 5
+    };
+
+    if (lvgl_port_init(&lvgl_cfg) != ESP_OK) {
+        TT_LOG_E(TAG, "lvgl port init failed");
+        return false;
+    }
+
+    // Add display
+    display = twodotfour_display_init();
+    if (display == nullptr) {
+        TT_LOG_E(TAG, "failed to add display");
+        return false;
+    }
+
+    // Add touch
+    if (!twodotfour_touch_init(&touch_io_handle, &touch_handle)) {
+        return false;
+    }
+
+    const lvgl_port_touch_cfg_t touch_cfg = {
+        .disp = display,
+        .handle = touch_handle,
+    };
+
+    auto* touch_indev= lvgl_port_add_touch(&touch_cfg);
+    if (touch_indev == nullptr) {
+        TT_LOG_E(TAG, "failed to add touch to lvgl");
+        return false;
+    }
+
+    // Set syncing functions
+    tt::lvgl::sync_set(&lvgl_port_lock, &lvgl_port_unlock);
+
+    return true;
+}

Boards/YellowBoard/sdcard.cpp

@@ -0,0 +1,79 @@
+#include "Hal/Sdcard.h"
+#include "Check.h"
+#include "Log.h"
+#include "config.h"
+
+#include "esp_vfs_fat.h"
+#include "sdmmc_cmd.h"
+
+#define TAG "twodotfour_sdcard"
+
+typedef struct {
+    const char* mount_point;
+    sdmmc_card_t* card;
+} MountData;
+
+static void* sdcard_mount(const char* mount_point) {
+    TT_LOG_I(TAG, "Mounting %s", mount_point);
+
+    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
+        .format_if_mount_failed = TWODOTFOUR_SDCARD_FORMAT_ON_MOUNT_FAILED,
+        .max_files = TWODOTFOUR_SDCARD_MAX_OPEN_FILES,
+        .allocation_unit_size = TWODOTFOUR_SDCARD_ALLOC_UNIT_SIZE,
+        .disk_status_check_enable = TWODOTFOUR_SDCARD_STATUS_CHECK_ENABLED
+    };
+
+    sdmmc_card_t* card;
+
+    // Init without card detect (CD) and write protect (WD)
+    sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
+    slot_config.gpio_cs = TWODOTFOUR_SDCARD_PIN_CS;
+    slot_config.host_id = TWODOTFOUR_SDCARD_SPI_HOST;
+
+    sdmmc_host_t host = SDSPI_HOST_DEFAULT();
+    host.max_freq_khz = TWODOTFOUR_SDCARD_SPI_FREQUENCY;
+    esp_err_t ret = esp_vfs_fat_sdspi_mount(mount_point, &host, &slot_config, &mount_config, &card);
+
+    if (ret != ESP_OK) {
+        if (ret == ESP_FAIL) {
+            TT_LOG_E(TAG, "Mounting failed. Ensure the card is formatted with FAT.");
+        } else {
+            TT_LOG_E(TAG, "Mounting failed (%s)", esp_err_to_name(ret));
+        }
+        return nullptr;
+    }
+
+    auto* data = static_cast<MountData*>(malloc(sizeof(MountData)));
+    *data = (MountData) {
+        .mount_point = mount_point,
+        .card = card
+    };
+
+    sdmmc_card_print_info(stdout, data->card);
+
+    return data;
+}
+
+static void sdcard_unmount(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    TT_LOG_I(TAG, "Unmounting %s", data->mount_point);
+
+    tt_assert(data != nullptr);
+    if (esp_vfs_fat_sdcard_unmount(data->mount_point, data->card) != ESP_OK) {
+        TT_LOG_E(TAG, "Unmount failed for %s", data->mount_point);
+    }
+
+    free(data);
+}
+
+static bool sdcard_is_mounted(void* context) {
+    auto* data = static_cast<MountData*>(context);
+    return (data != nullptr) && (sdmmc_get_status(data->card) == ESP_OK);
+}
+
+extern const tt::hal::sdcard::SdCard twodotfour_sdcard = {
+    .mount = &sdcard_mount,
+    .unmount = &sdcard_unmount,
+    .is_mounted = &sdcard_is_mounted,
+    .mount_behaviour = tt::hal::sdcard::MountBehaviourAnytime
+};

Boards/YellowBoard/touch.cpp

@@ -0,0 +1,50 @@
+#include "config.h"
+#include "driver/i2c.h"
+#include "esp_err.h"
+#include "esp_lcd_touch_cst816s.h"
+#include "esp_lcd_touch.h"
+#include "Log.h"
+
+#define TAG "twodotfour_cst816"
+
+bool twodotfour_touch_init(esp_lcd_panel_io_handle_t* io_handle, esp_lcd_touch_handle_t* touch_handle) {
+    TT_LOG_I(TAG, "Touch init");
+
+    const esp_lcd_panel_io_i2c_config_t touch_io_config = ESP_LCD_TOUCH_IO_I2C_CST816S_CONFIG();
+
+    // TODO: Check when ESP-IDF publishes fix (5.3.2 or 5.4.x)
+    static_assert(ESP_IDF_VERSION == ESP_IDF_VERSION_VAL(5, 3, 1));
+    esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)TWODOTFOUR_TOUCH_I2C_PORT, &touch_io_config, io_handle);
+    /*
+    if (esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)TWODOTFOUR_TOUCH_I2C_PORT, &touch_io_config, io_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Touch I2C IO init failed");
+        return false;
+    }
+    */
+
+    esp_lcd_touch_config_t config = {
+        .x_max = 240,
+        .y_max = 320,
+        .rst_gpio_num = GPIO_NUM_25,
+        .int_gpio_num = GPIO_NUM_21,
+        .levels = {
+            .reset = 0,
+            .interrupt = 0,
+        },
+        .flags = {
+            .swap_xy = 0,
+            .mirror_x = 0,
+            .mirror_y = 0,
+        },
+        .process_coordinates = nullptr,
+        .interrupt_callback = nullptr,
+        .user_data = nullptr
+    };
+
+    if (esp_lcd_touch_new_i2c_cst816s(*io_handle, &config, touch_handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Driver init failed");
+        return false;
+    }
+
+    return true;
+}

Boards/YellowBoard/yellow_board.cpp

@@ -0,0 +1,17 @@
+#include "yellow_board.h"
+#include "display_i.h"
+
+bool twodotfour_lvgl_init();
+bool twodotfour_bootstrap();
+
+extern const tt::hal::sdcard::SdCard twodotfour_sdcard;
+
+const tt::hal::Configuration yellow_board_24inch_cap = {
+    .bootstrap = &twodotfour_bootstrap,
+    .init_graphics = &twodotfour_lvgl_init,
+    .display = {
+        .set_backlight_duty = &twodotfour_backlight_set
+    },
+    .sdcard = &twodotfour_sdcard,
+    .power = nullptr
+};

Boards/YellowBoard/yellow_board.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "Hal/Configuration.h"
+
+// Capacitive touch version of the 2.4" yellow board
+extern const tt::hal::Configuration yellow_board_24inch_cap;