From 7918bab27d3ef8c6a8037335497663f586c2305f Mon Sep 17 00:00:00 2001 From: Bo Date: Tue, 10 Feb 2026 03:16:00 +0800 Subject: [PATCH] feat: add config view for lvgl. Signed-off-by: Bo --- main/CMakeLists.txt | 6 +- main/buttons/button_driver.c | 7 +- main/display/display.c | 202 +++++++++++++++++++++++ main/display/display.h | 7 + main/display/font5x7.h | 105 ++++++++++++ main/idf_component.yml | 1 + main/imu/I2C_Driver.c | 54 +++++++ main/imu/I2C_Driver.h | 23 +++ main/imu/QMI8658.c | 303 +++++++++++++++++++++++++++++++++++ main/imu/QMI8658.h | 161 +++++++++++++++++++ main/imu/imu_manager.c | 55 +++++++ main/imu/imu_manager.h | 8 + main/mimi.c | 5 + main/ui/config_screen.c | 187 +++++++++++++++++++++ main/ui/config_screen.h | 8 + 15 files changed, 1130 insertions(+), 2 deletions(-) create mode 100644 main/display/font5x7.h create mode 100644 main/imu/I2C_Driver.c create mode 100644 main/imu/I2C_Driver.h create mode 100644 main/imu/QMI8658.c create mode 100644 main/imu/QMI8658.h create mode 100644 main/imu/imu_manager.c create mode 100644 main/imu/imu_manager.h create mode 100644 main/ui/config_screen.c create mode 100644 main/ui/config_screen.h diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index 60d6bf1..ba2684c 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -6,6 +6,10 @@ idf_component_register( "rgb/rgb.c" "buttons/multi_button.c" "buttons/button_driver.c" + "imu/I2C_Driver.c" + "imu/QMI8658.c" + "imu/imu_manager.c" + "ui/config_screen.c" "bus/message_bus.c" "wifi/wifi_manager.c" "telegram/telegram_bot.c" @@ -29,5 +33,5 @@ idf_component_register( 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 + driver esp_lcd esp_timer led_strip qrcode ) diff --git a/main/buttons/button_driver.c b/main/buttons/button_driver.c index e50df3c..fc67cd4 100644 --- a/main/buttons/button_driver.c +++ b/main/buttons/button_driver.c @@ -4,6 +4,7 @@ #include "esp_timer.h" #include "driver/gpio.h" #include "display/display.h" +#include "ui/config_screen.h" void ESP32_Button_init(void){ gpio_reset_pin(Button_PIN1); @@ -31,7 +32,11 @@ 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(); + if (config_screen_is_active()) { + config_screen_scroll_down(); + } else { + display_cycle_backlight(); + } } } void Button_DOUBLE_CLICK_Callback(void* btn){ diff --git a/main/display/display.c b/main/display/display.c index 4c3b255..4370f70 100644 --- a/main/display/display.c +++ b/main/display/display.c @@ -2,6 +2,7 @@ #include #include +#include #include "esp_check.h" #include "esp_log.h" #include "driver/ledc.h" @@ -9,6 +10,8 @@ #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 @@ -47,10 +50,109 @@ 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; + +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 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 = { @@ -169,6 +271,106 @@ void display_show_banner(void) ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(panel_handle, 0, 0, BANNER_W, BANNER_H, start)); } +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 (!panel_handle) { + ESP_LOGW(TAG, "display not initialized"); + return; + } + if (!qr_text || !ip_text || !lines) { + return; + } + + fb_ensure(); + if (!framebuffer) { + ESP_LOGW(TAG, "framebuffer alloc failed"); + 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); + } + } + } + + ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(panel_handle, 0, 0, BANNER_W, BANNER_H, framebuffer)); +} + bool display_get_banner_center_rgb(uint8_t *r, uint8_t *g, uint8_t *b) { if (!r || !g || !b) { diff --git a/main/display/display.h b/main/display/display.h index 29dc315..23b6a19 100644 --- a/main/display/display.h +++ b/main/display/display.h @@ -2,18 +2,25 @@ #include #include +#include #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); #ifdef __cplusplus } diff --git a/main/display/font5x7.h b/main/display/font5x7.h new file mode 100644 index 0000000..3e48fcd --- /dev/null +++ b/main/display/font5x7.h @@ -0,0 +1,105 @@ +#pragma once + +#include + +#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 +}; diff --git a/main/idf_component.yml b/main/idf_component.yml index 8093f0d..afbca8e 100644 --- a/main/idf_component.yml +++ b/main/idf_component.yml @@ -15,3 +15,4 @@ dependencies: # # All dependencies of `main` are public by default. # public: true espressif/led_strip: ^2.4.1 + qrcode: "^0.1.0" diff --git a/main/imu/I2C_Driver.c b/main/imu/I2C_Driver.c new file mode 100644 index 0000000..f765743 --- /dev/null +++ b/main/imu/I2C_Driver.c @@ -0,0 +1,54 @@ +#include "I2C_Driver.h" + + +#define I2C_TRANS_BUF_MINIMUM_SIZE (sizeof(i2c_cmd_desc_t) + \ + sizeof(i2c_cmd_link_t) * 8) /* It is required to have allocate one i2c_cmd_desc_t per command: + * start + write (device address) + write buffer + + * start + write (device address) + read buffer + read buffer for NACK + + * stop */ +static const char *I2C_TAG = "I2C"; +/** + * @brief i2c master initialization + */ +static esp_err_t i2c_master_init(void) +{ + int i2c_master_port = I2C_MASTER_NUM; + + i2c_config_t conf = { + .mode = I2C_MODE_MASTER, + .sda_io_num = I2C_Touch_SDA_IO, + .scl_io_num = I2C_Touch_SCL_IO, + .sda_pullup_en = GPIO_PULLUP_ENABLE, + .scl_pullup_en = GPIO_PULLUP_ENABLE, + .master.clk_speed = I2C_MASTER_FREQ_HZ, + }; + + i2c_param_config(i2c_master_port, &conf); + + return i2c_driver_install(i2c_master_port, conf.mode, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0); +} +void I2C_Init(void) +{ + /********************* I2C *********************/ + ESP_ERROR_CHECK(i2c_master_init()); + ESP_LOGI(I2C_TAG, "I2C initialized successfully"); +} + + +// Reg addr is 8 bit +esp_err_t I2C_Write(uint8_t Driver_addr, uint8_t Reg_addr, const uint8_t *Reg_data, uint32_t Length) +{ + uint8_t buf[Length+1]; + + buf[0] = Reg_addr; + // Copy Reg_data to buf starting at buf[1] + memcpy(&buf[1], Reg_data, Length); + return i2c_master_write_to_device(I2C_MASTER_NUM, Driver_addr, buf, Length+1, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS); +} + + + +esp_err_t I2C_Read(uint8_t Driver_addr, uint8_t Reg_addr, uint8_t *Reg_data, uint32_t Length) +{ + return i2c_master_write_read_device(I2C_MASTER_NUM, Driver_addr, &Reg_addr, 1, Reg_data, Length, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS); +} diff --git a/main/imu/I2C_Driver.h b/main/imu/I2C_Driver.h new file mode 100644 index 0000000..34ad182 --- /dev/null +++ b/main/imu/I2C_Driver.h @@ -0,0 +1,23 @@ +#pragma once + +#include +#include // For memcpy +#include "esp_log.h" +#include "driver/gpio.h" +#include "driver/i2c.h" + + +/********************* I2C *********************/ +#define I2C_Touch_SCL_IO 47 /*!< GPIO number used for I2C master clock */ +#define I2C_Touch_SDA_IO 48 /*!< GPIO number used for I2C master data */ +#define I2C_MASTER_NUM 0 /*!< I2C master i2c port number, the number of i2c peripheral interfaces available will depend on the chip */ +#define I2C_MASTER_FREQ_HZ 400000 /*!< I2C master clock frequency */ +#define I2C_MASTER_TX_BUF_DISABLE 0 /*!< I2C master doesn't need buffer */ +#define I2C_MASTER_RX_BUF_DISABLE 0 /*!< I2C master doesn't need buffer */ +#define I2C_MASTER_TIMEOUT_MS 1000 + + +void I2C_Init(void); +// Reg addr is 8 bit +esp_err_t I2C_Write(uint8_t Driver_addr, uint8_t Reg_addr, const uint8_t *Reg_data, uint32_t Length); +esp_err_t I2C_Read(uint8_t Driver_addr, uint8_t Reg_addr, uint8_t *Reg_data, uint32_t Length); \ No newline at end of file diff --git a/main/imu/QMI8658.c b/main/imu/QMI8658.c new file mode 100644 index 0000000..7b47107 --- /dev/null +++ b/main/imu/QMI8658.c @@ -0,0 +1,303 @@ +#include "QMI8658.h" + +IMUdata Accel; +IMUdata Gyro; + +uint8_t Device_addr ; // default for SD0/SA0 low, 0x6A if high +acc_scale_t acc_scale = ACC_RANGE_4G; +gyro_scale_t gyro_scale = GYR_RANGE_64DPS; +acc_odr_t acc_odr = acc_odr_norm_8000; +gyro_odr_t gyro_odr = gyro_odr_norm_8000; +sensor_state_t sensor_state = sensor_default; +lpf_t acc_lpf; + +float accelScales, gyroScales; +float accelScales = 0; +uint8_t readings[12]; +uint32_t reading_timestamp_us; // timestamp in arduino micros() time +/** + * Inialize Wire and send default configs + * @param addr I2C address of sensor, typically 0x6A or 0x6B + */ +void QMI8658_Init(void) +{ + uint8_t buf[1]; + Device_addr = QMI8658_L_SLAVE_ADDRESS; + I2C_Read(Device_addr, QMI8658_REVISION_ID, buf, 1); + printf("QMI8658 Device ID: %x\r\n",buf[0]); // Get chip id + setState(sensor_running); + + setAccScale(acc_scale); + setAccODR(acc_odr); + setAccLPF(LPF_MODE_0); + switch (acc_scale) { + // Possible accelerometer scales (and their register bit settings) are: + // 2 Gs (00), 4 Gs (01), 8 Gs (10), and 16 Gs (11). + // Here's a bit of an algorith to calculate DPS/(ADC tick) based on that + // 2-bit value: + case ACC_RANGE_2G: accelScales = 2.0 / 32768.0; break; + case ACC_RANGE_4G: accelScales = 4.0 / 32768.0; break; + case ACC_RANGE_8G: accelScales = 8.0 / 32768.0; break; + case ACC_RANGE_16G: accelScales = 16.0 / 32768.0; break; + } + + setGyroScale(gyro_scale); + setGyroODR(gyro_odr); + setGyroLPF(LPF_MODE_3); + switch (gyro_scale) { + // Possible gyro scales (and their register bit settings) are: + // 250 DPS (00), 500 DPS (01), 1000 DPS (10), and 2000 DPS (11). + // Here's a bit of an algorith to calculate DPS/(ADC tick) based on that + // 2-bit value: + case GYR_RANGE_16DPS: gyroScales = 16.0 / 32768.0; break; + case GYR_RANGE_32DPS: gyroScales = 32.0 / 32768.0; break; + case GYR_RANGE_64DPS: gyroScales = 64.0 / 32768.0; break; + case GYR_RANGE_128DPS: gyroScales = 128.0 / 32768.0; break; + case GYR_RANGE_256DPS: gyroScales = 256.0 / 32768.0; break; + case GYR_RANGE_512DPS: gyroScales = 512.0 / 32768.0; break; + case GYR_RANGE_1024DPS: gyroScales = 1024.0 / 32768.0; break; + } +} +void QMI8658_Loop(void) +{ + getAccelerometer(); +} + +/** + * Transmit one uint8_t of data to QMI8658. + * @param addr address of data to be written + * @param data the data to be written + */ +void QMI8658_transmit(uint8_t addr, uint8_t data) +{ + I2C_Write(Device_addr, addr, &data, 1); +} + +/** + * Receive one uint8_t of data from QMI8658. + * @param addr address of data to be read + * @return the uint8_t of data that was read + */ +uint8_t QMI8658_receive(uint8_t addr) +{ + uint8_t retval; + I2C_Read(Device_addr, addr, &retval, 1); + return retval; +} + +/** + * Writes data to CTRL9 (command register) and waits for ACK. + * @param command the command to be executed + */ +void QMI8658_CTRL9_Write(uint8_t command) +{ + // transmit command + QMI8658_transmit(QMI8658_CTRL9, command); + + // wait for command to be done + while (((QMI8658_receive(QMI8658_STATUSINT)) & 0x80) == 0x00); +} + +/** + * Set output data rate (ODR) of accelerometer. + * @param odr acc_odr_t variable representing new data rate + */ +void setAccODR(acc_odr_t odr) +{ + if (sensor_state != sensor_default) // If the device is not in the default state + { + uint8_t ctrl2 = QMI8658_receive(QMI8658_CTRL2); + ctrl2 &= ~QMI8658_AODR_MASK; // clear previous setting + ctrl2 |= odr; // OR in new setting + QMI8658_transmit(QMI8658_CTRL2, ctrl2); + } + acc_odr = odr; +} + +/** + * Set output data rate (ODR) of gyro. + * @param odr gyro_odr_t variable representing new data rate + */ +void setGyroODR(gyro_odr_t odr) +{ + if (sensor_state != sensor_default) + { + uint8_t ctrl3 = QMI8658_receive(QMI8658_CTRL3); + ctrl3 &= ~QMI8658_GODR_MASK; // clear previous setting + ctrl3 |= odr; // OR in new setting + QMI8658_transmit(QMI8658_CTRL3, ctrl3); + } + gyro_odr = odr; +} + +/** + * Set scale of accelerometer output. + * @param scale acc_scale_t variable representing new scale + */ +void setAccScale(acc_scale_t scale) +{ + if (sensor_state != sensor_default) + { + uint8_t ctrl2 = QMI8658_receive(QMI8658_CTRL2); + ctrl2 &= ~QMI8658_ASCALE_MASK; // clear previous setting + ctrl2 |= scale << QMI8658_ASCALE_OFFSET; // OR in new setting + QMI8658_transmit(QMI8658_CTRL2, ctrl2); + } + acc_scale = scale; +} + +/** + * Set scale of gyro output. + * @param scale gyro_scale_t variable representing new scale + */ +void setGyroScale(gyro_scale_t scale) +{ + if (sensor_state != sensor_default) + { + uint8_t ctrl3 = QMI8658_receive(QMI8658_CTRL3); + ctrl3 &= ~QMI8658_GSCALE_MASK; // clear previous setting + ctrl3 |= scale << QMI8658_GSCALE_OFFSET; // OR in new setting + QMI8658_transmit(QMI8658_CTRL3, ctrl3); + } + gyro_scale = scale; +} + +/** + * Set new low-pass filter value for accelerometer + * @param lp lpf_t variable representing new low-pass filter value + */ +void setAccLPF(lpf_t lpf) +{ + if (sensor_state != sensor_default) + { + uint8_t ctrl5 = QMI8658_receive(QMI8658_CTRL5); + ctrl5 &= !QMI8658_ALPF_MASK; + ctrl5 |= lpf << QMI8658_ALPF_OFFSET; + ctrl5 |= 0x01; // turn on acc low pass filter + QMI8658_transmit(QMI8658_CTRL5, ctrl5); + } + acc_lpf = lpf; +} + +/** + * Set new low-pass filter value for gyro + * @param lp lpf_t variable representing new low-pass filter value + */ +void setGyroLPF(lpf_t lpf) +{ + if (sensor_state != sensor_default) + { + uint8_t ctrl5 = QMI8658_receive(QMI8658_CTRL5); + ctrl5 &= !QMI8658_GLPF_MASK; + ctrl5 |= lpf << QMI8658_GLPF_OFFSET; + ctrl5 |= 0x10; // turn on gyro low pass filter + QMI8658_transmit(QMI8658_CTRL5, ctrl5); + } +} + +/** + * Set new state of QMI8658. + * @param state new state to transition to + */ +void setState(sensor_state_t state) +{ + uint8_t ctrl1; + switch (state) + { + case sensor_running: + ctrl1 = QMI8658_receive(QMI8658_CTRL1); + // enable 2MHz oscillator + ctrl1 &= 0xFE; + // enable auto address increment for fast block reads + ctrl1 |= 0x40; + QMI8658_transmit(QMI8658_CTRL1, ctrl1); + + // enable high speed internal clock, + // acc and gyro in full mode, and + // disable syncSample mode + QMI8658_transmit(QMI8658_CTRL7, 0x43); + + // disable AttitudeEngine Motion On Demand + QMI8658_transmit(QMI8658_CTRL6, 0x00); + break; + case sensor_power_down: + // disable high speed internal clock, + // acc and gyro powered down + QMI8658_transmit(QMI8658_CTRL7, 0x00); + + ctrl1 = QMI8658_receive(QMI8658_CTRL1); + // disable 2MHz oscillator + ctrl1|= 0x01; + QMI8658_transmit(QMI8658_CTRL1, ctrl1); + break; + case sensor_locking: + ctrl1 = QMI8658_receive(QMI8658_CTRL1); + // enable 2MHz oscillator + ctrl1 &= 0xFE; + // enable auto address increment for fast block reads + ctrl1 |= 0x40; + QMI8658_transmit(QMI8658_CTRL1, ctrl1); + + // enable high speed internal clock, + // acc and gyro in full mode, and + // enable syncSample mode + QMI8658_transmit(QMI8658_CTRL7, 0x83); + + // disable AttitudeEngine Motion On Demand + QMI8658_transmit(QMI8658_CTRL6, 0x00); + + // disable internal AHB clock gating: + QMI8658_transmit(QMI8658_CAL1_L, 0x01); + QMI8658_CTRL9_Write(0x12); + // re-enable clock gating + QMI8658_transmit(QMI8658_CAL1_L, 0x00); + QMI8658_CTRL9_Write(0x12); + break; + default: + break; + } + sensor_state = state; +} + + +void getAccelerometer(void) +{ + + uint8_t buf[6]; + I2C_Read(Device_addr, QMI8658_AX_L, buf, 6); + Accel.x = (float)((int16_t)((buf[1]<<8) | (buf[0]))); + Accel.y = (float)((int16_t)((buf[3]<<8) | (buf[2]))); + Accel.z = (float)((int16_t)((buf[5]<<8) | (buf[4]))); + Accel.x = Accel.x * accelScales; + Accel.y = Accel.y * accelScales; + Accel.z = Accel.z * accelScales; + +} +void getGyroscope(void) +{ + uint8_t buf[6]; + I2C_Read(Device_addr, QMI8658_GX_L, buf, 6); + Gyro.x = (float)((int16_t)((buf[1]<<8) | (buf[0]))); + Gyro.y = (float)((int16_t)((buf[3]<<8) | (buf[2]))); + Gyro.z = (float)((int16_t)((buf[5]<<8) | (buf[4]))); + Gyro.x = Gyro.x * gyroScales; + Gyro.y = Gyro.y * gyroScales; + Gyro.z = Gyro.z * gyroScales; +} + + + + + + + + + + + + + + + + + diff --git a/main/imu/QMI8658.h b/main/imu/QMI8658.h new file mode 100644 index 0000000..fd739ef --- /dev/null +++ b/main/imu/QMI8658.h @@ -0,0 +1,161 @@ +#pragma once + +#include "I2C_Driver.h" + +//device address +#define QMI8658_L_SLAVE_ADDRESS (0x6B) +#define QMI8658_H_SLAVE_ADDRESS (0x6A) + +#define QMI8658_WHO_AM_I 0x00 // devide identifier +#define QMI8658_REVISION_ID 0x01 +#define QMI8658_CTRL1 0x02 // SPI interface and sensor enable +#define QMI8658_CTRL2 0x03 // Accelerometer settings +#define QMI8658_CTRL3 0x04 // Gyro settings +#define QMI8658_CTRL4 0x05 // reserved (we don't use this) +#define QMI8658_CTRL5 0x06 // Low-pass filter settings +#define QMI8658_CTRL6 0x07 // AttitudeEngine settings (we don't use these) +#define QMI8658_CTRL7 0x08 // Sensor enable +#define QMI8658_CTRL8 0x09 // Motion detection control (not in current lib version) +#define QMI8658_CTRL9 0x0A // Host commands (not in current lib version) + +#define QMI8658_CAL1_L 0x0B // calibration 1 register, lower bits +#define QMI8658_CAL1_H 0x0C // calibration 1 register, higher bits +#define QMI8658_CAL2_L 0x0D // calibration 2 register, lower bits +#define QMI8658_CAL2_H 0x0E // calibration 2 register, higher bits +#define QMI8658_CAL3_L 0x0F // calibration 3 register, lower bits +#define QMI8658_CAL3_H 0x10 // calibration 3 register, higher bits +#define QMI8658_CAL4_L 0x11 // calibration 4 register, lower bits +#define QMI8658_CAL4_H 0x12 // calibration 4 register, higher bits + +#define QMI8658_TEMP_L 0x33 // lower bits of temperature data +#define QMI8658_TEMP_H 0x34 // upper bits of temperature data + +#define QMI8658_STATUSINT 0x2D // status + interrupt register + +#define QMI8658_AX_L 0x35 // lower bits of x-axis acceleration +#define QMI8658_AX_H 0x36 // upper bits of x-axis acceleration +#define QMI8658_AY_L 0x37 // lower bits of y-axis acceleration +#define QMI8658_AY_H 0x38 // upper bits of y-axis acceleration +#define QMI8658_AZ_L 0x39 +#define QMI8658_AZ_H 0x3A +#define QMI8658_GX_L 0x3B // lower bits of x-axis angular velocity +#define QMI8658_GX_H 0x3C // upper bits of x-axis angular velocity +#define QMI8658_GY_L 0x3D +#define QMI8658_GY_H 0x3E +#define QMI8658_GZ_L 0x3F +#define QMI8658_GZ_H 0x40 + +#define QMI8658_AODR_MASK 0x0F // bits in acc data rate are 1, rest are 0 (CTRL2) +#define QMI8658_GODR_MASK 0x0F // bits in gyro data rate are 1, rest are 0 (CTRL3) +#define QMI8658_ASCALE_MASK 0x70 // bits in acc scale are 1, rest are 0 +#define QMI8658_GSCALE_MASK 0x70 // bits in gyro scale are 1, rest are 0 +#define QMI8658_ALPF_MASK 0x06 // bits in acc low pass filter setting +#define QMI8658_GLPF_MASK 0x60 // bits in gyro low pass filter setting +#define QMI8658_ASCALE_OFFSET 4 // offset to acc scale bits +#define QMI8658_GSCALE_OFFSET 4 // offset to gyro scale bits +#define QMI8658_ALPF_OFFSET 1 // offset to acc low pass filter bits +#define QMI8658_GLPF_OFFSET 5 // offset to gyro low pass filter bits + +#define QMI8658_COMM_TIMEOUT 50 // communication timeout, in ms + + +// delay between refreshes of sensor data in us +// applies to individual sensor readings while in locking mode +// has no effect in running mode +#define QMI8658_REFRESH_DELAY 2000 + +// control clock gating (necessary to use data locking) +#define QMI8658_CTRL_CMD_AHB_CLOCK_GATING 0x12 + + +typedef enum { + acc_odr_norm_8000 = 0x0, + acc_odr_norm_4000, + acc_odr_norm_2000, + acc_odr_norm_1000, + acc_odr_norm_500, + acc_odr_norm_250, + acc_odr_norm_120, + acc_odr_norm_60, + acc_odr_norm_30, + acc_odr_lp_128 = 0xC, + acc_odr_lp_21, + acc_odr_lp_11, + acc_odr_lp_3, +} acc_odr_t; + +typedef enum { + gyro_odr_norm_8000 = 0x0, + gyro_odr_norm_4000, + gyro_odr_norm_2000, + gyro_odr_norm_1000, + gyro_odr_norm_500, + gyro_odr_norm_250, + gyro_odr_norm_120, + gyro_odr_norm_60, + gyro_odr_norm_30 +} gyro_odr_t; + +typedef enum { + ACC_RANGE_2G = 0x0, + ACC_RANGE_4G, + ACC_RANGE_8G, + ACC_RANGE_16G +} acc_scale_t; + +typedef enum { + GYR_RANGE_16DPS = 0x0, + GYR_RANGE_32DPS, + GYR_RANGE_64DPS, + GYR_RANGE_128DPS, + GYR_RANGE_256DPS, + GYR_RANGE_512DPS, + GYR_RANGE_1024DPS +} gyro_scale_t; + +typedef enum { + LPF_MODE_0 = 0x0, //2.66% of ODR + LPF_MODE_1 = 0x2, //3.63% of ODR + LPF_MODE_2 = 0x4, //5.39% of ODR + LPF_MODE_3 = 0x6 //13.37% of ODR +} lpf_t; + +typedef enum { + sensor_default, + sensor_power_down, + sensor_running, + sensor_locking +} sensor_state_t; + +typedef struct __IMUdata { + float x; + float y; + float z; +} IMUdata; + +extern IMUdata Accel; +extern IMUdata Gyro; + +void QMI8658_Init(void); +void QMI8658_Loop(void); +void QMI8658_transmit(uint8_t addr, uint8_t data); +uint8_t QMI8658_receive(uint8_t addr); +void QMI8658_CTRL9_Write(uint8_t command); +void QMI8658_sensor_update(); +void QMI8658_update_if_needed(); +void setAccODR(acc_odr_t odr); +void setGyroODR(gyro_odr_t odr); +void setAccScale(acc_scale_t scale); +void setGyroScale(gyro_scale_t scale); +void setAccLPF(lpf_t lpf); +void setGyroLPF(lpf_t lpf); +void setState(sensor_state_t state); +void getRawReadings(int16_t* buf); +float getAccX(); +float getAccY(); +float getAccZ(); +float getGyroX(); +float getGyroY(); +float getGyroZ(); +void getAccelerometer(void); +void getGyroscope(void); \ No newline at end of file diff --git a/main/imu/imu_manager.c b/main/imu/imu_manager.c new file mode 100644 index 0000000..758bbdf --- /dev/null +++ b/main/imu/imu_manager.c @@ -0,0 +1,55 @@ +#include "imu/imu_manager.h" + +#include +#include "esp_log.h" +#include "esp_timer.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "imu/I2C_Driver.h" +#include "imu/QMI8658.h" + +static const char *TAG = "imu"; + +static imu_shake_cb_t s_shake_cb = NULL; +static int64_t s_last_shake_us = 0; + +static void imu_task(void *arg) +{ + (void)arg; + const float threshold_g = 1.6f; + const int64_t min_interval_us = 800000; + + while (1) { + QMI8658_Loop(); + float ax = Accel.x; + float ay = Accel.y; + float az = Accel.z; + float mag = sqrtf(ax * ax + ay * ay + az * az); + float delta = fabsf(mag - 1.0f); + + if (delta > threshold_g) { + int64_t now = esp_timer_get_time(); + if (now - s_last_shake_us > min_interval_us) { + s_last_shake_us = now; + ESP_LOGI(TAG, "Shake detected (delta=%.2f)", delta); + if (s_shake_cb) { + s_shake_cb(); + } + } + } + + vTaskDelay(pdMS_TO_TICKS(50)); + } +} + +void imu_manager_init(void) +{ + I2C_Init(); + QMI8658_Init(); + xTaskCreatePinnedToCore(imu_task, "imu_task", 4096, NULL, 4, NULL, 0); +} + +void imu_manager_set_shake_callback(imu_shake_cb_t cb) +{ + s_shake_cb = cb; +} diff --git a/main/imu/imu_manager.h b/main/imu/imu_manager.h new file mode 100644 index 0000000..08f1c34 --- /dev/null +++ b/main/imu/imu_manager.h @@ -0,0 +1,8 @@ +#pragma once + +#include + +typedef void (*imu_shake_cb_t)(void); + +void imu_manager_init(void); +void imu_manager_set_shake_callback(imu_shake_cb_t cb); diff --git a/main/mimi.c b/main/mimi.c index ff0c176..bad1b19 100644 --- a/main/mimi.c +++ b/main/mimi.c @@ -23,6 +23,8 @@ #include "tools/tool_registry.h" #include "display/display.h" #include "buttons/button_driver.h" +#include "ui/config_screen.h" +#include "imu/imu_manager.h" #include "rgb/rgb.h" static const char *TAG = "mimi"; @@ -104,6 +106,9 @@ void app_main(void) ESP_ERROR_CHECK(rgb_init()); rgb_set(255, 0, 0); button_Init(); + config_screen_init(); + imu_manager_init(); + imu_manager_set_shake_callback(config_screen_toggle); /* Phase 1: Core infrastructure */ ESP_ERROR_CHECK(init_nvs()); diff --git a/main/ui/config_screen.c b/main/ui/config_screen.c new file mode 100644 index 0000000..7b044db --- /dev/null +++ b/main/ui/config_screen.c @@ -0,0 +1,187 @@ +#include "ui/config_screen.h" + +#include +#include + +#include "display/display.h" +#include "display/font5x7.h" +#include "wifi/wifi_manager.h" +#include "mimi_config.h" +#include "mimi_secrets.h" +#include "nvs.h" +#include "esp_log.h" +#include "esp_timer.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; +static int s_sel_dir = 1; +static esp_timer_handle_t s_scroll_timer = NULL; + +#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); +} + +static void update_selected_scroll(void *arg) +{ + (void)arg; + if (!s_active || s_line_count == 0) { + return; + } + + const char *line = s_line_ptrs[s_selected]; + if (!line) { + return; + } + + int line_px = (int)strlen(line) * CHAR_W; + int max_offset = line_px - (int)RIGHT_W; + if (max_offset <= 0) { + s_sel_offset_px = 0; + s_sel_dir = 1; + return; + } + + s_sel_offset_px += s_sel_dir * 4; + if (s_sel_offset_px >= max_offset) { + s_sel_offset_px = max_offset; + s_sel_dir = -1; + } else if (s_sel_offset_px <= 0) { + s_sel_offset_px = 0; + s_sel_dir = 1; + } + + render_config_screen(); +} + +void config_screen_init(void) +{ + build_config_lines(); + const esp_timer_create_args_t timer_args = { + .callback = &update_selected_scroll, + .name = "cfg_scroll", + .arg = NULL, + }; + ESP_ERROR_CHECK(esp_timer_create(&timer_args, &s_scroll_timer)); + ESP_ERROR_CHECK(esp_timer_start_periodic(s_scroll_timer, 150000)); +} + +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_sel_dir = 1; + s_active = true; + ESP_LOGI(TAG, "Switch to config screen"); + render_config_screen(); +} + +bool config_screen_is_active(void) +{ + return s_active; +} + +void config_screen_scroll_down(void) +{ + if (!s_active || s_line_count == 0) { + return; + } + + s_scroll++; + if (s_scroll >= s_line_count) { + s_scroll = 0; + } + s_selected = s_scroll; + s_sel_offset_px = 0; + s_sel_dir = 1; + render_config_screen(); +} diff --git a/main/ui/config_screen.h b/main/ui/config_screen.h new file mode 100644 index 0000000..fd8eea6 --- /dev/null +++ b/main/ui/config_screen.h @@ -0,0 +1,8 @@ +#pragma once + +#include + +void config_screen_init(void); +void config_screen_toggle(void); +bool config_screen_is_active(void); +void config_screen_scroll_down(void);