diff --git a/main/Kconfig.projbuild b/main/Kconfig.projbuild new file mode 100644 index 0000000..ba60e00 --- /dev/null +++ b/main/Kconfig.projbuild @@ -0,0 +1,8 @@ +menu "BLK_BOX Config" + config USE_NEW_DISPLAY + bool "use new TFT display" + default y + help + Whether or not you have a new TFT display. + Incorrectly selecting may result in wrong colors. +endmenu \ No newline at end of file diff --git a/main/drivers/CMakeLists.txt b/main/drivers/CMakeLists.txt index 69a6fa7..024ffff 100644 --- a/main/drivers/CMakeLists.txt +++ b/main/drivers/CMakeLists.txt @@ -1,6 +1,7 @@ set(SOURCES "TM1640/TM16xx.cpp" "TM1640/TM1640.cpp" + "esp_lcd_ili9488/esp_lcd_ili9488.c" "bottom_half.cpp" "char_lcd.cpp" "game_timer.cpp" diff --git a/main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.c b/main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.c new file mode 100644 index 0000000..2f034d8 --- /dev/null +++ b/main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.c @@ -0,0 +1,467 @@ +// Addapted from: +// https://github.com/atanisoft/esp_lcd_ili9488 + +/* + * SPDX-FileCopyrightText: 2022 atanisoft (github.com/atanisoft) + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static const char *TAG = "ili9488"; + +typedef struct +{ + uint8_t cmd; + uint8_t data[16]; + uint8_t data_bytes; +} lcd_init_cmd_t; + +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 memory_access_control; + uint8_t color_mode; + size_t buffer_size; + uint8_t *color_buffer; +} ili9488_panel_t; + +enum ili9488_constants +{ + ILI9488_INTRFC_MODE_CTL = 0xB0, + ILI9488_FRAME_RATE_NORMAL_CTL = 0xB1, + ILI9488_INVERSION_CTL = 0xB4, + ILI9488_FUNCTION_CTL = 0xB6, + ILI9488_ENTRY_MODE_CTL = 0xB7, + ILI9488_POWER_CTL_ONE = 0xC0, + ILI9488_POWER_CTL_TWO = 0xC1, + ILI9488_POWER_CTL_THREE = 0xC5, + ILI9488_POSITIVE_GAMMA_CTL = 0xE0, + ILI9488_NEGATIVE_GAMMA_CTL = 0xE1, + ILI9488_ADJUST_CTL_THREE = 0xF7, + + ILI9488_COLOR_MODE_16BIT = 0x55, + ILI9488_COLOR_MODE_18BIT = 0x66, + + ILI9488_INTERFACE_MODE_USE_SDO = 0x00, + ILI9488_INTERFACE_MODE_IGNORE_SDO = 0x80, + + ILI9488_IMAGE_FUNCTION_DISABLE_24BIT_DATA = 0x00, + + ILI9488_WRITE_MODE_BCTRL_DD_ON = 0x28, + ILI9488_FRAME_RATE_60HZ = 0xA0, + + ILI9488_INIT_LENGTH_MASK = 0x1F, + ILI9488_INIT_DONE_FLAG = 0xFF +}; + +static esp_err_t panel_ili9488_del(esp_lcd_panel_t *panel) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + + if (ili9488->reset_gpio_num >= 0) + { + gpio_reset_pin(ili9488->reset_gpio_num); + } + + if (ili9488->color_buffer != NULL) + { + heap_caps_free(ili9488->color_buffer); + } + + ESP_LOGI(TAG, "del ili9488 panel @%p", ili9488); + free(ili9488); + return ESP_OK; +} + +static esp_err_t panel_ili9488_reset(esp_lcd_panel_t *panel) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + esp_lcd_panel_io_handle_t io = ili9488->io; + + if (ili9488->reset_gpio_num >= 0) + { + ESP_LOGI(TAG, "Setting GPIO:%d to %d", ili9488->reset_gpio_num, + ili9488->reset_level); + // perform hardware reset + gpio_set_level(ili9488->reset_gpio_num, ili9488->reset_level); + vTaskDelay(pdMS_TO_TICKS(10)); + ESP_LOGI(TAG, "Setting GPIO:%d to %d", ili9488->reset_gpio_num, + !ili9488->reset_level); + gpio_set_level(ili9488->reset_gpio_num, !ili9488->reset_level); + vTaskDelay(pdMS_TO_TICKS(10)); + } + else + { + ESP_LOGI(TAG, "Sending SW_RESET to display"); + esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0); + vTaskDelay(pdMS_TO_TICKS(20)); + } + + return ESP_OK; +} + +static esp_err_t panel_ili9488_init(esp_lcd_panel_t *panel) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + esp_lcd_panel_io_handle_t io = ili9488->io; + + // ORIGINAL + lcd_init_cmd_t ili9488_init[] = + { +#if CONFIG_USE_NEW_DISPLAY + { ILI9488_POSITIVE_GAMMA_CTL, { 0x00, 0x08, 0x0c, 0x02, 0x0e, 0x04, 0x30, 0x45, 0x47, 0x04, 0x0C, 0x0a, 0x2e, 0x34, 0x0F }, 15 }, + { ILI9488_NEGATIVE_GAMMA_CTL, { 0x00, 0x11, 0x0d, 0x01, 0x0f, 0x05, 0x39, 0x36, 0x51, 0x06, 0x0f, 0x0d, 0x33, 0x37, 0x0F }, 15 }, +#else + { ILI9488_POSITIVE_GAMMA_CTL, { 0x00, 0x03, 0x09, 0x08, 0x16, 0x0A, 0x3F, 0x78, 0x4C, 0x09, 0x0A, 0x08, 0x16, 0x1A, 0x0F }, 15 }, + { ILI9488_NEGATIVE_GAMMA_CTL, { 0x00, 0x16, 0x19, 0x03, 0x0F, 0x05, 0x32, 0x45, 0x46, 0x04, 0x0E, 0x0D, 0x35, 0x37, 0x0F }, 15 }, +#endif /* CONFIG_USE_NEW_DISPLAY */ + + { ILI9488_POWER_CTL_ONE, { 0x17, 0x15 }, 2 }, + { ILI9488_POWER_CTL_TWO, { 0x41 }, 1 }, + { ILI9488_POWER_CTL_THREE, { 0x00, 0x12, 0x80 }, 3 }, + { LCD_CMD_MADCTL, { ili9488->memory_access_control }, 1 }, + { LCD_CMD_COLMOD, { ili9488->color_mode }, 1 }, + { ILI9488_INTRFC_MODE_CTL, { ILI9488_INTERFACE_MODE_USE_SDO }, 1 }, + { ILI9488_FRAME_RATE_NORMAL_CTL, { ILI9488_FRAME_RATE_60HZ }, 1 }, + { ILI9488_INVERSION_CTL, { 0x02 }, 1 }, + { ILI9488_FUNCTION_CTL, { 0x02, 0x02, 0x3B }, 3}, + { ILI9488_ENTRY_MODE_CTL, { 0xC6 }, 1 }, + { ILI9488_ADJUST_CTL_THREE, { 0xA9, 0x51, 0x2C, 0x02 }, 4 }, + { LCD_CMD_NOP, { 0 }, ILI9488_INIT_DONE_FLAG }, + }; + + // WITH CONSTS INLINED: + // lcd_init_cmd_t ili9488_init[] = + // { + // { 0xE0, + // { 0x00, 0x03, 0x09, 0x08, 0x16, + // 0x0A, 0x3F, 0x78, 0x4C, 0x09, + // 0x0A, 0x08, 0x16, 0x1A, 0x0F }, + // 15 + // }, + // { 0xE1, + // { 0x00, 0x16, 0x19, 0x03, 0x0F, + // 0x05, 0x32, 0x45, 0x46, 0x04, + // 0x0E, 0x0D, 0x35, 0x37, 0x0F}, + // 15 + // }, + // { 0xC0, { 0x17, 0x15 }, 2 }, + // { 0xC1, { 0x41 }, 1 }, + // { 0xC5, { 0x00, 0x12, 0x80 }, 3 }, + // { 0x36, { ili9488->memory_access_control }, 1 }, + // { 0x3A, { ili9488->color_mode }, 1 }, + // { 0xB0, { ILI9488_INTERFACE_MODE_USE_SDO }, 1 }, + // { 0xB1, { ILI9488_FRAME_RATE_60HZ }, 1 }, + // { 0xB4, { 0x02 }, 1 }, + // { 0xB6, { 0x02, 0x02, 0x3B }, 3}, + // { 0xB7, { 0xC6 }, 1 }, + // { 0xF7, { 0xA9, 0x51, 0x2C, 0x02 }, 4 }, + // { 0x00, { 0 }, ILI9488_INIT_DONE_FLAG }, + // }; + + // code from LCD manufacturer. (Not working): + // lcd_init_cmd_t ili9488_init[] = { + // { 0xF7, { 0xA9, 0x51, 0x2C, 0x82 }, 4 }, + // { 0x36, { 0x48 }, 1 }, + // { 0x3A, { 0x55 }, 1 }, + // { 0xB4, { 0x02 }, 1 }, + // { 0xB1, { 0xA0, 0x11 }, 2 }, + // { 0xC0, { 0x0F, 0x0F }, 2 }, + // { 0xC1, { 0x41 }, 1 }, + // { 0xC2, { 0x22 }, 1 }, + // { 0xB7, { 0xC6 }, 1 }, + // { 0xc5, { 0x00, 0x53, 0x80 }, 3 }, + // { 0xE0, { 0x00, 0x08, 0x0c, 0x02, 0x0e, 0x04, 0x30, 0x45, 0x47, 0x04, 0x0C, 0x0a, 0x2e, 0x34, 0x0F }, 15 }, + // { 0xE1, { 0x00, 0x11, 0x0d, 0x01, 0x0f, 0x05, 0x39, 0x36, 0x51, 0x06, 0x0f, 0x0d, 0x33, 0x37, 0x0F }, 15 }, + // { 0x21, { 0x00 }, 1 }, + // { 0x3A, { 0x55 }, 1 }, + // { LCD_CMD_NOP, { 0 }, ILI9488_INIT_DONE_FLAG }, + // }; + + ESP_LOGI(TAG, "Initializing ILI9488"); + int cmd = 0; + while ( ili9488_init[cmd].data_bytes != ILI9488_INIT_DONE_FLAG ) + { + ESP_LOGD(TAG, "Sending CMD: %02x, len: %d", ili9488_init[cmd].cmd, + ili9488_init[cmd].data_bytes & ILI9488_INIT_LENGTH_MASK); + esp_lcd_panel_io_tx_param( + io, ili9488_init[cmd].cmd, ili9488_init[cmd].data, + ili9488_init[cmd].data_bytes & ILI9488_INIT_LENGTH_MASK); + cmd++; + } + + // Take the display out of sleep mode. + esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0); + vTaskDelay(pdMS_TO_TICKS(100)); + + // Turn on the display. + esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPON, NULL, 0); + vTaskDelay(pdMS_TO_TICKS(100)); + + ESP_LOGI(TAG, "Initialization complete"); + + return ESP_OK; +} + +#define SEND_COORDS(start, end, io, cmd) \ + esp_lcd_panel_io_tx_param(io, cmd, (uint8_t[]) { \ + (start >> 8) & 0xFF, \ + start & 0xFF, \ + ((end - 1) >> 8) & 0xFF, \ + (end - 1) & 0xFF, \ + }, 4) + +static esp_err_t panel_ili9488_draw_bitmap( + esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, + const void *color_data) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + assert((x_start < x_end) && (y_start < y_end) && + "starting position must be smaller than end position"); + esp_lcd_panel_io_handle_t io = ili9488->io; + + x_start += ili9488->x_gap; + x_end += ili9488->x_gap; + y_start += ili9488->y_gap; + y_end += ili9488->y_gap; + + size_t color_data_len = (x_end - x_start) * (y_end - y_start); + + SEND_COORDS(x_start, x_end, io, LCD_CMD_CASET); + SEND_COORDS(y_start, y_end, io, LCD_CMD_RASET); + + // When the ILI9488 is used in 18-bit color mode we need to convert the + // incoming color data from RGB565 (16-bit) to RGB666. + // + // NOTE: 16-bit color does not work via SPI interface :( + if (ili9488->color_mode == ILI9488_COLOR_MODE_18BIT) + { + uint8_t *buf = ili9488->color_buffer; + uint16_t *raw_color_data = (uint16_t *) color_data; + for (uint32_t i = 0, pixel_index = 0; i < color_data_len; i++) { + buf[pixel_index++] = (uint8_t) (((raw_color_data[i] & 0xF800) >> 8) | + ((raw_color_data[i] & 0x8000) >> 13)); + buf[pixel_index++] = (uint8_t) ((raw_color_data[i] & 0x07E0) >> 3); + buf[pixel_index++] = (uint8_t) (((raw_color_data[i] & 0x001F) << 3) | + ((raw_color_data[i] & 0x0010) >> 2)); + } + + esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, buf, color_data_len * 3); + } + else + { + // 16-bit color we can transmit as-is to the display. + esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, color_data, color_data_len * 2); + } + + return ESP_OK; +} + +#undef SEND_COORDS + +static esp_err_t panel_ili9488_invert_color( + esp_lcd_panel_t *panel, bool invert_color_data) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + esp_lcd_panel_io_handle_t io = ili9488->io; + + if (invert_color_data) + { + esp_lcd_panel_io_tx_param(io, LCD_CMD_INVON, NULL, 0); + } + else + { + esp_lcd_panel_io_tx_param(io, LCD_CMD_INVOFF, NULL, 0); + } + + return ESP_OK; +} + +static esp_err_t panel_ili9488_mirror( + esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + esp_lcd_panel_io_handle_t io = ili9488->io; + if (mirror_x) + { + ili9488->memory_access_control &= ~LCD_CMD_MX_BIT; + } + else + { + ili9488->memory_access_control |= LCD_CMD_MX_BIT; + } + if (mirror_y) + { + ili9488->memory_access_control |= LCD_CMD_MY_BIT; + } + else + { + ili9488->memory_access_control &= ~LCD_CMD_MY_BIT; + } + esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, &ili9488->memory_access_control, 1); + return ESP_OK; +} + +static esp_err_t panel_ili9488_swap_xy(esp_lcd_panel_t *panel, bool swap_axes) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + esp_lcd_panel_io_handle_t io = ili9488->io; + if (swap_axes) + { + ili9488->memory_access_control |= LCD_CMD_MV_BIT; + } + else + { + ili9488->memory_access_control &= ~LCD_CMD_MV_BIT; + } + esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, &ili9488->memory_access_control, 1); + return ESP_OK; +} + +static esp_err_t panel_ili9488_set_gap( + esp_lcd_panel_t *panel, int x_gap, int y_gap) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + ili9488->x_gap = x_gap; + ili9488->y_gap = y_gap; + return ESP_OK; +} + +static esp_err_t panel_ili9488_disp_on_off(esp_lcd_panel_t *panel, bool on_off) +{ + ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base); + esp_lcd_panel_io_handle_t io = ili9488->io; + +#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0) + // In ESP-IDF v4.x the API used false for "on" and true for "off" + // invert the logic to be consistent with IDF v5.x. + on_off = !on_off; +#endif + + if (on_off) + { + esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPON, NULL, 0); + } + else + { + esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPOFF, NULL, 0); + } + + // give time for the ILI9488 to recover after an on/off command + vTaskDelay(pdMS_TO_TICKS(100)); + + return ESP_OK; +} + +esp_err_t esp_lcd_new_panel_ili9488( + const esp_lcd_panel_io_handle_t io, + const esp_lcd_panel_dev_config_t *panel_dev_config, + const size_t buffer_size, + esp_lcd_panel_handle_t *ret_panel) +{ + esp_err_t ret = ESP_OK; + ili9488_panel_t *ili9488 = NULL; + ESP_GOTO_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, + err, TAG, "invalid argument"); + ili9488 = (ili9488_panel_t *)(calloc(1, sizeof(ili9488_panel_t))); + ESP_GOTO_ON_FALSE(ili9488, ESP_ERR_NO_MEM, err, TAG, "no mem for ili9488 panel"); + + if (panel_dev_config->reset_gpio_num >= 0) + { + gpio_config_t cfg; + memset(&cfg, 0, sizeof(gpio_config_t)); + esp_rom_gpio_pad_select_gpio(panel_dev_config->reset_gpio_num); + cfg.pin_bit_mask = BIT64(panel_dev_config->reset_gpio_num); + cfg.mode = GPIO_MODE_OUTPUT; + ESP_GOTO_ON_ERROR(gpio_config(&cfg), err, TAG, + "configure GPIO for RESET line failed"); + } + + if (panel_dev_config->bits_per_pixel == 16) + { + ili9488->color_mode = ILI9488_COLOR_MODE_16BIT; + } + else + { + ESP_GOTO_ON_FALSE(buffer_size > 0, ESP_ERR_INVALID_ARG, err, TAG, + "Color conversion buffer size must be specified"); + ili9488->color_mode = ILI9488_COLOR_MODE_18BIT; + + // Allocate DMA buffer for color conversions + ili9488->color_buffer = + (uint8_t *)heap_caps_malloc(buffer_size * 3, MALLOC_CAP_DMA); + ESP_GOTO_ON_FALSE(ili9488->color_buffer, ESP_ERR_NO_MEM, err, TAG, + "Failed to allocate DMA color conversion buffer"); + } + + ili9488->memory_access_control = LCD_CMD_MX_BIT | LCD_CMD_BGR_BIT; + switch (panel_dev_config->color_space) + { + case ESP_LCD_COLOR_SPACE_RGB: + ESP_LOGI(TAG, "Configuring for RGB color order"); + ili9488->memory_access_control &= ~LCD_CMD_BGR_BIT; + break; + case ESP_LCD_COLOR_SPACE_BGR: + ESP_LOGI(TAG, "Configuring for BGR color order"); + break; + default: + ESP_GOTO_ON_FALSE(false, ESP_ERR_INVALID_ARG, err, TAG, + "Unsupported color mode!"); + } + + ili9488->io = io; + ili9488->reset_gpio_num = panel_dev_config->reset_gpio_num; + ili9488->reset_level = panel_dev_config->flags.reset_active_high; + ili9488->base.del = panel_ili9488_del; + ili9488->base.reset = panel_ili9488_reset; + ili9488->base.init = panel_ili9488_init; + ili9488->base.draw_bitmap = panel_ili9488_draw_bitmap; + ili9488->base.invert_color = panel_ili9488_invert_color; + ili9488->base.set_gap = panel_ili9488_set_gap; + ili9488->base.mirror = panel_ili9488_mirror; + ili9488->base.swap_xy = panel_ili9488_swap_xy; +#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0) + ili9488->base.disp_off = panel_ili9488_disp_on_off; +#else + ili9488->base.disp_on_off = panel_ili9488_disp_on_off; +#endif + *ret_panel = &(ili9488->base); + ESP_LOGI(TAG, "new ili9488 panel @%p", ili9488); + + return ESP_OK; + +err: + if (ili9488) + { + if (panel_dev_config->reset_gpio_num >= 0) + { + gpio_reset_pin(panel_dev_config->reset_gpio_num); + } + if (ili9488->color_buffer != NULL) + { + heap_caps_free(ili9488->color_buffer); + } + free(ili9488); + } + return ret; +} \ No newline at end of file diff --git a/main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.h b/main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.h new file mode 100644 index 0000000..87eecb9 --- /dev/null +++ b/main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.h @@ -0,0 +1,45 @@ +// Addapted from: +// https://github.com/atanisoft/esp_lcd_ili9488 + +/* + * SPDX-FileCopyrightText: 2022 atanisoft (github.com/atanisoft) + * + * SPDX-License-Identifier: MIT + */ + +#pragma once + +#include "esp_lcd_panel_vendor.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Create LCD panel for model ILI9488 + * + * @param[in] io LCD panel IO handle + * @param[in] panel_dev_config general panel device configuration + * @param[in] buffer_size size of buffer to allocate for color conversions. + * @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 + * + * NOTE: If you are using the SPI interface you *MUST* 18-bit color mode + * in @param panel_dev_config field bits_per_pixel and @param buffer_size + * must be provided. + * + * NOTE: For parallel IO (Intel 8080) interface 16-bit color mode should + * be used and @param buffer_size will be ignored. + + */ +esp_err_t esp_lcd_new_panel_ili9488(const esp_lcd_panel_io_handle_t io, + const esp_lcd_panel_dev_config_t *panel_dev_config, + const size_t buffer_size, + esp_lcd_panel_handle_t *ret_panel); + +#ifdef __cplusplus +} +#endif diff --git a/main/drivers/tft.cpp b/main/drivers/tft.cpp index d944feb..3c4839e 100644 --- a/main/drivers/tft.cpp +++ b/main/drivers/tft.cpp @@ -87,7 +87,6 @@ static void initialize_display() { } }; - const esp_lcd_panel_dev_config_t lcd_config = { .reset_gpio_num = TFT_PIN_RESET, .color_space = LCD_RGB_ELEMENT_ORDER_BGR, @@ -103,7 +102,7 @@ static void initialize_display() { esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)SPI2_HOST, &io_config, &lcd_io_handle)); ESP_ERROR_CHECK(esp_lcd_new_panel_ili9488(lcd_io_handle, &lcd_config, LV_BUFFER_SIZE, &lcd_handle)); - + ESP_ERROR_CHECK(esp_lcd_panel_reset(lcd_handle)); ESP_ERROR_CHECK(esp_lcd_panel_init(lcd_handle)); ESP_ERROR_CHECK(esp_lcd_panel_invert_color(lcd_handle, true)); diff --git a/main/drivers/tft.h b/main/drivers/tft.h index a59cae7..5a704ef 100644 --- a/main/drivers/tft.h +++ b/main/drivers/tft.h @@ -22,7 +22,7 @@ #include #include #include -#include +#include "esp_lcd_ili9488/esp_lcd_ili9488.h" #include #include #include diff --git a/main/helper.cpp b/main/helper.cpp index 0030796..23c2c0b 100644 --- a/main/helper.cpp +++ b/main/helper.cpp @@ -21,18 +21,6 @@ void clean_bomb(void) { lcd_set_cursor(&lcd, 0, 0); } -void poster_child_task(void* arg) { - while (1) { - if (get_help_button_pressed()) { - play_raw(MOUNT_POINT "/poster.pcm"); - } - vTaskDelay(pdMS_TO_TICKS(10)); - } - - vTaskDelete(NULL); -} - - static const int STRING_MAX_LEN = 8; void do_star_codes(StarCodeHandler* star_codes, int star_codes_len) { KeypadKey key; @@ -112,10 +100,11 @@ static char* write_time(uint32_t game_time) { uint8_t minutes = (game_time / (1000*60)) % 60; uint8_t seconds = (game_time / (1000)) % 60; - sprintf(str_buf, "%d:%d:%d", hours, minutes, seconds); + sprintf(str_buf, "%d:%02d:%02d", hours, minutes, seconds); return str_buf; } +extern uint32_t initial_game_time; void display_game_results(void) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { lv_style_init(&game_results_style); @@ -125,12 +114,13 @@ void display_game_results(void) { lv_style_set_text_align(&game_results_style, LV_TEXT_ALIGN_CENTER); game_results_label = lv_label_create(lv_scr_act()); - lv_obj_add_flag(game_results_label, LV_OBJ_FLAG_HIDDEN); lv_obj_align(game_results_label, LV_ALIGN_CENTER, 0, 0); lv_obj_add_style(game_results_label, &game_results_style, LV_STATE_DEFAULT); char buf[100] = {0}; - char* time = write_time(get_game_time()); + int32_t time_s = get_game_time(); + int32_t time_spent = initial_game_time - time_s; + char* time = write_time(time_spent); sprintf(buf, "Finished!\nTotal Time (w/ penalties): %s\nTotal Strikes: %ld", time, total_strikes); lv_label_set_text(game_results_label, buf); diff --git a/main/idf_component.yml b/main/idf_component.yml index 0a3858d..fe50ec9 100644 --- a/main/idf_component.yml +++ b/main/idf_component.yml @@ -3,7 +3,7 @@ dependencies: # iamflinks/i2c_lcd_pcf8574: "^1.0.1" espressif/led_strip: "^2.5.4" lvgl/lvgl: "^8.1" - atanisoft/esp_lcd_ili9488: "^1.0.9" + # atanisoft/esp_lcd_ili9488: "^1.0.9" ## Required IDF version idf: version: ">=4.1.0" diff --git a/main/main.cpp b/main/main.cpp index c340010..e2c77ff 100755 --- a/main/main.cpp +++ b/main/main.cpp @@ -25,7 +25,7 @@ #include "steps/step6.h" static const char *TAG = "main"; -uint32_t initial_game_time = 60*60*1000; +uint32_t initial_game_time = 90*60*1000; uint32_t skip_to_step = 0; extern "C" void app_main(void) { diff --git a/sdkconfig b/sdkconfig index d29baac..c43eeef 100644 --- a/sdkconfig +++ b/sdkconfig @@ -344,7 +344,7 @@ CONFIG_IDF_TOOLCHAIN="gcc" CONFIG_IDF_TARGET_ARCH_XTENSA=y CONFIG_IDF_TARGET_ARCH="xtensa" CONFIG_IDF_TARGET="esp32s3" -CONFIG_IDF_INIT_VERSION="5.2.1" +CONFIG_IDF_INIT_VERSION="$IDF_INIT_VERSION" CONFIG_IDF_TARGET_ESP32S3=y CONFIG_IDF_FIRMWARE_CHIP_ID=0x0009 @@ -510,6 +510,12 @@ CONFIG_PARTITION_TABLE_OFFSET=0x8000 CONFIG_PARTITION_TABLE_MD5=y # end of Partition Table +# +# BLK_BOX Config +# +CONFIG_USE_NEW_DISPLAY=y +# end of BLK_BOX Config + # # Compiler options #