firstpass/soundshot
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Enhance Bluetooth functionality and GUI integration

Browse Source 
- Add Bluetooth device list management with discovery and pairing support
- Implement volume control with AVRC integration
- Add system event handling for GUI-to-Bluetooth communication
- Enhance menu system with device selection and volume control pages
- Improve memory management by making menu creation lazy
- Add proper event subscription between GUI and Bluetooth modules
- Update filter coefficient for improved audio clicking behavior

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Brent Perteet
2025-08-25 16:46:16 +00:00
parent 25f875b3b2
commit 439c6ef22d
7 changed files with 826 additions and 5831 deletions
Download Patch File Download Diff File Expand all files Collapse all files

268
main/bt_app.c
View File

@@ -28,6 +28,7 @@
#include "nvs.h"
#include "esp_timer.h"
/* log tags */
#define BT_AV_TAG "BT_AV"
#define BT_RC_CT_TAG "RC_CT"
@@ -133,6 +134,8 @@ static void bt_app_av_state_connecting_hdlr(uint16_t event, void *param);
static void bt_app_av_state_connected_hdlr(uint16_t event, void *param);
static void bt_app_av_state_disconnecting_hdlr(uint16_t event, void *param);
static void add_device_to_list(esp_bd_addr_t bda, const char *name, bool is_paired, int rssi);
/*********************************
* STATIC VARIABLE DEFINITIONS
********************************/
@@ -147,12 +150,19 @@ static int s_media_state = APP_AV_MEDIA_STATE_IDLE; /* sub states of A
static int s_intv_cnt = 0; /* count of heart beat intervals */
static int s_connecting_intv = 0; /* count of heart beat intervals for connecting */
static uint32_t s_pkt_cnt = 0; /* count of packets */
/* Device list for GUI */
static bt_device_list_t s_device_list = {0};
static esp_avrc_rn_evt_cap_mask_t s_avrc_peer_rn_cap; /* AVRC target notification event capability bit mask */
static TimerHandle_t s_tmr;
static int s_current_device_index = -1; /* index of device currently being attempted */
static paired_device_t s_known_devices[MAX_PAIRED_DEVICES]; /* cached list of known devices */
static size_t s_known_device_count = 0; /* count of cached known devices */
/* Volume control */
static uint8_t s_volume_level = 64; /* Current volume (0-127, default ~50%) */
static bool s_volume_control_available = false; /* Whether AVRC volume control is available */
/*********************************
* NVS STORAGE FUNCTION DEFINITIONS
********************************/
@@ -706,6 +716,9 @@ static void filter_inquiry_scan_result(esp_bt_gap_cb_param_t *param)
// Save discovered audio device to NVS (but don't connect to it)
nvs_add_discovered_device(param->disc_res.bda, (char *)s_peer_bdname);
// Add to device list for GUI
add_device_to_list(param->disc_res.bda, (char *)s_peer_bdname, false, rssi);
ESP_LOGI(BT_AV_TAG, "Found audio device, address %s, name %s (saved to NVS, not connecting)",
bda_str, s_peer_bdname);
@@ -920,7 +933,7 @@ void generate_synth_pcm(uint8_t *buf, int len) {
#define MAX_RATE_HZ 440.0f
#define CLICK_AMPLITUDE 32000 // 16-bit
#define EXP_K 3.0f
#define DEADBAND_ANGLE 0.25f
#define DEADBAND_ANGLE 0.5f
static float click_timer = 0.0f;
@@ -1466,8 +1479,8 @@ void bt_av_notify_evt_handler(uint8_t event_id, esp_avrc_rn_param_t *event_param
/* when volume changed locally on target, this event comes */
case ESP_AVRC_RN_VOLUME_CHANGE: {
ESP_LOGI(BT_RC_CT_TAG, "Volume changed: %d", event_parameter->volume);
ESP_LOGI(BT_RC_CT_TAG, "Set absolute volume: volume %d", event_parameter->volume + 5);
esp_avrc_ct_send_set_absolute_volume_cmd(APP_RC_CT_TL_RN_VOLUME_CHANGE, event_parameter->volume + 5);
// Update our stored volume level
s_volume_level = event_parameter->volume;
bt_av_volume_changed();
break;
}
@@ -1494,6 +1507,7 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
esp_avrc_ct_send_get_rn_capabilities_cmd(APP_RC_CT_TL_GET_CAPS);
} else {
s_avrc_peer_rn_cap.bits = 0;
s_volume_control_available = false;
}
break;
}
@@ -1525,6 +1539,15 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
ESP_LOGI(BT_RC_CT_TAG, "remote rn_cap: count %d, bitmask 0x%x", rc->get_rn_caps_rsp.cap_count,
rc->get_rn_caps_rsp.evt_set.bits);
s_avrc_peer_rn_cap.bits = rc->get_rn_caps_rsp.evt_set.bits;
// Check if volume control is available
if (esp_avrc_rn_evt_bit_mask_operation(ESP_AVRC_BIT_MASK_OP_TEST, &s_avrc_peer_rn_cap, ESP_AVRC_RN_VOLUME_CHANGE)) {
s_volume_control_available = true;
ESP_LOGI(BT_RC_CT_TAG, "Volume control is available");
} else {
s_volume_control_available = false;
ESP_LOGI(BT_RC_CT_TAG, "Volume control is not available");
}
bt_av_volume_changed();
break;
@@ -1532,6 +1555,8 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
/* when set absolute volume responded, this event comes */
case ESP_AVRC_CT_SET_ABSOLUTE_VOLUME_RSP_EVT: {
ESP_LOGI(BT_RC_CT_TAG, "Set absolute volume response: volume %d", rc->set_volume_rsp.volume);
// Update our stored volume level with the confirmed value
s_volume_level = rc->set_volume_rsp.volume;
break;
}
/* other */
@@ -1572,8 +1597,31 @@ static void bt_app_task_handler(void *arg)
ESP_LOGI("MY_TASK", "Running on core %d", core_id);
for (;;) {
// Check for system events first
uint32_t notifiedBits = 0;
if (xTaskNotifyWait(0xFFFFFFFF, 0xFFFFFFFF, &notifiedBits, pdMS_TO_TICKS(10)) == pdTRUE) {
if (notifiedBits & EM_EVENT_BT_REFRESH) {
ESP_LOGI(BT_AV_TAG, "BT Refresh event received");
bt_clear_discovered_devices();
// Notify GUI that refresh is done - could add completion event if needed
}
if (notifiedBits & EM_EVENT_BT_CONNECT) {
int device_index = system_getBtDeviceIndex();
ESP_LOGI(BT_AV_TAG, "BT Connect event received for device %d", device_index);
bt_connect_device(device_index);
}
if (notifiedBits & EM_EVENT_VOLUME_UP) {
ESP_LOGI(BT_AV_TAG, "Volume Up event received");
bt_volume_up();
}
if (notifiedBits & EM_EVENT_VOLUME_DOWN) {
ESP_LOGI(BT_AV_TAG, "Volume Down event received");
bt_volume_down();
}
}
/* receive message from work queue and handle it */
if (pdTRUE == xQueueReceive(s_bt_app_task_queue, &msg, (TickType_t)portMAX_DELAY)) {
if (pdTRUE == xQueueReceive(s_bt_app_task_queue, &msg, pdMS_TO_TICKS(10))) {
ESP_LOGD(BT_APP_CORE_TAG, "%s, signal: 0x%x, event: 0x%x", __func__, msg.sig, msg.event);
switch (msg.sig) {
@@ -1628,7 +1676,10 @@ void bt_app_task_start_up(void)
s_bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
//xTaskCreate(bt_app_task_handler, "BtAppTask", 8192, NULL, 10, &s_bt_app_task_handle);
xTaskCreatePinnedToCore(bt_app_task_handler, "BtAppTask", 8192, NULL, 10, NULL, 1);
xTaskCreatePinnedToCore(bt_app_task_handler, "BtAppTask", 8192, NULL, 10, &s_bt_app_task_handle, 1);
// Subscribe to system events for GUI communication
system_subscribe(s_bt_app_task_handle);
}
void bt_app_task_shut_down(void)
@@ -1733,7 +1784,214 @@ void bt_app_init(void)
ESP_LOGI(BT_APP_CORE_TAG, "Audio synth producer started");
vTaskDelay(pdMS_TO_TICKS(1000));
}
/*********************************
* BLUETOOTH DEVICE LIST MANAGEMENT FOR GUI
********************************/
static void add_device_to_list(esp_bd_addr_t bda, const char *name, bool is_paired, int rssi) {
if (!bda) {
ESP_LOGE(BT_AV_TAG, "Null BDA in add_device_to_list");
return;
}
// Check if device already exists
for (int i = 0; i < s_device_list.count; i++) {
if (memcmp(s_device_list.devices[i].bda, bda, ESP_BD_ADDR_LEN) == 0) {
// Update existing device
strncpy(s_device_list.devices[i].name, name ? name : "Unknown", MAX_BT_NAME_LEN - 1);
s_device_list.devices[i].name[MAX_BT_NAME_LEN - 1] = '\0';
s_device_list.devices[i].is_paired = is_paired;
s_device_list.devices[i].rssi = rssi;
ESP_LOGI(BT_AV_TAG, "Updated existing device: %s (%s)",
s_device_list.devices[i].name,
is_paired ? "paired" : "discovered");
return;
}
}
// Add new device if there's space
if (s_device_list.count < MAX_BT_DEVICES) {
memcpy(s_device_list.devices[s_device_list.count].bda, bda, ESP_BD_ADDR_LEN);
strncpy(s_device_list.devices[s_device_list.count].name, name ? name : "Unknown", MAX_BT_NAME_LEN - 1);
s_device_list.devices[s_device_list.count].name[MAX_BT_NAME_LEN - 1] = '\0';
s_device_list.devices[s_device_list.count].is_paired = is_paired;
s_device_list.devices[s_device_list.count].rssi = rssi;
s_device_list.count++;
ESP_LOGI(BT_AV_TAG, "Added new device to list: %s (%s), total devices: %d",
s_device_list.devices[s_device_list.count - 1].name,
is_paired ? "paired" : "discovered",
s_device_list.count);
} else {
ESP_LOGW(BT_AV_TAG, "Device list full, cannot add device: %s", name ? name : "Unknown");
}
}
static void load_paired_devices_to_list(void) {
paired_device_t paired_devices[MAX_PAIRED_DEVICES];
size_t count = MAX_PAIRED_DEVICES;
ESP_LOGI(BT_AV_TAG, "Attempting to load paired devices from NVS");
esp_err_t err = nvs_load_paired_devices(paired_devices, &count);
if (err == ESP_OK) {
ESP_LOGI(BT_AV_TAG, "Successfully loaded %d paired devices from NVS", (int)count);
for (size_t i = 0; i < count; i++) {
add_device_to_list(paired_devices[i].bda, paired_devices[i].name, true, 0);
}
ESP_LOGI(BT_AV_TAG, "Added %d paired devices to device list", (int)count);
} else {
ESP_LOGW(BT_AV_TAG, "Failed to load paired devices from NVS: %s", esp_err_to_name(err));
}
}
bt_device_list_t* bt_get_device_list(void) {
// Initialize device list if needed
if (s_device_list.count == 0) {
ESP_LOGI(BT_AV_TAG, "Loading paired devices to list");
load_paired_devices_to_list();
}
ESP_LOGI(BT_AV_TAG, "Device list has %d devices", s_device_list.count);
return &s_device_list;
}
bool bt_start_discovery(void) {
if (s_device_list.discovery_active) {
ESP_LOGW(BT_AV_TAG, "Discovery already active");
return false; // Already discovering
}
// Check if Bluetooth stack is initialized
if (!esp_bluedroid_get_status()) {
ESP_LOGE(BT_AV_TAG, "Bluetooth stack not initialized");
return false;
}
// Check current A2DP state - avoid discovery during connection attempts
if (s_a2d_state == APP_AV_STATE_CONNECTING || s_a2d_state == APP_AV_STATE_DISCOVERING) {
ESP_LOGW(BT_AV_TAG, "Cannot start discovery - A2DP state: %d", s_a2d_state);
// Still load paired devices for display
load_paired_devices_to_list();
return false;
}
// Bluetooth stack is initialized and A2DP state is good - proceed with discovery
// Load paired devices first
ESP_LOGI(BT_AV_TAG, "Loading paired devices before discovery");
load_paired_devices_to_list();
ESP_LOGI(BT_AV_TAG, "Starting Bluetooth device discovery (A2DP state: %d)", s_a2d_state);
// Cancel any previous discovery to ensure clean state
esp_bt_gap_cancel_discovery();
// Small delay to ensure clean state
vTaskDelay(pdMS_TO_TICKS(100));
// Set discovery state first to prevent race conditions
s_device_list.discovery_active = true;
esp_err_t result = esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);
if (result == ESP_OK) {
ESP_LOGI(BT_AV_TAG, "Device discovery started successfully");
return true;
} else {
ESP_LOGE(BT_AV_TAG, "Failed to start discovery: %s (0x%x)", esp_err_to_name(result), result);
s_device_list.discovery_active = false; // Reset on failure
return false;
}
}
bool bt_stop_discovery(void) {
esp_err_t result = esp_bt_gap_cancel_discovery();
s_device_list.discovery_active = false;
ESP_LOGI(BT_AV_TAG, "Device discovery stopped");
return (result == ESP_OK);
}
bool bt_connect_device(int device_index) {
if (device_index < 0 || device_index >= s_device_list.count) {
ESP_LOGE(BT_AV_TAG, "Invalid device index: %d", device_index);
return false;
}
bt_device_info_t *device = &s_device_list.devices[device_index];
// Stop any ongoing discovery
if (s_device_list.discovery_active) {
bt_stop_discovery();
}
// Copy device info for connection attempt
memcpy(s_peer_bda, device->bda, ESP_BD_ADDR_LEN);
strncpy((char*)s_peer_bdname, device->name, ESP_BT_GAP_MAX_BDNAME_LEN);
s_peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN] = '\0';
// If device is paired, connect directly
if (device->is_paired) {
ESP_LOGI(BT_AV_TAG, "Connecting to paired device: %s", device->name);
s_a2d_state = APP_AV_STATE_CONNECTING;
esp_a2d_source_connect(device->bda);
} else {
ESP_LOGI(BT_AV_TAG, "Pairing and connecting to device: %s", device->name);
s_a2d_state = APP_AV_STATE_DISCOVERED;
// The GAP callback will handle the connection after discovery stops
esp_bt_gap_cancel_discovery();
}
return true;
}
void bt_clear_discovered_devices(void) {
int new_count = 0;
// Keep only paired devices
for (int i = 0; i < s_device_list.count; i++) {
if (s_device_list.devices[i].is_paired) {
if (new_count != i) {
s_device_list.devices[new_count] = s_device_list.devices[i];
}
new_count++;
}
}
s_device_list.count = new_count;
ESP_LOGI(BT_AV_TAG, "Cleared discovered devices, kept %d paired devices", new_count);
}
void bt_volume_up(void) {
if (!s_volume_control_available) {
ESP_LOGW(BT_AV_TAG, "Volume control not available");
return;
}
if (s_volume_level < 127) {
s_volume_level += 10; // Increase by ~8%
if (s_volume_level > 127) s_volume_level = 127;
ESP_LOGI(BT_AV_TAG, "Setting volume to %d", s_volume_level);
esp_avrc_ct_send_set_absolute_volume_cmd(APP_RC_CT_TL_RN_VOLUME_CHANGE, s_volume_level);
}
}
void bt_volume_down(void) {
if (!s_volume_control_available) {
ESP_LOGW(BT_AV_TAG, "Volume control not available");
return;
}
if (s_volume_level > 0) {
s_volume_level -= 10; // Decrease by ~8%
if (s_volume_level < 0) s_volume_level = 0;
ESP_LOGI(BT_AV_TAG, "Setting volume to %d", s_volume_level);
esp_avrc_ct_send_set_absolute_volume_cmd(APP_RC_CT_TL_RN_VOLUME_CHANGE, s_volume_level);
}
}
int bt_get_current_volume(void) {
// Convert from 0-127 to 0-100 for GUI
return (s_volume_level * 100) / 127;
}

38
main/bt_app.h
View File

@@ -10,6 +10,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include "esp_bt_defs.h"
/* log tag */
#define BT_APP_CORE_TAG "BT_APP_CORE"
@@ -67,4 +68,41 @@ void bt_app_task_shut_down(void);
void bt_app_init(void);
/* Bluetooth device management for GUI */
#define MAX_BT_DEVICES 20
#define MAX_BT_NAME_LEN 32
typedef struct {
esp_bd_addr_t bda;
char name[MAX_BT_NAME_LEN];
bool is_paired;
int rssi;
} bt_device_info_t;
typedef struct {
bt_device_info_t devices[MAX_BT_DEVICES];
int count;1
bool discovery_active;
} bt_device_list_t;
/* Get current device list for GUI display */
bt_device_list_t* bt_get_device_list(void);
/* Start device discovery */
bool bt_start_discovery(void);
/* Stop device discovery */
bool bt_stop_discovery(void);
/* Connect to specific device by index in device list */
bool bt_connect_device(int device_index);
/* Clear discovered devices (keep paired devices) */
void bt_clear_discovered_devices(void);
/* Volume control functions */
void bt_volume_up(void);
void bt_volume_down(void);
int bt_get_current_volume(void);
#endif /* __BT_APP_CORE_H__ */

510
main/gui.c
View File

@@ -1,5 +1,6 @@
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
@@ -19,6 +20,7 @@
#include "keypad.h"
#include "bubble.h"
#include "system.h"
#include "bt_app.h"
#define DEVKIT
#undef DEVKIT
@@ -62,6 +64,13 @@ static void gui_task(void *pvParameters);
static void createBubble(lv_obj_t * scr);
static void build_scrollable_menu(void);
static void currentFocusIndex(menu_context_t *ctx);
static lv_obj_t * addMenuItem(lv_obj_t *page, const char *text);
static lv_obj_t* create_menu_container(void);
static void show_bt_device_list(void);
static void show_volume_control(void);
static lv_obj_t* create_volume_page(void);
static void update_volume_display(int volume);
static void ensure_menu_styles(void);
#define MAX_ITEMS 10
#define VISIBLE_ITEMS 3
@@ -98,6 +107,54 @@ static bool notify_lvgl_flush_ready(void *user_ctx) {
return true;
}
static lv_obj_t* create_main_page(void) {
lv_obj_t* main_page;
ensure_menu_styles();
lv_obj_t* menu = create_menu_container();
main_page = lv_menu_page_create(menu, NULL);
lv_obj_set_style_radius(main_page, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_style_border_width(main_page, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_scrollbar_mode(main_page, LV_SCROLLBAR_MODE_AUTO);
lv_obj_set_size(main_page, lv_pct(100), lv_pct(100));
// Add menu items
lv_obj_t* tmpObj;
tmpObj = addMenuItem(main_page, "Bluetooth");
lv_obj_add_state(tmpObj, LV_STATE_FOCUSED); // First item focused
addMenuItem(main_page, "Calibration");
addMenuItem(main_page, "Volume");
addMenuItem(main_page, "About");
addMenuItem(main_page, "Exit");
return main_page;
}
static void show_menu(void) {
lv_obj_t* menu = create_menu_container();
lv_obj_t* main_page = create_main_page();
lv_menu_set_page(menu, main_page);
_currentPage = main_page;
lv_obj_remove_flag(menu, LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
}
static void cleanup_menu(void) {
if (_menu) {
lv_obj_del(_menu);
_menu = NULL;
_currentPage = NULL;
ESP_LOGI(TAG, "Menu cleaned up to free memory");
}
}
static void show_bubble(void) {
cleanup_menu(); // Free menu memory when returning to bubble
lv_obj_remove_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
}
static void create_lvgl_demo(void)
{
@@ -107,7 +164,7 @@ static void create_lvgl_demo(void)
lv_obj_t *scr = lv_scr_act();
createBubble(scr);
//build_scrollable_menu();
// Menu will be created lazily when needed
lvgl_port_unlock();
@@ -167,7 +224,7 @@ static void lvgl_init(void)
#if 1
const lvgl_port_cfg_t lvgl_cfg = {
.task_priority = 4, // LVGL task priority
.task_stack = 16384, // LVGL task stack size
.task_stack = 8192, // LVGL task stack size (reduced for memory savings)
.task_affinity = 0, // LVGL task can run on any core
.task_max_sleep_ms = 500, // Maximum sleep in LVGL task
.timer_period_ms = 5 // LVGL timer period
@@ -236,7 +293,7 @@ void gui_start(void)
gpio_set_level(PIN_NUM_BK_LIGHT, 1);
xTaskCreate(gui_task, "gui_task", 4096, NULL, 5, NULL);
xTaskCreate(gui_task, "gui_task", 8192, NULL, 5, NULL);
}
@@ -281,11 +338,30 @@ static const char * items[] = { // your menu entries
static lv_obj_t * btn_array[ITEM_COUNT];
static int selected_idx = 0;
// Called whenever a button is “activated” (Enter/Click)
// Called whenever a button is "activated" (Enter/Click)
static void btn_click_cb(lv_event_t * e) {
lv_obj_t * btn = lv_event_get_target(e);
const char * txt = lv_label_get_text(lv_obj_get_child(btn, 0));
ESP_LOGI(TAG, "Activated: %s\n", txt);
// Handle specific menu items
if (strcmp(txt, "Bluetooth") == 0) {
LOCK();
show_bt_device_list();
UNLOCK();
} else if (strcmp(txt, "Volume") == 0) {
LOCK();
show_volume_control();
UNLOCK();
} else if (strcmp(txt, "Exit") == 0) {
LOCK();
_mode = GUI_BUBBLE;
show_bubble();
UNLOCK();
}
// Add more menu handlers here as needed
ESP_LOGI(TAG, "End btn_click_cb");
}
// Repaint all rows so only btn_array[selected_idx] is highlighted
@@ -384,10 +460,22 @@ static void activate_selected(void)
static lv_obj_t * addMenuItem(lv_obj_t *page, const char *text)
{
if (!page || !text) {
ESP_LOGE(TAG, "Null parameters in addMenuItem");
return NULL;
}
// Ensure styles are initialized
ensure_menu_styles();
lv_obj_t * btn = lv_btn_create(page);
if (!btn) {
ESP_LOGE(TAG, "Failed to create button in addMenuItem");
return NULL;
}
lv_obj_set_size(btn, LV_PCT(100), ROW_H);
lv_obj_add_style(btn, &_styleUnfocusedBtn, LV_PART_MAIN | LV_STATE_DEFAULT);
lv_obj_add_style(btn, &_styleFocusedBtn, LV_PART_MAIN | LV_STATE_FOCUSED);
@@ -402,6 +490,12 @@ static lv_obj_t * addMenuItem(lv_obj_t *page, const char *text)
// label & center
lv_obj_t * lbl = lv_label_create(btn);
if (!lbl) {
ESP_LOGE(TAG, "Failed to create label in addMenuItem");
lv_obj_del(btn);
return NULL;
}
lv_label_set_text(lbl, text);
lv_obj_set_style_radius(lbl, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_style_border_width(lbl, 0, LV_PART_MAIN | LV_STATE_ANY);
@@ -441,6 +535,309 @@ static void currentFocusIndex(menu_context_t *ctx)
}
// ───── LAZY MENU CREATION ─────
static void ensure_menu_styles(void) {
static bool styles_initialized = false;
if (!styles_initialized) {
lv_style_init(&_styleFocusedBtn);
lv_style_init(&_styleUnfocusedBtn);
lv_style_set_bg_color(&_styleUnfocusedBtn, lv_color_make(0xff,0xff,0xff)); // white bg
lv_style_set_text_color(&_styleUnfocusedBtn, lv_color_black()); // orange text
lv_style_set_bg_color(&_styleFocusedBtn, lv_color_make(0x33,0x99,0xFF)); // blue bg
lv_style_set_text_color(&_styleFocusedBtn, lv_color_white()); // black text
styles_initialized = true;
}
}
static lv_obj_t* create_menu_container(void) {
if (_menu == NULL) {
_menu = lv_menu_create(lv_scr_act());
lv_obj_set_style_radius(_menu, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_style_border_width(_menu, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_size(_menu, lv_pct(100), lv_pct(100));
lv_obj_center(_menu);
lv_obj_set_scrollbar_mode(_menu, LV_SCROLLBAR_MODE_AUTO);
lv_obj_add_flag(_menu, LV_OBJ_FLAG_HIDDEN); // Hidden by default
}
return _menu;
}
// ───── BLUETOOTH DEVICE LIST PAGE ─────
static lv_obj_t* _bt_page = NULL;
static int _bt_selected_device = 0;
// ───── VOLUME CONTROL PAGE ─────
static lv_obj_t* _volume_page = NULL;
static lv_obj_t* _volume_bar = NULL;
static lv_obj_t* _volume_label = NULL;
static int _current_volume = 50; // Default volume (0-100)
static void bt_device_click_cb(lv_event_t * e) {
if (!e) {
ESP_LOGE(TAG, "Null event in bt_device_click_cb");
return;
}
lv_obj_t * btn = lv_event_get_target(e);
if (!btn) {
ESP_LOGE(TAG, "Null button in bt_device_click_cb");
return;
}
lv_obj_t * child = lv_obj_get_child(btn, 0);
if (!child) {
ESP_LOGE(TAG, "Null child in bt_device_click_cb");
return;
}
const char * txt = lv_label_get_text(child);
if (!txt) {
ESP_LOGE(TAG, "Null text in bt_device_click_cb");
return;
}
// Handle special buttons
if (strcmp(txt, "Back") == 0) {
LOCK();
bt_stop_discovery();
_mode = GUI_MENU;
show_menu();
UNLOCK();
return;
} else if (strcmp(txt, "Refresh") == 0) {
LOCK();
// Use system event instead of direct BT call
system_requestBtRefresh();
UNLOCK();
return;
}
// Find which device was clicked
bt_device_list_t* device_list = bt_get_device_list();
if (!device_list) {
ESP_LOGE(TAG, "Null device list in bt_device_click_cb");
return;
}
if (!_bt_page) {
ESP_LOGE(TAG, "Null _bt_page in bt_device_click_cb");
return;
}
for (int i = 0; i < device_list->count; i++) {
lv_obj_t * child = lv_obj_get_child(_bt_page, i);
if (child == btn) {
ESP_LOGI(TAG, "Requesting connection to device %d: %s", i, device_list->devices[i].name);
// Use system event instead of direct BT call
system_requestBtConnect(i);
// Return to bubble mode after selection
_mode = GUI_BUBBLE;
show_bubble();
return;
}
}
}
static lv_obj_t* create_bt_device_page(void) {
ESP_LOGI(TAG, "Creating Bluetooth device page");
lv_obj_t* menu = create_menu_container();
if (!menu) {
ESP_LOGE(TAG, "Failed to create menu container");
return NULL;
}
_bt_page = lv_menu_page_create(menu, NULL);
if (!_bt_page) {
ESP_LOGE(TAG, "Failed to create Bluetooth page");
return NULL;
}
lv_obj_set_style_radius(_bt_page, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_style_border_width(_bt_page, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_scrollbar_mode(_bt_page, LV_SCROLLBAR_MODE_AUTO);
lv_obj_set_size(_bt_page, lv_pct(100), lv_pct(100));
ESP_LOGI(TAG, "Starting Bluetooth discovery");
bool discovery_started = true;
#if 0
// Try to start discovery (may fail if BT stack is busy)
bool discovery_started = bt_start_discovery();
if (!discovery_started) {
ESP_LOGW(TAG, "Discovery not started - will show paired devices only");
}
#endif
// Get device list
ESP_LOGI(TAG, "Getting device list");
bt_device_list_t* device_list = bt_get_device_list();
if (!device_list) {
ESP_LOGE(TAG, "Failed to get device list");
return _bt_page;
}
if (device_list->count == 0) {
// Show appropriate message based on discovery status
const char* msg = discovery_started ? "Scanning for devices..." : "No devices found";
lv_obj_t* tmpObj = addMenuItem(_bt_page, msg);
lv_obj_add_state(tmpObj, LV_STATE_DISABLED);
} else {
// Add devices to the page
bool first = true;
for (int i = 0; i < device_list->count; i++) {
char device_text[64];
snprintf(device_text, sizeof(device_text), "%s%s",
device_list->devices[i].name,
device_list->devices[i].is_paired ? " (paired)" : "");
lv_obj_t* btn = addMenuItem(_bt_page, device_text);
lv_obj_add_event_cb(btn, bt_device_click_cb, LV_EVENT_CLICKED, NULL);
if (first) {
lv_obj_add_state(btn, LV_STATE_FOCUSED);
first = false;
}
}
}
// Add back/refresh options
lv_obj_t* refresh_btn = addMenuItem(_bt_page, "Refresh");
lv_obj_add_event_cb(refresh_btn, bt_device_click_cb, LV_EVENT_CLICKED, NULL);
lv_obj_t* back_btn = addMenuItem(_bt_page, "Back");
lv_obj_add_event_cb(back_btn, bt_device_click_cb, LV_EVENT_CLICKED, NULL);
return _bt_page;
}
static void show_bt_device_list(void) {
ESP_LOGI(TAG, "Showing Bluetooth device list");
lv_obj_t* menu = create_menu_container();
if (!menu) {
ESP_LOGE(TAG, "Failed to create menu container for Bluetooth list");
return;
}
lv_obj_t* bt_page = create_bt_device_page();
if (!bt_page) {
ESP_LOGE(TAG, "Failed to create Bluetooth device page");
return;
}
lv_menu_set_page(menu, bt_page);
_currentPage = bt_page;
_mode = GUI_MENU; // Keep in menu mode
lv_obj_remove_flag(menu, LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
ESP_LOGI(TAG, "Bluetooth device list displayed");
}
// ───── VOLUME CONTROL PAGE ─────
static lv_obj_t* create_volume_page(void) {
ESP_LOGI(TAG, "Creating volume control page");
lv_obj_t* menu = create_menu_container();
if (!menu) {
ESP_LOGE(TAG, "Failed to create menu container for volume control");
return NULL;
}
_volume_page = lv_menu_page_create(menu, NULL);
if (!_volume_page) {
ESP_LOGE(TAG, "Failed to create volume page");
return NULL;
}
lv_obj_set_style_radius(_volume_page, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_style_border_width(_volume_page, 0, LV_PART_MAIN | LV_STATE_ANY);
lv_obj_set_scrollbar_mode(_volume_page, LV_SCROLLBAR_MODE_OFF);
lv_obj_set_size(_volume_page, lv_pct(100), lv_pct(100));
// Create title label
lv_obj_t* title = lv_label_create(_volume_page);
lv_label_set_text(title, "Volume Control");
lv_obj_set_style_text_align(title, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 5);
// Create volume bar (progress bar)
_volume_bar = lv_bar_create(_volume_page);
lv_obj_set_size(_volume_bar, 120, 20);
lv_obj_align(_volume_bar, LV_ALIGN_CENTER, 0, -10);
lv_bar_set_range(_volume_bar, 0, 100);
lv_bar_set_value(_volume_bar, _current_volume, LV_ANIM_OFF);
// Create volume percentage label
_volume_label = lv_label_create(_volume_page);
char volume_text[16];
snprintf(volume_text, sizeof(volume_text), "%d%%", _current_volume);
lv_label_set_text(_volume_label, volume_text);
lv_obj_set_style_text_align(_volume_label, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_align(_volume_label, LV_ALIGN_CENTER, 0, 15);
// Create instruction labels
lv_obj_t* instr1 = lv_label_create(_volume_page);
lv_label_set_text(instr1, "KEY0: Volume Up");
lv_obj_set_style_text_align(instr1, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_align(instr1, LV_ALIGN_BOTTOM_MID, 0, -25);
lv_obj_t* instr2 = lv_label_create(_volume_page);
lv_label_set_text(instr2, "KEY1: Volume Down");
lv_obj_set_style_text_align(instr2, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_align(instr2, LV_ALIGN_BOTTOM_MID, 0, -10);
return _volume_page;
}
static void show_volume_control(void) {
ESP_LOGI(TAG, "Showing volume control");
lv_obj_t* menu = create_menu_container();
if (!menu) {
ESP_LOGE(TAG, "Failed to create menu container for volume control");
return;
}
lv_obj_t* volume_page = create_volume_page();
if (!volume_page) {
ESP_LOGE(TAG, "Failed to create volume page");
return;
}
lv_menu_set_page(menu, volume_page);
_currentPage = volume_page;
_mode = GUI_MENU; // Keep in menu mode
lv_obj_remove_flag(menu, LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
ESP_LOGI(TAG, "Volume control displayed");
}
static void update_volume_display(int volume) {
if (_volume_bar && _volume_label) {
LOCK();
lv_bar_set_value(_volume_bar, volume, LV_ANIM_ON);
char volume_text[16];
snprintf(volume_text, sizeof(volume_text), "%d%%", volume);
lv_label_set_text(_volume_label, volume_text);
UNLOCK();
_current_volume = volume;
ESP_LOGI(TAG, "Volume display updated to %d%%", volume);
}
}
// ───── BUILD THE MENU ─────
static void build_scrollable_menu(void) {
@@ -523,10 +920,8 @@ static void gui_task(void *pvParameters)
uint32_t ev = 0;
LOCK();
// _mode = GUI_MENU;
// lv_obj_remove_flag(_menu, LV_OBJ_FLAG_HIDDEN);
_mode = GUI_BUBBLE;
lv_obj_remove_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
//lv_obj_add_flag(_menu, LV_OBJ_FLAG_HIDDEN);
UNLOCK();
ESP_LOGI(TAG, "Start GUI Task...");
@@ -537,7 +932,7 @@ static void gui_task(void *pvParameters)
if (xQueueReceive(q, &ev, pdMS_TO_TICKS(10)) == pdTRUE)
{
switch (ev) {
#if 0
case (KEY_UP << KEY_LONG_PRESS):
{
system_setZeroAngle();
@@ -549,48 +944,95 @@ static void gui_task(void *pvParameters)
system_clearZeroAngle();
break;
}
#if 0
case (KEY0 << KEY_SHORT_PRESS):
#endif
case (KEY_UP << KEY_SHORT_PRESS):
if (_mode == GUI_MENU)
{
menuNext();
// Check if we're on the volume control page
if (_currentPage == _volume_page) {
// Volume up
if (_current_volume < 100) {
_current_volume += 5;
if (_current_volume > 100) _current_volume = 100;
update_volume_display(_current_volume);
system_requestVolumeUp();
}
} else {
menuNext();
}
}
ESP_LOGI(TAG, "MAIN: Button 1 SHORT");
ESP_LOGI(TAG, "MAIN: Button UP SHORT");
break;
case (KEY_DOWN << KEY_SHORT_PRESS):
{
if (_mode == GUI_MENU)
{
// Check if we're on the volume control page
if (_currentPage == _volume_page) {
// Volume down
if (_current_volume > 0) {
_current_volume -= 5;
if (_current_volume < 0) _current_volume = 0;
update_volume_display(_current_volume);
system_requestVolumeDown();
}
} else {
menuPrevious();
}
}
ESP_LOGI(TAG, "MAIN: Button DOWN SHORT");
break;
}
case (KEY0 << KEY_LONG_PRESS):
{
ESP_LOGI(TAG, "MAIN: Button 0 LONG - Enter");
LOCK();
if (_mode != GUI_MENU)
{
_mode = GUI_MENU;
lv_obj_remove_flag(_menu, LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
show_menu(); // Use lazy loading
}
else
if (_mode == GUI_MENU)
else if (_mode == GUI_MENU)
{
activate_selected();
_mode = GUI_BUBBLE;
// lv_obj_remove_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
// lv_obj_add_flag(_menu, LV_OBJ_FLAG_HIDDEN);
}
break;
}
case (KEY1 << KEY_SHORT_PRESS):
{
if (_mode == GUI_MENU)
{
menuPrevious();
// Check if we're in special pages - don't auto-exit
if (_currentPage == _bt_page) {
// Don't automatically exit to bubble mode from Bluetooth page
} else if (_currentPage == _volume_page) {
// Don't automatically exit to bubble mode from Volume page
} else {
ESP_LOGI(TAG, "return to main");
// In main menu - activate selection and exit to bubble
activate_selected();
_mode = GUI_BUBBLE;
show_bubble(); // Cleanup menu and show bubble
}
}
UNLOCK();
ESP_LOGI(TAG, "MAIN: Button 0 LONG - Exit");
break;
}
case (KEY1 << KEY_LONG_PRESS):
ESP_LOGI(TAG, "MAIN: Button 2 LONG");
gpio_set_level(PIN_NUM_nON, 0);
{
LOCK();
if (_mode == GUI_MENU)
{
_mode = GUI_BUBBLE;
show_bubble(); // Cleanup menu and show bubble
}
else
{
// Power off on long press from bubble mode
gpio_set_level(PIN_NUM_nON, 0);
}
UNLOCK();
ESP_LOGI(TAG, "MAIN: Button 1 LONG - Back/Power");
break;
#endif
}
default:
break;
}

32
main/system.c
View File

@@ -166,4 +166,36 @@ void system_notifyAll(uint32_t eventBits) {
}
xSemaphoreGive(em->mutex);
}
}
void system_requestBtRefresh(void) {
ESP_LOGI("system", "BT Refresh requested");
system_notifyAll(EM_EVENT_BT_REFRESH);
}
void system_requestBtConnect(int device_index) {
xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
_systemState.btDeviceIndex = device_index;
xSemaphoreGive(_eventManager.mutex);
ESP_LOGI("system", "BT Connect requested for device %d", device_index);
system_notifyAll(EM_EVENT_BT_CONNECT);
}
int system_getBtDeviceIndex(void) {
int index;
xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
index = _systemState.btDeviceIndex;
xSemaphoreGive(_eventManager.mutex);
return index;
}
void system_requestVolumeUp(void) {
ESP_LOGI("system", "Volume Up requested");
system_notifyAll(EM_EVENT_VOLUME_UP);
}
void system_requestVolumeDown(void) {
ESP_LOGI("system", "Volume Down requested");
system_notifyAll(EM_EVENT_VOLUME_DOWN);
}

18
main/system.h
View File

@@ -32,10 +32,13 @@ typedef struct SystemState_s
float zeroAngle;
int primaryAxis;
// BT event data
int btDeviceIndex;
} SystemState_t;
#define MAX_INDICATION_ANGLE 5.0f
#define MAX_INDICATION_ANGLE 7.5f
#define FILTER_COEFF 0.4f // 0 to 1 Smaller number is heavier filter
#define PRIMARY_AXIS ANGLE_YZ
#define RIFLE_AXIS Y
@@ -43,6 +46,10 @@ typedef struct SystemState_s
#define EM_MAX_SUBSCRIBERS 8 // tweak as needed
#define EM_EVENT_NEW_DATA (1UL<<0)
#define EM_EVENT_ERROR (1UL<<1)
#define EM_EVENT_BT_REFRESH (1UL<<2)
#define EM_EVENT_BT_CONNECT (1UL<<3)
#define EM_EVENT_VOLUME_UP (1UL<<4)
#define EM_EVENT_VOLUME_DOWN (1UL<<5)
// …add more event bit-masks here…
typedef struct {
@@ -72,5 +79,14 @@ BaseType_t system_unsubscribe(TaskHandle_t task);
// Notify all subscribers of one or more event bits
void system_notifyAll(uint32_t eventBits);
// BT-specific event functions
void system_requestBtRefresh(void);
void system_requestBtConnect(int device_index);
int system_getBtDeviceIndex(void);
// Volume control functions
void system_requestVolumeUp(void);
void system_requestVolumeDown(void);
#endif