diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 0000000..4039bef
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,16 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/gcc",
+            "cStandard": "c17",
+            "cppStandard": "gnu++17",
+            "intelliSenseMode": "linux-gcc-x64"
+        }
+    ],
+    "version": 4
+}
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 0de0370..2ad07a6 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -35,7 +35,10 @@
         "semphr.h": "c",
         "lv_spinbox.h": "c",
         "lv_slider.h": "c",
-        "lv_menu.h": "c"
+        "lv_menu.h": "c",
+        "stdint.h": "c",
+        "random": "c"
     },
-    "git.ignoreLimitWarning": true
+    "git.ignoreLimitWarning": true,
+    "idf.pythonInstallPath": "/usr/bin/python"
 }
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d0db1e5..1af5975 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,21 @@
-# The following lines of boilerplate have to be in your project's
-# CMakeLists in this exact order for cmake to work correctly
+# The following lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+configure_file(${CMAKE_SOURCE_DIR}/settings.json ${CMAKE_BINARY_DIR}/settings.json COPYONLY)
+
+execute_process(
+    COMMAND ${CMAKE_COMMAND} -E echo "Parsing settings.json..."
+)
+
+execute_process(
+    COMMAND ${CMAKE_COMMAND} -E env python ${CMAKE_SOURCE_DIR}/prepare_config.py
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+)
+
+
+
+
 cmake_minimum_required(VERSION 3.16)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(level-shot)
+include("${CMAKE_SOURCE_DIR}/project_settings.cmake")
+project(${PROJECT_NAME})
\ No newline at end of file
diff --git a/bt_test/bt_test.ino b/bt_test/bt_test.ino
new file mode 100644
index 0000000..fffe3d8
--- /dev/null
+++ b/bt_test/bt_test.ino
@@ -0,0 +1,51 @@
+#include <BluetoothSerial.h>
+#include "esp_bt.h"
+#include "esp_bt_main.h"
+#include "esp_bt_device.h"
+
+BluetoothSerial SerialBT;
+
+void setBluetoothTxPower(esp_power_level_t powerLevel) {
+  esp_err_t err = esp_bredr_tx_power_set(powerLevel, powerLevel);
+  if (err != ESP_OK) {
+    Serial.printf("Failed to set TX Power: %s\n", esp_err_to_name(err));
+  } else {
+    Serial.printf("TX Power set to level %d\n", powerLevel);
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  delay(1000);
+
+  Serial.println("Initializing Bluetooth...");
+
+  if (!btStart()) {
+    Serial.println("Failed to start BT controller");
+    return;
+  }
+
+  // Disable and re-enable the classic BT stack to safely set TX power
+  esp_bluedroid_disable();
+  esp_bluedroid_deinit();
+
+  // Set Classic BT TX power (e.g., ESP_PWR_LVL_P9 = highest)
+  //setBluetoothTxPower(ESP_PWR_LVL_P9);
+  setBluetoothTxPower(ESP_PWR_LVL_N12);
+  
+
+  esp_bluedroid_init();
+  esp_bluedroid_enable();
+
+  if (!SerialBT.begin("ESP32-TXPowerTest")) {
+    Serial.println("Bluetooth Serial failed to start");
+    return;
+  }
+
+  Serial.println("Bluetooth initialized and ready!");
+}
+
+void loop() {
+  SerialBT.println("Hello from ESP32 with boosted TX power!");
+  delay(1);
+}
diff --git a/flash_tool/flash.py b/flash_tool/flash.py
index 6caa081..d5d07e9 100644
--- a/flash_tool/flash.py
+++ b/flash_tool/flash.py
@@ -27,7 +27,9 @@ def main():
     # Define binaries and offsets
     bootloader = root / "build" / "bootloader" / "bootloader.bin"
     firmware = root / "build" / f"{project}.bin"
+    ota_intitial = root / "build" / "ota_data_initial.bin"
     partition = root / "build" / "partition_table" / "partition-table.bin"
+    
 
     # Verify binaries exist
     for f in [bootloader, firmware, partition]:
@@ -47,8 +49,9 @@ def main():
         "--flash-mode", flash_mode,       # ✅ hyphenated flags
         "--flash-freq", flash_freq,
         "--flash-size", flash_size,
-        "0x0", str(bootloader),
-        "0x10000", str(firmware),
+        "0x1000", str(bootloader),
+        "0x20000", str(firmware),
+        "0x11000", str(ota_intitial),
         "0x8000", str(partition)
     ]
 
diff --git a/flash_tool/monitor.py b/flash_tool/monitor.py
index fcabfcf..f46a89a 100644
--- a/flash_tool/monitor.py
+++ b/flash_tool/monitor.py
@@ -3,11 +3,7 @@ import serial
 import sys
 import time
 from pathlib import Path
-# import colorama
-# colorama.just_fix_windows_console()
 
-print("\x1b[0;32mThis should be green\x1b[0m")
-print("\x1b[0;31mThis should be red\x1b[0m")
 
 def main():
     # Load config
@@ -27,6 +23,10 @@ def main():
 
     try:
         with serial.Serial(port, baud, timeout=0.5) as ser:
+            # 🔧 Clear DTR and RTS lines (common for ESP32 reset handling)
+            ser.dtr = False
+            ser.rts = False
+            
             print("[Serial Monitor] Press Ctrl+C to exit.\n")
             while True:
                 if ser.in_waiting:
diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt
index 0fbfeb0..3ba20b1 100644
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -1,19 +1,4 @@
-<<<<<<< HEAD
-idf_component_register(SRCS "system.c.LOCAL.c" "bt_app.c" "system.c" "bubble.c" "keypad.c" "main.c"
-                                                   
-                            "gui.c"
-                            "lsm6dsv.c"
-                    INCLUDE_DIRS "."
-                    REQUIRES "driver" 
-                               "esp_lcd" 
-                               "lvgl" 
-                               "esp_lvgl_port"
-                               "esp_timer"
-                               "nvs_flash"
-                               "bt")
-=======
 idf_component_register(SRCS "bt_app.c" "system.c" "bubble.c" "keypad.c" "main.c"
-                                                   
                             "gui.c"
                             "lsm6dsv.c"
                     INCLUDE_DIRS "."
@@ -24,5 +9,4 @@ idf_component_register(SRCS "bt_app.c" "system.c" "bubble.c" "keypad.c" "main.c"
                                "esp_timer"
                                "nvs_flash"
                                "bt")
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
 
diff --git a/main/bt_app.c b/main/bt_app.c
index 6ef3f48..3a41284 100644
--- a/main/bt_app.c
+++ b/main/bt_app.c
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 /*
  * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
@@ -413,10 +412,48 @@ void generate_synth_pcm(uint8_t *buf, int len) {
 #define MIN_RATE_HZ 1.0f
 #define MAX_RATE_HZ 440.0f
 #define CLICK_AMPLITUDE 32000  // 16-bit
+#define EXP_K           3.0f
+#define DEADBAND_ANGLE  0.25f
 
 static float click_timer = 0.0f;
 
-void generate_synth_clicks(uint8_t *buf, int len, float balance) {
+void generate_exp(uint8_t *buf, int len, float balance)
+{
+    const float k = 3.0f;
+
+    int16_t *samples = (int16_t *)buf;
+    int samples_needed = len / 4;
+
+    float abs_balance = fabsf(balance);
+    float rate_hz = MAX_RATE_HZ*expf(k*(abs_balance - 1.0f));
+    //float rate_hz = MIN_RATE_HZ * powf(MAX_RATE_HZ / MIN_RATE_HZ, abs_balance);
+    float samples_per_click = SAMPLE_RATE / rate_hz;
+
+    for (int i = 0; i < samples_needed; i++) {
+        int16_t left = 0;
+        int16_t right = 0;
+
+        if (click_timer <= 0.0f) {
+            // Insert a short pulse: single sample spike
+            if (balance < 0) {
+                left = CLICK_AMPLITUDE;
+            } else if (balance > 0) {
+                right = CLICK_AMPLITUDE;
+            }
+            click_timer += samples_per_click;
+        }
+
+        click_timer -= 1.0f;
+
+        samples[i * 2 + 0] = left;
+        samples[i * 2 + 1] = right;
+
+    }
+}
+void generate_synth_clicks(uint8_t *buf, int len, float balance) 
+{
+    generate_exp(buf, len, balance);
+    return;
 
     int16_t *samples = (int16_t *)buf;
     int samples_needed = len / 4;
@@ -490,13 +527,20 @@ void audio_producer_task(void *pvParameters) {
         {
             ImuData_t d = system_getImuData();
 
-            if (fabs(d.raw[system_getPrimaryAxis()]) > 45.0f)
+            if (fabs(d.raw[ANGLE_XY]) > 45.0f)
             {
                 balance = 0.0f;
             }
             else
             {
-                balance = -d.angle / MAX_INDICATION_ANGLE;
+                if (fabs(d.angle) <= DEADBAND_ANGLE)
+                {
+                    balance = 0.0f;
+                }
+                else
+                {
+                    balance = -d.angle / MAX_INDICATION_ANGLE;
+                }
             }
         }
     
@@ -1077,18 +1121,35 @@ void bt_app_init(void)
     esp_err_t ret;
     char bda_str[18] = {0};
 
+    esp_bluedroid_disable();
+    esp_bluedroid_deinit();
 
     //esp_err_t esp_bredr_tx_power_get(esp_power_level_t *min_power_level, esp_power_level_t *max_power_level)
     esp_power_level_t pmin;
     esp_power_level_t pmax;
-    esp_bredr_tx_power_get(&pmin, &pmax);
+    
+    
 
-    ESP_LOGI(BT_APP_CORE_TAG, "BT Power min = %d\nBT Power max = %d", pmin, pmax);
+    /*
+     * This example only uses the functions of Classical Bluetooth.
+     * So release the controller memory for Bluetooth Low Energy.
+     */
+    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));
 
-    //pmin = ESP_PWR_LVL_P6;
-    //pmax = ESP_PWR_LVL_P7;
-    pmin = ESP_PWR_LVL_N12;
-    pmax = ESP_PWR_LVL_N9;
+    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+    if (esp_bt_controller_init(&bt_cfg) != ESP_OK) {
+        ESP_LOGE(BT_AV_TAG, "%s initialize controller failed", __func__);
+        return;
+    }
+    if (esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT) != ESP_OK) {
+        ESP_LOGE(BT_AV_TAG, "%s enable controller failed", __func__);
+        return;
+    }
+
+    pmin = ESP_PWR_LVL_P7;
+    pmax = ESP_PWR_LVL_P7;
+    // pmin = ESP_PWR_LVL_N12;
+    // pmax = ESP_PWR_LVL_N12;
     
     esp_err_t err = esp_bredr_tx_power_set(pmin, pmax);
     if (err != ESP_OK) {
@@ -1099,26 +1160,6 @@ void bt_app_init(void)
 
     ESP_LOGI(BT_APP_CORE_TAG, "BT Power min = %d\nBT Power max = %d", pmin, pmax);
 
-    /*
-     * This example only uses the functions of Classical Bluetooth.
-     * So release the controller memory for Bluetooth Low Energy.
-     */
-    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));
-
-    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
-    if (esp_bt_controller_init(&bt_cfg) != ESP_OK) {
-        ESP_LOGE(BT_AV_TAG, "%s initialize controller failed", __func__);
-        return;
-    }
-    if (esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT) != ESP_OK) {
-        ESP_LOGE(BT_AV_TAG, "%s enable controller failed", __func__);
-        return;
-    }
-
-     err = esp_bredr_tx_power_set(pmin, pmax);
-    if (err != ESP_OK) {
-        ESP_LOGE(BT_APP_CORE_TAG, "Failed to set TX power: %s", esp_err_to_name(err));
-    }
     esp_bluedroid_config_t bluedroid_cfg = BT_BLUEDROID_INIT_CONFIG_DEFAULT();
 #if (CONFIG_EXAMPLE_SSP_ENABLED == false)
     bluedroid_cfg.ssp_en = false;
@@ -1167,1162 +1208,4 @@ void bt_app_init(void)
 
 
 
-=======
-/*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Unlicense OR CC0-1.0
- */
-
-#include <stdint.h>
-#include <string.h>
-#include <stdbool.h>
-#include <math.h>
-#include "freertos/FreeRTOSConfig.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/queue.h"
-#include "freertos/task.h"
-#include "freertos/stream_buffer.h"
-#include "esp_log.h"
-
-#include "bt_app.h"
-#include "system.h"
-
-#include "esp_bt.h"
-#include "esp_bt_main.h"
-#include "esp_bt_device.h"
-#include "esp_gap_bt_api.h"
-#include "esp_a2dp_api.h"
-#include "esp_avrc_api.h"
-
-/* log tags */
-#define BT_AV_TAG             "BT_AV"
-#define BT_RC_CT_TAG          "RC_CT"
-
-/* device name */
-#define TARGET_DEVICE_NAME    "ESP_SPEAKER"
-#define LOCAL_DEVICE_NAME     "ESP_A2DP_SRC"
-
-/* AVRCP used transaction label */
-#define APP_RC_CT_TL_GET_CAPS            (0)
-#define APP_RC_CT_TL_RN_VOLUME_CHANGE    (1)
-
-enum {
-    BT_APP_STACK_UP_EVT   = 0x0000,    /* event for stack up */
-    BT_APP_HEART_BEAT_EVT = 0xff00,    /* event for heart beat */
-};
-
-/* A2DP global states */
-enum {
-    APP_AV_STATE_IDLE,
-    APP_AV_STATE_DISCOVERING,
-    APP_AV_STATE_DISCOVERED,
-    APP_AV_STATE_UNCONNECTED,
-    APP_AV_STATE_CONNECTING,
-    APP_AV_STATE_CONNECTED,
-    APP_AV_STATE_DISCONNECTING,
-};
-
-/* sub states of APP_AV_STATE_CONNECTED */
-enum {
-    APP_AV_MEDIA_STATE_IDLE,
-    APP_AV_MEDIA_STATE_STARTING,
-    APP_AV_MEDIA_STATE_STARTED,
-    APP_AV_MEDIA_STATE_STOPPING,
-};
-
-/*********************************
- * STATIC FUNCTION DECLARATIONS
- ********************************/
-
-/* application task handler */
-static void bt_app_task_handler(void *arg);
-/* message sender for Work queue */
-static bool bt_app_send_msg(bt_app_msg_t *msg);
-/* handler for dispatched message */
-static void bt_app_work_dispatched(bt_app_msg_t *msg);
-
-/* handler for bluetooth stack enabled events */
-static void bt_av_hdl_stack_evt(uint16_t event, void *p_param);
-
-/* avrc controller event handler */
-static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param);
-
-/* GAP callback function */
-static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param);
-
-/* callback function for A2DP source */
-static void bt_app_a2d_cb(esp_a2d_cb_event_t event, esp_a2d_cb_param_t *param);
-
-/* callback function for A2DP source audio data stream */
-static int32_t bt_app_a2d_data_cb(uint8_t *data, int32_t len);
-
-/* callback function for AVRCP controller */
-static void bt_app_rc_ct_cb(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t *param);
-
-/* handler for heart beat timer */
-static void bt_app_a2d_heart_beat(TimerHandle_t arg);
-
-/* A2DP application state machine */
-static void bt_app_av_sm_hdlr(uint16_t event, void *param);
-
-/* utils for transfer BLuetooth Deveice Address into string form */
-static char *bda2str(esp_bd_addr_t bda, char *str, size_t size);
-
-/* A2DP application state machine handler for each state */
-static void bt_app_av_state_unconnected_hdlr(uint16_t event, void *param);
-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 VARIABLE DEFINITIONS
- ********************************/
-static QueueHandle_t s_bt_app_task_queue = NULL;
-static TaskHandle_t s_bt_app_task_handle = NULL;
-
-
-static esp_bd_addr_t s_peer_bda = {0};                        /* Bluetooth Device Address of peer device*/
-static uint8_t s_peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];  /* Bluetooth Device Name of peer device*/
-static int s_a2d_state = APP_AV_STATE_IDLE;                   /* A2DP global state */
-static int s_media_state = APP_AV_MEDIA_STATE_IDLE;           /* sub states of APP_AV_STATE_CONNECTED */
-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 */
-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 FUNCTION DEFINITIONS
- ********************************/
-static char *bda2str(esp_bd_addr_t bda, char *str, size_t size)
-{
-    if (bda == NULL || str == NULL || size < 18) {
-        return NULL;
-    }
-
-    sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x",
-            bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
-    return str;
-}
-
-static bool get_name_from_eir(uint8_t *eir, uint8_t *bdname, uint8_t *bdname_len)
-{
-    uint8_t *rmt_bdname = NULL;
-    uint8_t rmt_bdname_len = 0;
-
-    if (!eir) {
-        return false;
-    }
-
-    /* get complete or short local name from eir data */
-    rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME, &rmt_bdname_len);
-    if (!rmt_bdname) {
-        rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME, &rmt_bdname_len);
-    }
-
-    if (rmt_bdname) {
-        if (rmt_bdname_len > ESP_BT_GAP_MAX_BDNAME_LEN) {
-            rmt_bdname_len = ESP_BT_GAP_MAX_BDNAME_LEN;
-        }
-
-        if (bdname) {
-            memcpy(bdname, rmt_bdname, rmt_bdname_len);
-            bdname[rmt_bdname_len] = '\0';
-        }
-        if (bdname_len) {
-            *bdname_len = rmt_bdname_len;
-        }
-        return true;
-    }
-
-    return false;
-}
-
-static void filter_inquiry_scan_result(esp_bt_gap_cb_param_t *param)
-{
-    char bda_str[18];
-    uint32_t cod = 0;    /* class of device */
-    int32_t rssi = -129;  /* invalid value */
-    uint8_t *eir = NULL;
-    esp_bt_gap_dev_prop_t *p;
-
-    /* handle the discovery results */
-    
-    for (int i = 0; i < param->disc_res.num_prop; i++) {
-        p = param->disc_res.prop + i;
-        switch (p->type) {
-        case ESP_BT_GAP_DEV_PROP_COD:
-            cod = *(uint32_t *)(p->val);
-            
-            break;
-        case ESP_BT_GAP_DEV_PROP_RSSI:
-            rssi = *(int8_t *)(p->val);
-
-            break;
-        case ESP_BT_GAP_DEV_PROP_EIR:
-            eir = (uint8_t *)(p->val);
-            break;
-        case ESP_BT_GAP_DEV_PROP_BDNAME:
-        default:
-            break;
-        }
-    }
-
-    /* search for device with MAJOR service class as "rendering" in COD */
-    if (!esp_bt_gap_is_valid_cod(cod) ||
-            !(esp_bt_gap_get_cod_srvc(cod) & ESP_BT_COD_SRVC_RENDERING)) {
-        return;
-    }
-
-    ESP_LOGI(BT_AV_TAG, "Scanned device: %s", bda2str(param->disc_res.bda, bda_str, 18));
-    ESP_LOGI(BT_AV_TAG, "--Class of Device: 0x%"PRIx32, cod);
-    ESP_LOGI(BT_AV_TAG, "--RSSI: %"PRId32, rssi);
-
-    /* search for target device in its Extended Inqury Response */
-    if (eir) {
-        get_name_from_eir(eir, s_peer_bdname, NULL);
-        //if (strcmp((char *)s_peer_bdname, TARGET_DEVICE_NAME) == 0) 
-        {
-            ESP_LOGI(BT_AV_TAG, "Found a target device, address %s, name %s", bda_str, s_peer_bdname);
-            s_a2d_state = APP_AV_STATE_DISCOVERED;
-            memcpy(s_peer_bda, param->disc_res.bda, ESP_BD_ADDR_LEN);
-            ESP_LOGI(BT_AV_TAG, "Cancel device discovery ...");
-            esp_bt_gap_cancel_discovery();
-        }
-    }
-}
-
-static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
-{
-    switch (event) {
-    /* when device discovered a result, this event comes */
-    case ESP_BT_GAP_DISC_RES_EVT: {
-        if (s_a2d_state == APP_AV_STATE_DISCOVERING) {
-            filter_inquiry_scan_result(param);
-        }
-        break;
-    }
-    /* when discovery state changed, this event comes */
-    case ESP_BT_GAP_DISC_STATE_CHANGED_EVT: {
-        if (param->disc_st_chg.state == ESP_BT_GAP_DISCOVERY_STOPPED) {
-            if (s_a2d_state == APP_AV_STATE_DISCOVERED) {
-                s_a2d_state = APP_AV_STATE_CONNECTING;
-                ESP_LOGI(BT_AV_TAG, "Device discovery stopped.");
-                ESP_LOGI(BT_AV_TAG, "a2dp connecting to peer: %s", s_peer_bdname);
-                /* connect source to peer device specified by Bluetooth Device Address */
-                esp_a2d_source_connect(s_peer_bda);
-            } else {
-                /* not discovered, continue to discover */
-                ESP_LOGI(BT_AV_TAG, "Device discovery failed, continue to discover...");
-                esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);
-            }
-        } else if (param->disc_st_chg.state == ESP_BT_GAP_DISCOVERY_STARTED) {
-            ESP_LOGI(BT_AV_TAG, "Discovery started.");
-        }
-        break;
-    }
-    /* when authentication completed, this event comes */
-    case ESP_BT_GAP_AUTH_CMPL_EVT: {
-        if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
-            ESP_LOGI(BT_AV_TAG, "authentication success: %s", param->auth_cmpl.device_name);
-            esp_log_buffer_hex(BT_AV_TAG, param->auth_cmpl.bda, ESP_BD_ADDR_LEN);
-        } else {
-            ESP_LOGE(BT_AV_TAG, "authentication failed, status: %d", param->auth_cmpl.stat);
-        }
-        break;
-    }
-    /* when Legacy Pairing pin code requested, this event comes */
-    case ESP_BT_GAP_PIN_REQ_EVT: {
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_PIN_REQ_EVT min_16_digit: %d", param->pin_req.min_16_digit);
-        if (param->pin_req.min_16_digit) {
-            ESP_LOGI(BT_AV_TAG, "Input pin code: 0000 0000 0000 0000");
-            esp_bt_pin_code_t pin_code = {0};
-            esp_bt_gap_pin_reply(param->pin_req.bda, true, 16, pin_code);
-        } else {
-            ESP_LOGI(BT_AV_TAG, "Input pin code: 1234");
-            esp_bt_pin_code_t pin_code;
-            pin_code[0] = '1';
-            pin_code[1] = '2';
-            pin_code[2] = '3';
-            pin_code[3] = '4';
-            esp_bt_gap_pin_reply(param->pin_req.bda, true, 4, pin_code);
-        }
-        break;
-    }
-
-#if (CONFIG_EXAMPLE_SSP_ENABLED == true)
-    /* when Security Simple Pairing user confirmation requested, this event comes */
-    case ESP_BT_GAP_CFM_REQ_EVT:
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %"PRIu32, param->cfm_req.num_val);
-        esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
-        break;
-    /* when Security Simple Pairing passkey notified, this event comes */
-    case ESP_BT_GAP_KEY_NOTIF_EVT:
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_KEY_NOTIF_EVT passkey: %"PRIu32, param->key_notif.passkey);
-        break;
-    /* when Security Simple Pairing passkey requested, this event comes */
-    case ESP_BT_GAP_KEY_REQ_EVT:
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
-        break;
-#endif
-
-    /* when GAP mode changed, this event comes */
-    case ESP_BT_GAP_MODE_CHG_EVT:
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_MODE_CHG_EVT mode: %d", param->mode_chg.mode);
-        break;
-    case ESP_BT_GAP_GET_DEV_NAME_CMPL_EVT:
-        if (param->get_dev_name_cmpl.status == ESP_BT_STATUS_SUCCESS) {
-            ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_GET_DEV_NAME_CMPL_EVT device name: %s", param->get_dev_name_cmpl.name);
-        } else {
-            ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_GET_DEV_NAME_CMPL_EVT failed, state: %d", param->get_dev_name_cmpl.status);
-        }
-        break;
-    /* other */
-    default: {
-        ESP_LOGI(BT_AV_TAG, "event: %d", event);
-        break;
-    }
-    }
-
-    return;
-}
-
-static void bt_av_hdl_stack_evt(uint16_t event, void *p_param)
-{
-    ESP_LOGD(BT_AV_TAG, "%s event: %d", __func__, event);
-
-    switch (event) {
-    /* when stack up worked, this event comes */
-    case BT_APP_STACK_UP_EVT: {
-        char *dev_name = LOCAL_DEVICE_NAME;
-        esp_bt_gap_set_device_name(dev_name);
-        esp_bt_gap_register_callback(bt_app_gap_cb);
-
-        esp_avrc_ct_init();
-        esp_avrc_ct_register_callback(bt_app_rc_ct_cb);
-
-        esp_avrc_rn_evt_cap_mask_t evt_set = {0};
-        esp_avrc_rn_evt_bit_mask_operation(ESP_AVRC_BIT_MASK_OP_SET, &evt_set, ESP_AVRC_RN_VOLUME_CHANGE);
-        ESP_ERROR_CHECK(esp_avrc_tg_set_rn_evt_cap(&evt_set));
-
-        esp_a2d_source_init();
-        esp_a2d_register_callback(&bt_app_a2d_cb);
-        esp_a2d_source_register_data_callback(bt_app_a2d_data_cb);
-
-        /* Avoid the state error of s_a2d_state caused by the connection initiated by the peer device. */
-        esp_bt_gap_set_scan_mode(ESP_BT_NON_CONNECTABLE, ESP_BT_NON_DISCOVERABLE);
-        esp_bt_gap_get_device_name();
-
-        ESP_LOGI(BT_AV_TAG, "Starting device discovery...");
-        s_a2d_state = APP_AV_STATE_DISCOVERING;
-        esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);
-
-        /* create and start heart beat timer */
-        do {
-            int tmr_id = 0;
-            s_tmr = xTimerCreate("connTmr", (10000 / portTICK_PERIOD_MS),
-                                 pdTRUE, (void *) &tmr_id, bt_app_a2d_heart_beat);
-            xTimerStart(s_tmr, portMAX_DELAY);
-        } while (0);
-        break;
-    }
-    /* other */
-    default: {
-        ESP_LOGE(BT_AV_TAG, "%s unhandled event: %d", __func__, event);
-        break;
-    }
-    }
-}
-
-static void bt_app_a2d_cb(esp_a2d_cb_event_t event, esp_a2d_cb_param_t *param)
-{
-    bt_app_work_dispatch(bt_app_av_sm_hdlr, event, param, sizeof(esp_a2d_cb_param_t), NULL);
-}
-
-
-
-#define SAMPLE_RATE     44100
-#define TONE_FREQ       440.0f     // A4
-#define FADE_FREQ       1.0f       // 1 Hz fade L->R
-#define STREAM_BUF_SIZE (8192)
-#define CHUNK_SIZE      (512)
-
-StreamBufferHandle_t audio_stream_buf;
-
-void generate_synth_pcm(uint8_t *buf, int len) {
-    static float phase = 0.0f;
-    static float fade_phase = 0.0f;
-
-    int16_t *samples = (int16_t *)buf;
-    int samples_needed = len / 4;  // 4 bytes per stereo frame (2 bytes L, 2 bytes R)
-
-    for (int i = 0; i < samples_needed; i++) {
-        // Fade L/R amplitude: 0..1 for L, inverted for R
-        float fade = (sinf(2 * M_PI * fade_phase) + 1.0f) * 0.5f;
-
-        // Sine wave sample
-        float sample = sinf(2 * M_PI * phase);
-
-        int16_t left  = (int16_t)(sample * fade * 32767);
-        int16_t right = (int16_t)(sample * (1.0f - fade) * 32767);
-
-        samples[i * 2 + 0] = left;
-        samples[i * 2 + 1] = right;
-
-        // Advance phases
-        phase += TONE_FREQ / SAMPLE_RATE;
-        if (phase >= 1.0f) phase -= 1.0f;
-
-        fade_phase += FADE_FREQ / SAMPLE_RATE;
-        if (fade_phase >= 1.0f) fade_phase -= 1.0f;
-    }
-}
-
-#define MIN_RATE_HZ 1.0f
-#define MAX_RATE_HZ 440.0f
-#define CLICK_AMPLITUDE 32000  // 16-bit
-
-static float click_timer = 0.0f;
-
-void generate_synth_clicks(uint8_t *buf, int len, float balance) {
-
-    int16_t *samples = (int16_t *)buf;
-    int samples_needed = len / 4;
-
-    float abs_balance = fabsf(balance);
-    float rate_hz = MIN_RATE_HZ * powf(MAX_RATE_HZ / MIN_RATE_HZ, abs_balance);
-    float samples_per_click = SAMPLE_RATE / rate_hz;
-
-    for (int i = 0; i < samples_needed; i++) {
-        int16_t left = 0;
-        int16_t right = 0;
-
-        if (click_timer <= 0.0f) {
-            // Insert a short pulse: single sample spike
-            if (balance < 0) {
-                left = CLICK_AMPLITUDE;
-            } else if (balance > 0) {
-                right = CLICK_AMPLITUDE;
-            }
-            click_timer += samples_per_click;
-        }
-
-        click_timer -= 1.0f;
-
-        samples[i * 2 + 0] = left;
-        samples[i * 2 + 1] = right;
-
-    }
-}
-
-void audio_producer_task(void *pvParameters) {
-    uint8_t chunk[CHUNK_SIZE];
-
-    int core_id = xPortGetCoreID();
-
-    ESP_LOGI("Producer", "Running on core %d", core_id);
-
-    system_subscribe(xTaskGetCurrentTaskHandle());
-#if 0    
-    
-
-    while (1) {
-        generate_synth_pcm(chunk, sizeof(chunk));
-
-        size_t sent = xStreamBufferSend(audio_stream_buf, chunk, sizeof(chunk), portMAX_DELAY);
-
-        if (sent < sizeof(chunk)) {
-            ESP_LOGW(BT_APP_CORE_TAG, "Dropped %d bytes", sizeof(chunk) - sent);
-        }
-    }
-#endif
-
-    static float phase = 0.0f;
-
-    float balance = 0.0f;  // -1.0 = left, +1.0 = right
-
-    uint32_t raw_value;
-    uint32_t notifiedBits = 0;
-
-    while (1) {
-        // Non-blocking check for new notification:
-                    
-            // clear on entry (first param), wait for any bit, block forever
-        xTaskNotifyWait(
-            0,        // clear any old bits on entry
-            0,        // clear bits on exit
-            &notifiedBits,
-            0);
-
-        if (notifiedBits & EM_EVENT_NEW_DATA) 
-        {
-            ImuData_t d = system_getImuData();
-
-            if (fabs(d.raw[system_getPrimaryAxis()]) > 45.0f)
-            {
-                balance = 0.0f;
-            }
-            else
-            {
-                balance = -d.angle / MAX_INDICATION_ANGLE;
-            }
-        }
-    
-        if (balance > 1.0f)
-        {
-            balance = 1.0f;
-        }
-        else
-        if (balance < -1.0f)
-        {
-            balance = -1.0f;
-        }
-        generate_synth_clicks(chunk, sizeof(chunk), balance);
-
-#if 0
-        // Synthesize audio using latest balance
-        int16_t *samples = (int16_t *)chunk;
-        int samples_needed = CHUNK_SIZE / 4;
-
-        for (int i = 0; i < samples_needed; i++) {
-            float sample = sinf(2 * M_PI * phase);
-
-            float left_gain  = 0.5f * (1.0f - balance);
-            float right_gain = 0.5f * (1.0f + balance);
-
-            int16_t left  = (int16_t)(sample * left_gain * 32767);
-            int16_t right = (int16_t)(sample * right_gain * 32767);
-
-            samples[i * 2 + 0] = left;
-            samples[i * 2 + 1] = right;
-
-            phase += TONE_FREQ / SAMPLE_RATE;
-            if (phase >= 1.0f) phase -= 1.0f;
-        }
-#endif
-
-        // Push chunk to FIFO
-        xStreamBufferSend(audio_stream_buf, chunk, sizeof(chunk), portMAX_DELAY);
-    }
-}
-
-/* generate some random noise to simulate source audio */
-static int32_t bt_app_a2d_data_cb(uint8_t *data, int32_t len)
-{
-        size_t bytes_read = xStreamBufferReceive(audio_stream_buf, data, len, 0);
-
-    if (bytes_read < len) {
-        memset(data + bytes_read, 0, len - bytes_read);  // fill silence
-    }
-
-    return len;
-#if 0    
-    if (data == NULL || len < 0) {
-        return 0;
-    }
-
-    int16_t *p_buf = (int16_t *)data;
-    for (int i = 0; i < (len >> 1); i++) {
-        p_buf[i] = rand() % (1 << 16);
-    }
-
-    return len;
-#endif    
-}
-
-#if 0
-
-/* Generate a continuous 440Hz sine wave */
-static int32_t bt_app_a2d_data_cb(uint8_t *data, int32_t len)
-{
-
-        if (data == NULL || len < 0) {
-        return 0;
-    }
-
-    int16_t *p_buf = (int16_t *)data;
-    for (int i = 0; i < (len >> 1); i++) {
-        p_buf[i] = rand() % (1 << 16);
-    }
-
-    return len;
-#if 0
-    static double phase = 0.0;
-    const double frequency = 440.0; // A4 tone (440 Hz)
-    const double sample_rate = 44100.0; // 44.1 kHz sample rate
-    const double phase_increment = 2.0 * M_PI * frequency / sample_rate;
-    const int16_t amplitude = 32767; // Maximum amplitude for 16-bit audio
-    
-    //ESP_LOGI(BT_AV_TAG, "len: %d", (int)len);
-    // Process stereo samples (each sample is 16-bit)
-    for (int i = 0; i < len / 4; i++) {
-        // Generate the sample value
-        int16_t sample = (int16_t)(amplitude * sin(phase));
-        
-        // Write the same sample to both left and right channels
-        // Left channel
-        data[4*i] = sample & 0xFF;         // Low byte
-        data[4*i + 1] = (sample >> 8);     // High byte
-        // Right channel
-        data[4*i + 2] = sample & 0xFF;     // Low byte
-        data[4*i + 3] = (sample >> 8);     // High byte
-        
-        // Update phase for next sample
-        phase += phase_increment;
-        if (phase >= 2.0 * M_PI) {
-            phase -= 2.0 * M_PI;  // Keep phase in [0, 2π)
-        }
-    }
-    return len;
-#endif    
-}
-#endif
-
-static void bt_app_a2d_heart_beat(TimerHandle_t arg)
-{
-    bt_app_work_dispatch(bt_app_av_sm_hdlr, BT_APP_HEART_BEAT_EVT, NULL, 0, NULL);
-}
-
-static void bt_app_av_sm_hdlr(uint16_t event, void *param)
-{
-    ESP_LOGI(BT_AV_TAG, "%s state: %d, event: 0x%x", __func__, s_a2d_state, event);
-
-    /* select handler according to different states */
-    switch (s_a2d_state) {
-    case APP_AV_STATE_DISCOVERING:
-    case APP_AV_STATE_DISCOVERED:
-        break;
-    case APP_AV_STATE_UNCONNECTED:
-        bt_app_av_state_unconnected_hdlr(event, param);
-        break;
-    case APP_AV_STATE_CONNECTING:
-        bt_app_av_state_connecting_hdlr(event, param);
-        break;
-    case APP_AV_STATE_CONNECTED:
-        bt_app_av_state_connected_hdlr(event, param);
-        break;
-    case APP_AV_STATE_DISCONNECTING:
-        bt_app_av_state_disconnecting_hdlr(event, param);
-        break;
-    default:
-        ESP_LOGE(BT_AV_TAG, "%s invalid state: %d", __func__, s_a2d_state);
-        break;
-    }
-}
-
-static void bt_app_av_state_unconnected_hdlr(uint16_t event, void *param)
-{
-    esp_a2d_cb_param_t *a2d = NULL;
-    /* handle the events of interest in unconnected state */
-    switch (event) {
-    case ESP_A2D_CONNECTION_STATE_EVT:
-    case ESP_A2D_AUDIO_STATE_EVT:
-    case ESP_A2D_AUDIO_CFG_EVT:
-    case ESP_A2D_MEDIA_CTRL_ACK_EVT:
-        break;
-    case BT_APP_HEART_BEAT_EVT: {
-        uint8_t *bda = s_peer_bda;
-        ESP_LOGI(BT_AV_TAG, "a2dp connecting to peer: %02x:%02x:%02x:%02x:%02x:%02x",
-                 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
-        esp_a2d_source_connect(s_peer_bda);
-        s_a2d_state = APP_AV_STATE_CONNECTING;
-        s_connecting_intv = 0;
-        break;
-    }
-    case ESP_A2D_REPORT_SNK_DELAY_VALUE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        ESP_LOGI(BT_AV_TAG, "%s, delay value: %u * 1/10 ms", __func__, a2d->a2d_report_delay_value_stat.delay_value);
-        break;
-    }
-    default: {
-        ESP_LOGE(BT_AV_TAG, "%s unhandled event: %d", __func__, event);
-        break;
-    }
-    }
-}
-
-static void bt_app_av_state_connecting_hdlr(uint16_t event, void *param)
-{
-    esp_a2d_cb_param_t *a2d = NULL;
-
-    /* handle the events of interest in connecting state */
-    switch (event) {
-    case ESP_A2D_CONNECTION_STATE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        if (a2d->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTED) {
-            ESP_LOGI(BT_AV_TAG, "a2dp connected");
-            s_a2d_state =  APP_AV_STATE_CONNECTED;
-            s_media_state = APP_AV_MEDIA_STATE_IDLE;
-        } else if (a2d->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
-            s_a2d_state =  APP_AV_STATE_UNCONNECTED;
-        }
-        break;
-    }
-    case ESP_A2D_AUDIO_STATE_EVT:
-    case ESP_A2D_AUDIO_CFG_EVT:
-    case ESP_A2D_MEDIA_CTRL_ACK_EVT:
-        break;
-    case BT_APP_HEART_BEAT_EVT:
-        /**
-         * Switch state to APP_AV_STATE_UNCONNECTED
-         * when connecting lasts more than 2 heart beat intervals.
-         */
-        if (++s_connecting_intv >= 2) {
-            s_a2d_state = APP_AV_STATE_UNCONNECTED;
-            s_connecting_intv = 0;
-        }
-        break;
-    case ESP_A2D_REPORT_SNK_DELAY_VALUE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        ESP_LOGI(BT_AV_TAG, "%s, delay value: %u * 1/10 ms", __func__, a2d->a2d_report_delay_value_stat.delay_value);
-        break;
-    }
-    default:
-        ESP_LOGE(BT_AV_TAG, "%s unhandled event: %d", __func__, event);
-        break;
-    }
-}
-
-static void bt_app_av_media_proc(uint16_t event, void *param)
-{
-    esp_a2d_cb_param_t *a2d = NULL;
-
-    switch (s_media_state) {
-    case APP_AV_MEDIA_STATE_IDLE: {
-        if (event == BT_APP_HEART_BEAT_EVT) {
-            ESP_LOGI(BT_AV_TAG, "a2dp media ready checking ...");
-            esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_CHECK_SRC_RDY);
-        } else if (event == ESP_A2D_MEDIA_CTRL_ACK_EVT) {
-            a2d = (esp_a2d_cb_param_t *)(param);
-            if (a2d->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_CHECK_SRC_RDY &&
-                    a2d->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
-                ESP_LOGI(BT_AV_TAG, "a2dp media ready, starting ...");
-                esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_START);
-                s_media_state = APP_AV_MEDIA_STATE_STARTING;
-            }
-        }
-        break;
-    }
-    case APP_AV_MEDIA_STATE_STARTING: {
-        if (event == ESP_A2D_MEDIA_CTRL_ACK_EVT) {
-            a2d = (esp_a2d_cb_param_t *)(param);
-            if (a2d->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_START &&
-                    a2d->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
-                ESP_LOGI(BT_AV_TAG, "a2dp media start successfully.");
-                s_intv_cnt = 0;
-                s_media_state = APP_AV_MEDIA_STATE_STARTED;
-            } else {
-                /* not started successfully, transfer to idle state */
-                ESP_LOGI(BT_AV_TAG, "a2dp media start failed.");
-                s_media_state = APP_AV_MEDIA_STATE_IDLE;
-            }
-        }
-        break;
-    }
-    case APP_AV_MEDIA_STATE_STARTED: {
-        if (event == BT_APP_HEART_BEAT_EVT) {
-#if 0            
-            /* stop media after 10 heart beat intervals */
-            if (++s_intv_cnt >= 10) {
-                ESP_LOGI(BT_AV_TAG, "a2dp media suspending...");
-                esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_SUSPEND);
-                s_media_state = APP_AV_MEDIA_STATE_STOPPING;
-                s_intv_cnt = 0;
-            }
-#endif                
-        }
-        break;
-    }
-    case APP_AV_MEDIA_STATE_STOPPING: {
-        if (event == ESP_A2D_MEDIA_CTRL_ACK_EVT) {
-            a2d = (esp_a2d_cb_param_t *)(param);
-            if (a2d->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_SUSPEND &&
-                    a2d->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
-                ESP_LOGI(BT_AV_TAG, "a2dp media suspend successfully, disconnecting...");
-                s_media_state = APP_AV_MEDIA_STATE_IDLE;
-                esp_a2d_source_disconnect(s_peer_bda);
-                s_a2d_state = APP_AV_STATE_DISCONNECTING;
-            } else {
-                ESP_LOGI(BT_AV_TAG, "a2dp media suspending...");
-                esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_SUSPEND);
-            }
-        }
-        break;
-    }
-    default: {
-        break;
-    }
-    }
-}
-
-static void bt_app_av_state_connected_hdlr(uint16_t event, void *param)
-{
-    esp_a2d_cb_param_t *a2d = NULL;
-
-    /* handle the events of interest in connected state */
-    switch (event) {
-    case ESP_A2D_CONNECTION_STATE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        if (a2d->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
-            ESP_LOGI(BT_AV_TAG, "a2dp disconnected");
-            s_a2d_state = APP_AV_STATE_UNCONNECTED;
-        }
-        break;
-    }
-    case ESP_A2D_AUDIO_STATE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        if (ESP_A2D_AUDIO_STATE_STARTED == a2d->audio_stat.state) {
-            s_pkt_cnt = 0;
-        }
-        break;
-    }
-    case ESP_A2D_AUDIO_CFG_EVT:
-        // not supposed to occur for A2DP source
-        break;
-    case ESP_A2D_MEDIA_CTRL_ACK_EVT:
-    case BT_APP_HEART_BEAT_EVT: {
-        bt_app_av_media_proc(event, param);
-        break;
-    }
-    case ESP_A2D_REPORT_SNK_DELAY_VALUE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        ESP_LOGI(BT_AV_TAG, "%s, delay value: %u * 1/10 ms", __func__, a2d->a2d_report_delay_value_stat.delay_value);
-        break;
-    }
-    default: {
-        ESP_LOGE(BT_AV_TAG, "%s unhandled event: %d", __func__, event);
-        break;
-    }
-    }
-}
-
-static void bt_app_av_state_disconnecting_hdlr(uint16_t event, void *param)
-{
-    esp_a2d_cb_param_t *a2d = NULL;
-
-    /* handle the events of interest in disconnecing state */
-    switch (event) {
-    case ESP_A2D_CONNECTION_STATE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        if (a2d->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
-            ESP_LOGI(BT_AV_TAG, "a2dp disconnected");
-            s_a2d_state =  APP_AV_STATE_UNCONNECTED;
-        }
-        break;
-    }
-    case ESP_A2D_AUDIO_STATE_EVT:
-    case ESP_A2D_AUDIO_CFG_EVT:
-    case ESP_A2D_MEDIA_CTRL_ACK_EVT:
-    case BT_APP_HEART_BEAT_EVT:
-        break;
-    case ESP_A2D_REPORT_SNK_DELAY_VALUE_EVT: {
-        a2d = (esp_a2d_cb_param_t *)(param);
-        ESP_LOGI(BT_AV_TAG, "%s, delay value: 0x%u * 1/10 ms", __func__, a2d->a2d_report_delay_value_stat.delay_value);
-        break;
-    }
-    default: {
-        ESP_LOGE(BT_AV_TAG, "%s unhandled event: %d", __func__, event);
-        break;
-    }
-    }
-}
-
-/* callback function for AVRCP controller */
-static void bt_app_rc_ct_cb(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t *param)
-{
-    switch (event) {
-    case ESP_AVRC_CT_CONNECTION_STATE_EVT:
-    case ESP_AVRC_CT_PASSTHROUGH_RSP_EVT:
-    case ESP_AVRC_CT_METADATA_RSP_EVT:
-    case ESP_AVRC_CT_CHANGE_NOTIFY_EVT:
-    case ESP_AVRC_CT_REMOTE_FEATURES_EVT:
-    case ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT:
-    case ESP_AVRC_CT_SET_ABSOLUTE_VOLUME_RSP_EVT: {
-        bt_app_work_dispatch(bt_av_hdl_avrc_ct_evt, event, param, sizeof(esp_avrc_ct_cb_param_t), NULL);
-        break;
-    }
-    default: {
-        ESP_LOGE(BT_RC_CT_TAG, "Invalid AVRC event: %d", event);
-        break;
-    }
-    }
-}
-
-static void bt_av_volume_changed(void)
-{
-    if (esp_avrc_rn_evt_bit_mask_operation(ESP_AVRC_BIT_MASK_OP_TEST, &s_avrc_peer_rn_cap,
-                                           ESP_AVRC_RN_VOLUME_CHANGE)) {
-        esp_avrc_ct_send_register_notification_cmd(APP_RC_CT_TL_RN_VOLUME_CHANGE, ESP_AVRC_RN_VOLUME_CHANGE, 0);
-    }
-}
-
-void bt_av_notify_evt_handler(uint8_t event_id, esp_avrc_rn_param_t *event_parameter)
-{
-    switch (event_id) {
-    /* 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);
-        bt_av_volume_changed();
-        break;
-    }
-    /* other */
-    default:
-        break;
-    }
-}
-
-/* AVRC controller event handler */
-static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
-{
-    ESP_LOGD(BT_RC_CT_TAG, "%s evt %d", __func__, event);
-    esp_avrc_ct_cb_param_t *rc = (esp_avrc_ct_cb_param_t *)(p_param);
-
-    switch (event) {
-    /* when connection state changed, this event comes */
-    case ESP_AVRC_CT_CONNECTION_STATE_EVT: {
-        uint8_t *bda = rc->conn_stat.remote_bda;
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC conn_state event: state %d, [%02x:%02x:%02x:%02x:%02x:%02x]",
-                 rc->conn_stat.connected, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
-
-        if (rc->conn_stat.connected) {
-            esp_avrc_ct_send_get_rn_capabilities_cmd(APP_RC_CT_TL_GET_CAPS);
-        } else {
-            s_avrc_peer_rn_cap.bits = 0;
-        }
-        break;
-    }
-    /* when passthrough responded, this event comes */
-    case ESP_AVRC_CT_PASSTHROUGH_RSP_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC passthrough response: key_code 0x%x, key_state %d, rsp_code %d", rc->psth_rsp.key_code,
-                    rc->psth_rsp.key_state, rc->psth_rsp.rsp_code);
-        break;
-    }
-    /* when metadata responded, this event comes */
-    case ESP_AVRC_CT_METADATA_RSP_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC metadata response: attribute id 0x%x, %s", rc->meta_rsp.attr_id, rc->meta_rsp.attr_text);
-        free(rc->meta_rsp.attr_text);
-        break;
-    }
-    /* when notification changed, this event comes */
-    case ESP_AVRC_CT_CHANGE_NOTIFY_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC event notification: %d", rc->change_ntf.event_id);
-        bt_av_notify_evt_handler(rc->change_ntf.event_id, &rc->change_ntf.event_parameter);
-        break;
-    }
-    /* when indicate feature of remote device, this event comes */
-    case ESP_AVRC_CT_REMOTE_FEATURES_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC remote features %"PRIx32", TG features %x", rc->rmt_feats.feat_mask, rc->rmt_feats.tg_feat_flag);
-        break;
-    }
-    /* when get supported notification events capability of peer device, this event comes */
-    case ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT: {
-        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;
-
-        bt_av_volume_changed();
-        break;
-    }
-    /* 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);
-        break;
-    }
-    /* other */
-    default: {
-        ESP_LOGE(BT_RC_CT_TAG, "%s unhandled event: %d", __func__, event);
-        break;
-    }
-    }
-}
-
-static bool bt_app_send_msg(bt_app_msg_t *msg)
-{
-    if (msg == NULL) {
-        return false;
-    }
-
-    if (pdTRUE != xQueueSend(s_bt_app_task_queue, msg, 10 / portTICK_PERIOD_MS)) {
-        ESP_LOGE(BT_APP_CORE_TAG, "%s xQueue send failed", __func__);
-        return false;
-    }
-
-    return true;
-}
-
-static void bt_app_work_dispatched(bt_app_msg_t *msg)
-{
-    if (msg->cb) {
-        msg->cb(msg->event, msg->param);
-    }
-}
-
-static void bt_app_task_handler(void *arg)
-{
-    bt_app_msg_t msg;
-
-    int core_id = xPortGetCoreID();
-
-    ESP_LOGI("MY_TASK", "Running on core %d", core_id);
-
-    for (;;) {
-        /* receive message from work queue and handle it */
-        if (pdTRUE == xQueueReceive(s_bt_app_task_queue, &msg, (TickType_t)portMAX_DELAY)) {
-            ESP_LOGD(BT_APP_CORE_TAG, "%s, signal: 0x%x, event: 0x%x", __func__, msg.sig, msg.event);
-
-            switch (msg.sig) {
-            case BT_APP_SIG_WORK_DISPATCH:
-                bt_app_work_dispatched(&msg);
-                break;
-            default:
-                ESP_LOGW(BT_APP_CORE_TAG, "%s, unhandled signal: %d", __func__, msg.sig);
-                break;
-            }
-
-            if (msg.param) {
-                free(msg.param);
-            }
-        }
-    }
-}
-
-/*********************************
- * EXTERN FUNCTION DEFINITIONS
- ********************************/
-
-bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback)
-{
-    ESP_LOGD(BT_APP_CORE_TAG, "%s event: 0x%x, param len: %d", __func__, event, param_len);
-
-    bt_app_msg_t msg;
-    memset(&msg, 0, sizeof(bt_app_msg_t));
-
-    msg.sig = BT_APP_SIG_WORK_DISPATCH;
-    msg.event = event;
-    msg.cb = p_cback;
-
-    if (param_len == 0) {
-        return bt_app_send_msg(&msg);
-    } else if (p_params && param_len > 0) {
-        if ((msg.param = malloc(param_len)) != NULL) {
-            memcpy(msg.param, p_params, param_len);
-            /* check if caller has provided a copy callback to do the deep copy */
-            if (p_copy_cback) {
-                p_copy_cback(msg.param, p_params, param_len);
-            }
-            return bt_app_send_msg(&msg);
-        }
-    }
-
-    return false;
-}
-
-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);
-}
-
-void bt_app_task_shut_down(void)
-{
-    if (s_bt_app_task_handle) {
-        vTaskDelete(s_bt_app_task_handle);
-        s_bt_app_task_handle = NULL;
-    }
-    if (s_bt_app_task_queue) {
-        vQueueDelete(s_bt_app_task_queue);
-        s_bt_app_task_queue = NULL;
-    }
-}
-
-
-void bt_app_init(void)
-{
-    esp_err_t ret;
-    char bda_str[18] = {0};
-
-
-    /*
-     * This example only uses the functions of Classical Bluetooth.
-     * So release the controller memory for Bluetooth Low Energy.
-     */
-    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));
-
-    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
-    if (esp_bt_controller_init(&bt_cfg) != ESP_OK) {
-        ESP_LOGE(BT_AV_TAG, "%s initialize controller failed", __func__);
-        return;
-    }
-    if (esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT) != ESP_OK) {
-        ESP_LOGE(BT_AV_TAG, "%s enable controller failed", __func__);
-        return;
-    }
-
-    esp_bluedroid_config_t bluedroid_cfg = BT_BLUEDROID_INIT_CONFIG_DEFAULT();
-#if (CONFIG_EXAMPLE_SSP_ENABLED == false)
-    bluedroid_cfg.ssp_en = false;
-#endif
-    if ((ret = esp_bluedroid_init_with_cfg(&bluedroid_cfg)) != ESP_OK) {
-        ESP_LOGE(BT_AV_TAG, "%s initialize bluedroid failed: %s", __func__, esp_err_to_name(ret));
-        return;
-    }
-
-    if (esp_bluedroid_enable() != ESP_OK) {
-        ESP_LOGE(BT_AV_TAG, "%s enable bluedroid failed", __func__);
-        return;
-    }
-
-#if (CONFIG_EXAMPLE_SSP_ENABLED == true)
-    /* set default parameters for Secure Simple Pairing */
-    esp_bt_sp_param_t param_type = ESP_BT_SP_IOCAP_MODE;
-    esp_bt_io_cap_t iocap = ESP_BT_IO_CAP_IO;
-    esp_bt_gap_set_security_param(param_type, &iocap, sizeof(uint8_t));
-#endif
-
-    /*
-     * Set default parameters for Legacy Pairing
-     * Use variable pin, input pin code when pairing
-     */
-    esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_VARIABLE;
-    esp_bt_pin_code_t pin_code;
-    esp_bt_gap_set_pin(pin_type, 0, pin_code);
-
-    ESP_LOGI(BT_AV_TAG, "Own address:[%s]", bda2str((uint8_t *)esp_bt_dev_get_address(), bda_str, sizeof(bda_str)));
-    bt_app_task_start_up();
-    /* Bluetooth device name, connection mode and profile set up */
-    bt_app_work_dispatch(bt_av_hdl_stack_evt, BT_APP_STACK_UP_EVT, NULL, 0, NULL);
-
-
-
-    audio_stream_buf = xStreamBufferCreate(STREAM_BUF_SIZE, 1);
-    assert(audio_stream_buf != NULL);
-
-    //xTaskCreate(audio_producer_task, "audio_producer", 4096, NULL, 5, NULL);
-    xTaskCreatePinnedToCore(audio_producer_task, "audio_producer", 4096, NULL, 5, NULL, 1);
-
-    ESP_LOGI(BT_APP_CORE_TAG, "Audio synth producer started");
-
-    vTaskDelay(pdMS_TO_TICKS(1000));
-
-    //esp_err_t esp_bredr_tx_power_get(esp_power_level_t *min_power_level, esp_power_level_t *max_power_level)
-    esp_power_level_t pmin;
-    esp_power_level_t pmax;
-    esp_bredr_tx_power_get(&pmin, &pmax);
-
-    ESP_LOGI(BT_APP_CORE_TAG, "BT Power min = %d\nBT Power max = %d", pmin, pmax);
-
-    pmin = ESP_PWR_LVL_P7;
-    pmax = ESP_PWR_LVL_P7;
-    esp_bredr_tx_power_set(pmin, pmax);
-
-    esp_bredr_tx_power_get(&pmin, &pmax);
-
-    ESP_LOGI(BT_APP_CORE_TAG, "BT Power min = %d\nBT Power max = %d", pmin, pmax);
-
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
 }
\ No newline at end of file
diff --git a/main/gpio.h b/main/gpio.h
index 592327c..76bd0ba 100644
--- a/main/gpio.h
+++ b/main/gpio.h
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 #ifndef GPIO_H
 #define GPIO_H
 
@@ -27,34 +26,4 @@
 #define PIN_NUM_BK_LIGHT      5       // Backlight control pin, -1 if not used
 #endif
 
-=======
-#ifndef GPIO_H
-#define GPIO_H
-
-// Define keypad buttons
-#define PIN_NUM_BUTTON_0        36
-#define PIN_NUM_BUTTON_1        39
-#define PIN_NUM_LED_1           32
-#define PIN_NUM_LED_2           33
-#define PIN_NUM_nON				26
-
-
-// Define GPIO pins
-#ifdef DEVKIT
-#define PIN_NUM_MOSI           23      // SDA pin for LCD
-#define PIN_NUM_CLK            18      // SCL pin for LCD
-#define PIN_NUM_CS            2       // CS pin
-#define PIN_NUM_DC            12       // Data/Command pin (RS)
-#define PIN_NUM_RST           13       // Reset pin
-#define PIN_NUM_BK_LIGHT      -1       // Backlight control pin, -1 if not used
-#else
-#define PIN_NUM_MOSI           23      // SDA pin for LCD
-#define PIN_NUM_CLK            18      // SCL pin for LCD
-#define PIN_NUM_CS            12       // CS pin
-#define PIN_NUM_DC            15       // Data/Command pin (RS)
-#define PIN_NUM_RST           13       // Reset pin
-#define PIN_NUM_BK_LIGHT      5       // Backlight control pin, -1 if not used
-#endif
-
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
 #endif
\ No newline at end of file
diff --git a/main/gui.c b/main/gui.c
index 66d11ba..3aaa5a3 100644
--- a/main/gui.c
+++ b/main/gui.c
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 #include <stdio.h>
 #include <math.h>
 #include "freertos/FreeRTOS.h"
@@ -617,624 +616,4 @@ static void gui_task(void)
     
 
     
-=======
-#include <stdio.h>
-#include <math.h>
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#include "esp_lcd_panel_io.h"
-#include "esp_lcd_panel_vendor.h"
-#include "esp_lcd_panel_ops.h"
-#include "driver/gpio.h"
-#include "driver/spi_master.h"
-#include "esp_err.h"
-#include "esp_log.h"
-#include "esp_timer.h"
-#include "lvgl.h"
-#include "esp_lvgl_port.h"
-
-#include "gui.h"
-#include "gpio.h"
-#include "keypad.h"
-#include "bubble.h"
-#include "system.h"
-
-#define DEVKIT
-#undef DEVKIT
-
-static const char *TAG = "gui";
-
-#define UNLOCK()    lvgl_port_unlock()
-#define LOCK()      lvgl_port_lock(0)
-
-// LCD Pin Configuration
-#define LCD_PIXEL_CLOCK_HZ     (5 * 1000 * 1000)
-#define LCD_SPI_HOST           SPI2_HOST
-
-#define PIN_NUM_nON             26
-
-
-
-// ST7735S properties
-#define LCD_H_RES              160
-#define LCD_V_RES              80
-#define LCD_CMD_BITS           8
-#define LCD_PARAM_BITS         8
-#define LCD_COLOR_SPACE        ESP_LCD_COLOR_SPACE_RGB
-#define LCD_BITS_PER_PIXEL    16
-
-static esp_lcd_panel_handle_t panel_handle = NULL;
-esp_lcd_panel_io_handle_t io_handle = NULL;
-static lv_disp_t *disp = NULL;
-static lv_obj_t *imu_label = NULL;  // Label for IMU data
-
-static lv_style_t style_mono8;
-
-typedef struct
-{
-    int selected;
-    int count;
-    lv_obj_t *obj;
-} menu_context_t;
-
-static void gui_task(void);
-static void createBubble(lv_obj_t * scr);
-static void build_scrollable_menu(void);
-static void currentFocusIndex(menu_context_t *ctx);
-
-#define MAX_ITEMS 10
-#define VISIBLE_ITEMS 3
-#define MENU_MAX_STRING_LENGTH  30
-
-static const char *menu_items[MAX_ITEMS] = {
-    "V-Moda Crossfade", "Item 2", "Item 3", "Item 4",
-    "Item 5", "Item 6", "Item 7", "Item 8",
-    "Item 9", "Item 10"
-};
-
-static lv_obj_t *list;
-static lv_obj_t *buttons[MAX_ITEMS];
-static int selected_index = 0;
-static lv_obj_t *_bubble = NULL;
-static lv_obj_t * _menu = NULL;
-static lv_obj_t *_currentPage = NULL;
-
-static GuiMode_t _mode = GUI_BUBBLE;
-
-/* 1. Prepare a default (unfocused) style */
-static lv_style_t _styleUnfocusedBtn;
-
-
-/* 2. Prepare a focus style */
-static lv_style_t _styleFocusedBtn;
-
-static menu_context_t _menuContext;
-
-static bool notify_lvgl_flush_ready(void *user_ctx) {
-    if (disp) {
-        lv_display_flush_ready(disp);
-    }
-    return true;
-}
-
-
-static void create_lvgl_demo(void)
-{
-
-    lvgl_port_lock(0);
-    // Create a screen with black background
-    lv_obj_t *scr = lv_scr_act();
-    
-    createBubble(scr);
-    //build_scrollable_menu();
-
-    lvgl_port_unlock();
-
-
-}
-
-static void lcd_init(void)
-{
-    ESP_LOGI(TAG, "Initialize SPI bus");
-    spi_bus_config_t buscfg = {
-        .sclk_io_num = PIN_NUM_CLK,
-        .mosi_io_num = PIN_NUM_MOSI,
-        .miso_io_num = -1,
-        .quadwp_io_num = -1,
-        .quadhd_io_num = -1,
-        .max_transfer_sz = LCD_H_RES * LCD_V_RES * 2
-    };
-
-    ESP_ERROR_CHECK(spi_bus_initialize(LCD_SPI_HOST, &buscfg, SPI_DMA_CH_AUTO));
-
-    ESP_LOGI(TAG, "Install panel IO");
-    
-    esp_lcd_panel_io_spi_config_t io_config = {
-        .dc_gpio_num = PIN_NUM_DC,
-        .cs_gpio_num = PIN_NUM_CS,
-        .pclk_hz = LCD_PIXEL_CLOCK_HZ,
-        .lcd_cmd_bits = LCD_CMD_BITS,
-        .lcd_param_bits = LCD_PARAM_BITS,
-        .spi_mode = 3,
-        .trans_queue_depth = 10,
-        .user_ctx = NULL,
-    };
-    ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_SPI_HOST, &io_config, &io_handle));
-
-    esp_lcd_panel_dev_config_t panel_config = {
-        .reset_gpio_num = PIN_NUM_RST,
-        .rgb_endian = LCD_RGB_ENDIAN_BGR,
-        .bits_per_pixel = LCD_BITS_PER_PIXEL,
-    };
-    ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(io_handle, &panel_config, &panel_handle));
-    ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
-    ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
-    ESP_ERROR_CHECK(esp_lcd_panel_invert_color(panel_handle, true));
-
-
-    
-    ESP_ERROR_CHECK(esp_lcd_panel_set_gap(panel_handle, 1, 26));  // ST7735S typically needs these offsets
-
-    ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));
-}
-
-static void lvgl_init(void)
-{
-    lv_init();
-     
-
-#if 1
-    const lvgl_port_cfg_t lvgl_cfg = {
-        .task_priority = 4,        // LVGL task priority
-        .task_stack = 16384,        // LVGL task stack size
-        .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
-    };
-    
-    ESP_ERROR_CHECK(lvgl_port_init(&lvgl_cfg));
-#endif
-
-    const lvgl_port_display_cfg_t disp_cfg = {
-        .io_handle = io_handle,
-        .panel_handle = panel_handle,
-        .buffer_size = LCD_H_RES * LCD_V_RES * 2,
-        .double_buffer = false,
-        .hres = LCD_H_RES,
-        .vres = LCD_V_RES,
-        .monochrome = false,
-        .rotation = {
-            .swap_xy = true,
-            .mirror_x = true,
-            .mirror_y = false,
-        },
-        .flags = {
-            //.buff_dma = true,
-            .swap_bytes = true,
-        }
-    };
-
-    disp = lvgl_port_add_disp(&disp_cfg);
-    //lv_display_set_color_format(disp, LV_COLOR_FORMAT_RGB565);
-
-
-}
-
-static void createBubble(lv_obj_t * scr)
-{
-
-    // 2) Create a bubble level of size 200×60, with range [−30°, +30°], initial 0°:
-    lv_obj_t * level = bubble_create(scr, 150, 40, -10.0f, +10.0f, 0.0f);
-    lv_obj_align(level, LV_ALIGN_CENTER, 0, 0);
-
-    // 3) … Later, when you read your accelerometer or keypad‐derived angle …
-    float new_angle = 10.0f;
-    bubble_setValue(level, new_angle);
-
-    // 4) You can call bubble_level_set_value(level, …) as often as you like.
-    //    Each call invalidates the object and LVGL will call the draw callback
-    //    (usually on the next tick, or immediately if LVGL is idle).
-
-    _bubble = level;
-}
-
-
-void gui_start(void)
-{
-
-	// Initialize LCD
-    lcd_init();
-
-    // Initialize LVGL
-    lvgl_init();
-
-	// Create UI
-    create_lvgl_demo();
-
-    keypad_start();
-
-	gpio_set_level(PIN_NUM_BK_LIGHT, 1);
-
-    xTaskCreate(gui_task, "gui_task", 4096, NULL, 5, NULL);
-
-}
-
-static uint32_t waitForKeyPress(void)
-{
-    QueueHandle_t q = keypad_getQueue();
-    uint32_t ev = 0;
-
-    if (xQueueReceive(q, &ev, portMAX_DELAY) == pdTRUE) 
-    {
-        return ev;
-    }
-
-    return 0;
-}
-
-static void handleMainMenu(void)
-{
-    lvgl_port_lock(0);
-    // Create a screen with black background
-    lv_obj_t *scr = lv_scr_act();
-
-    //create_menu(scr);
-
-    lvgl_port_unlock();
-}
-
-
-// ───── MENU CONFIG ─────
-#define ROW_H      20                                      // height of each row
-static const char * items[] = {                          // your menu entries
-    "VMode Crossmade",
-    "Second Choice",
-    "Another Option",
-    "Yet Another",
-    "Yet Another",
-    "Last One"
-};
-#define ITEM_COUNT (sizeof(items)/sizeof(items[0]))
-
-// ───── STATE & HELPERS ─────
-static lv_obj_t * btn_array[ITEM_COUNT];
-static int        selected_idx = 0;
-
-// 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);
-}
-
-// Repaint all rows so only btn_array[selected_idx] is highlighted
-static void refresh_highlight(void) {
-
-    return;
-    lvgl_port_lock(0);
-
-    int index = 0;
-
-    lv_obj_t *page = _currentPage;
-
-    lv_obj_t * child = NULL;
-    lv_obj_t * next = lv_obj_get_child(page, index);
-    lv_obj_t * selected = NULL;
-    while(next) {
-        child = next;
-
-        ESP_LOGI(TAG, "Child: %p", child);
-        
-
-        if (lv_obj_has_flag(child, LV_OBJ_FLAG_USER_1))
-        {
-            lv_obj_set_style_bg_color(child, lv_color_hex(0xFF8800), 0);
-                lv_obj_set_style_text_color(lv_obj_get_child(child,0),
-                                            lv_color_white(), 0);
-
-            selected = child;
-            ESP_LOGI(TAG, "Selected");
-        }
-        else 
-        {
-            lv_obj_set_style_bg_color(child, lv_color_white(), 0);
-            lv_obj_set_style_text_color(lv_obj_get_child(child,0),
-                                        lv_color_black(), 0);
-        }
-
-        index++;
-        next = lv_obj_get_child(page, index);
-    }
-
-    if (selected)
-    {
-        lv_obj_scroll_to_view(selected, LV_ANIM_ON);
-    }
-
-    lvgl_port_unlock();
-}
-
-
-static void menuInc(int inc)
-{
-    LOCK();
-
-    currentFocusIndex(&_menuContext);
-
-    ESP_LOGI(TAG, "Current Index: %d", _menuContext.selected);
-
-    lv_obj_t *next = NULL;
-
-    // check if we are at the first or last in the page
-    lv_obj_t *test = lv_obj_get_child(_currentPage, (inc > 0 ? -1 : 0));
-
-    if (_menuContext.obj != test)
-    {
-        next = lv_obj_get_child(_currentPage, _menuContext.selected + inc);
-        lv_obj_add_state(next, LV_STATE_FOCUSED);
-        lv_obj_clear_state(_menuContext.obj, LV_STATE_FOCUSED);
-        lv_obj_scroll_to_view(next, LV_ANIM_ON);
-
-        _menuContext.obj = next;
-        _menuContext.selected += inc;
-    }
-    
-    UNLOCK();
-}
-
-static void menuNext(void) 
-{
-    menuInc(1);
-}
-
-
-static void menuPrevious(void) 
-{
-    menuInc(-1);
-}
-
-// Fire the “clicked” event on the selected row
-static void activate_selected(void) 
-{
-    LOCK();
-    lv_obj_send_event(_menuContext.obj, LV_EVENT_CLICKED, NULL);
-    UNLOCK();
-}
-
-static lv_obj_t * addMenuItem(lv_obj_t *page, const char *text)
-{
-    lv_obj_t * btn = lv_btn_create(page);
-    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);
-
-    lv_obj_add_state(btn, LV_STATE_DEFAULT);
-
-
-    // style it just like your old list
-//    lv_obj_set_style_bg_color(btn, lv_color_white(), 0);
-    lv_obj_set_style_radius(btn, 0, LV_PART_MAIN); 
-    lv_obj_set_style_border_width(btn, 0, LV_PART_MAIN);
-    lv_obj_clear_flag(btn, LV_OBJ_FLAG_SCROLLABLE);
-
-    // label & center
-    lv_obj_t * lbl = lv_label_create(btn);
-    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);
-
-    // click callback
-    lv_obj_add_event_cb(btn, btn_click_cb, LV_EVENT_CLICKED, NULL);
-
-    return btn;
-}
-
-static int getSelectedIndex(lv_obj_t *page)
-{
-    return -1;
-}
-
-
-
-static void currentFocusIndex(menu_context_t *ctx)
-{
-    ctx->count = lv_obj_get_child_cnt(_currentPage);
-    ctx->obj = NULL;
-    ctx->selected = -1;
-
-    // return the index of the currently focused object
-    for(int i = 0; i < ctx->count; i++) {
-        lv_obj_t * child = lv_obj_get_child(_currentPage, i);
-        
-        if (lv_obj_has_state(child, LV_STATE_FOCUSED))
-        {
-            ctx->obj = child;
-            ctx->selected = i;
-
-            return;
-        }
-    }
-
-    
-
-}
-// ───── BUILD THE MENU ─────
-static void build_scrollable_menu(void) {
-
-
-    lv_style_init(&_styleFocusedBtn);
-    lv_style_init(&_styleUnfocusedBtn);
-
-    lv_style_set_bg_color(&_styleUnfocusedBtn, lv_color_make(0xff,0xff,0xff));  // gray bg
-    lv_style_set_text_color(&_styleUnfocusedBtn, lv_color_hex(0xFF8800));
-
-    lv_style_set_bg_color(&_styleFocusedBtn, lv_color_make(0x33,0x99,0xFF)); // blue bg
-    lv_style_set_text_color(&_styleUnfocusedBtn,lv_color_black());
-
-
-    // 2) Inside it, create the lv_menu and hide its sidebar/header
-    lv_obj_t *menu = lv_menu_create(lv_scr_act());
-    _menu = menu;
-    
-    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_t    * main = lv_menu_page_create(menu, NULL);
-    lv_obj_set_style_radius(main,       0, LV_PART_MAIN | LV_STATE_ANY);
-    lv_obj_set_style_border_width(main, 0, LV_PART_MAIN | LV_STATE_ANY);
-    lv_obj_set_scrollbar_mode(main, LV_SCROLLBAR_MODE_AUTO);
-    lv_obj_set_size(main, lv_pct(100), lv_pct(100));
-
-    lv_menu_set_page(menu, main);
-
-    lv_obj_t    * tmpObj;
-
-
-
-    lv_obj_t    * calMenu = lv_menu_page_create(menu, NULL);
-    lv_obj_set_style_radius(calMenu,       0, LV_PART_MAIN | LV_STATE_ANY);
-    lv_obj_set_style_border_width(calMenu, 0, LV_PART_MAIN | LV_STATE_ANY);
-    lv_obj_set_scrollbar_mode(calMenu, LV_SCROLLBAR_MODE_AUTO);
-
-    tmpObj = addMenuItem(main, "Bluetooth");
-    lv_obj_add_state(tmpObj, LV_STATE_FOCUSED);
-    //lv_obj_add_flag(tmpObj, LV_OBJ_FLAG_USER_1);
-        
-    tmpObj = addMenuItem(main, "Calibration");
-    lv_menu_set_load_page_event(menu, tmpObj, calMenu);
-    
-
-    tmpObj = addMenuItem(main, "Volume");
-    
-    addMenuItem(main, "About");
-    addMenuItem(main, "Exit");
-
-    
-    addMenuItem(calMenu, "Calibrate Level");
-    addMenuItem(calMenu, "Reset Calibration");
-    addMenuItem(calMenu, "Exit");
-
-    _currentPage = main;
-
-    // 6) Initial highlight
-    selected_idx = 0;
-    refresh_highlight();
-
-    
-
-}
-
-
-static void gui_task(void)
-{
-    system_subscribe(xTaskGetCurrentTaskHandle());
-
-    // Grab queue handle
-    QueueHandle_t q = keypad_getQueue();
-    uint32_t ev = 0;
-
-    LOCK();
-    // _mode = GUI_MENU;
-    // lv_obj_remove_flag(_menu, LV_OBJ_FLAG_HIDDEN);
-    lv_obj_remove_flag(_bubble, LV_OBJ_FLAG_HIDDEN);
-    //lv_obj_add_flag(_menu, LV_OBJ_FLAG_HIDDEN);
-    UNLOCK();
-
-    while (1)
-    {
-        
-
-        if (xQueueReceive(q, &ev, pdMS_TO_TICKS(10)) == pdTRUE) 
-        {
-            switch (ev) {
-
-                case (KEY_UP << KEY_LONG_PRESS):
-                {
-                    system_setZeroAngle();
-                    break;
-                }
-
-                case (KEY_DOWN << KEY_LONG_PRESS):
-                {
-                    system_clearZeroAngle();
-                    break;
-                }
-#if 0                
-            case (KEY0 << KEY_SHORT_PRESS):
-
-                if (_mode == GUI_MENU)
-                {
-                    menuNext();
-                }
-                ESP_LOGI(TAG, "MAIN: Button 1 SHORT");
-                break;
-            case (KEY0 << KEY_LONG_PRESS):
-            {
-
-             
-                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);
-                }
-                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();
-                }
-                break;
-            }
-            case (KEY1 << KEY_LONG_PRESS):
-                ESP_LOGI(TAG, "MAIN: Button 2 LONG");
-                gpio_set_level(PIN_NUM_nON, 0);
-                break;
-#endif                
-            default:
-                break;
-            }
-        }
-    
-        
-        if (_mode == GUI_BUBBLE)
-        {
-            uint32_t notifiedBits = 0;
-                // clear on entry (first param), wait for any bit, block forever
-            xTaskNotifyWait(
-                0xFFFFFFFF,        // clear any old bits on entry
-                0xFFFFFFFF,        // clear bits on exit
-                &notifiedBits,
-                pdMS_TO_TICKS(100));
-
-            if (notifiedBits & EM_EVENT_NEW_DATA) 
-            {
-                ImuData_t d = system_getImuData();
-                bubble_setValue(_bubble, -d.angle);
-            }
-        }
-
-    }
-    
-
-    
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
 }
\ No newline at end of file
diff --git a/main/keypad.h b/main/keypad.h
index fbd1aa3..4f0df73 100644
--- a/main/keypad.h
+++ b/main/keypad.h
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 #ifndef _KEYPAD_H
 #define _KEYPAD_H
 
@@ -21,28 +20,4 @@ typedef enum
 void keypad_start(void);
 QueueHandle_t keypad_getQueue(void);
 
-=======
-#ifndef _KEYPAD_H
-#define _KEYPAD_H
-
-#include "freertos/FreeRTOS.h"
-#include "freertos/queue.h"
-
-typedef enum 
-{
-    KEY0 = 	(1 << 0),
-    KEY1 = 	(1 << 1),
-} keycode_t;
-
-
-#define KEY_SHORT_PRESS	0
-#define KEY_LONG_PRESS	4
-
-#define KEY_UP      KEY0
-#define KEY_DOWN    KEY1
-
-void keypad_start(void);
-QueueHandle_t keypad_getQueue(void);
-
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
 #endif
\ No newline at end of file
diff --git a/main/main.c b/main/main.c
index 731d8e1..7463480 100644
--- a/main/main.c
+++ b/main/main.c
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 /*
  * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
@@ -40,6 +39,31 @@ typedef struct {
     float prev_output;  // y[n-1]
 } LowPassFilter;
 
+#define ALPHA_MIN   0.2f
+#define ALPHA_MAX   0.4f
+
+// Clamp function to bound value between min and max
+double clamp(double value, double min, double max) {
+    if (value < min) return min;
+    if (value > max) return max;
+    return value;
+}
+
+// Compute alpha using linear ramp
+float compute_alpha_linear(double x, float alpha_min, float alpha_max, float threshold) {
+    float abs_x = fabs(x);
+    float t = clamp(abs_x / threshold, 0.0, 1.0);  // Normalize |x| to [0,1]
+    return alpha_min + (alpha_max - alpha_min) * t;
+}
+
+// Compute sigmoid-based dynamic alpha
+float compute_alpha_sigmoid(float x, float alpha_min, float alpha_max, float k, float midpoint) {
+    float abs_x = fabs(x);
+    float exponent = -k * (abs_x - midpoint);
+    float sigmoid = 1.0 / (1.0 + exp(exponent));
+    return alpha_min + (alpha_max - alpha_min) * sigmoid;
+}
+
 // Initialize the filter.  alpha = smoothing factor.
 //   e.g. alpha = dt/(RC+dt) if you derive from cutoff freq & sample time.
 //   init_output can be 0 or your first sample to avoid startup glitch.
@@ -51,7 +75,11 @@ static inline void LPF_Init(LowPassFilter *f, float alpha, float init_output) {
 // Run one input sample through the filter.
 // Returns y[n] = alpha * x[n] + (1-alpha) * y[n-1].
 static inline float LPF_Update(LowPassFilter *f, float input) {
-    float out = f->alpha * input + (1.0f - f->alpha) * f->prev_output;
+    
+    //float alpha = compute_alpha_sigmoid(input, ALPHA_MIN, ALPHA_MAX, 1.0f, 0.0f);
+    float alpha = compute_alpha_linear(input, ALPHA_MIN, ALPHA_MAX, 2.0f);
+    float out = alpha * input + (1.0f - alpha) * f->prev_output;
+    //float out = f->alpha * input + (1.0f - f->alpha) * f->prev_output;
     f->prev_output = out;
     return out;
 }
@@ -290,296 +318,3 @@ void app_main(void)
     }    
 #endif
 }
-=======
-/*
- * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Unlicense OR CC0-1.0
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <inttypes.h>
-#include "math.h"
-
-#include "esp_system.h"
-#include "esp_log.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/timers.h"
-#include "driver/gpio.h"
-#include "nvs.h"
-#include "nvs_flash.h"
-
-
-#include "bt_app.h"
-#include "lsm6dsv.h"
-#include "gui.h"
-#include "gpio.h"
-#include "keypad.h"
-#include "system.h"
-
-
-
-
-/*********************************
- * STATIC FUNCTION DECLARATIONS
- ********************************/
-typedef struct {
-    float alpha;        // smoothing factor, 0<alpha<1
-    float prev_output;  // y[n-1]
-} LowPassFilter;
-
-// Initialize the filter.  alpha = smoothing factor.
-//   e.g. alpha = dt/(RC+dt) if you derive from cutoff freq & sample time.
-//   init_output can be 0 or your first sample to avoid startup glitch.
-static inline void LPF_Init(LowPassFilter *f, float alpha, float init_output) {
-    f->alpha       = alpha;
-    f->prev_output = init_output;
-}
-
-// Run one input sample through the filter.
-// Returns y[n] = alpha * x[n] + (1-alpha) * y[n-1].
-static inline float LPF_Update(LowPassFilter *f, float input) {
-    float out = f->alpha * input + (1.0f - f->alpha) * f->prev_output;
-    f->prev_output = out;
-    return out;
-}
-
-
-/*********************************
- * STATIC VARIABLE DEFINITIONS
- ********************************/
-static const char *TAG = "main";
-
-/*********************************
- * STATIC FUNCTION DEFINITIONS
- ********************************/
-
-static void init_gpio(void)
-{
-    gpio_config_t io_conf;
-
-
-    // Configure output GPIO
-    io_conf.pin_bit_mask = (1ULL << PIN_NUM_LED_1) | (1ULL << PIN_NUM_LED_2);
-    io_conf.mode = GPIO_MODE_OUTPUT;
-    io_conf.intr_type = GPIO_INTR_DISABLE;
-    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
-    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
-    gpio_config(&io_conf);
-
-
-
-    
-#if 1
-    // Configure output power signal
-    gpio_set_level(PIN_NUM_nON, 1);
-    
-    io_conf.pin_bit_mask = (1ULL << PIN_NUM_nON);
-    io_conf.mode = GPIO_MODE_OUTPUT;
-    io_conf.intr_type = GPIO_INTR_DISABLE;
-    io_conf.pull_up_en = GPIO_PULLUP_ENABLE;
-    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
-    gpio_config(&io_conf);
-#endif
-    
-
-
-    // Configure LCD Backlight GPIO
-    io_conf.pin_bit_mask =  (1ULL << PIN_NUM_BK_LIGHT);
-    io_conf.mode = GPIO_MODE_OUTPUT;
-    io_conf.intr_type = GPIO_INTR_DISABLE;
-    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
-    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
-    gpio_config(&io_conf);
-}
-
-
-
-
-// IMU task to read sensor data
-static void imu_task(void *pvParameters) {
-    lsm6dsv_data_t imu_data;
-    char data_str[128];
-
-    float roll, pitch, yaw;
-    lsm6dsv_fifo_t fifo;
-
-    ImuData_t imu;
-
-    LowPassFilter lpf;
-    LPF_Init(&lpf, FILTER_COEFF, 0);
-
-    while (1) {
-
-       // uint8_t samples = lsm6dsv_fifo_ready();
-
-        //ESP_LOGI(TAG, "Samples: %d", samples);
-        // while (samples)
-        // {
-        //     lsm6dsv_fifo_read(&fifo);
-
-            
-
-        //     // snprintf(data_str, sizeof(data_str),
-        //     //     "tag: %d, count: %d, (%d, %d, %d)",
-        //     //     fifo.tag, fifo.count, x, y, z);
-
-        //     // ESP_LOGI(TAG, "%s", data_str);
-
-        //     samples--;
-        // }
-
-        // lsm6dsv_getAttitude(&fifo, &roll, &pitch, &yaw);
-
-        // snprintf(data_str, sizeof(data_str),
-        //     "r: %0.3f, p: %0.3f, y: %0.3f",
-        //     roll, pitch, yaw);
-
-        // ESP_LOGI(TAG, "%s", data_str);
-
-    float xz;
-    float yz;
-    float xy;
-
-#if 1
-        if (lsm6dsv_read_data(&imu_data) == ESP_OK) 
-        {
-            // snprintf(data_str, sizeof(data_str),
-            //         "Acc: %.2f, %.2f, %.2f; "
-            //         "Gyro: %.2f, %.2f, %.2f (%d)\n",
-            //         imu_data.acc_x, imu_data.acc_y, imu_data.acc_z,
-            //         imu_data.gyro_x, imu_data.gyro_y, imu_data.gyro_z, lsm6dsv_fifo_ready());
-
-            
-
-            
-#if 1            
-            imu.raw[ANGLE_XZ] = atan2f((float)imu_data.acc_z, (float)imu_data.acc_x) * 180 / M_PI;
-            imu.raw[ANGLE_YZ] = atan2f((float)imu_data.acc_z, (float)imu_data.acc_y) * 180 / M_PI;
-            imu.raw[ANGLE_XY] = atan2f((float)imu_data.acc_x, (float)imu_data.acc_y) * 180 / M_PI;
-
-            
-            float angle;
-
-
-            angle = system_getAngle(); 
-
-            if (angle > MAX_INDICATION_ANGLE)
-            {
-                angle = MAX_INDICATION_ANGLE;
-            }
-            else
-            if (angle < -MAX_INDICATION_ANGLE)
-            {
-                angle = -MAX_INDICATION_ANGLE;
-            }
-            
-            // low pass filter the angle measurement
-            imu.angle = LPF_Update(&lpf, angle);
-
-            //imu.filtered[ANGLE_XY] = LPF_Update(&lpf, imu.raw[ANGLE_XY]);
-
-            system_setImuData(imu);
-
-            // snprintf(data_str, sizeof(data_str),
-            //         "(%.2f, %.2f, %.2f)", xy, yz, xy);
-#endif                    
-
-#if 0
-            snprintf(data_str, sizeof(data_str),
-                    "(%.1f, %.1f, %.1f) (%.2f, %.2f, %.2f)", 
-                    imu.raw[ANGLE_XZ], imu.raw[ANGLE_YZ], imu.raw[ANGLE_XY],
-                    (float)imu_data.acc_x, (float)imu_data.acc_y, (float)imu_data.acc_z);
-            ESP_LOGI(TAG, "%s", data_str);
-#endif
-            // Update label text in LVGL task
-            //lv_label_set_text(imu_label, data_str);
-            
-        }
-#endif        
-        vTaskDelay(pdMS_TO_TICKS(100)); // Update every 100ms
-    }
-}
-
-/*********************************
- * MAIN ENTRY POINT
- ********************************/
-
-void app_main(void)
-{
-    
-    /* initialize NVS — it is used to store PHY calibration data */
-    esp_err_t ret = nvs_flash_init();
-    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
-        ESP_ERROR_CHECK(nvs_flash_erase());
-        ret = nvs_flash_init();
-    }
-    ESP_ERROR_CHECK(ret);
-
-    init_gpio();
-
-    system_init();
-
-   
-
-    // Initialize IMU
-    ESP_ERROR_CHECK(lsm6dsv_init(22, 21));  // SCL = IO14, SDA = IO15
-
-
-
-    // Create IMU task
-    TaskHandle_t h = xTaskCreate(imu_task, "imu_task", 4096, NULL, 5, NULL);
-    
-
-    
-    bt_app_init();
-
-    gui_start();
-    
-    gpio_set_level(PIN_NUM_LED_2, 1);
-
-
-#if 0
-
-    keypad_start();
-    QueueHandle_t q = keypad_getQueue();
-    uint32_t ev = 0;
-
-    //gpio_set_level(PIN_NUM_LED_1, 1);
-    gpio_set_level(PIN_NUM_LED_2, 1);
-
-    // Main loop - LVGL task will run automatically
-    while (1) {
-        
-        if (xQueueReceive(q, &ev, pdMS_TO_TICKS(10)) == pdTRUE) 
-        {
-            switch (ev) 
-            {
-                case (KEY_UP << KEY_LONG_PRESS):
-                {
-                    system_setZeroAngle();
-                    break;
-                }
-
-                case (KEY_DOWN << KEY_LONG_PRESS):
-                {
-                    system_clearZeroAngle();
-                    break;
-                }
-            }
-            
-        }
- 
-    }
-#else
-    while (1)
-    {
-        vTaskDelay(pdMS_TO_TICKS(1000));
-    }    
-#endif
-}
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
diff --git a/main/system.c b/main/system.c
index 4c9ea22..ffeb70a 100644
--- a/main/system.c
+++ b/main/system.c
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 #include "system.h"
 #include "esp_log.h"
 
@@ -167,174 +166,4 @@ void system_notifyAll(uint32_t eventBits) {
         }
         xSemaphoreGive(em->mutex);
     }
-=======
-#include "system.h"
-#include "esp_log.h"
-
-static SystemState_t _systemState;
-
-static EventGroupHandle_t _systemEvent;
-static EventManager_t _eventManager;
-
-void system_init(void)
-{
-    _systemState.zeroAngle = 0.0f;
-    _systemState.primaryAxis = PRIMARY_AXIS;
-
-	EventGroupHandle_t evt = xEventGroupCreate();
-
-	_eventManager.count = 0;
-    _eventManager.mutex = xSemaphoreCreateMutex();
-}
-
-int system_getPrimaryAxis(void)
-{
-    int axis;
-
-    xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
-    axis = _systemState.primaryAxis;
-    xSemaphoreGive(_eventManager.mutex);
-
-    return axis;
-}
-
-float system_getAngle(void)
-{
-    float angle;
-
-    xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
-
-    
-    angle = _systemState.imu.raw[_systemState.primaryAxis] - _systemState.zeroAngle;
-
-
-	xSemaphoreGive(_eventManager.mutex);
-
-    return angle;    
-}
-
-void system_setZeroAngle(void)
-{
-    xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
-
-    
-	_systemState.zeroAngle = _systemState.imu.raw[_systemState.primaryAxis];
-
-    ESP_LOGI("system", "Zero: %.1f", _systemState.zeroAngle);
-
-	xSemaphoreGive(_eventManager.mutex);
-}
-
-void system_clearZeroAngle(void)
-{
-    xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
-
-	_systemState.zeroAngle = 0.0f;
-
-    ESP_LOGI("system", "Zero: %.1f", _systemState.zeroAngle);
-
-	xSemaphoreGive(_eventManager.mutex);
-}
-
-float system_getZeroAngle(void)
-{
-    float angle;
-
-    xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
-
-	angle = _systemState.zeroAngle;
-
-	xSemaphoreGive(_eventManager.mutex);
-
-    return angle;
-}
-
-void system_setImuData(ImuData_t imu)
-{
-	xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
-
-	_systemState.imu = imu;
-
-	xSemaphoreGive(_eventManager.mutex);
-
-    //ESP_LOGI("g", "New IMU Data: %.2f", xy);
-
-	system_notifyAll(EM_EVENT_NEW_DATA);
-}
-
-ImuData_t system_getImuData(void)
-{
-	ImuData_t imu;
-	xSemaphoreTake(_eventManager.mutex, portMAX_DELAY);
-
-    imu = _systemState.imu;
-
-	xSemaphoreGive(_eventManager.mutex);
-
-	return imu;
-}
-
-void system_waitForEvent(void)
-{
-}
-
-SystemState_t *system_getState(void)
-{
-	return &_systemState;
-}
-
-
-BaseType_t system_subscribe(TaskHandle_t task) {
-
-	EventManager_t *em = &_eventManager;
-
-    ESP_LOGI("g", "Subscribe: %p", task);
-    if (xSemaphoreTake(em->mutex, portMAX_DELAY) == pdFALSE) {
-        return pdFAIL;
-    }
-    if (em->count < EM_MAX_SUBSCRIBERS) {
-        // avoid duplicates?
-        ESP_LOGI("g", "PASS");
-        em->subscribers[em->count++] = task;
-        xSemaphoreGive(em->mutex);
-        return pdPASS;
-    }
-    xSemaphoreGive(em->mutex);
-    return pdFAIL; // full
-}
-
-BaseType_t system_unsubscribe(TaskHandle_t task) {
-
-	EventManager_t *em = &_eventManager;
-
-    BaseType_t removed = pdFAIL;
-    if (xSemaphoreTake(em->mutex, portMAX_DELAY) == pdTRUE) {
-        for (size_t i = 0; i < em->count; ++i) {
-            if (em->subscribers[i] == task) {
-                // shift down
-                for (size_t j = i; j + 1 < em->count; ++j)
-                    em->subscribers[j] = em->subscribers[j+1];
-                em->count--;
-                removed = pdPASS;
-                break;
-            }
-        }
-        xSemaphoreGive(em->mutex);
-    }
-    return removed;
-}
-
-void system_notifyAll(uint32_t eventBits) {
-	EventManager_t *em = &_eventManager;
-    if (xSemaphoreTake(em->mutex, portMAX_DELAY) == pdTRUE) {
-        for (size_t i = 0; i < em->count; ++i) {
-            // set the bits in each task's notification value
-            //ESP_LOGI("g", "Notify: %p", em->subscribers[i]);
-            xTaskNotify(em->subscribers[i],
-                        eventBits,
-                        eSetBits);
-        }
-        xSemaphoreGive(em->mutex);
-    }
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
 }
\ No newline at end of file
diff --git a/main/system.h b/main/system.h
index 6a4a2a3..967bd87 100644
--- a/main/system.h
+++ b/main/system.h
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 #ifndef SYSTEM_H
 #define SYSTEM_H
 
@@ -37,8 +36,9 @@ typedef struct SystemState_s
 
 
 #define MAX_INDICATION_ANGLE    5.0f
-#define FILTER_COEFF            0.2f        // 0 to 1   Smaller number is heavier filter
+#define FILTER_COEFF            0.4f        // 0 to 1   Smaller number is heavier filter
 #define PRIMARY_AXIS            ANGLE_YZ
+#define RIFLE_AXIS              Y
 
 #define EM_MAX_SUBSCRIBERS 8    // tweak as needed
 #define EM_EVENT_NEW_DATA   (1UL<<0)
@@ -73,80 +73,4 @@ BaseType_t system_unsubscribe(TaskHandle_t task);
 void    system_notifyAll(uint32_t eventBits);
 
 
-=======
-#ifndef SYSTEM_H
-#define SYSTEM_H
-
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/semphr.h"
-
-#define DISABLE_GUI
-
-enum
-{
-    ANGLE_XY = 0,
-    ANGLE_XZ,
-    ANGLE_YZ,
-};
-
-
-
-typedef struct
-{
-    float raw[3];
-    float filtered[3];
-    float angle;
-} ImuData_t;
-
-typedef struct SystemState_s
-{
-	ImuData_t imu;
-
-	EventGroupHandle_t event;
-
-    float zeroAngle;
-    int primaryAxis;
-
-} SystemState_t;
-
-
-#define MAX_INDICATION_ANGLE    5.0f
-#define FILTER_COEFF            0.2f        // 0 to 1   Smaller number is heavier filter
-#define PRIMARY_AXIS            ANGLE_YZ
-
-#define EM_MAX_SUBSCRIBERS 8    // tweak as needed
-#define EM_EVENT_NEW_DATA   (1UL<<0)
-#define EM_EVENT_ERROR      (1UL<<1)
-// …add more event bit-masks here…
-
-typedef struct {
-    TaskHandle_t subscribers[EM_MAX_SUBSCRIBERS];
-    size_t      count;
-    SemaphoreHandle_t mutex;
-} EventManager_t;
-
-void system_init(void);
-void system_setImuData(ImuData_t imu);
-
-ImuData_t system_getImuData(void);
-
-int system_getPrimaryAxis(void);
-float system_getAngle(void);
-
-void system_setZeroAngle(void);
-void system_clearZeroAngle(void);
-float system_getZeroAngle(void);
-
-// Subscribe (register) current task to receive events
-BaseType_t system_subscribe(TaskHandle_t task);
-
-// Unsubscribe if you ever need
-BaseType_t system_unsubscribe(TaskHandle_t task);
-
-// Notify all subscribers of one or more event bits
-void    system_notifyAll(uint32_t eventBits);
-
-
->>>>>>> 4feb4c0a98bddb1f2a172ea4b195ce31ba18d442
 #endif
\ No newline at end of file
diff --git a/prepare_config.py b/prepare_config.py
index 1a089b7..09ef547 100644
--- a/prepare_config.py
+++ b/prepare_config.py
@@ -7,4 +7,4 @@ with open("project_settings.cmake", "w") as out:
     out.write(f'set(PROJECT_NAME "{cfg["project_name"]}")\n')
     out.write(f'set(CHIP "{cfg["chip"]}")\n')
     out.write(f'set(PORT "{cfg["port"]}")\n')
-    out.write(f'set(BAUD "{cfg["baud"]}")\n')
+    out.write(f'set(BAUD "{cfg["flash_baud"]}")\n')
diff --git a/project_settings.cmake b/project_settings.cmake
new file mode 100644
index 0000000..1788cf6
--- /dev/null
+++ b/project_settings.cmake
@@ -0,0 +1,4 @@
+set(PROJECT_NAME "soundshot")
+set(CHIP "esp32")
+set(PORT "COM3")
+set(BAUD "460800")
diff --git a/settings.json b/settings.json
index 67211c2..d5349dd 100644
--- a/settings.json
+++ b/settings.json
@@ -1,11 +1,11 @@
 {
   "project_name": "soundshot",
-  "chip": "esp32h2",
-  "port": "COM8",
+  "chip": "esp32",
+  "port": "COM3",
   "monitor_baud": 115200,
   "flash_baud": 460800,
   "flash_mode": "dio",
-  "flash_freq": "48m",
+  "flash_freq": "40m",
   "flash_size": "2MB",
   "before": "default-reset",
   "after": "hard-reset"