titor/mimiclaw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #64 from IRONICBo/chore/simplify-device-usage

Browse Source 
refactor: remove LCD/LED dependencies and fix Telegram duplicate update handling
This commit is contained in:
crispyberry
2026-02-20 00:37:27 +08:00
committed by GitHub
parent cca3e759e4 b1d8f41f1c
commit 37a141df07
16 changed files with 128 additions and 1299 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
assets/banner_172x320.rgb565
View File

Binary file not shown.

BIN
assets/banner_320x172.rgb565
View File

Binary file not shown.

7
main/CMakeLists.txt
View File

@@ -1,9 +1,6 @@
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"
"imu/I2C_Driver.c"
@@ -32,10 +29,8 @@ idf_component_register(
"skills/skill_loader.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 qrcode
driver esp_timer
)

4
main/buttons/button_driver.c
View File

@@ -3,7 +3,6 @@
#include "esp_log.h"
#include "esp_timer.h"
#include "driver/gpio.h"
#include "display/display.h"
#include "ui/config_screen.h"
void ESP32_Button_init(void){
@@ -34,8 +33,6 @@ void Button_SINGLE_CLICK_Callback(void* btn){
BOOT_KEY_State = SINGLE_CLICK;
if (config_screen_is_active()) {
config_screen_scroll_down();
} else {
display_cycle_backlight();
}
}
}
@@ -72,4 +69,3 @@ void button_Init(void)
BOOT_KEY_State = NONE_PRESS;
button_start(&BUTTON1);
}

17
main/cli/serial_cli.c
View File

@@ -552,11 +552,20 @@ esp_err_t serial_cli_init(void)
repl_config.prompt = "mimi> ";
repl_config.max_cmdline_length = 256;
/* UART console (primary), USB Serial/JTAG available as secondary */
esp_console_dev_uart_config_t hw_config =
ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
#if CONFIG_ESP_CONSOLE_UART_DEFAULT || CONFIG_ESP_CONSOLE_UART_CUSTOM
esp_console_dev_uart_config_t hw_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_console_new_repl_uart(&hw_config, &repl_config, &repl));
#elif CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
esp_console_dev_usb_serial_jtag_config_t hw_config =
ESP_CONSOLE_DEV_USB_SERIAL_JTAG_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_console_new_repl_usb_serial_jtag(&hw_config, &repl_config, &repl));
#elif CONFIG_ESP_CONSOLE_USB_CDC
esp_console_dev_usb_cdc_config_t hw_config = ESP_CONSOLE_DEV_CDC_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_console_new_repl_usb_cdc(&hw_config, &repl_config, &repl));
#else
ESP_LOGE(TAG, "No supported console backend is enabled");
return ESP_ERR_NOT_SUPPORTED;
#endif
/* Register commands */
esp_console_register_help_command();

307
main/display/Vernon_ST7789T/Vernon_ST7789T.c
View File

@@ -1,307 +0,0 @@
/*
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include <sys/cdefs.h>
#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;
}

47
main/display/Vernon_ST7789T/Vernon_ST7789T.h
View File

@@ -1,47 +0,0 @@
/*
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <stdbool.h>
#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

598
main/display/display.c
View File

@@ -1,598 +0,0 @@
#include "display/display.h"
#include "mimi_config.h"
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/timers.h"
#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"
#include "display/font5x7.h"
#include "qrcode.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;
static uint16_t *framebuffer = NULL;
static SemaphoreHandle_t s_display_lock = NULL;
static TimerHandle_t s_card_hide_timer = NULL;
static uint32_t s_card_generation = 0;
typedef enum {
SCREEN_KIND_NONE = 0,
SCREEN_KIND_BANNER,
SCREEN_KIND_CONFIG,
SCREEN_KIND_CARD,
} screen_kind_t;
static screen_kind_t s_screen_kind = SCREEN_KIND_NONE;
typedef struct {
int x;
int y;
int box;
uint16_t fg;
} qr_draw_ctx_t;
static qr_draw_ctx_t s_qr_ctx;
extern const uint8_t _binary_banner_320x172_rgb565_start[];
extern const uint8_t _binary_banner_320x172_rgb565_end[];
static inline uint16_t rgb565(uint8_t r, uint8_t g, uint8_t b)
{
return (uint16_t)(((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3));
}
static bool display_lock_take(TickType_t wait_ticks)
{
if (!s_display_lock) {
return false;
}
return xSemaphoreTake(s_display_lock, wait_ticks) == pdTRUE;
}
static void display_lock_give(void)
{
if (s_display_lock) {
xSemaphoreGive(s_display_lock);
}
}
static void draw_framebuffer_locked(void)
{
if (!panel_handle || !framebuffer) {
return;
}
esp_err_t err = esp_lcd_panel_draw_bitmap(panel_handle, 0, 0, BANNER_W, BANNER_H, framebuffer);
if (err != ESP_OK) {
ESP_LOGW(TAG, "panel draw failed: %s", esp_err_to_name(err));
}
}
static void card_hide_timer_cb(TimerHandle_t timer)
{
uint32_t generation = (uint32_t)(uintptr_t)pvTimerGetTimerID(timer);
bool should_hide = false;
if (!display_lock_take(pdMS_TO_TICKS(30))) {
return;
}
should_hide = (s_screen_kind == SCREEN_KIND_CARD && s_card_generation == generation);
display_lock_give();
if (should_hide) {
display_show_banner();
}
}
static void fb_ensure(void)
{
if (!framebuffer) {
framebuffer = (uint16_t *)calloc(BANNER_W * BANNER_H, sizeof(uint16_t));
}
}
static inline void fb_set_pixel(int x, int y, uint16_t color)
{
if (x < 0 || y < 0 || x >= BANNER_W || y >= BANNER_H || !framebuffer) {
return;
}
framebuffer[y * BANNER_W + x] = color;
}
static void fb_fill_rect(int x, int y, int w, int h, uint16_t color)
{
if (!framebuffer) {
return;
}
for (int yy = y; yy < y + h; yy++) {
for (int xx = x; xx < x + w; xx++) {
fb_set_pixel(xx, yy, color);
}
}
}
static void fb_fill_rect_clipped(int x, int y, int w, int h, uint16_t color, int clip_x0, int clip_x1)
{
if (!framebuffer) {
return;
}
int x0 = x;
int x1 = x + w;
if (x0 < clip_x0) {
x0 = clip_x0;
}
if (x1 > clip_x1) {
x1 = clip_x1;
}
if (x1 <= x0) {
return;
}
for (int yy = y; yy < y + h; yy++) {
for (int xx = x0; xx < x1; xx++) {
fb_set_pixel(xx, yy, color);
}
}
}
static void fb_draw_char_scaled_clipped(int x, int y, char c, uint16_t color, int scale, int clip_x0, int clip_x1)
{
if (c < 32 || c > 127) {
c = '?';
}
const uint8_t *glyph = font5x7[(uint8_t)c - 32];
for (int col = 0; col < FONT5X7_WIDTH; col++) {
uint8_t bits = glyph[col];
for (int row = 0; row < FONT5X7_HEIGHT; row++) {
if (bits & (1 << row)) {
int px = x + col * scale;
int py = y + row * scale;
fb_fill_rect_clipped(px, py, scale, scale, color, clip_x0, clip_x1);
}
}
}
}
static void fb_draw_text_clipped(int x, int y, const char *text, uint16_t color, int line_height, int scale,
int clip_x0, int clip_x1)
{
int cx = x;
int cy = y;
for (size_t i = 0; text[i] != '\0'; i++) {
if (text[i] == '\n') {
cy += line_height;
cx = x;
continue;
}
fb_draw_char_scaled_clipped(cx, cy, text[i], color, scale, clip_x0, clip_x1);
cx += (FONT5X7_WIDTH + 1) * scale;
}
}
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;
if (!s_display_lock) {
s_display_lock = xSemaphoreCreateMutex();
if (!s_display_lock) {
return ESP_ERR_NO_MEM;
}
}
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);
if (!s_card_hide_timer) {
s_card_hide_timer = xTimerCreate("card_hide",
pdMS_TO_TICKS(MIMI_TG_CARD_SHOW_MS),
pdFALSE, NULL, card_hide_timer_cb);
if (!s_card_hide_timer) {
return ESP_ERR_NO_MEM;
}
}
return ret;
}
void display_show_banner(void)
{
if (!display_lock_take(pdMS_TO_TICKS(200))) {
ESP_LOGW(TAG, "display lock timeout (banner)");
return;
}
if (!panel_handle) {
ESP_LOGW(TAG, "display not initialized");
display_lock_give();
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);
display_lock_give();
return;
}
esp_err_t err = esp_lcd_panel_draw_bitmap(panel_handle, 0, 0, BANNER_W, BANNER_H, start);
if (err != ESP_OK) {
ESP_LOGW(TAG, "banner draw failed: %s", esp_err_to_name(err));
} else {
s_screen_kind = SCREEN_KIND_BANNER;
}
if (s_card_hide_timer) {
xTimerStop(s_card_hide_timer, 0);
}
display_lock_give();
}
static void qr_draw_cb(esp_qrcode_handle_t qrcode)
{
int size = esp_qrcode_get_size(qrcode);
int quiet = 2;
int scale = s_qr_ctx.box / (size + quiet * 2);
if (scale < 1) {
scale = 1;
}
int qr_px = (size + quiet * 2) * scale;
int origin_x = s_qr_ctx.x + (s_qr_ctx.box - qr_px) / 2 + quiet * scale;
int origin_y = s_qr_ctx.y + (s_qr_ctx.box - qr_px) / 2 + quiet * scale;
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
if (esp_qrcode_get_module(qrcode, x, y)) {
fb_fill_rect(origin_x + x * scale, origin_y + y * scale, scale, scale, s_qr_ctx.fg);
}
}
}
}
void display_show_config_screen(const char *qr_text, const char *ip_text,
const char **lines, size_t line_count, size_t scroll,
size_t selected, int selected_offset_px)
{
if (!qr_text || !ip_text || !lines) {
return;
}
if (!display_lock_take(pdMS_TO_TICKS(200))) {
ESP_LOGW(TAG, "display lock timeout (config)");
return;
}
if (!panel_handle) {
ESP_LOGW(TAG, "display not initialized");
display_lock_give();
return;
}
fb_ensure();
if (!framebuffer) {
ESP_LOGW(TAG, "framebuffer alloc failed");
display_lock_give();
return;
}
const uint16_t color_bg = rgb565(0, 0, 0);
const uint16_t color_fg = rgb565(255, 255, 255);
const uint16_t color_qr_bg = rgb565(255, 255, 255);
const uint16_t color_qr_fg = rgb565(0, 0, 0);
const uint16_t color_title = rgb565(100, 200, 255);
const uint16_t color_sel_bg = rgb565(50, 80, 120);
fb_fill_rect(0, 0, BANNER_W, BANNER_H, color_bg);
// QR area (left column)
const int left_pad = 6;
const int qr_box = 110;
const int qr_x = left_pad;
const int qr_y = (BANNER_H - qr_box) / 2 - 8;
fb_fill_rect(qr_x, qr_y, qr_box, qr_box, color_qr_bg);
s_qr_ctx.x = qr_x;
s_qr_ctx.y = qr_y;
s_qr_ctx.box = qr_box;
s_qr_ctx.fg = color_qr_fg;
esp_qrcode_config_t cfg = ESP_QRCODE_CONFIG_DEFAULT();
cfg.display_func = qr_draw_cb;
cfg.max_qrcode_version = 6;
cfg.qrcode_ecc_level = ESP_QRCODE_ECC_MED;
esp_qrcode_generate(&cfg, qr_text);
// IP text under QR
fb_draw_text_clipped(qr_x, qr_y + qr_box + 4, ip_text, color_fg, 10, 1, 0, BANNER_W);
// Right column
const int right_x = qr_x + qr_box + 10;
const int right_w = BANNER_W - right_x - 6;
(void)right_w;
fb_draw_text_clipped(right_x, 4, "Configuration", color_title, 14, 2, right_x, BANNER_W);
const int line_height = 16;
const int start_y = 24;
size_t lines_per_page = (BANNER_H - start_y - 6) / line_height;
for (size_t i = 0; i < lines_per_page; i++) {
if (line_count == 0) {
break;
}
size_t idx = (scroll + i) % line_count;
if (idx < line_count) {
int line_y = start_y + (int)i * line_height;
if (idx == selected) {
fb_fill_rect(right_x, line_y - 1, BANNER_W - right_x - 2, line_height + 2, color_sel_bg);
fb_draw_text_clipped(right_x - selected_offset_px, line_y, lines[idx], color_fg, line_height, 2, right_x, BANNER_W);
} else {
fb_fill_rect(right_x, line_y - 1, BANNER_W - right_x - 2, line_height + 2, color_bg);
fb_draw_text_clipped(right_x, line_y, lines[idx], color_fg, line_height, 2, right_x, BANNER_W);
}
}
}
draw_framebuffer_locked();
s_screen_kind = SCREEN_KIND_CONFIG;
if (s_card_hide_timer) {
xTimerStop(s_card_hide_timer, 0);
}
display_lock_give();
}
void display_show_message_card(const char *title, const char *body)
{
if (!title || !body) {
return;
}
if (!display_lock_take(pdMS_TO_TICKS(200))) {
ESP_LOGW(TAG, "display lock timeout (card)");
return;
}
if (!panel_handle) {
display_lock_give();
return;
}
fb_ensure();
if (!framebuffer) {
ESP_LOGW(TAG, "framebuffer alloc failed");
display_lock_give();
return;
}
const uint16_t color_bg = rgb565(0, 0, 0);
const uint16_t color_title = rgb565(100, 200, 255);
const uint16_t color_fg = rgb565(255, 255, 255);
const int body_scale = (MIMI_TG_CARD_BODY_SCALE < 1) ? 1 : MIMI_TG_CARD_BODY_SCALE;
const int title_scale = 2;
const int title_line_h = (FONT5X7_HEIGHT + 1) * title_scale;
const int body_line_h = (FONT5X7_HEIGHT + 1) * body_scale + 1;
const int body_y = 10 + title_line_h;
const int max_cols = (BANNER_W - 12) / ((FONT5X7_WIDTH + 1) * body_scale);
int max_lines = (BANNER_H - body_y - 6) / body_line_h;
if (max_lines < 1) {
max_lines = 1;
}
fb_fill_rect(0, 0, BANNER_W, BANNER_H, color_bg);
fb_draw_text_clipped(6, 6, title, color_title, title_line_h, title_scale, 0, BANNER_W);
char wrapped[512];
size_t w = 0;
int cols = 0;
int lines = 1;
for (size_t i = 0; body[i] != '\0'; i++) {
if (w >= sizeof(wrapped) - 2 || lines > max_lines) {
break;
}
char c = body[i];
if (c == '\r') {
continue;
}
if (c == '\n') {
wrapped[w++] = '\n';
cols = 0;
lines++;
continue;
}
if (cols >= max_cols) {
wrapped[w++] = '\n';
cols = 0;
lines++;
if (lines > max_lines || w >= sizeof(wrapped) - 2) {
break;
}
}
wrapped[w++] = c;
cols++;
}
if (w == 0) {
strncpy(wrapped, "(empty)", sizeof(wrapped) - 1);
wrapped[sizeof(wrapped) - 1] = '\0';
} else {
wrapped[w] = '\0';
}
fb_draw_text_clipped(6, body_y, wrapped, color_fg, body_line_h, body_scale, 0, BANNER_W);
draw_framebuffer_locked();
s_screen_kind = SCREEN_KIND_CARD;
s_card_generation++;
uint32_t generation = s_card_generation;
if (s_card_hide_timer) {
vTimerSetTimerID(s_card_hide_timer, (void *)(uintptr_t)generation);
xTimerStop(s_card_hide_timer, 0);
xTimerChangePeriod(s_card_hide_timer, pdMS_TO_TICKS(MIMI_TG_CARD_SHOW_MS), 0);
xTimerStart(s_card_hide_timer, 0);
}
display_lock_give();
}
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;
}

28
main/display/display.h
View File

@@ -1,28 +0,0 @@
#pragma once
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "esp_err.h"
#ifdef __cplusplus
extern "C" {
#endif
#define DISPLAY_WIDTH 320
#define DISPLAY_HEIGHT 172
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);
void display_show_config_screen(const char *qr_text, const char *ip_text,
const char **lines, size_t line_count, size_t scroll,
size_t selected, int selected_offset_px);
void display_show_message_card(const char *title, const char *body);
#ifdef __cplusplus
}
#endif

105
main/display/font5x7.h
View File

@@ -1,105 +0,0 @@
#pragma once
#include <stdint.h>
#define FONT5X7_WIDTH 5
#define FONT5X7_HEIGHT 7
static const uint8_t font5x7[96][5] = {
{0x00,0x00,0x00,0x00,0x00}, // ' '
{0x00,0x00,0x5f,0x00,0x00}, // '!'
{0x00,0x07,0x00,0x07,0x00}, // '"'
{0x14,0x7f,0x14,0x7f,0x14}, // '#'
{0x24,0x2a,0x7f,0x2a,0x12}, // '$'
{0x23,0x13,0x08,0x64,0x62}, // '%'
{0x36,0x49,0x55,0x22,0x50}, // '&'
{0x00,0x05,0x03,0x00,0x00}, // '\''
{0x00,0x1c,0x22,0x41,0x00}, // '('
{0x00,0x41,0x22,0x1c,0x00}, // ')'
{0x14,0x08,0x3e,0x08,0x14}, // '*'
{0x08,0x08,0x3e,0x08,0x08}, // '+'
{0x00,0x50,0x30,0x00,0x00}, // ','
{0x08,0x08,0x08,0x08,0x08}, // '-'
{0x00,0x60,0x60,0x00,0x00}, // '.'
{0x20,0x10,0x08,0x04,0x02}, // '/'
{0x3e,0x51,0x49,0x45,0x3e}, // '0'
{0x00,0x42,0x7f,0x40,0x00}, // '1'
{0x42,0x61,0x51,0x49,0x46}, // '2'
{0x21,0x41,0x45,0x4b,0x31}, // '3'
{0x18,0x14,0x12,0x7f,0x10}, // '4'
{0x27,0x45,0x45,0x45,0x39}, // '5'
{0x3c,0x4a,0x49,0x49,0x30}, // '6'
{0x01,0x71,0x09,0x05,0x03}, // '7'
{0x36,0x49,0x49,0x49,0x36}, // '8'
{0x06,0x49,0x49,0x29,0x1e}, // '9'
{0x00,0x36,0x36,0x00,0x00}, // ':'
{0x00,0x56,0x36,0x00,0x00}, // ';'
{0x08,0x14,0x22,0x41,0x00}, // '<'
{0x14,0x14,0x14,0x14,0x14}, // '='
{0x00,0x41,0x22,0x14,0x08}, // '>'
{0x02,0x01,0x51,0x09,0x06}, // '?'
{0x32,0x49,0x79,0x41,0x3e}, // '@'
{0x7e,0x11,0x11,0x11,0x7e}, // 'A'
{0x7f,0x49,0x49,0x49,0x36}, // 'B'
{0x3e,0x41,0x41,0x41,0x22}, // 'C'
{0x7f,0x41,0x41,0x22,0x1c}, // 'D'
{0x7f,0x49,0x49,0x49,0x41}, // 'E'
{0x7f,0x09,0x09,0x09,0x01}, // 'F'
{0x3e,0x41,0x49,0x49,0x7a}, // 'G'
{0x7f,0x08,0x08,0x08,0x7f}, // 'H'
{0x00,0x41,0x7f,0x41,0x00}, // 'I'
{0x20,0x40,0x41,0x3f,0x01}, // 'J'
{0x7f,0x08,0x14,0x22,0x41}, // 'K'
{0x7f,0x40,0x40,0x40,0x40}, // 'L'
{0x7f,0x02,0x0c,0x02,0x7f}, // 'M'
{0x7f,0x04,0x08,0x10,0x7f}, // 'N'
{0x3e,0x41,0x41,0x41,0x3e}, // 'O'
{0x7f,0x09,0x09,0x09,0x06}, // 'P'
{0x3e,0x41,0x51,0x21,0x5e}, // 'Q'
{0x7f,0x09,0x19,0x29,0x46}, // 'R'
{0x46,0x49,0x49,0x49,0x31}, // 'S'
{0x01,0x01,0x7f,0x01,0x01}, // 'T'
{0x3f,0x40,0x40,0x40,0x3f}, // 'U'
{0x1f,0x20,0x40,0x20,0x1f}, // 'V'
{0x3f,0x40,0x38,0x40,0x3f}, // 'W'
{0x63,0x14,0x08,0x14,0x63}, // 'X'
{0x07,0x08,0x70,0x08,0x07}, // 'Y'
{0x61,0x51,0x49,0x45,0x43}, // 'Z'
{0x00,0x7f,0x41,0x41,0x00}, // '['
{0x02,0x04,0x08,0x10,0x20}, // '\\'
{0x00,0x41,0x41,0x7f,0x00}, // ']'
{0x04,0x02,0x01,0x02,0x04}, // '^'
{0x40,0x40,0x40,0x40,0x40}, // '_'
{0x00,0x01,0x02,0x04,0x00}, // '`'
{0x20,0x54,0x54,0x54,0x78}, // 'a'
{0x7f,0x48,0x44,0x44,0x38}, // 'b'
{0x38,0x44,0x44,0x44,0x20}, // 'c'
{0x38,0x44,0x44,0x48,0x7f}, // 'd'
{0x38,0x54,0x54,0x54,0x18}, // 'e'
{0x08,0x7e,0x09,0x01,0x02}, // 'f'
{0x0c,0x52,0x52,0x52,0x3e}, // 'g'
{0x7f,0x08,0x04,0x04,0x78}, // 'h'
{0x00,0x44,0x7d,0x40,0x00}, // 'i'
{0x20,0x40,0x44,0x3d,0x00}, // 'j'
{0x7f,0x10,0x28,0x44,0x00}, // 'k'
{0x00,0x41,0x7f,0x40,0x00}, // 'l'
{0x7c,0x04,0x18,0x04,0x78}, // 'm'
{0x7c,0x08,0x04,0x04,0x78}, // 'n'
{0x38,0x44,0x44,0x44,0x38}, // 'o'
{0x7c,0x14,0x14,0x14,0x08}, // 'p'
{0x08,0x14,0x14,0x18,0x7c}, // 'q'
{0x7c,0x08,0x04,0x04,0x08}, // 'r'
{0x48,0x54,0x54,0x54,0x20}, // 's'
{0x04,0x3f,0x44,0x40,0x20}, // 't'
{0x3c,0x40,0x40,0x20,0x7c}, // 'u'
{0x1c,0x20,0x40,0x20,0x1c}, // 'v'
{0x3c,0x40,0x30,0x40,0x3c}, // 'w'
{0x44,0x28,0x10,0x28,0x44}, // 'x'
{0x0c,0x50,0x50,0x50,0x3c}, // 'y'
{0x44,0x64,0x54,0x4c,0x44}, // 'z'
{0x00,0x08,0x36,0x41,0x00}, // '{'
{0x00,0x00,0x7f,0x00,0x00}, // '|'
{0x00,0x41,0x36,0x08,0x00}, // '}'
{0x10,0x08,0x08,0x10,0x08}, // '~'
{0x00,0x00,0x00,0x00,0x00} // DEL
};

2
main/idf_component.yml
View File

@@ -14,5 +14,3 @@ dependencies:
# # `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
qrcode: "^0.1.0"

19
main/mimi.c
View File

@@ -23,11 +23,8 @@
#include "tools/tool_registry.h"
#include "cron/cron_service.h"
#include "heartbeat/heartbeat.h"
#include "display/display.h"
#include "buttons/button_driver.h"
#include "ui/config_screen.h"
#include "imu/imu_manager.h"
#include "rgb/rgb.h"
#include "skills/skill_loader.h"
static const char *TAG = "mimi";
@@ -83,12 +80,6 @@ static void outbound_dispatch_task(void *arg)
} else {
ESP_LOGI(TAG, "Telegram send success for %s (%d bytes)", msg.chat_id, (int)strlen(msg.content));
}
if (config_screen_is_active()) {
config_screen_toggle();
}
char title[48];
snprintf(title, sizeof(title), "TG OUT %s", msg.chat_id);
display_show_message_card(title, msg.content);
} else if (strcmp(msg.channel, MIMI_CHAN_WEBSOCKET) == 0) {
esp_err_t ws_err = ws_server_send(msg.chat_id, msg.content);
if (ws_err != ESP_OK) {
@@ -108,7 +99,6 @@ void app_main(void)
{
/* Silence noisy components */
esp_log_level_set("esp-x509-crt-bundle", ESP_LOG_WARN);
esp_log_level_set("QRCODE", ESP_LOG_WARN);
ESP_LOGI(TAG, "========================================");
ESP_LOGI(TAG, " MimiClaw - ESP32-S3 AI Agent");
@@ -120,15 +110,10 @@ 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);
/* Input */
button_Init();
config_screen_init();
imu_manager_init();
imu_manager_set_shake_callback(config_screen_toggle);
imu_manager_set_shake_callback(NULL);
/* Phase 1: Core infrastructure */
ESP_ERROR_CHECK(init_nvs());

39
main/rgb/rgb.c
View File

@@ -1,39 +0,0 @@
#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);
}

15
main/rgb/rgb.h
View File

@@ -1,15 +0,0 @@
#pragma once
#include <stdint.h>
#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

116
main/telegram/telegram_bot.c
View File

@@ -2,13 +2,12 @@
#include "mimi_config.h"
#include "bus/message_bus.h"
#include "proxy/http_proxy.h"
#include "display/display.h"
#include "ui/config_screen.h"
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include "esp_log.h"
#include "esp_timer.h"
#include "esp_http_client.h"
#include "esp_crt_bundle.h"
#include "nvs.h"
@@ -18,6 +17,16 @@ static const char *TAG = "telegram";
static char s_bot_token[128] = MIMI_SECRET_TG_TOKEN;
static int64_t s_update_offset = 0;
static int64_t s_last_saved_offset = -1;
static int64_t s_last_offset_save_us = 0;
#define TG_OFFSET_NVS_KEY "update_offset"
#define TG_DEDUP_CACHE_SIZE 64
#define TG_OFFSET_SAVE_INTERVAL_US (5LL * 1000 * 1000)
#define TG_OFFSET_SAVE_STEP 10
static uint64_t s_seen_msg_keys[TG_DEDUP_CACHE_SIZE] = {0};
static size_t s_seen_msg_idx = 0;
/* HTTP response accumulator */
typedef struct {
@@ -26,6 +35,77 @@ typedef struct {
size_t cap;
} http_resp_t;
static uint64_t fnv1a64(const char *s)
{
uint64_t h = 1469598103934665603ULL;
if (!s) {
return h;
}
while (*s) {
h ^= (unsigned char)(*s++);
h *= 1099511628211ULL;
}
return h;
}
static uint64_t make_msg_key(const char *chat_id, int msg_id)
{
uint64_t h = fnv1a64(chat_id);
return (h << 16) ^ (uint64_t)(msg_id & 0xFFFF) ^ ((uint64_t)msg_id << 32);
}
static bool seen_msg_contains(uint64_t key)
{
for (size_t i = 0; i < TG_DEDUP_CACHE_SIZE; i++) {
if (s_seen_msg_keys[i] == key) {
return true;
}
}
return false;
}
static void seen_msg_insert(uint64_t key)
{
s_seen_msg_keys[s_seen_msg_idx] = key;
s_seen_msg_idx = (s_seen_msg_idx + 1) % TG_DEDUP_CACHE_SIZE;
}
static void save_update_offset_if_needed(bool force)
{
if (s_update_offset <= 0) {
return;
}
int64_t now = esp_timer_get_time();
bool should_save = force;
if (!should_save && s_last_saved_offset >= 0) {
if ((s_update_offset - s_last_saved_offset) >= TG_OFFSET_SAVE_STEP) {
should_save = true;
} else if ((now - s_last_offset_save_us) >= TG_OFFSET_SAVE_INTERVAL_US) {
should_save = true;
}
} else if (!should_save) {
should_save = true;
}
if (!should_save) {
return;
}
nvs_handle_t nvs;
if (nvs_open(MIMI_NVS_TG, NVS_READWRITE, &nvs) != ESP_OK) {
return;
}
if (nvs_set_i64(nvs, TG_OFFSET_NVS_KEY, s_update_offset) == ESP_OK) {
if (nvs_commit(nvs) == ESP_OK) {
s_last_saved_offset = s_update_offset;
s_last_offset_save_us = now;
}
}
nvs_close(nvs);
}
static esp_err_t http_event_handler(esp_http_client_event_t *evt)
{
http_resp_t *resp = (http_resp_t *)evt->user_data;
@@ -231,6 +311,7 @@ static void process_updates(const char *json_str)
continue;
}
s_update_offset = uid + 1;
save_update_offset_if_needed(false);
}
/* Extract message */
@@ -246,6 +327,12 @@ static void process_updates(const char *json_str)
cJSON *chat_id = cJSON_GetObjectItem(chat, "id");
if (!chat_id) continue;
int msg_id_val = -1;
cJSON *message_id = cJSON_GetObjectItem(message, "message_id");
if (cJSON_IsNumber(message_id)) {
msg_id_val = (int)message_id->valuedouble;
}
char chat_id_str[32];
if (cJSON_IsString(chat_id) && chat_id->valuestring) {
strncpy(chat_id_str, chat_id->valuestring, sizeof(chat_id_str) - 1);
@@ -256,14 +343,18 @@ static void process_updates(const char *json_str)
continue;
}
ESP_LOGI(TAG, "Message from chat %s: %.40s...", chat_id_str, text->valuestring);
if (config_screen_is_active()) {
config_screen_toggle();
if (msg_id_val >= 0) {
uint64_t msg_key = make_msg_key(chat_id_str, msg_id_val);
if (seen_msg_contains(msg_key)) {
ESP_LOGW(TAG, "Drop duplicate message update_id=%" PRId64 " chat=%s message_id=%d",
uid, chat_id_str, msg_id_val);
continue;
}
char title[48];
snprintf(title, sizeof(title), "TG IN %s", chat_id_str);
display_show_message_card(title, text->valuestring);
seen_msg_insert(msg_key);
}
ESP_LOGI(TAG, "Message update_id=%" PRId64 " message_id=%d from chat %s: %.40s...",
uid, msg_id_val, chat_id_str, text->valuestring);
/* Push to inbound bus */
mimi_msg_t msg = {0};
@@ -320,6 +411,13 @@ esp_err_t telegram_bot_init(void)
if (nvs_get_str(nvs, MIMI_NVS_KEY_TG_TOKEN, tmp, &len) == ESP_OK && tmp[0]) {
strncpy(s_bot_token, tmp, sizeof(s_bot_token) - 1);
}
int64_t offset = 0;
if (nvs_get_i64(nvs, TG_OFFSET_NVS_KEY, &offset) == ESP_OK && offset > 0) {
s_update_offset = offset;
s_last_saved_offset = offset;
ESP_LOGI(TAG, "Loaded Telegram update offset: %" PRId64, s_update_offset);
}
nvs_close(nvs);
}

123
main/ui/config_screen.c
View File

@@ -1,124 +1,19 @@
#include "ui/config_screen.h"
#include <stdio.h>
#include <string.h>
#include "display/display.h"
#include "display/font5x7.h"
#include "wifi/wifi_manager.h"
#include "mimi_config.h"
#include "nvs.h"
#include "esp_log.h"
#define CONFIG_LINE_MAX 64
#define CONFIG_LINES_MAX 12
static const char *TAG = "config_screen";
static char s_lines[CONFIG_LINES_MAX][CONFIG_LINE_MAX];
static const char *s_line_ptrs[CONFIG_LINES_MAX];
static size_t s_line_count = 0;
static size_t s_scroll = 0;
static bool s_active = false;
static size_t s_selected = 0;
static int s_sel_offset_px = 0;
#define QR_BOX 110
#define LEFT_PAD 6
#define RIGHT_X (LEFT_PAD + QR_BOX + 10)
#define RIGHT_W (DISPLAY_WIDTH - RIGHT_X - 6)
#define FONT_SCALE 2
#define CHAR_W ((FONT5X7_WIDTH + 1) * FONT_SCALE)
static void build_line(char *out, size_t out_len, const char *label,
const char *ns, const char *key,
const char *build_val, bool mask)
{
char nvs_val[128] = {0};
const char *source = "not set";
const char *display = "(empty)";
nvs_handle_t nvs;
if (nvs_open(ns, NVS_READONLY, &nvs) == ESP_OK) {
size_t len = sizeof(nvs_val);
if (nvs_get_str(nvs, key, nvs_val, &len) == ESP_OK && nvs_val[0]) {
source = "NVS";
display = nvs_val;
}
nvs_close(nvs);
}
if (strcmp(source, "not set") == 0 && build_val[0] != '\0') {
source = "build";
display = build_val;
}
char masked[32] = {0};
if (mask && strcmp(display, "(empty)") != 0) {
size_t dlen = strlen(display);
if (dlen > 4) {
snprintf(masked, sizeof(masked), "%.4s****", display);
display = masked;
}
}
snprintf(out, out_len, "%s: %s [%s]", label, display, source);
}
static void build_config_lines(void)
{
s_line_count = 0;
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "WiFi SSID", MIMI_NVS_WIFI, MIMI_NVS_KEY_SSID, MIMI_SECRET_WIFI_SSID, false);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "WiFi Pass", MIMI_NVS_WIFI, MIMI_NVS_KEY_PASS, MIMI_SECRET_WIFI_PASS, true);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "TG Token", MIMI_NVS_TG, MIMI_NVS_KEY_TG_TOKEN, MIMI_SECRET_TG_TOKEN, true);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "API Key", MIMI_NVS_LLM, MIMI_NVS_KEY_API_KEY, MIMI_SECRET_API_KEY, true);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "Model", MIMI_NVS_LLM, MIMI_NVS_KEY_MODEL, MIMI_SECRET_MODEL, false);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "Provider", MIMI_NVS_LLM, MIMI_NVS_KEY_PROVIDER, MIMI_SECRET_MODEL_PROVIDER, false);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "Proxy Host", MIMI_NVS_PROXY, MIMI_NVS_KEY_PROXY_HOST, MIMI_SECRET_PROXY_HOST, false);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "Proxy Port", MIMI_NVS_PROXY, MIMI_NVS_KEY_PROXY_PORT, MIMI_SECRET_PROXY_PORT, false);
build_line(s_lines[s_line_count++], CONFIG_LINE_MAX, "Search Key", MIMI_NVS_SEARCH, MIMI_NVS_KEY_API_KEY, MIMI_SECRET_SEARCH_KEY, true);
for (size_t i = 0; i < s_line_count; i++) {
s_line_ptrs[i] = s_lines[i];
}
}
static void render_config_screen(void)
{
const char *ip = wifi_manager_get_ip();
if (!ip || ip[0] == '\0') {
ip = "0.0.0.0";
}
char qr_text[64] = {0};
char ip_text[64] = {0};
snprintf(qr_text, sizeof(qr_text), "%s:8888", ip);
snprintf(ip_text, sizeof(ip_text), "%s:8888", ip);
display_show_config_screen(qr_text, ip_text, s_line_ptrs, s_line_count, s_scroll, s_selected, s_sel_offset_px);
}
void config_screen_init(void)
{
build_config_lines();
s_active = false;
}
void config_screen_toggle(void)
{
if (s_active) {
s_active = false;
display_show_banner();
return;
}
build_config_lines();
s_scroll = 0;
s_selected = 0;
s_sel_offset_px = 0;
s_active = true;
ESP_LOGI(TAG, "Switch to config screen");
render_config_screen();
s_active = !s_active;
ESP_LOGI(TAG, "Config screen is disabled (active=%s)", s_active ? "true" : "false");
}
bool config_screen_is_active(void)
@@ -128,15 +23,7 @@ bool config_screen_is_active(void)
void config_screen_scroll_down(void)
{
if (!s_active || s_line_count == 0) {
return;
if (s_active) {
ESP_LOGI(TAG, "Config screen scrolling is disabled");
}
s_scroll++;
if (s_scroll >= s_line_count) {
s_scroll = 0;
}
s_selected = s_scroll;
s_sel_offset_px = 0;
render_config_screen();
}