diff --git a/.gitignore b/.gitignore index cdeda01..c312ba3 100644 --- a/.gitignore +++ b/.gitignore @@ -40,3 +40,5 @@ nanobot/ # OS .DS_Store Thumbs.db + +references/ \ No newline at end of file diff --git a/assets/banner_172x320.rgb565 b/assets/banner_172x320.rgb565 new file mode 100644 index 0000000..c58e269 Binary files /dev/null and b/assets/banner_172x320.rgb565 differ diff --git a/assets/banner_320x172.rgb565 b/assets/banner_320x172.rgb565 new file mode 100644 index 0000000..6d14ca6 Binary files /dev/null and b/assets/banner_320x172.rgb565 differ diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index 490a733..60d6bf1 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -1,6 +1,11 @@ idf_component_register( SRCS "mimi.c" + "display/display.c" + "display/Vernon_ST7789T/Vernon_ST7789T.c" + "rgb/rgb.c" + "buttons/multi_button.c" + "buttons/button_driver.c" "bus/message_bus.c" "wifi/wifi_manager.c" "telegram/telegram_bot.c" @@ -19,7 +24,10 @@ idf_component_register( "tools/tool_files.c" INCLUDE_DIRS "." + EMBED_FILES + "../assets/banner_320x172.rgb565" REQUIRES nvs_flash esp_wifi esp_netif esp_http_client esp_http_server esp_https_ota esp_event json spiffs console vfs app_update esp-tls + driver esp_lcd esp_timer led_strip ) diff --git a/main/buttons/button_driver.c b/main/buttons/button_driver.c new file mode 100644 index 0000000..e50df3c --- /dev/null +++ b/main/buttons/button_driver.c @@ -0,0 +1,70 @@ +#include "buttons/button_driver.h" +#include "esp_err.h" +#include "esp_log.h" +#include "esp_timer.h" +#include "driver/gpio.h" +#include "display/display.h" + +void ESP32_Button_init(void){ + gpio_reset_pin(Button_PIN1); + gpio_set_direction(Button_PIN1, GPIO_MODE_INPUT); + gpio_set_pull_mode(Button_PIN1, GPIO_PULLUP_ONLY); +} +uint8_t Button_GPIO_Get_Level(int GPIO_PIN){ + return (uint8_t)(gpio_get_level(GPIO_PIN)); +} +void Timer_Callback(void *arg){ + button_ticks(); +} + + + +struct Button BUTTON1; +PressEvent BOOT_KEY_State,PWR_KEY_State; +uint8_t Read_Button_GPIO_Level(uint8_t button_id) +{ + if(!button_id) + return (uint8_t)(gpio_get_level(Button_PIN1)); + return 0; +} +void Button_SINGLE_CLICK_Callback(void* btn){ + struct Button *user_button = (struct Button *)btn; + if(user_button == &BUTTON1){ + BOOT_KEY_State = SINGLE_CLICK; + display_cycle_backlight(); + } +} +void Button_DOUBLE_CLICK_Callback(void* btn){ + struct Button *user_button = (struct Button *)btn; + if(user_button == &BUTTON1){ + BOOT_KEY_State = DOUBLE_CLICK; + } +} +void Button_LONG_PRESS_START_Callback(void* btn){ + struct Button *user_button = (struct Button *)btn; + if(user_button == &BUTTON1){ + BOOT_KEY_State= LONG_PRESS_START; + } +} +void button_Init(void) +{ + ESP32_Button_init(); + button_init(&BUTTON1, Read_Button_GPIO_Level, 0 , 0); + button_attach(&BUTTON1, SINGLE_CLICK, Button_SINGLE_CLICK_Callback); + button_attach(&BUTTON1, DOUBLE_CLICK, Button_DOUBLE_CLICK_Callback); + button_attach(&BUTTON1, LONG_PRESS_START, Button_LONG_PRESS_START_Callback); + + const esp_timer_create_args_t clock_tick_timer_args = + { + .callback = &Timer_Callback, + .name = "Timer_task", + .arg = NULL, + }; + esp_timer_handle_t clock_tick_timer = NULL; + ESP_ERROR_CHECK(esp_timer_create(&clock_tick_timer_args, &clock_tick_timer)); + ESP_ERROR_CHECK(esp_timer_start_periodic(clock_tick_timer, 1000 * 5)); + + BOOT_KEY_State = NONE_PRESS; + button_start(&BUTTON1); +} + diff --git a/main/buttons/button_driver.h b/main/buttons/button_driver.h new file mode 100644 index 0000000..17d896e --- /dev/null +++ b/main/buttons/button_driver.h @@ -0,0 +1,16 @@ +#ifndef BUTTON_BSP_H +#define BUTTON_BSP_H +#include +#include +#include "buttons/multi_button.h" + + +#define BOOT_KEY_PIN 0 + +#define Button_PIN1 BOOT_KEY_PIN + +extern PressEvent BOOT_KEY_State; + +void button_Init(void); + +#endif diff --git a/main/buttons/multi_button.c b/main/buttons/multi_button.c new file mode 100644 index 0000000..66d1020 --- /dev/null +++ b/main/buttons/multi_button.c @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2016 Zibin Zheng + * All rights reserved + */ + +#include "multi_button.h" + +#define EVENT_CB(ev) if(handle->cb[ev])handle->cb[ev]((void*)handle) +#define PRESS_REPEAT_MAX_NUM 15 /*!< The maximum value of the repeat counter */ + +//button handle list head. +static struct Button* head_handle = NULL; + +static void button_handler(struct Button* handle); + +/** + * @brief Initializes the button struct handle. + * @param handle: the button handle struct. + * @param pin_level: read the HAL GPIO of the connected button level. + * @param active_level: pressed GPIO level. + * @param button_id: the button id. + * @retval None + */ +void button_init(struct Button* handle, uint8_t(*pin_level)(uint8_t), uint8_t active_level, uint8_t button_id) +{ + memset(handle, 0, sizeof(struct Button)); + handle->event = (uint8_t)NONE_PRESS; + handle->hal_button_Level = pin_level; + handle->button_level = !active_level; + handle->active_level = active_level; + handle->button_id = button_id; +} + +/** + * @brief Attach the button event callback function. + * @param handle: the button handle struct. + * @param event: trigger event type. + * @param cb: callback function. + * @retval None + */ +void button_attach(struct Button* handle, PressEvent event, BtnCallback cb) +{ + handle->cb[event] = cb; +} + +/** + * @brief Inquire the button event happen. + * @param handle: the button handle struct. + * @retval button event. + */ +PressEvent get_button_event(struct Button* handle) +{ + return (PressEvent)(handle->event); +} + +/** + * @brief Button driver core function, driver state machine. + * @param handle: the button handle struct. + * @retval None + */ +static void button_handler(struct Button* handle) +{ + uint8_t read_gpio_level = handle->hal_button_Level(handle->button_id); + + //ticks counter working.. + if((handle->state) > 0) handle->ticks++; + + /*------------button debounce handle---------------*/ + if(read_gpio_level != handle->button_level) { //not equal to prev one + //continue read 3 times same new level change + if(++(handle->debounce_cnt) >= DEBOUNCE_TICKS) { + handle->button_level = read_gpio_level; + handle->debounce_cnt = 0; + } + } else { //level not change ,counter reset. + handle->debounce_cnt = 0; + } + + /*-----------------State machine-------------------*/ + switch (handle->state) { + case 0: + if(handle->button_level == handle->active_level) { //start press down + handle->event = (uint8_t)PRESS_DOWN; + EVENT_CB(PRESS_DOWN); + handle->ticks = 0; + handle->repeat = 1; + handle->state = 1; + } else { + handle->event = (uint8_t)NONE_PRESS; + } + break; + + case 1: + if(handle->button_level != handle->active_level) { //released press up + handle->event = (uint8_t)PRESS_UP; + EVENT_CB(PRESS_UP); + handle->ticks = 0; + handle->state = 2; + } else if(handle->ticks > LONG_TICKS) { + handle->event = (uint8_t)LONG_PRESS_START; + EVENT_CB(LONG_PRESS_START); + handle->state = 5; + } + break; + + case 2: + if(handle->button_level == handle->active_level) { //press down again + handle->event = (uint8_t)PRESS_DOWN; + EVENT_CB(PRESS_DOWN); + if(handle->repeat != PRESS_REPEAT_MAX_NUM) { + handle->repeat++; + } + EVENT_CB(PRESS_REPEAT); // repeat hit + handle->ticks = 0; + handle->state = 3; + } else if(handle->ticks > SHORT_TICKS) { //released timeout + if(handle->repeat == 1) { + handle->event = (uint8_t)SINGLE_CLICK; + EVENT_CB(SINGLE_CLICK); + } else if(handle->repeat == 2) { + handle->event = (uint8_t)DOUBLE_CLICK; + EVENT_CB(DOUBLE_CLICK); // repeat hit + } + handle->state = 0; + } + break; + + case 3: + if(handle->button_level != handle->active_level) { //released press up + handle->event = (uint8_t)PRESS_UP; + EVENT_CB(PRESS_UP); + if(handle->ticks < SHORT_TICKS) { + handle->ticks = 0; + handle->state = 2; //repeat press + } else { + handle->state = 0; + } + } else if(handle->ticks > SHORT_TICKS) { // SHORT_TICKS < press down hold time < LONG_TICKS + handle->state = 1; + } + break; + + case 5: + if(handle->button_level == handle->active_level) { + //continue hold trigger + handle->event = (uint8_t)LONG_PRESS_HOLD; + EVENT_CB(LONG_PRESS_HOLD); + } else { //released + handle->event = (uint8_t)PRESS_UP; + EVENT_CB(PRESS_UP); + handle->state = 0; //reset + } + break; + default: + handle->state = 0; //reset + break; + } +} + +/** + * @brief Start the button work, add the handle into work list. + * @param handle: target handle struct. + * @retval 0: succeed. -1: already exist. + */ +int button_start(struct Button* handle) +{ + struct Button* target = head_handle; + while(target) { + if(target == handle) return -1; //already exist. + target = target->next; + } + handle->next = head_handle; + head_handle = handle; + return 0; +} + +/** + * @brief Stop the button work, remove the handle off work list. + * @param handle: target handle struct. + * @retval None + */ +void button_stop(struct Button* handle) +{ + struct Button** curr; + for(curr = &head_handle; *curr; ) { + struct Button* entry = *curr; + if(entry == handle) { + *curr = entry->next; +// free(entry); + return;//glacier add 2021-8-18 + } else { + curr = &entry->next; + } + } +} + +/** + * @brief background ticks, timer repeat invoking interval 5ms. + * @param None. + * @retval None + */ +void button_ticks(void) +{ + struct Button* target; + for(target=head_handle; target; target=target->next) { + button_handler(target); + } +} diff --git a/main/buttons/multi_button.h b/main/buttons/multi_button.h new file mode 100644 index 0000000..2974168 --- /dev/null +++ b/main/buttons/multi_button.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2016 Zibin Zheng + * All rights reserved + */ + +#ifndef _MULTI_BUTTON_H_ +#define _MULTI_BUTTON_H_ + +#include +#include + +//According to your need to modify the constants. +#define TICKS_INTERVAL 5 //ms +#define DEBOUNCE_TICKS 3 //MAX 7 (0 ~ 7) +#define SHORT_TICKS (300 /TICKS_INTERVAL) +#define LONG_TICKS (1000 /TICKS_INTERVAL) + + +typedef void (*BtnCallback)(void*); + +typedef enum { + PRESS_DOWN = 0, + PRESS_UP, + PRESS_REPEAT, + SINGLE_CLICK, + DOUBLE_CLICK, + LONG_PRESS_START, + LONG_PRESS_HOLD, + number_of_event, + NONE_PRESS +}PressEvent; + +typedef struct Button { + uint16_t ticks; + uint8_t repeat : 4; + uint8_t event : 4; + uint8_t state : 3; + uint8_t debounce_cnt : 3; + uint8_t active_level : 1; + uint8_t button_level : 1; + uint8_t button_id; + uint8_t (*hal_button_Level)(uint8_t button_id_); + BtnCallback cb[number_of_event]; + struct Button* next; +}Button; + +#ifdef __cplusplus +extern "C" { +#endif + +void button_init(struct Button* handle, uint8_t(*pin_level)(uint8_t), uint8_t active_level, uint8_t button_id); +void button_attach(struct Button* handle, PressEvent event, BtnCallback cb); +PressEvent get_button_event(struct Button* handle); +int button_start(struct Button* handle); +void button_stop(struct Button* handle); +void button_ticks(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/main/display/Vernon_ST7789T/Vernon_ST7789T.c b/main/display/Vernon_ST7789T/Vernon_ST7789T.c new file mode 100644 index 0000000..f6ef3fa --- /dev/null +++ b/main/display/Vernon_ST7789T/Vernon_ST7789T.c @@ -0,0 +1,307 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include "sdkconfig.h" +#if CONFIG_LCD_ENABLE_DEBUG_LOG +// The local log level must be defined before including esp_log.h +// Set the maximum log level for this source file +#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG +#endif +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "esp_lcd_panel_interface.h" +#include "esp_lcd_panel_io.h" +#include "esp_lcd_panel_vendor.h" +#include "esp_lcd_panel_ops.h" +#include "esp_lcd_panel_commands.h" +#include "driver/gpio.h" +#include "esp_log.h" +#include "esp_check.h" + +#include "display/Vernon_ST7789T/Vernon_ST7789T.h" + +static const char *TAG = "lcd_panel.st7789t"; + +static esp_err_t panel_st7789t_del(esp_lcd_panel_t *panel); +static esp_err_t panel_st7789t_reset(esp_lcd_panel_t *panel); +static esp_err_t panel_st7789t_init(esp_lcd_panel_t *panel); +static esp_err_t panel_st7789t_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_st7789t_invert_color(esp_lcd_panel_t *panel, bool invert_color_data); +static esp_err_t panel_st7789t_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y); +static esp_err_t panel_st7789t_swap_xy(esp_lcd_panel_t *panel, bool swap_axes); +static esp_err_t panel_st7789t_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap); +static esp_err_t panel_st7789t_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_cal; // save surrent value of LCD_CMD_COLMOD register +} st7789t_panel_t; + +esp_err_t esp_lcd_new_panel_st7789t(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_st7789t_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel) +{ +#if CONFIG_LCD_ENABLE_DEBUG_LOG + esp_log_level_set(TAG, ESP_LOG_DEBUG); +#endif + esp_err_t ret = ESP_OK; + st7789t_panel_t *st7789t = NULL; + ESP_GOTO_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument"); + st7789t = calloc(1, sizeof(st7789t_panel_t)); + ESP_GOTO_ON_FALSE(st7789t, ESP_ERR_NO_MEM, err, TAG, "no mem for st7789t panel"); + + if (panel_dev_config->reset_gpio_num >= 0) { + gpio_config_t io_conf = { + .mode = GPIO_MODE_OUTPUT, + .pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num, + }; + ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed"); + } + + switch (panel_dev_config->rgb_endian) { + case LCD_RGB_ENDIAN_RGB: + st7789t->madctl_val = 0; + break; + case LCD_RGB_ENDIAN_BGR: + st7789t->madctl_val |= LCD_CMD_BGR_BIT; + break; + default: + ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported color space"); + break; + } + + uint8_t fb_bits_per_pixel = 0; + switch (panel_dev_config->bits_per_pixel) { + case 16: // RGB565 + st7789t->colmod_cal = 0x55; + fb_bits_per_pixel = 16; + break; + case 18: // RGB666 + st7789t->colmod_cal = 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 + fb_bits_per_pixel = 24; + break; + default: + ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported pixel width"); + break; + } + + st7789t->io = io; + st7789t->fb_bits_per_pixel = fb_bits_per_pixel; + st7789t->reset_gpio_num = panel_dev_config->reset_gpio_num; + st7789t->reset_level = panel_dev_config->flags.reset_active_high; + st7789t->base.del = panel_st7789t_del; + st7789t->base.reset = panel_st7789t_reset; + st7789t->base.init = panel_st7789t_init; + st7789t->base.draw_bitmap = panel_st7789t_draw_bitmap; + st7789t->base.invert_color = panel_st7789t_invert_color; + st7789t->base.set_gap = panel_st7789t_set_gap; + st7789t->base.mirror = panel_st7789t_mirror; + st7789t->base.swap_xy = panel_st7789t_swap_xy; + st7789t->base.disp_on_off = panel_st7789t_disp_on_off; + *ret_panel = &(st7789t->base); + ESP_LOGD(TAG, "new st7789t panel @%p", st7789t); + // printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n"); + return ESP_OK; + +err: + if (st7789t) { + if (panel_dev_config->reset_gpio_num >= 0) { + gpio_reset_pin(panel_dev_config->reset_gpio_num); + } + free(st7789t); + } + return ret; +} + +static esp_err_t panel_st7789t_del(esp_lcd_panel_t *panel) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + + if (st7789t->reset_gpio_num >= 0) { + gpio_reset_pin(st7789t->reset_gpio_num); + } + ESP_LOGD(TAG, "del st7789t panel @%p", st7789t); + free(st7789t); + return ESP_OK; +} + +static esp_err_t panel_st7789t_reset(esp_lcd_panel_t *panel) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + esp_lcd_panel_io_handle_t io = st7789t->io; + + // perform hardware reset + if (st7789t->reset_gpio_num >= 0) { + gpio_set_level(st7789t->reset_gpio_num, st7789t->reset_level); + vTaskDelay(pdMS_TO_TICKS(10)); + gpio_set_level(st7789t->reset_gpio_num, !st7789t->reset_level); + vTaskDelay(pdMS_TO_TICKS(10)); + } else { // perform software reset + esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0); + vTaskDelay(pdMS_TO_TICKS(20)); // spec, wait at least 5m before sending new command + } + + return ESP_OK; +} + +static esp_err_t panel_st7789t_init(esp_lcd_panel_t *panel) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + esp_lcd_panel_io_handle_t io = st7789t->io; + // LCD goes into sleep mode and display will be turned off after power on reset, exit sleep mode first + // printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n"); + esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0); + vTaskDelay(pdMS_TO_TICKS(100)); + // esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {st7789t->madctl_val,}, 1); + // esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD, (uint8_t[]) {st7789t->colmod_cal,}, 1); + + /* Memory Data Access Control, MX=MV=1, MY=ML=MH=0, RGB=0 */ + esp_lcd_panel_io_tx_param(io, 0x36, (uint8_t []){0x00}, 1); // 0x36: 接口像素格式 X镜像，Y镜像 + /* Interface Pixel Format, 16bits/pixel for RGB/MCU interface */ + esp_lcd_panel_io_tx_param(io, 0x3A, (uint8_t []){0x55}, 1); // 0x3A: Porch 设置 + + esp_lcd_panel_io_tx_param(io, 0xB0, (uint8_t []){0x00, 0xE8}, 2); + /* Porch Setting */ + esp_lcd_panel_io_tx_param(io, 0xB2, (uint8_t []){0x0c, 0x0c, 0x00, 0x33, 0x33}, 5); + /* Gate Control, Vgh=13.65V, Vgl=-10.43V */ + esp_lcd_panel_io_tx_param(io, 0xB7, (uint8_t []){0x75}, 1); + /* VCOM Setting, VCOM=1.175V */ + esp_lcd_panel_io_tx_param(io, 0xBB, (uint8_t []){0x1A}, 1); + /* LCM Control, XOR: BGR, MX, MH */ + esp_lcd_panel_io_tx_param(io, 0xC0, (uint8_t []){0x80}, 1); + /* VDV and VRH Command Enable, enable=1 */ + esp_lcd_panel_io_tx_param(io, 0xC2, (uint8_t []){0x01, 0xff}, 2); + /* VRH Set, Vap=4.4+... */ + esp_lcd_panel_io_tx_param(io, 0xC3, (uint8_t []){0x13}, 1); + /* VDV Set, VDV=0 */ + esp_lcd_panel_io_tx_param(io, 0xC4, (uint8_t []){0x20}, 1); + /* Frame Rate Control, 60Hz, inversion=0 */ + esp_lcd_panel_io_tx_param(io, 0xC6, (uint8_t []){0x0F}, 1); + /* Power Control 1, AVDD=6.8V, AVCL=-4.8V, VDDS=2.3V */ + esp_lcd_panel_io_tx_param(io, 0xD0, (uint8_t []){0xA4, 0xA1}, 1); + /* Positive Voltage Gamma Control */ + esp_lcd_panel_io_tx_param(io, 0xE0, (uint8_t []){0xD0, 0x0D, 0x14, 0x0D, 0x0D, 0x09, 0x38, 0x44, 0x4E, 0x3A, 0x17, 0x18, 0x2F, 0x30}, 14); + /* Negative Voltage Gamma Control */ + esp_lcd_panel_io_tx_param(io, 0xE1, (uint8_t []){0xD0, 0x09, 0x0F, 0x08, 0x07, 0x14, 0x37, 0x44, 0x4D, 0x38, 0x15, 0x16, 0x2C, 0x2E}, 14); + /* Sleep Out */ + esp_lcd_panel_io_tx_param(io, 0x21, NULL, 0); + /* Display On */ + esp_lcd_panel_io_tx_param(io, 0x29, NULL, 0); + + esp_lcd_panel_io_tx_param(io, 0x2C, NULL, 0); + + return ESP_OK; +} + +static esp_err_t panel_st7789t_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_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 = st7789t->io; + + x_start += st7789t->x_gap; + x_end += st7789t->x_gap; + y_start += st7789t->y_gap; + y_end += st7789t->y_gap; + + // define an area of frame memory where MCU can access + 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); + 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); + // transfer frame buffer + size_t len = (x_end - x_start) * (y_end - y_start) * st7789t->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_st7789t_invert_color(esp_lcd_panel_t *panel, bool invert_color_data) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + esp_lcd_panel_io_handle_t io = st7789t->io; + int command = 0; + if (invert_color_data) { + command = LCD_CMD_INVON; + } else { + command = LCD_CMD_INVOFF; + } + esp_lcd_panel_io_tx_param(io, command, NULL, 0); + return ESP_OK; +} + +static esp_err_t panel_st7789t_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + esp_lcd_panel_io_handle_t io = st7789t->io; + if (mirror_x) { + st7789t->madctl_val |= LCD_CMD_MX_BIT; + } else { + st7789t->madctl_val &= ~LCD_CMD_MX_BIT; + } + if (mirror_y) { + st7789t->madctl_val |= LCD_CMD_MY_BIT; + } else { + st7789t->madctl_val &= ~LCD_CMD_MY_BIT; + } + esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) { + st7789t->madctl_val + }, 1); + return ESP_OK; +} + +static esp_err_t panel_st7789t_swap_xy(esp_lcd_panel_t *panel, bool swap_axes) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + esp_lcd_panel_io_handle_t io = st7789t->io; + if (swap_axes) { + st7789t->madctl_val |= LCD_CMD_MV_BIT; + } else { + st7789t->madctl_val &= ~LCD_CMD_MV_BIT; + } + esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) { + st7789t->madctl_val + }, 1); + return ESP_OK; +} + +static esp_err_t panel_st7789t_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + st7789t->x_gap = x_gap; + st7789t->y_gap = y_gap; + return ESP_OK; +} + +static esp_err_t panel_st7789t_disp_on_off(esp_lcd_panel_t *panel, bool on_off) +{ + st7789t_panel_t *st7789t = __containerof(panel, st7789t_panel_t, base); + esp_lcd_panel_io_handle_t io = st7789t->io; + int command = 0; + if (on_off) { + command = LCD_CMD_DISPON; + } else { + command = LCD_CMD_DISPOFF; + } + esp_lcd_panel_io_tx_param(io, command, NULL, 0); + return ESP_OK; +} diff --git a/main/display/Vernon_ST7789T/Vernon_ST7789T.h b/main/display/Vernon_ST7789T/Vernon_ST7789T.h new file mode 100644 index 0000000..7472f57 --- /dev/null +++ b/main/display/Vernon_ST7789T/Vernon_ST7789T.h @@ -0,0 +1,47 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#pragma once + +#include +#include "esp_err.h" +#include "esp_lcd_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Configuration structure for panel device + */ +typedef struct { + int reset_gpio_num; /*!< GPIO used to reset the LCD panel, set to -1 if it's not used */ + union { + lcd_color_rgb_endian_t color_space; /*!< @deprecated Set RGB color space, please use rgb_endian instead */ + lcd_color_rgb_endian_t rgb_endian; /*!< Set RGB data endian: RGB or BGR */ + }; + unsigned int bits_per_pixel; /*!< Color depth, in bpp */ + struct { + unsigned int reset_active_high: 1; /*!< Setting this if the panel reset is high level active */ + } flags; /*!< LCD panel config flags */ + void *vendor_config; /*!< vendor specific configuration, optional, left as NULL if not used */ +} esp_lcd_panel_dev_st7789t_config_t; + +/** + * @brief Create LCD panel for model ST7789T + * + * @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_st7789t(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_st7789t_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel); + +#ifdef __cplusplus +} +#endif diff --git a/main/display/display.c b/main/display/display.c new file mode 100644 index 0000000..4c3b255 --- /dev/null +++ b/main/display/display.c @@ -0,0 +1,199 @@ +#include "display/display.h" + +#include +#include +#include "esp_check.h" +#include "esp_log.h" +#include "driver/ledc.h" +#include "driver/spi_master.h" +#include "esp_lcd_panel_io.h" +#include "esp_lcd_panel_ops.h" +#include "display/Vernon_ST7789T/Vernon_ST7789T.h" + +#define LCD_HOST SPI3_HOST + +#define LCD_PIXEL_CLOCK_HZ (12 * 1000 * 1000) +#define LCD_CMD_BITS 8 +#define LCD_PARAM_BITS 8 + +#define LCD_H_RES 172 +#define LCD_V_RES 320 + +#define BANNER_W 320 +#define BANNER_H 172 + +#define LCD_PIN_SCLK 40 +#define LCD_PIN_MOSI 45 +#define LCD_PIN_MISO -1 +#define LCD_PIN_DC 41 +#define LCD_PIN_RST 39 +#define LCD_PIN_CS 42 +#define LCD_PIN_BK_LIGHT 46 + +#define LCD_X_GAP 34 +#define LCD_Y_GAP 0 + +#define LEDC_TIMER LEDC_TIMER_0 +#define LEDC_MODE LEDC_LOW_SPEED_MODE +#define LEDC_CHANNEL LEDC_CHANNEL_0 +#define LEDC_DUTY_RES LEDC_TIMER_13_BIT +#define LEDC_FREQUENCY_HZ 4000 + +#define BACKLIGHT_MIN_PERCENT 10 +#define BACKLIGHT_MAX_PERCENT 100 +#define BACKLIGHT_STEP_PERCENT 10 + +static const char *TAG = "display"; + +static esp_lcd_panel_handle_t panel_handle = NULL; +static uint8_t backlight_percent = 50; + +extern const uint8_t _binary_banner_320x172_rgb565_start[]; +extern const uint8_t _binary_banner_320x172_rgb565_end[]; + +static void backlight_ledc_init(void) +{ + ledc_timer_config_t ledc_timer = { + .speed_mode = LEDC_MODE, + .timer_num = LEDC_TIMER, + .duty_resolution = LEDC_DUTY_RES, + .freq_hz = LEDC_FREQUENCY_HZ, + .clk_cfg = LEDC_AUTO_CLK, + }; + ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer)); + + ledc_channel_config_t ledc_channel = { + .speed_mode = LEDC_MODE, + .channel = LEDC_CHANNEL, + .timer_sel = LEDC_TIMER, + .intr_type = LEDC_INTR_DISABLE, + .gpio_num = LCD_PIN_BK_LIGHT, + .duty = 0, + .hpoint = 0, + }; + ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel)); +} + +void display_set_backlight_percent(uint8_t percent) +{ + if (percent > BACKLIGHT_MAX_PERCENT) { + percent = BACKLIGHT_MAX_PERCENT; + } + backlight_percent = percent; + + uint32_t duty_max = (1U << LEDC_DUTY_RES) - 1; + uint32_t duty = (duty_max * backlight_percent) / 100; + ESP_ERROR_CHECK(ledc_set_duty(LEDC_MODE, LEDC_CHANNEL, duty)); + ESP_ERROR_CHECK(ledc_update_duty(LEDC_MODE, LEDC_CHANNEL)); +} + +uint8_t display_get_backlight_percent(void) +{ + return backlight_percent; +} + +void display_cycle_backlight(void) +{ + uint8_t next = backlight_percent + BACKLIGHT_STEP_PERCENT; + if (next > BACKLIGHT_MAX_PERCENT) { + next = BACKLIGHT_MIN_PERCENT; + } + display_set_backlight_percent(next); + ESP_LOGI(TAG, "Backlight -> %u%%", next); +} + +esp_err_t display_init(void) +{ + esp_err_t ret = ESP_OK; + + spi_bus_config_t buscfg = { + .sclk_io_num = LCD_PIN_SCLK, + .mosi_io_num = LCD_PIN_MOSI, + .miso_io_num = LCD_PIN_MISO, + .quadwp_io_num = -1, + .quadhd_io_num = -1, + .max_transfer_sz = LCD_H_RES * LCD_V_RES * sizeof(uint16_t), + }; + ESP_RETURN_ON_ERROR(spi_bus_initialize(LCD_HOST, &buscfg, SPI_DMA_CH_AUTO), TAG, "spi bus init failed"); + + esp_lcd_panel_io_handle_t io_handle = NULL; + esp_lcd_panel_io_spi_config_t io_config = { + .dc_gpio_num = LCD_PIN_DC, + .cs_gpio_num = LCD_PIN_CS, + .pclk_hz = LCD_PIXEL_CLOCK_HZ, + .lcd_cmd_bits = LCD_CMD_BITS, + .lcd_param_bits = LCD_PARAM_BITS, + .spi_mode = 0, + .trans_queue_depth = 10, + .on_color_trans_done = NULL, + .user_ctx = NULL, + }; + ESP_RETURN_ON_ERROR(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST, &io_config, &io_handle), TAG, "panel io init failed"); + + esp_lcd_panel_dev_st7789t_config_t panel_config = { + .reset_gpio_num = LCD_PIN_RST, + .rgb_endian = LCD_RGB_ENDIAN_BGR, + .bits_per_pixel = 16, + }; + + ESP_RETURN_ON_ERROR(esp_lcd_new_panel_st7789t(io_handle, &panel_config, &panel_handle), TAG, "panel init failed"); + ESP_RETURN_ON_ERROR(esp_lcd_panel_reset(panel_handle), TAG, "panel reset failed"); + ESP_RETURN_ON_ERROR(esp_lcd_panel_init(panel_handle), TAG, "panel init failed"); + ESP_RETURN_ON_ERROR(esp_lcd_panel_mirror(panel_handle, true, true), TAG, "panel mirror failed"); + ESP_RETURN_ON_ERROR(esp_lcd_panel_swap_xy(panel_handle, true), TAG, "panel swap failed"); + ESP_RETURN_ON_ERROR(esp_lcd_panel_set_gap(panel_handle, LCD_Y_GAP, LCD_X_GAP), TAG, "panel gap failed"); + ESP_RETURN_ON_ERROR(esp_lcd_panel_disp_on_off(panel_handle, true), TAG, "panel on failed"); + + backlight_ledc_init(); + display_set_backlight_percent(backlight_percent); + + return ret; +} + +void display_show_banner(void) +{ + if (!panel_handle) { + ESP_LOGW(TAG, "display not initialized"); + return; + } + + const uint8_t *start = _binary_banner_320x172_rgb565_start; + const uint8_t *end = _binary_banner_320x172_rgb565_end; + size_t len = (size_t)(end - start); + size_t expected = (size_t)BANNER_W * (size_t)BANNER_H * 2; + if (len < expected) { + ESP_LOGW(TAG, "banner data too small (%u < %u)", (unsigned)len, (unsigned)expected); + return; + } + + ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(panel_handle, 0, 0, BANNER_W, BANNER_H, start)); +} + +bool display_get_banner_center_rgb(uint8_t *r, uint8_t *g, uint8_t *b) +{ + if (!r || !g || !b) { + return false; + } + + const uint8_t *start = _binary_banner_320x172_rgb565_start; + const uint8_t *end = _binary_banner_320x172_rgb565_end; + size_t len = (size_t)(end - start); + size_t expected = (size_t)BANNER_W * (size_t)BANNER_H * 2; + if (len < expected) { + return false; + } + + size_t cx = BANNER_W / 2; + size_t cy = BANNER_H / 2; + size_t idx = (cy * BANNER_W + cx) * 2; + uint16_t pixel = (uint16_t)start[idx] | ((uint16_t)start[idx + 1] << 8); + + uint8_t r5 = (pixel >> 11) & 0x1F; + uint8_t g6 = (pixel >> 5) & 0x3F; + uint8_t b5 = pixel & 0x1F; + + *r = (uint8_t)((r5 * 255) / 31); + *g = (uint8_t)((g6 * 255) / 63); + *b = (uint8_t)((b5 * 255) / 31); + return true; +} diff --git a/main/display/display.h b/main/display/display.h new file mode 100644 index 0000000..29dc315 --- /dev/null +++ b/main/display/display.h @@ -0,0 +1,20 @@ +#pragma once + +#include +#include +#include "esp_err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +esp_err_t display_init(void); +void display_show_banner(void); +void display_set_backlight_percent(uint8_t percent); +uint8_t display_get_backlight_percent(void); +void display_cycle_backlight(void); +bool display_get_banner_center_rgb(uint8_t *r, uint8_t *g, uint8_t *b); + +#ifdef __cplusplus +} +#endif diff --git a/main/idf_component.yml b/main/idf_component.yml new file mode 100644 index 0000000..8093f0d --- /dev/null +++ b/main/idf_component.yml @@ -0,0 +1,17 @@ +## IDF Component Manager Manifest File +dependencies: + ## Required IDF version + idf: + version: '>=4.1.0' + # # Put list of dependencies here + # # For components maintained by Espressif: + # component: "~1.0.0" + # # For 3rd party components: + # username/component: ">=1.0.0,<2.0.0" + # username2/component2: + # version: "~1.0.0" + # # For transient dependencies `public` flag can be set. + # # `public` flag doesn't have an effect dependencies of the `main` component. + # # All dependencies of `main` are public by default. + # public: true + espressif/led_strip: ^2.4.1 diff --git a/main/mimi.c b/main/mimi.c index 0c61150..ff0c176 100644 --- a/main/mimi.c +++ b/main/mimi.c @@ -21,6 +21,9 @@ #include "cli/serial_cli.h" #include "proxy/http_proxy.h" #include "tools/tool_registry.h" +#include "display/display.h" +#include "buttons/button_driver.h" +#include "rgb/rgb.h" static const char *TAG = "mimi"; @@ -95,6 +98,13 @@ void app_main(void) ESP_LOGI(TAG, "PSRAM free: %d bytes", (int)heap_caps_get_free_size(MALLOC_CAP_SPIRAM)); + /* Display + input */ + ESP_ERROR_CHECK(display_init()); + display_show_banner(); + ESP_ERROR_CHECK(rgb_init()); + rgb_set(255, 0, 0); + button_Init(); + /* Phase 1: Core infrastructure */ ESP_ERROR_CHECK(init_nvs()); ESP_ERROR_CHECK(esp_event_loop_create_default()); diff --git a/main/rgb/rgb.c b/main/rgb/rgb.c new file mode 100644 index 0000000..3b9f5e7 --- /dev/null +++ b/main/rgb/rgb.c @@ -0,0 +1,39 @@ +#include "rgb/rgb.h" + +#include "esp_check.h" +#include "led_strip.h" + +#define RGB_GPIO 38 + +static led_strip_handle_t s_strip = NULL; + +esp_err_t rgb_init(void) +{ + led_strip_config_t strip_config = { + .strip_gpio_num = RGB_GPIO, + .max_leds = 1, + .led_pixel_format = LED_PIXEL_FORMAT_GRB, + .led_model = LED_MODEL_WS2812, + .flags.invert_out = false, + }; + + led_strip_rmt_config_t rmt_config = { + .clk_src = RMT_CLK_SRC_DEFAULT, + .resolution_hz = 10 * 1000 * 1000, + .flags.with_dma = false, + }; + + ESP_RETURN_ON_ERROR(led_strip_new_rmt_device(&strip_config, &rmt_config, &s_strip), "rgb", "led_strip init failed"); + led_strip_clear(s_strip); + return ESP_OK; +} + +void rgb_set(uint8_t r, uint8_t g, uint8_t b) +{ + if (!s_strip) { + return; + } + /* Swap R/G for this board's LED ordering */ + led_strip_set_pixel(s_strip, 0, g, r, b); + led_strip_refresh(s_strip); +} diff --git a/main/rgb/rgb.h b/main/rgb/rgb.h new file mode 100644 index 0000000..fa59683 --- /dev/null +++ b/main/rgb/rgb.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include "esp_err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +esp_err_t rgb_init(void); +void rgb_set(uint8_t r, uint8_t g, uint8_t b); + +#ifdef __cplusplus +} +#endif diff --git a/main/tools/tool_files.c b/main/tools/tool_files.c index 3fada9e..7bf16cc 100644 --- a/main/tools/tool_files.c +++ b/main/tools/tool_files.c @@ -8,6 +8,7 @@ #include #include "esp_log.h" #include "cJSON.h" +#include static const char *TAG = "tool_files";