diff --git a/.gitignore b/.gitignore index e7816b8..cae43d8 100644 --- a/.gitignore +++ b/.gitignore @@ -45,3 +45,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..ba2684c 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -1,6 +1,15 @@ 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" + "imu/QMI8658.c" + "imu/imu_manager.c" + "ui/config_screen.c" "bus/message_bus.c" "wifi/wifi_manager.c" "telegram/telegram_bot.c" @@ -19,7 +28,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 qrcode ) diff --git a/main/buttons/button_driver.c b/main/buttons/button_driver.c new file mode 100644 index 0000000..fc67cd4 --- /dev/null +++ b/main/buttons/button_driver.c @@ -0,0 +1,75 @@ +#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" +#include "ui/config_screen.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; + if (config_screen_is_active()) { + config_screen_scroll_down(); + } else { + 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..4370f70 --- /dev/null +++ b/main/display/display.c @@ -0,0 +1,401 @@ +#include "display/display.h" + +#include +#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" +#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; + +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 = { + .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)); +} + +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) { + 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..23b6a19 --- /dev/null +++ b/main/display/display.h @@ -0,0 +1,27 @@ +#pragma once + +#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 +} +#endif 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 new file mode 100644 index 0000000..afbca8e --- /dev/null +++ b/main/idf_component.yml @@ -0,0 +1,18 @@ +## 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 + 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 1547c3a..0658055 100644 --- a/main/mimi.c +++ b/main/mimi.c @@ -21,6 +21,11 @@ #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 "ui/config_screen.h" +#include "imu/imu_manager.h" +#include "rgb/rgb.h" static const char *TAG = "mimi"; @@ -95,6 +100,16 @@ 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(); + config_screen_init(); + imu_manager_init(); + imu_manager_set_shake_callback(config_screen_toggle); + /* 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"; 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);