전원 버튼 ON/OFF 임계 카운트 분리

- 버튼 감지 타이밍이 초기화 등으로 런타임과 달라서 체감상 3초로 맞추기 위해 분리

CMakeLists.txt

@@ -10,6 +10,9 @@ target_include_directories(app PRIVATE
     src/command
     src/command/handlers
     src/ble
+    src/power
+    src/dfu
+    src/nvs
     src/drivers/battery
     src/drivers/echo_adc
     src/drivers/led
@@ -20,17 +23,20 @@ target_include_directories(app PRIVATE
 
 target_sources(app PRIVATE
     src/main.c
-    src/app_nvs.c
+    src/nvs/app_nvs.c
     src/command/parser.c
+    src/command/ble_cmd_queue.c
     src/command/cmd_common.c
     src/command/cmd_table.c
     src/command/handlers/cmd_device.c
     src/command/handlers/cmd_info.c
     src/command/handlers/cmd_piezo.c
     src/command/handlers/cmd_sensor.c
-    src/power_control.c
+    src/power/power_control.c
+    src/dfu/dfu_manager.c
     src/measurement/piezo_measure.c
     src/ble/ble_service.c
+    src/ble/ble_tx_power.c
     src/drivers/battery/battery_adc.c
     src/drivers/echo_adc/echo_adc.c
     src/drivers/led/led_control.c

Kconfig

@@ -0,0 +1,12 @@
+source "Kconfig.zephyr"
+
+menu "VesiScan application options"
+
+config VESIS_DEBUG_PRINT
+    bool "Enable VesiScan debug print output"
+    default y
+    help
+      Enable DBG_PRINTF, DBG_CORE, and DBG_ERR output through printk().
+      Disable this option to compile out these project debug prints.
+
+endmenu

boards/nrf52840dk_nrf52840.conf

@@ -1,2 +1,3 @@
-CONFIG_BT_CTLR_TX_PWR_PLUS_4=y
+CONFIG_BT_CTLR_TX_PWR_PLUS_8=y
 CONFIG_BT_CTLR_TX_PWR_DYNAMIC_CONTROL=y
+CONFIG_BT_CTLR_CONN_RSSI=y

prj.conf

@@ -5,6 +5,8 @@
 CONFIG_GPIO=y
 
 # Debug Message (RTT)
+# Build-time switch for project DBG_PRINTF/DBG_CORE/DBG_ERR macros.
+CONFIG_VESIS_DEBUG_PRINT=n
 # Zephyr logging subsystem enable.
 CONFIG_LOG=y
 # Print logs immediately when log API is called.
@@ -123,7 +125,7 @@ CONFIG_BOOTLOADER_MCUBOOT=y
 # Enable zcbor library used by mcumgr/SMP/DFU CBOR payloads.
 CONFIG_ZCBOR=y
 # Version string used by MCUboot imgtool signing and versioned DFU zip naming.
-CONFIG_MCUBOOT_IMGTOOL_SIGN_VERSION="0.0.2+26"
+CONFIG_MCUBOOT_IMGTOOL_SIGN_VERSION="0.0.0+0"
 
 # Internal flash
 # Enable internal flash driver.
@@ -151,7 +153,7 @@ CONFIG_MCUMGR=y
 # Enable mcumgr/SMP messages over BLE SMP service.
 CONFIG_MCUMGR_TRANSPORT_BT=y
 # Require authenticated BLE connection for mcumgr read/write operations.
-CONFIG_MCUMGR_TRANSPORT_BT_PERM_RW_AUTHEN=n
+CONFIG_MCUMGR_TRANSPORT_BT_PERM_RW_AUTHEN=y
 # Reassemble SMP packets fragmented over BLE.
 CONFIG_MCUMGR_TRANSPORT_BT_REASSEMBLY=y
 # mcumgr transport receive buffer size for DFU image chunks.
@@ -179,9 +181,4 @@ CONFIG_MCUMGR_GRP_OS=y
 # Enable image manager for MCUboot image state/verify/confirm operations.
 CONFIG_IMG_MANAGER=y
 # Write uploaded image data to flash as a stream.
-CONFIG_STREAM_FLASH=y
-
-# Netcore HCI IPC
-# nRF52840 build does not use network core HCI IPC.
-#CONFIG_SB_CONFIG_NETCORE_HCI_IPC=y
-#SB_CONFIG_NETCORE_HCI_IPC=y
+CONFIG_STREAM_FLASH=y

src/ble/ble_service.c

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/*******************************************************************************
  * @file    ble_service.c
  * @brief   BLE NUS service module
  *
@@ -12,8 +12,6 @@
 #include <zephyr/kernel.h>
 #include <zephyr/bluetooth/bluetooth.h>
 #include <zephyr/bluetooth/hci.h>
-#include <zephyr/bluetooth/hci_vs.h>
-#include <zephyr/sys/byteorder.h>
 #include <zephyr/bluetooth/conn.h>
 #include <zephyr/bluetooth/uuid.h>
 #include <zephyr/bluetooth/gatt.h>
@@ -25,40 +23,21 @@
 #include <errno.h>
 
 #include "ble_service.h"
+#include "ble_tx_power.h"
 #include "main.h"
 #include "debug_print.h"
 #include "led_control.h"
 
 LOG_MODULE_REGISTER(ble_svc, LOG_LEVEL_INF);
 
-/* Module variables */
+/* BLE service 상태 */
 static struct bt_conn *current_conn;
 static ble_data_rx_cb_t rx_callback;
 static bool dfu_advertising_mode;
 static bool advertising_unlimited;
 static uint8_t conn_param_update_attempts;
 static int64_t last_rx_conn_param_update_ms;
-
-#define BLE_TX_POWER_NORMAL_DBM        4
-#define BLE_TX_POWER_STRESS_DBM        8
-#define BLE_RSSI_MONITOR_ENABLED      0
-#define BLE_RSSI_STRESS_DBM          (-80)
-#define BLE_RSSI_STRESS_COUNT          3
-#define BLE_RSSI_MONITOR_INTERVAL_MS 500
-#define BLE_TX_SLOW_MS                50
-#define BLE_TX_CRITICAL_MS           100
-#define BLE_TX_STUCK_MS              200
-#define BLE_TX_SLOW_COUNT              3
-#define BLE_TX_BUSY_STRESS_RETRY       4
-
-extern int bt_hci_get_conn_handle(const struct bt_conn *conn, uint16_t *conn_handle);
-
-static uint16_t current_conn_handle;
-static bool current_conn_handle_valid;
-static int8_t current_tx_power_dbm = BLE_TX_POWER_NORMAL_DBM;
-static uint8_t low_rssi_count;
-static uint8_t slow_tx_count;
-static struct k_work_delayable tx_power_monitor_work;
+static uint16_t current_notify_mtu = 23U;
 
 #if IS_ENABLED(CONFIG_BT_SMP)
 #define BLE_REQUIRED_SECURITY_LEVEL    BT_SECURITY_L4
@@ -77,154 +56,63 @@ static struct k_work adv_restart_work;
 static struct k_work_delayable adv_timeout_work;
 static struct k_work_delayable conn_param_update_work;
 
-static int ble_tx_power_write(uint8_t handle_type, uint16_t handle, int8_t dbm,
-                              const char *reason)
+/*
+ * Store the UATT MTU used by normal GATT/NUS notifications.
+ * NUS notifications can carry application payload up to UATT MTU - 3 bytes.
+ */
+static void att_mtu_updated(struct bt_conn *conn, uint16_t tx, uint16_t rx)
 {
-    struct net_buf *buf;
-    struct net_buf *rsp;
-    struct bt_hci_cp_vs_write_tx_power_level *cp;
-    struct bt_hci_rp_vs_write_tx_power_level *rp;
-    int err;
+    uint16_t uatt = bt_gatt_get_uatt_mtu(conn);
 
-    buf = bt_hci_cmd_alloc(K_NO_WAIT);
-    if (buf == NULL)
+    if (uatt != 0U)
     {
-        return -ENOBUFS;
-    }
-
-    cp = net_buf_add(buf, sizeof(*cp));
-    cp->handle_type = handle_type;
-    cp->handle = sys_cpu_to_le16(handle);
-    cp->tx_power_level = dbm;
-
-    err = bt_hci_cmd_send_sync(BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL, buf, &rsp);
-    if (err)
-    {
-        DBG_ERR("[BLE] TX power set fail reason=%s err=%d\r\n", reason, err);
-        return err;
-    }
-
-    rp = (void *)rsp->data;
-    if (rp->status != 0U)
-    {
-        err = -EIO;
-        DBG_ERR("[BLE] TX power set rejected reason=%s status=0x%02x\r\n",
-                reason, rp->status);
+        current_notify_mtu = uatt;
     }
     else
     {
-        current_tx_power_dbm = rp->selected_tx_power;
-        DBG_CORE("[BLE] TX power %d dBm reason=%s\r\n",
-                 current_tx_power_dbm, reason);
+        current_notify_mtu = (tx < rx) ? tx : rx;
     }
 
-    net_buf_unref(rsp);
-    return err;
+    DBG_PRINTF("[BLE] ATT MTU updated tx=%u rx=%u uatt=%u used=%u notify_payload=%u\r\n",
+               tx, rx, uatt, current_notify_mtu,
+               (current_notify_mtu > 3U) ? (current_notify_mtu - 3U) : 0U);
 }
 
-static int ble_set_conn_tx_power(int8_t dbm, const char *reason)
+
+/* MTU Exchange 연결 직후 요청 */
+static void mtu_exchange_cb(struct bt_conn *conn, uint8_t err, struct bt_gatt_exchange_params *params)
 {
-    if (!current_conn_handle_valid || current_tx_power_dbm == dbm)
-    {
-        return 0;
-    }
+    uint16_t uatt;
 
-    return ble_tx_power_write(BT_HCI_VS_LL_HANDLE_TYPE_CONN,
-                              current_conn_handle,
-                              dbm,
-                              reason ? reason : "unknown");
-}
+    ARG_UNUSED(params);
 
-static void ble_tx_power_stress(const char *reason)
-{
-    (void)ble_set_conn_tx_power(BLE_TX_POWER_STRESS_DBM, reason);
-}
-
-static int ble_read_conn_rssi(int8_t *rssi)
-{
-    struct net_buf *buf;
-    struct net_buf *rsp;
-    struct bt_hci_cp_read_rssi *cp;
-    struct bt_hci_rp_read_rssi *rp;
-    int err;
-
-    if (!current_conn_handle_valid || rssi == NULL)
-    {
-        return -ENOTCONN;
-    }
-
-    buf = bt_hci_cmd_alloc(K_NO_WAIT);
-    if (buf == NULL)
-    {
-        return -ENOBUFS;
-    }
-
-    cp = net_buf_add(buf, sizeof(*cp));
-    cp->handle = sys_cpu_to_le16(current_conn_handle);
-
-    err = bt_hci_cmd_send_sync(BT_HCI_OP_READ_RSSI, buf, &rsp);
     if (err)
     {
-        return err;
-    }
-
-    rp = (void *)rsp->data;
-    if (rp->status != 0U)
-    {
-        err = -EIO;
-    }
-    else
-    {
-        *rssi = rp->rssi;
-    }
-
-    net_buf_unref(rsp);
-    return err;
-}
-
-static void tx_power_monitor_handler(struct k_work *work)
-{
-    int8_t rssi = 0;
-    int err;
-
-    ARG_UNUSED(work);
-
-    if (!current_conn_handle_valid)
-    {
+        DBG_ERR("[BLE] MTU exchange failed err=%u\r\n", err);
         return;
     }
 
-    if (!BLE_RSSI_MONITOR_ENABLED)
+    uatt = bt_gatt_get_uatt_mtu(conn);
+    if (uatt != 0U)
     {
-        return;
+        current_notify_mtu = uatt;
     }
 
-    err = ble_read_conn_rssi(&rssi);
-    if (err)
-    {
-        ble_tx_power_stress("rssi-silence");
-    }
-    else if (rssi <= BLE_RSSI_STRESS_DBM)
-    {
-        if (low_rssi_count < UINT8_MAX)
-        {
-            low_rssi_count++;
-        }
-
-        if (low_rssi_count >= BLE_RSSI_STRESS_COUNT)
-        {
-            ble_tx_power_stress("rssi-low");
-        }
-    }
-    else
-    {
-        low_rssi_count = 0U;
-    }
-
-    k_work_schedule(&tx_power_monitor_work,
-                    K_MSEC(BLE_RSSI_MONITOR_INTERVAL_MS));
+    DBG_PRINTF("[BLE] MTU exchange complete uatt=%u notify_payload=%u\r\n",
+               uatt,
+               (uatt > 3U) ? (uatt - 3U) : 0U);
 }
 
+static struct bt_gatt_exchange_params mtu_exchange_params =
+{
+    .func = mtu_exchange_cb,
+};
+static struct bt_gatt_cb gatt_callbacks =
+{
+    .att_mtu_updated = att_mtu_updated,
+};
+
+/* 로컬 BLE MAC 주소 로그 */
 static void ble_log_local_identity(void)
 {
     bt_addr_le_t addr = {0};
@@ -243,15 +131,18 @@ static void ble_log_local_identity(void)
 }
 
 #if IS_ENABLED(CONFIG_BT_SMP)
+/* NUS 접근 전 보안 level 확인 */
 static bool ble_conn_is_secure(const struct bt_conn *conn)
 {
     return (conn != NULL) && (bt_conn_get_security(conn) >= BLE_REQUIRED_SECURITY_LEVEL);
 }
 
+/* 6자리 ASCII passkey를 숫자로 변환 */
 static int ble_passkey_to_uint(const char *passkey, unsigned int *value)
 {
     unsigned int parsed = 0U;
 
+    // 입력 포인터 방어
     if ((passkey == NULL) || (value == NULL))
     {
         return -EINVAL;
@@ -259,6 +150,7 @@ static int ble_passkey_to_uint(const char *passkey, unsigned int *value)
 
     for (size_t i = 0; i < PASSKEY_LENGTH; i++)
     {
+        // 숫자 6자리만 허용
         if ((passkey[i] < '0') || (passkey[i] > '9'))
         {
             return -EINVAL;
@@ -271,6 +163,7 @@ static int ble_passkey_to_uint(const char *passkey, unsigned int *value)
     return 0;
 }
 
+/* 저장된 passkey 검증, 실패 시 기본값 사용 */
 static int ble_security_configure(void)
 {
     unsigned int passkey;
@@ -294,6 +187,7 @@ static int ble_security_configure(void)
     return 0;
 }
 
+/* Just Works/passkey pairing 요청 자동 승인 */
 static void auth_pairing_confirm(struct bt_conn *conn)
 {
     int err = bt_conn_auth_pairing_confirm(conn);
@@ -307,6 +201,7 @@ static void auth_pairing_confirm(struct bt_conn *conn)
     DBG_CORE("[BLE] Pairing confirmed\r\n");
 }
 
+/* pairing 취소 로그 */
 static void auth_cancel(struct bt_conn *conn)
 {
     ARG_UNUSED(conn);
@@ -314,6 +209,7 @@ static void auth_cancel(struct bt_conn *conn)
 }
 
 #if IS_ENABLED(CONFIG_BT_APP_PASSKEY)
+/* Zephyr pairing callback에 현재 passkey 제공 */
 static uint32_t auth_app_passkey(struct bt_conn *conn)
 {
     unsigned int passkey;
@@ -330,6 +226,7 @@ static uint32_t auth_app_passkey(struct bt_conn *conn)
 }
 #endif
 
+/* pairing 처리 callback 묶음 */
 static struct bt_conn_auth_cb auth_cb =
 {
     .pairing_confirm = auth_pairing_confirm,
@@ -339,24 +236,28 @@ static struct bt_conn_auth_cb auth_cb =
 #endif
 };
 
+/* pairing 성공 로그 */
 static void auth_pairing_complete(struct bt_conn *conn, bool bonded)
 {
     ARG_UNUSED(conn);
     DBG_CORE("[BLE] Pairing complete bonded=%u\r\n", bonded ? 1U : 0U);
 }
 
+/* pairing 실패 시 연결 종료 */
 static void auth_pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
 {
     DBG_ERR("[BLE] Pairing failed reason=%u\r\n", reason);
     (void)bt_conn_disconnect(conn, BT_HCI_ERR_AUTH_FAIL);
 }
 
+/* pairing 결과 callback 묶음 */
 static struct bt_conn_auth_info_cb auth_info_cb =
 {
     .pairing_complete = auth_pairing_complete,
     .pairing_failed = auth_pairing_failed,
 };
 
+/* BLE 보안 callback 등록, passkey 설정 */
 static int ble_security_init(void)
 {
     int err = bt_conn_auth_cb_register(&auth_cb);
@@ -378,6 +279,7 @@ static int ble_security_init(void)
 }
 #endif
 
+/* callback context 밖에서 advertising 재시작 */
 static void adv_restart_handler(struct k_work *work)
 {
     ARG_UNUSED(work);
@@ -394,14 +296,15 @@ static bool ble_disconnect_reason_uses_unlimited_adv(uint8_t reason)
 {
     switch (reason)
     {
-    case BT_HCI_ERR_REMOTE_USER_TERM_CONN:  // 0x13 앱이 연결을 정상 종료
-        return false;                       // → 10분 타임아웃 후 전원 OFF
+        case BT_HCI_ERR_REMOTE_USER_TERM_CONN:  // 0x13 앱이 연결을 정상 종료
+            return false;                       // 10분 타임아웃 후 전원 OFF
 
-    default:
-        return true;                        // 그 외 전부 → 무제한 광고
+        default:
+            return true;                        // 그 외 전부 → 무제한 광고
     }
 }
 
+/* 광고 timeout 시 자동 전원 OFF 판단 */
 static void adv_timeout_handler(struct k_work *work)
 {
     ARG_UNUSED(work);
@@ -415,14 +318,14 @@ static void adv_timeout_handler(struct k_work *work)
     }
 }
 
+/* 현재 연결 파라미터가 목표값인지 비교 */
 static bool ble_conn_param_is_preferred(uint16_t interval, uint16_t latency,
                                         uint16_t timeout)
 {
-    return (interval == BLE_MIN_CONN_INTERVAL) &&
-           (latency == BLE_SLAVE_LATENCY) &&
-           (timeout == BLE_CONN_SUP_TIMEOUT);
+    return (interval == BLE_MIN_CONN_INTERVAL) && (latency == BLE_SLAVE_LATENCY) && (timeout == BLE_CONN_SUP_TIMEOUT);
 }
 
+/* 15ms interval 목표로 connection parameter update 요청 */
 static int ble_request_preferred_conn_params(bool count_attempt)
 {
     struct bt_le_conn_param conn_param =
@@ -432,22 +335,51 @@ static int ble_request_preferred_conn_params(bool count_attempt)
         .latency = BLE_SLAVE_LATENCY,
         .timeout = BLE_CONN_SUP_TIMEOUT,
     };
+    struct bt_conn_info info;
     int err;
 
+    // 연결 없으면 요청 불가
     if (current_conn == NULL)
     {
         return -ENOTCONN;
     }
 
+    // 현재 체결된 파라미터를 조회해서, 이미 목표값이면 재요청/재시도 불필요
+    err = bt_conn_get_info(current_conn, &info);
+    if ((err == 0) && (info.type == BT_CONN_TYPE_LE))
+    {
+        uint16_t cur_interval = (uint16_t)(info.le.interval_us / 1250U);
+        uint16_t cur_latency = info.le.latency;
+        uint16_t cur_timeout = info.le.timeout;
+
+        DBG_PRINTF("[BLE] Current params: interval=%u(%u.%01ums) latency=%u timeout=%u(%ums)\r\n",
+                   cur_interval,
+                   (cur_interval * 125U) / 100U,
+                   ((cur_interval * 125U) % 100U) / 10U,
+                   cur_latency,
+                   cur_timeout,
+                   cur_timeout * 10U);
+
+        if (ble_conn_param_is_preferred(cur_interval, cur_latency, cur_timeout))
+        {
+            DBG_PRINTF("[BLE] Already at preferred params, skip request\r\n");
+            return -EALREADY;
+        }
+    }
+
+    // 예약 재시도에서만 attempt 증가
     if (count_attempt)
     {
         conn_param_update_attempts++;
     }
 
-    DBG_PRINTF("[BLE] Request params: interval=%u latency=%u timeout=%u attempt=%u\r\n",
+    DBG_PRINTF("[BLE] Request params: interval=%u(%u.%01ums) latency=%u timeout=%u(%ums) attempt=%u\r\n",
                BLE_MIN_CONN_INTERVAL,
+               (BLE_MIN_CONN_INTERVAL * 125U) / 100U,
+               ((BLE_MIN_CONN_INTERVAL * 125U) % 100U) / 10U,
                BLE_SLAVE_LATENCY,
                BLE_CONN_SUP_TIMEOUT,
+               BLE_CONN_SUP_TIMEOUT * 10U,
                conn_param_update_attempts);
 
     err = bt_conn_le_param_update(current_conn, &conn_param);
@@ -460,6 +392,7 @@ static int ble_request_preferred_conn_params(bool count_attempt)
     return 0;
 }
 
+/* connection parameter 재시도 work */
 static void conn_param_update_handler(struct k_work *work)
 {
     ARG_UNUSED(work);
@@ -469,21 +402,19 @@ static void conn_param_update_handler(struct k_work *work)
         return;
     }
 
+    // central이 계속 거부하면 최대 횟수에서 중지
     if (conn_param_update_attempts >= BLE_CONN_PARAM_MAX_ATTEMPTS)
     {
         return;
     }
 
-    if (ble_request_preferred_conn_params(true) == 0 &&
-        conn_param_update_attempts < BLE_CONN_PARAM_MAX_ATTEMPTS)
+    if (ble_request_preferred_conn_params(true) == 0 && conn_param_update_attempts < BLE_CONN_PARAM_MAX_ATTEMPTS)
     {
-        k_work_schedule(&conn_param_update_work,
-                        K_MSEC(BLE_CONN_PARAM_RETRY_INTERVAL_MS));
+        k_work_schedule(&conn_param_update_work, K_MSEC(BLE_CONN_PARAM_RETRY_INTERVAL_MS));
     }
 }
 
-/* Advertising data */
-
+/* Advertising scan response data */
 static const struct bt_data sd[] =
 {
     // 평상시 Web Bluetooth 앱이 찾을 수 있도록 NUS UUID 광고
@@ -496,7 +427,7 @@ static const struct bt_data sd_dfu[] =
     BT_DATA_BYTES(BT_DATA_UUID128_SOME, SMP_BT_SVC_UUID_VAL),
 };
 
-/* Connection callbacks */
+/* BLE 연결 완료 처리 */
 static void connected(struct bt_conn *conn, uint8_t err)
 {
     if (err)
@@ -508,23 +439,26 @@ static void connected(struct bt_conn *conn, uint8_t err)
 
     current_conn = bt_conn_ref(conn);
     ble_connection_st = true;
-    current_conn_handle_valid = (bt_hci_get_conn_handle(conn, &current_conn_handle) == 0);
-    current_tx_power_dbm = BLE_TX_POWER_NORMAL_DBM;
-    low_rssi_count = 0U;
-    slow_tx_count = 0U;
-    (void)ble_set_conn_tx_power(BLE_TX_POWER_NORMAL_DBM, "connected");
-    if (BLE_RSSI_MONITOR_ENABLED)
-    {
-        k_work_schedule(&tx_power_monitor_work, K_MSEC(BLE_RSSI_MONITOR_INTERVAL_MS));
-    }
+    ble_tx_power_on_connected(conn); // TX power/RSSI 상태는 별도 모듈에서 관리
 
-    /* 연결 정보 출력 */
     char addr_str[BT_ADDR_LE_STR_LEN];
     bt_addr_le_to_str(bt_conn_get_dst(conn), addr_str, sizeof(addr_str));
-    DBG_CORE("[BLE] Peer: %s\r\n", addr_str);
+    DBG_CORE("[BLE] Peer: %s\r\n", addr_str); // 연결 정보 출력
 
+
+    err = bt_gatt_exchange_mtu(conn, &mtu_exchange_params);
+    if (err)
+    {
+        DBG_ERR("[BLE] MTU exchange request failed err=%d\r\n", err);
+    }
+    else
+    {
+        DBG_PRINTF("[BLE] MTU exchange requested\r\n");
+    }
     conn_param_update_attempts = 0U;
     last_rx_conn_param_update_ms = 0;
+
+    // 연결 직후 약간 기다린 뒤 preferred parameter 요청
     k_work_schedule(&conn_param_update_work, K_MSEC(BLE_CONN_PARAM_FIRST_DELAY_MS));
 
 #if IS_ENABLED(CONFIG_BT_SMP)
@@ -542,16 +476,13 @@ static void connected(struct bt_conn *conn, uint8_t err)
     DBG_CORE("[BLE] Connected\r\n");
 }
 
+/* BLE 연결 해제 처리 */
 static void disconnected(struct bt_conn *conn, uint8_t reason)
 {
     k_work_cancel_delayable(&conn_param_update_work);
-    k_work_cancel_delayable(&tx_power_monitor_work);
+    ble_tx_power_on_disconnected();
     conn_param_update_attempts = 0U;
     last_rx_conn_param_update_ms = 0;
-    current_conn_handle_valid = false;
-    current_tx_power_dbm = BLE_TX_POWER_NORMAL_DBM;
-    low_rssi_count = 0U;
-    slow_tx_count = 0U;
 
     if (current_conn)
     {
@@ -560,6 +491,7 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
     }
 
     ble_connection_st = false;
+    current_notify_mtu = 23U;
     if (dfu_advertising_mode)
     {
         // DFU 광고는 미연결 10분 타임아웃 적용
@@ -577,6 +509,7 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
     k_work_submit(&adv_restart_work);
 }
 
+/* central의 connection parameter 요청 허용 */
 static bool le_param_req(struct bt_conn *conn, struct bt_le_conn_param *param)
 {
     ARG_UNUSED(conn);
@@ -585,28 +518,33 @@ static bool le_param_req(struct bt_conn *conn, struct bt_le_conn_param *param)
     return true;
 }
 
-static void le_param_updated(struct bt_conn *conn, uint16_t interval,
-                             uint16_t latency, uint16_t timeout)
+/* connection parameter 변경 결과 확인 */
+static void le_param_updated(struct bt_conn *conn, uint16_t interval, uint16_t latency, uint16_t timeout)
 {
     ARG_UNUSED(conn);
 
-    DBG_PRINTF("[BLE] Params: interval=%d latency=%d timeout=%d\r\n",
-               interval, latency, timeout);
+    DBG_PRINTF("[BLE] Params: interval=%u(%u.%01ums) latency=%u timeout=%u(%ums)\r\n",
+               interval,
+               (interval * 125U) / 100U,
+               ((interval * 125U) % 100U) / 10U,
+               latency,
+               timeout,
+               timeout * 10U);
 
+    // 목표값 도달 시 재시도 work 중지
     if (ble_conn_param_is_preferred(interval, latency, timeout))
     {
         k_work_cancel_delayable(&conn_param_update_work);
     }
     else if (conn_param_update_attempts < BLE_CONN_PARAM_MAX_ATTEMPTS)
     {
-        k_work_schedule(&conn_param_update_work,
-                        K_MSEC(BLE_CONN_PARAM_RETRY_INTERVAL_MS));
+        k_work_schedule(&conn_param_update_work, K_MSEC(BLE_CONN_PARAM_RETRY_INTERVAL_MS));
     }
 }
 
 #if IS_ENABLED(CONFIG_BT_SMP)
-static void security_changed(struct bt_conn *conn, bt_security_t level,
-                             enum bt_security_err err)
+/* BLE security level 변경 결과 확인 */
+static void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
 {
     ARG_UNUSED(conn);
 
@@ -631,7 +569,7 @@ BT_CONN_CB_DEFINE(conn_callbacks) =
 #endif
 };
 
-/* NUS callbacks */
+/* NUS RX: 보안 확인 후 app parser로 전달 */
 static void nus_received(struct bt_conn *conn, const uint8_t *data, uint16_t len)
 {
 #if IS_ENABLED(CONFIG_BT_SMP)
@@ -659,6 +597,7 @@ static void nus_received(struct bt_conn *conn, const uint8_t *data, uint16_t len
     }
 }
 
+/* NUS TX 완료 callback */
 static void nus_sent(struct bt_conn *conn)
 {
     ARG_UNUSED(conn);
@@ -673,7 +612,7 @@ static struct bt_nus_cb nus_cb =
     .sent = nus_sent,
 };
 
-/* Public functions */
+/* BLE stack, security, NUS service 초기화 */
 int ble_service_init(ble_data_rx_cb_t rx_cb)
 {
     int err;
@@ -685,9 +624,8 @@ int ble_service_init(ble_data_rx_cb_t rx_cb)
     k_work_init(&adv_restart_work, adv_restart_handler);
     k_work_init_delayable(&adv_timeout_work, adv_timeout_handler);
     k_work_init_delayable(&conn_param_update_work, conn_param_update_handler);
-
-    k_work_init_delayable(&tx_power_monitor_work, tx_power_monitor_handler);
-    // Enable BLE stack
+    ble_tx_power_init();
+    // BLE stack 활성화
     err = bt_enable(NULL);
     if (err)
     {
@@ -708,6 +646,7 @@ int ble_service_init(ble_data_rx_cb_t rx_cb)
 
     ble_log_local_identity();
 
+    bt_gatt_cb_register(&gatt_callbacks);
 #if IS_ENABLED(CONFIG_BT_SMP)
     err = ble_security_init();
     if (err)
@@ -716,7 +655,7 @@ int ble_service_init(ble_data_rx_cb_t rx_cb)
     }
 #endif
 
-    // Initialize NUS
+    // NUS service 초기화
     err = bt_nus_init(&nus_cb);
     if (err)
     {
@@ -728,6 +667,7 @@ int ble_service_init(ble_data_rx_cb_t rx_cb)
     return 0;
 }
 
+/* 현재 모드에 맞는 advertising 시작 */
 int ble_advertising_start(void)
 {
     int err;
@@ -761,6 +701,8 @@ int ble_advertising_start(void)
         return err;
     }
 
+    ble_tx_power_apply_advertising();
+
     k_work_cancel_delayable(&adv_timeout_work);
     if (!advertising_unlimited)   // DFU 광고 포함, 미연결 10분 시 전원 OFF
     {
@@ -771,6 +713,7 @@ int ble_advertising_start(void)
     return 0;
 }
 
+/* advertising 중지, timeout work 취소 */
 int ble_advertising_stop(void)
 {
     int err = bt_le_adv_stop();
@@ -785,6 +728,7 @@ int ble_advertising_stop(void)
     return 0;
 }
 
+/* DFU 모드 진입, SMP advertising 준비 */
 int ble_dfu_advertising_enable(void)
 {
     if (dfu_advertising_mode)
@@ -818,9 +762,10 @@ bool ble_dfu_advertising_is_enabled(void)
     return dfu_advertising_mode;
 }
 
-/* DFU watchdog */
+/* DFU watchdog: 현재 연결 강제 disconnect */
 int ble_disconnect_active(void)
 {
+    // 연결 없으면 요청 불가
     if (current_conn == NULL)
     {
         return -ENOTCONN;
@@ -829,6 +774,7 @@ int ble_disconnect_active(void)
     return bt_conn_disconnect(current_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
 }
 
+/* NUS TX: 직렬화, retry, 완료 대기 */
 int ble_data_send(const uint8_t *data, uint16_t len)
 {
     int err;
@@ -852,7 +798,9 @@ int ble_data_send(const uint8_t *data, uint16_t len)
     k_mutex_lock(&nus_tx_lock, K_FOREVER);
 
     // 혹시 남아 있는 완료 신호가 있으면 비우고 이번 전송 전용 상태로 만듦
-    while (k_sem_take(&nus_tx_done_sem, K_NO_WAIT) == 0) {
+    while (k_sem_take(&nus_tx_done_sem, K_NO_WAIT) == 0)
+    {
+        // stale completion 비우기
     }
 
     //DBG_CORE("[NUS TX] send len=%u\r\n", len);
@@ -860,19 +808,17 @@ int ble_data_send(const uint8_t *data, uint16_t len)
     for (int retry = 0; ; retry++)
     {
         err = bt_nus_send(current_conn, data, len);
-        if (err != -ENOMEM || retry >= 20) {
+        // -ENOMEM만 짧게 재시도, 그 외 error는 즉시 종료
+        if (err != -ENOMEM || retry >= 20)
+        {
             break;
         }
 
-        /*
-         * -ENOMEM : BLE TX 버퍼가 가득참
-         * 바로 포기하지 않고 짧게 쉬었다가 다시 시도
-         */
+        // -ENOMEM : BLE TX 버퍼가 가득찬 경우: 바로 포기하지 않고 짧게 쉬었다가 다시 시도
         DBG_ERR("[NUS TX] busy, retry=%d\r\n", retry + 1);
-        if ((retry + 1) >= BLE_TX_BUSY_STRESS_RETRY)
-        {
-            ble_tx_power_stress("tx-queue-busy");
-        }
+        
+        // busy 반복 시 TX power boost 판단
+        ble_tx_power_on_tx_busy_retry(retry + 1);
         k_msleep(5);
     }
 
@@ -884,11 +830,12 @@ int ble_data_send(const uint8_t *data, uint16_t len)
     }
 
     // bt_nus_send() 성공 후 sent 콜백이 올 때까지 기다림 (다음 패킷을 보내도 되는 시점)
-    err = k_sem_take(&nus_tx_done_sem, K_MSEC(BLE_TX_STUCK_MS));
+    err = k_sem_take(&nus_tx_done_sem, K_MSEC(ble_tx_power_tx_stuck_ms()));
     if (err)
     {
-        ble_tx_power_stress("tx-complete-stuck");
-        err = k_sem_take(&nus_tx_done_sem, K_MSEC(1000 - BLE_TX_STUCK_MS));
+        // sent callback 지연도 링크 stress로 처리
+        ble_tx_power_on_tx_complete_timeout();
+        err = k_sem_take(&nus_tx_done_sem, K_MSEC(1000 - ble_tx_power_tx_stuck_ms()));
         if (err)
         {
             DBG_ERR("[NUS TX] completion timeout (err %d)\r\n", err);
@@ -899,34 +846,22 @@ int ble_data_send(const uint8_t *data, uint16_t len)
     {
         int64_t tx_elapsed_ms = k_uptime_get() - tx_start_ms;
 
-        if (tx_elapsed_ms >= BLE_TX_CRITICAL_MS)
-        {
-            ble_tx_power_stress("tx-complete-slow100");
-            slow_tx_count = 0U;
-        }
-        else if (tx_elapsed_ms >= BLE_TX_SLOW_MS)
-        {
-            if (slow_tx_count < UINT8_MAX)
-            {
-                slow_tx_count++;
-            }
-
-            if (slow_tx_count >= BLE_TX_SLOW_COUNT)
-            {
-                ble_tx_power_stress("tx-complete-slow50");
-            }
-        }
-        else
-        {
-            slow_tx_count = 0U;
-        }
+        // 완료 시간 기반 TX power 복구/boost 판단
+        ble_tx_power_on_tx_complete(tx_elapsed_ms);
     }
 
     k_mutex_unlock(&nus_tx_lock);
     return err;
 }
 
+/* BLE 연결 상태 */
 bool ble_is_connected(void)
 {
     return (current_conn != NULL);
 }
+
+/* ATT MTU used to calculate notify payload size */
+uint16_t ble_current_mtu(void)
+{
+    return current_notify_mtu;
+}

src/ble/ble_service.h

@@ -31,6 +31,7 @@ int ble_service_init(ble_data_rx_cb_t rx_cb);
 int ble_advertising_start(void);
 int ble_advertising_stop(void);
 int ble_data_send(const uint8_t *data, uint16_t len);
+uint16_t ble_current_mtu(void);
 int ble_dfu_advertising_enable(void);
 bool ble_dfu_advertising_is_enabled(void);
 bool ble_is_connected(void);

src/ble/ble_tx_power.c

@@ -0,0 +1,364 @@
+/*******************************************************************************
+ * @file    ble_tx_power.c
+ * @brief   BLE TX power and RSSI monitor helper
+ ******************************************************************************/
+#include <zephyr/kernel.h>
+#include <zephyr/bluetooth/hci.h>
+#include <zephyr/bluetooth/hci_vs.h>
+#include <zephyr/bluetooth/conn.h>
+#include <zephyr/sys/byteorder.h>
+#include <errno.h>
+
+#include "ble_tx_power.h"
+#include "debug_print.h"
+
+#define BLE_TX_POWER_NORMAL_DBM        4        // NORMAL: 평상시에는 전류 소모를 낮추기 위해 +4 dBm을 기본값으로 사용
+#define BLE_TX_POWER_STRESS_DBM        8        // BOOST: RSSI 또는 TX 지연이 나빠지면 일시적으로 +8 dBm으로 boost
+#define BLE_RSSI_MONITOR_ENABLED       1
+#define BLE_RSSI_STRESS_DBM            (-80)
+#define BLE_RSSI_STRESS_COUNT          3
+#define BLE_RSSI_MONITOR_INTERVAL_MS   500
+#define BLE_TX_SLOW_MS                 50
+#define BLE_TX_CRITICAL_MS             100
+#define BLE_TX_STUCK_MS                200
+#define BLE_TX_SLOW_COUNT              3
+#define BLE_TX_BUSY_STRESS_RETRY       4
+#define BLE_TX_RECOVER_HOLD_MS         10000
+
+extern int bt_hci_get_conn_handle(const struct bt_conn *conn, uint16_t *conn_handle);
+
+/* HCI vendor command는 bt_conn 포인터 대신 controller handle을 사용 */
+static uint16_t current_conn_handle;
+static bool current_conn_handle_valid;
+static int8_t current_tx_power_dbm = BLE_TX_POWER_NORMAL_DBM;
+static uint8_t low_rssi_count;
+static uint8_t slow_tx_count;
+static int64_t last_stress_ms;
+static struct k_work_delayable tx_power_monitor_work;
+
+/* Nordic vendor HCI command로 advertising/connection TX power 직접 설정 */
+static int ble_tx_power_write(uint8_t handle_type, uint16_t handle, int8_t dbm, const char *reason)
+{
+    struct net_buf *buf;
+    struct net_buf *rsp;
+    struct bt_hci_cp_vs_write_tx_power_level *cp;
+    struct bt_hci_rp_vs_write_tx_power_level *rp;
+    int err;
+
+    buf = bt_hci_cmd_alloc(K_NO_WAIT);
+    if (buf == NULL)
+    {
+        return -ENOBUFS;
+    }
+
+    cp = net_buf_add(buf, sizeof(*cp));
+    cp->handle_type = handle_type;
+    cp->handle = sys_cpu_to_le16(handle);
+    cp->tx_power_level = dbm;
+
+    err = bt_hci_cmd_send_sync(BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL, buf, &rsp);
+    if (err)
+    {
+        DBG_ERR("[BLE] TX power set fail reason=%s err=%d\r\n", reason, err);
+        return err;
+    }
+
+    rp = (void *)rsp->data;
+    if (rp->status != 0U)
+    {
+        err = -EIO;
+        DBG_ERR("[BLE] TX power set rejected reason=%s status=0x%02x\r\n", reason, rp->status);
+    }
+    else
+    {
+        if (handle_type == BT_HCI_VS_LL_HANDLE_TYPE_CONN)
+        {
+            current_tx_power_dbm = rp->selected_tx_power;
+        }
+        DBG_CORE("[BLE] TX power %d dBm reason=%s\r\n", rp->selected_tx_power, reason);
+    }
+
+    net_buf_unref(rsp);
+    return err;
+}
+
+/* 연결 handle이 유효할 때만 connection TX power 변경 */
+static int ble_set_conn_tx_power(int8_t dbm, const char *reason)
+{
+    // 연결 전이거나 이미 목표 출력이면 HCI 명령을 보내지 않음
+    if (!current_conn_handle_valid || current_tx_power_dbm == dbm)
+    {
+        return 0;
+    }
+
+    return ble_tx_power_write(BT_HCI_VS_LL_HANDLE_TYPE_CONN, current_conn_handle, dbm, reason ? reason : "unknown");
+}
+
+static void ble_tx_power_stress(const char *reason)
+{
+    // stress 발생 시각을 기록해서 이후 NORMAL 복귀 시점 판단
+    last_stress_ms = k_uptime_get();
+    (void)ble_set_conn_tx_power(BLE_TX_POWER_STRESS_DBM, reason);
+}
+
+/* 마지막 stress 이후 일정 시간 stress 없는 경우 NORMAL 출력으로 회복 */
+static void ble_tx_power_try_recover(void)
+{
+    // 이미 NORMAL이면 불필요한 HCI 명령 피함
+    if ((current_tx_power_dbm != BLE_TX_POWER_NORMAL_DBM) &&
+        ((k_uptime_get() - last_stress_ms) >= BLE_TX_RECOVER_HOLD_MS))
+    {
+        (void)ble_set_conn_tx_power(BLE_TX_POWER_NORMAL_DBM, "link-recovered");
+    }
+}
+
+/* 컨트롤러에 실제 적용된 연결 TX power 확인 */
+static int ble_read_conn_tx_power(int8_t *dbm)
+{
+    struct net_buf *buf;
+    struct net_buf *rsp;
+    struct bt_hci_cp_vs_read_tx_power_level *cp;
+    struct bt_hci_rp_vs_read_tx_power_level *rp;
+    int err;
+
+    // 연결 handle 없이는 controller에 연결 TX power 조회 불가
+    if (!current_conn_handle_valid || dbm == NULL)
+    {
+        return -ENOTCONN;
+    }
+
+    buf = bt_hci_cmd_alloc(K_NO_WAIT);
+    if (buf == NULL)
+    {
+        return -ENOBUFS;
+    }
+
+    cp = net_buf_add(buf, sizeof(*cp));
+    cp->handle_type = BT_HCI_VS_LL_HANDLE_TYPE_CONN;
+    cp->handle = sys_cpu_to_le16(current_conn_handle);
+
+    err = bt_hci_cmd_send_sync(BT_HCI_OP_VS_READ_TX_POWER_LEVEL, buf, &rsp);
+    if (err)
+    {
+        return err;
+    }
+
+    rp = (void *)rsp->data;
+    if (rp->status != 0U)
+    {
+        err = -EIO;
+    }
+    else
+    {
+        *dbm = rp->tx_power_level;
+    }
+
+    net_buf_unref(rsp);
+    return err;
+}
+
+/* 현재 연결의 RSSI를 읽어 링크 품질 판단에 사용 */
+static int ble_read_conn_rssi(int8_t *rssi)
+{
+    struct net_buf *buf;
+    struct net_buf *rsp;
+    struct bt_hci_cp_read_rssi *cp;
+    struct bt_hci_rp_read_rssi *rp;
+    int err;
+
+    // RSSI 조회도 연결 handle이 있어야 가능
+    if (!current_conn_handle_valid || rssi == NULL)
+    {
+        return -ENOTCONN;
+    }
+
+    buf = bt_hci_cmd_alloc(K_NO_WAIT);
+    if (buf == NULL)
+    {
+        return -ENOBUFS;
+    }
+
+    cp = net_buf_add(buf, sizeof(*cp));
+    cp->handle = sys_cpu_to_le16(current_conn_handle);
+
+    err = bt_hci_cmd_send_sync(BT_HCI_OP_READ_RSSI, buf, &rsp);
+    if (err)
+    {
+        return err;
+    }
+
+    rp = (void *)rsp->data;
+    if (rp->status != 0U)
+    {
+        err = -EIO;
+    }
+    else
+    {
+        *rssi = rp->rssi;
+    }
+
+    net_buf_unref(rsp);
+    return err;
+}
+
+/* 연결 중에는 주기적으로 RSSI를 확인하고, 필요하면 TX power boost */
+static void tx_power_monitor_handler(struct k_work *work)
+{
+    int8_t rssi = 0;
+    int err;
+
+    ARG_UNUSED(work);
+
+    if (!current_conn_handle_valid)
+    {
+        return;
+    }
+
+    if (!BLE_RSSI_MONITOR_ENABLED)
+    {
+        return;
+    }
+
+    err = ble_read_conn_rssi(&rssi);
+
+    // RSSI를 못 읽는 상황도 링크 품질 저하로 간주
+    if (err)
+    {
+        ble_tx_power_stress("rssi-silence");
+    }
+    else if (rssi <= BLE_RSSI_STRESS_DBM)
+    {
+        // 순간적인 RSSI 흔들림은 무시하고, 연속 low RSSI일 때만 boost
+        if (low_rssi_count < UINT8_MAX)
+        {
+            low_rssi_count++;
+        }
+
+        if (low_rssi_count >= BLE_RSSI_STRESS_COUNT)
+        {
+            ble_tx_power_stress("rssi-low");
+        }
+    }
+    else
+    {
+        // RSSI가 회복되면 연속 low RSSI 카운터 초기화
+        low_rssi_count = 0U;
+    }
+
+    // TX가 없어도 monitor 주기마다 NORMAL 복귀 여부 확인
+    ble_tx_power_try_recover();
+
+    // 연결이 유지되는 동안 monitor work 계속 반복
+    k_work_schedule(&tx_power_monitor_work, K_MSEC(BLE_RSSI_MONITOR_INTERVAL_MS));
+}
+
+/* RSSI monitor용 delayable work 초기화 */
+void ble_tx_power_init(void)
+{
+    k_work_init_delayable(&tx_power_monitor_work, tx_power_monitor_handler);
+}
+
+/* 연결 직후 TX power 상태를 초기화하고 RSSI monitor를 시작 */
+void ble_tx_power_on_connected(struct bt_conn *conn)
+{
+    int8_t cur_txp = 0;
+    int txp_ret;
+
+    // 이후 HCI 명령에서 사용할 controller connection handle 저장
+    current_conn_handle_valid = (bt_hci_get_conn_handle(conn, &current_conn_handle) == 0);
+    current_tx_power_dbm = BLE_TX_POWER_NORMAL_DBM;
+    low_rssi_count = 0U;
+    slow_tx_count = 0U;
+    last_stress_ms = k_uptime_get();
+
+    if (current_conn_handle_valid)
+    {
+        // 새 연결은 항상 NORMAL (4 dBm) 시작
+        (void)ble_tx_power_write(BT_HCI_VS_LL_HANDLE_TYPE_CONN, current_conn_handle, BLE_TX_POWER_NORMAL_DBM, "connected");
+    }
+
+    txp_ret = ble_read_conn_tx_power(&cur_txp); // 실제 적용값
+
+    if (txp_ret == 0)
+    {
+        DBG_CORE("[BLE] TX power (current) = %d dBm\r\n", cur_txp);
+    }
+    else
+    {
+        DBG_CORE("[BLE] TX power read fail ret=%d\r\n", txp_ret);
+    }
+
+    if (BLE_RSSI_MONITOR_ENABLED)
+    {
+        // 연결이 유지되는 동안만 RSSI monitor
+        k_work_schedule(&tx_power_monitor_work, K_MSEC(BLE_RSSI_MONITOR_INTERVAL_MS));
+    }
+}
+
+/* 연결 해제 시 monitor와 링크별 상태 초기화 */
+void ble_tx_power_on_disconnected(void)
+{
+    k_work_cancel_delayable(&tx_power_monitor_work);
+    current_conn_handle_valid = false;
+    current_tx_power_dbm = BLE_TX_POWER_NORMAL_DBM;
+    low_rssi_count = 0U;
+    slow_tx_count = 0U;
+    last_stress_ms = 0;
+}
+
+/* advertising handle의 TX power를 NORMAL 값으로 설정 */
+void ble_tx_power_apply_advertising(void)
+{
+    (void)ble_tx_power_write(BT_HCI_VS_LL_HANDLE_TYPE_ADV, 0, BLE_TX_POWER_NORMAL_DBM, "adv");
+}
+
+/* ble_service.c가 TX 완료 대기 timeout을 TX power 정책값과 공유 */
+uint32_t ble_tx_power_tx_stuck_ms(void)
+{
+    return BLE_TX_STUCK_MS;
+}
+
+/* NUS TX queue가 여러 번 busy이면 링크가 불안정한 상황으로 보고 출력 boost */
+void ble_tx_power_on_tx_busy_retry(uint8_t retry_count)
+{
+    if (retry_count >= BLE_TX_BUSY_STRESS_RETRY)
+    {
+        ble_tx_power_stress("tx-queue-busy");
+    }
+}
+
+/* sent callback이 늦게 오면 TX path가 막힌 것으로 보고 boost */
+void ble_tx_power_on_tx_complete_timeout(void)
+{
+    ble_tx_power_stress("tx-complete-stuck");
+}
+
+/* TX 완료 시간이 길어지는 것도 링크 품질 저하 신호로 사용 */
+void ble_tx_power_on_tx_complete(int64_t elapsed_ms)
+{
+    if (elapsed_ms >= BLE_TX_CRITICAL_MS)
+    {
+        // 100ms 이상이면 단발성이라도 즉시 boost
+        ble_tx_power_stress("tx-complete-slow100");
+        slow_tx_count = 0U;
+    }
+    else if (elapsed_ms >= BLE_TX_SLOW_MS)
+    {
+        // 50ms 이상은 연속 발생할 때만 boost
+        if (slow_tx_count < UINT8_MAX)
+        {
+            slow_tx_count++;
+        }
+
+        if (slow_tx_count >= BLE_TX_SLOW_COUNT)
+        {
+            ble_tx_power_stress("tx-complete-slow50");
+        }
+    }
+    else
+    {
+        // 정상 속도로 전송되면 slow 카운터 지우고 복귀 가능성 확인
+        slow_tx_count = 0U;
+        ble_tx_power_try_recover();
+    }
+}

src/ble/ble_tx_power.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * @file    ble_tx_power.h
+ * @brief   BLE TX power and RSSI monitor helper
+ ******************************************************************************/
+#ifndef BLE_TX_POWER_H__
+#define BLE_TX_POWER_H__
+
+#include <stdint.h>
+
+struct bt_conn;
+
+void ble_tx_power_init(void);
+void ble_tx_power_on_connected(struct bt_conn *conn);
+void ble_tx_power_on_disconnected(void);
+void ble_tx_power_apply_advertising(void);
+
+uint32_t ble_tx_power_tx_stuck_ms(void);
+void ble_tx_power_on_tx_busy_retry(uint8_t retry_count);
+void ble_tx_power_on_tx_complete_timeout(void);
+void ble_tx_power_on_tx_complete(int64_t elapsed_ms);
+
+#endif /* BLE_TX_POWER_H__ */

src/command/ble_cmd_queue.c

@@ -0,0 +1,97 @@
+/*******************************************************************************
+ * @file    ble_cmd_queue.c
+ * @brief   BLE RX command queue
+ ******************************************************************************/
+#include <stdint.h>
+#include <string.h>
+#include <zephyr/kernel.h>
+
+#include "ble_cmd_queue.h"
+#include "debug_print.h"
+#include "parser.h"
+
+#define BLE_CMD_MAX_LEN         256
+#define BLE_CMD_QUEUE_DEPTH     8           // RX command ring buffer depth
+#define BLE_CMD_WORKQ_STACK_SZ  8192
+#define BLE_CMD_WORKQ_PRIORITY  10
+
+static struct k_work_q ble_cmd_work_q;
+K_THREAD_STACK_DEFINE(ble_cmd_workq_stack, BLE_CMD_WORKQ_STACK_SZ);
+static struct k_work ble_cmd_work;          // BLE command worker
+static struct k_spinlock ble_cmd_lock;      // RX queue lock
+
+static uint8_t  ble_cmd_q_buf[BLE_CMD_QUEUE_DEPTH][BLE_CMD_MAX_LEN]; // command data
+static uint16_t ble_cmd_q_len[BLE_CMD_QUEUE_DEPTH];                  // command length
+static uint8_t  ble_cmd_q_head;             // next pop slot
+static uint8_t  ble_cmd_q_tail;             // next push slot
+static uint8_t  ble_cmd_q_count;            // queued command count
+
+/* Queue에 쌓인 BLE 명령을 parser로 전달 */
+static void ble_cmd_work_handler(struct k_work *work)
+{
+    ARG_UNUSED(work);
+
+    uint8_t local_buf[BLE_CMD_MAX_LEN];
+    uint16_t local_len;
+
+    for (;;)
+    {
+        k_spinlock_key_t key = k_spin_lock(&ble_cmd_lock);
+        if (ble_cmd_q_count == 0U)
+        {
+            k_spin_unlock(&ble_cmd_lock, key);
+            break;
+        }
+
+        local_len = ble_cmd_q_len[ble_cmd_q_head];
+        memcpy(local_buf, ble_cmd_q_buf[ble_cmd_q_head], local_len);
+        ble_cmd_q_head = (uint8_t)((ble_cmd_q_head + 1U) % BLE_CMD_QUEUE_DEPTH);
+        ble_cmd_q_count--;
+        k_spin_unlock(&ble_cmd_lock, key);
+
+        if (local_len == 0U)
+        {
+            DBG_ERR("[BLE RX] worker: empty\r\n");
+            continue;
+        }
+
+        ble_cmd_dispatch(local_buf, local_len);
+    }
+}
+
+/* BLE RX 명령 처리 queue 초기화 */
+void ble_cmd_queue_init(void)
+{
+    k_work_init(&ble_cmd_work, ble_cmd_work_handler);
+    k_work_queue_start(&ble_cmd_work_q, ble_cmd_workq_stack, K_THREAD_STACK_SIZEOF(ble_cmd_workq_stack), BLE_CMD_WORKQ_PRIORITY, NULL);
+}
+
+/* BLE RX 콜백에서 호출되는 명령 enqueue 함수 */
+void ble_cmd_queue_rx_handler(const uint8_t *data, uint16_t len)
+{
+    if (len > BLE_CMD_MAX_LEN)
+    {
+        DBG_ERR("[BLE RX] drop: len=%u exceeds %d\r\n", len, BLE_CMD_MAX_LEN);
+        return;
+    }
+
+    k_spinlock_key_t key = k_spin_lock(&ble_cmd_lock);
+    if (ble_cmd_q_count >= BLE_CMD_QUEUE_DEPTH)
+    {
+        k_spin_unlock(&ble_cmd_lock, key);
+        DBG_ERR("[BLE RX] drop: queue full\r\n");
+        return;
+    }
+
+    memcpy(ble_cmd_q_buf[ble_cmd_q_tail], data, len);
+    ble_cmd_q_len[ble_cmd_q_tail] = len;
+    ble_cmd_q_tail = (uint8_t)((ble_cmd_q_tail + 1U) % BLE_CMD_QUEUE_DEPTH);
+    ble_cmd_q_count++;
+    k_spin_unlock(&ble_cmd_lock, key);
+
+    int err = k_work_submit_to_queue(&ble_cmd_work_q, &ble_cmd_work);
+    if (err < 0)
+    {
+        DBG_ERR("[BLE RX] queue submit fail err=%d\r\n", err);
+    }
+}

src/command/ble_cmd_queue.h

@@ -0,0 +1,13 @@
+/*******************************************************************************
+ * @file    ble_cmd_queue.h
+ * @brief   BLE RX command queue
+ ******************************************************************************/
+#ifndef BLE_CMD_QUEUE_H__
+#define BLE_CMD_QUEUE_H__
+
+#include <stdint.h>
+
+void ble_cmd_queue_init(void);
+void ble_cmd_queue_rx_handler(const uint8_t *data, uint16_t len);
+
+#endif /* BLE_CMD_QUEUE_H__ */

src/command/cmd_common.c

@@ -4,6 +4,7 @@
  ******************************************************************************/
 #include <zephyr/kernel.h>
 #include <zephyr/sys/reboot.h>
+#include <zephyr/sys/util.h>
 #include <string.h>
 
 #include "cmd_common.h"
@@ -22,6 +23,14 @@ static uint8_t tx_id_buf[4 + HW_NO_LENGTH + SERIAL_NO_LENGTH + SERIAL_NO_LENGTH
 static uint8_t tx_rim_buf[4 + 2 + (IMU_FIFO_RIM_TARGET_SAMPLES * IMU_FIFO_SAMPLE_BYTES) + 2];
 static uint8_t g_echo_session;
 
+/* ATT MTU에 따른 패킷 분할 */
+#define ATT_NOTIFY_HEADER_SIZE 3U
+#define REB_OVERHEAD_SIZE      10U
+#define REC_OVERHEAD_SIZE      14U
+#define ECHO_SAMPLE_SIZE       2U
+#define RIM_OVERHEAD_SIZE      8U
+#define RIC_OVERHEAD_SIZE      12U
+
 uint8_t cmd_next_echo_session(void)
 {
     return g_echo_session++;
@@ -185,7 +194,27 @@ int cmd_send_response_imu(const int16_t accel[3], const int16_t gyro[3])
     return ble_data_send(buf, 18);
 }
 
-void cmd_send_response_echo(uint8_t session, uint8_t channel, const uint16_t *samples, uint16_t num_samples)
+/* ATT MTU에 따라 패킷 분할이 필요한지 계산 */
+static uint16_t calc_rec_samples_per_packet(uint16_t notify_payload_max)
+{
+    uint16_t samples_per_pkt = 1U;
+
+    // rec:는 고정 오버헤드가 14B, chunk 크기 다시 계산
+    if (notify_payload_max > REC_OVERHEAD_SIZE)
+    {
+        samples_per_pkt = (uint16_t)((notify_payload_max - REC_OVERHEAD_SIZE) / ECHO_SAMPLE_SIZE);
+    }
+
+    // 방어코드
+    if (samples_per_pkt == 0U)
+    {
+        samples_per_pkt = 1U;
+    }
+
+    return samples_per_pkt;
+}
+
+static void cmd_send_response_echo_reb(uint8_t session, uint8_t channel, const uint16_t *samples, uint16_t num_samples)
 {
     // 정적 버퍼 사용 (한 번에 한 명령만 처리)
     uint8_t *buf = tx_echo_buf;
@@ -210,6 +239,87 @@ void cmd_send_response_echo(uint8_t session, uint8_t channel, const uint16_t *sa
     ble_data_send(buf, payload_len + 2);
 }
 
+/*
+* rec: packet layout:
+*   tag (4B): "rec:"
+*   session (1B): 측정 세션 번호
+*   channel (1B): piezo 채널 번호
+*   offset (2B): 전체 샘플 배열에서 시작 인덱스
+*   total_samples (2B): 전체 샘플 수
+*   chunk_samples (2B): 현재 패킷에 들어간 샘플 수
+*   sample data (N): Piezo ADC samples
+*   crc (2B): tag부터 sample data까지 CRC16
+*/
+static void cmd_send_response_echo_rec(uint8_t session, uint8_t channel, const uint16_t *samples, uint16_t num_samples, uint16_t samples_per_pkt)
+{
+    uint8_t *buf = tx_echo_buf;
+
+    for (uint16_t off = 0U; off < num_samples; off = (uint16_t)(off + samples_per_pkt))
+    {
+        uint16_t remain = (uint16_t)(num_samples - off);
+        uint16_t chunk_samples = MIN(samples_per_pkt, remain);
+
+        buf[0] = 'r'; buf[1] = 'e'; buf[2] = 'c'; buf[3] = ':';
+        buf[4] = session;
+        buf[5] = channel;
+        buf[6] = (uint8_t)(off >> 8);
+        buf[7] = (uint8_t)(off & 0xFF);
+        buf[8] = (uint8_t)(num_samples >> 8);
+        buf[9] = (uint8_t)(num_samples & 0xFF);
+        buf[10] = (uint8_t)(chunk_samples >> 8);
+        buf[11] = (uint8_t)(chunk_samples & 0xFF);
+
+        // 마지막 chunk는 samples_per_pkt보다 작을 수 있음
+        for (uint16_t i = 0U; i < chunk_samples; i++)
+        {
+            buf[12 + i * 2] = (uint8_t)(samples[off + i] >> 8);
+            buf[13 + i * 2] = (uint8_t)(samples[off + i] & 0xFF);
+        }
+
+        uint16_t payload_len = (uint16_t)(REC_OVERHEAD_SIZE - 2U + (chunk_samples * ECHO_SAMPLE_SIZE));
+        uint16_t crc = cmd_crc16_compute(buf, payload_len);
+        DBG_PRINTF("[CMD] rec tx ch=%u off=%u total=%u chunk=%u len=%u\r\n",
+                   channel, off, num_samples, chunk_samples, (uint16_t)(payload_len + 2U));
+
+        buf[payload_len] = (uint8_t)(crc & 0xFF);
+        buf[payload_len + 1U] = (uint8_t)(crc >> 8);
+
+        // ble_data_send()는 NUS sent 콜백을 기다리고 다음 chunk 전송
+        if (ble_data_send(buf, (uint16_t)(payload_len + 2U)) != 0)
+        {
+            break;
+        }
+    }
+}
+
+/* Piezo echo ADC 응답 패킷 */
+void cmd_send_response_echo(uint8_t session, uint8_t channel, const uint16_t *samples, uint16_t num_samples)
+{
+    uint16_t notify_payload_max = 0U;
+    uint16_t mtu = ble_current_mtu();
+    uint16_t reb_len = (uint16_t)(REB_OVERHEAD_SIZE + (num_samples * ECHO_SAMPLE_SIZE));
+
+    // 협상된 ATT MTU에서 최대 payload
+    if (mtu > ATT_NOTIFY_HEADER_SIZE)
+    {
+        notify_payload_max = (uint16_t)(mtu - ATT_NOTIFY_HEADER_SIZE);
+    }
+
+    // 분할이 필요 없는 경우(기존 reb: 패킷이 MTU 안에 들어가는 경우) reb: 응답
+    if ((notify_payload_max == 0U) || (reb_len <= notify_payload_max))
+    {
+        cmd_send_response_echo_reb(session, channel, samples, num_samples);
+        return;
+    }
+
+    // 기존 reb: 패킷이 현재 MTU 보다 큰 경우 rec:로 전환
+    uint16_t samples_per_pkt = calc_rec_samples_per_packet(notify_payload_max);
+
+    DBG_PRINTF("[CMD] rec split mtu=%u samples=%u chunk=%u\r\n", mtu, num_samples, samples_per_pkt);
+
+    cmd_send_response_echo_rec(session, channel, samples, num_samples, samples_per_pkt);
+}
+
 void cmd_send_response_bundle(uint16_t batt_mv, const int16_t accel[3], const int16_t gyro[3], int16_t temp_cdeg)
 {
     uint8_t *buf = tx_bundle_buf;
@@ -239,7 +349,7 @@ void cmd_send_response_bundle(uint16_t batt_mv, const int16_t accel[3], const in
     ble_data_send(buf, sizeof(tx_bundle_buf));
 }
 
-void cmd_send_response_rim(const uint8_t *sample_bytes, uint16_t sample_count)
+static void cmd_send_response_rim_legacy(const uint8_t *sample_bytes, uint16_t sample_count)
 {
     uint8_t *buf = tx_rim_buf;
     uint16_t payload_len;
@@ -261,9 +371,98 @@ void cmd_send_response_rim(const uint8_t *sample_bytes, uint16_t sample_count)
     buf[payload_len + 1U] = (uint8_t)(crc >> 8);
 
     DBG_PRINTF("[MTB] tx rim samples=%u len=%u\r\n", sample_count, (uint16_t)(payload_len + 2U));
+
     ble_data_send(buf, (uint16_t)(payload_len + 2U));
 }
 
+static uint16_t calc_ric_samples_per_packet(uint16_t notify_payload_max)
+{
+    if (notify_payload_max < (RIC_OVERHEAD_SIZE + IMU_FIFO_SAMPLE_BYTES))
+    {
+        return 0U;
+    }
+
+    return (uint16_t)((notify_payload_max - RIC_OVERHEAD_SIZE) / IMU_FIFO_SAMPLE_BYTES);
+}
+
+/*
+* ric: packet layout:
+*   tag (4B): "ric:"
+*   offset (2B): 전체 샘플 배열에서 시작 인덱스
+*   total_samples (2B): 전체 IMU FIFO 샘플 수
+*   chunk_samples (2B): 현재 패킷에 들어간 샘플 수
+*   sample data (N): IMU FIFO samples
+*   crc (2B): tag부터 sample data까지 CRC16
+*/
+static void cmd_send_response_rim_ric(const uint8_t *sample_bytes, uint16_t sample_count, uint16_t samples_per_pkt)
+{
+    uint8_t *buf = tx_rim_buf;
+
+    for (uint16_t off = 0U; off < sample_count; off = (uint16_t)(off + samples_per_pkt))
+    {
+        uint16_t remain = (uint16_t)(sample_count - off);
+        uint16_t chunk_samples = MIN(samples_per_pkt, remain);
+
+        buf[0] = 'r'; buf[1] = 'i'; buf[2] = 'c'; buf[3] = ':';
+        buf[4] = (uint8_t)(off >> 8);
+        buf[5] = (uint8_t)(off & 0xFF);
+        buf[6] = (uint8_t)(sample_count >> 8);
+        buf[7] = (uint8_t)(sample_count & 0xFF);
+        buf[8] = (uint8_t)(chunk_samples >> 8);
+        buf[9] = (uint8_t)(chunk_samples & 0xFF);
+
+        memcpy(&buf[10], &sample_bytes[off * IMU_FIFO_SAMPLE_BYTES], (size_t)chunk_samples * IMU_FIFO_SAMPLE_BYTES);
+
+        uint16_t payload_len = (uint16_t)(RIC_OVERHEAD_SIZE - 2U + (chunk_samples * IMU_FIFO_SAMPLE_BYTES));
+        uint16_t crc = cmd_crc16_compute(buf, payload_len);
+        DBG_PRINTF("[CMD] ric tx off=%u total=%u chunk=%u len=%u\r\n",
+                   off, sample_count, chunk_samples, (uint16_t)(payload_len + 2U));
+
+        buf[payload_len] = (uint8_t)(crc & 0xFF);
+        buf[payload_len + 1U] = (uint8_t)(crc >> 8);
+
+        if (ble_data_send(buf, (uint16_t)(payload_len + 2U)) != 0)
+        {
+            break;
+        }
+    }
+}
+
+void cmd_send_response_rim(const uint8_t *sample_bytes, uint16_t sample_count)
+{
+    uint16_t notify_payload_max = 0U;
+    uint16_t mtu = ble_current_mtu();
+
+    if (sample_count > IMU_FIFO_RIM_TARGET_SAMPLES)
+    {
+        sample_count = IMU_FIFO_RIM_TARGET_SAMPLES;
+    }
+
+    uint16_t rim_len = (uint16_t)(RIM_OVERHEAD_SIZE + (sample_count * IMU_FIFO_SAMPLE_BYTES));
+
+    if (mtu > ATT_NOTIFY_HEADER_SIZE)
+    {
+        notify_payload_max = (uint16_t)(mtu - ATT_NOTIFY_HEADER_SIZE);
+    }
+
+    if ((notify_payload_max == 0U) || (rim_len <= notify_payload_max))
+    {
+        cmd_send_response_rim_legacy(sample_bytes, sample_count);
+        return;
+    }
+
+    uint16_t samples_per_pkt = calc_ric_samples_per_packet(notify_payload_max);
+
+    if (samples_per_pkt == 0U)
+    {
+        DBG_ERR("[CMD] ric skip mtu=%u payload=%u samples=%u\r\n", mtu, notify_payload_max, sample_count);
+        return;
+    }
+
+    DBG_PRINTF("[CMD] ric split mtu=%u samples=%u chunk=%u\r\n", mtu, sample_count, samples_per_pkt);
+    cmd_send_response_rim_ric(sample_bytes, sample_count, samples_per_pkt);
+}
+
 void cmd_send_response_piezo_config(const char *tag, uint16_t freq, uint16_t cycles, uint16_t avg, uint16_t delay_us, uint16_t samples)
 {
     uint8_t *buf = tx_cfg_buf;

src/command/handlers/cmd_piezo.c

@@ -277,7 +277,7 @@ int cmd_maa(const uint8_t *data, uint8_t data_len)
 
     if (status == ECHO_STATUS_OK) // Piezo GPIO, power, ADC initialization/wake succeeded
     {
-        DBG_PRINTF("[MBB] piezo sweep start\r\n");
+        DBG_PRINTF("[MAA] piezo sweep start\r\n");
         status = piezo_measure_sweep();
         if (status == ECHO_STATUS_OK)
         {

src/debug_print.h

@@ -14,8 +14,14 @@
  */
 #include <zephyr/sys/printk.h>
 
+#if defined(CONFIG_VESIS_DEBUG_PRINT)
 #define DBG_PRINTF(...) printk(__VA_ARGS__)
 #define DBG_CORE(...)   printk(__VA_ARGS__)
 #define DBG_ERR(...)    printk(__VA_ARGS__)
+#else
+#define DBG_PRINTF(...) do { } while (0)
+#define DBG_CORE(...)   printk(__VA_ARGS__)
+#define DBG_ERR(...)    printk(__VA_ARGS__)
+#endif
 
 #endif /* DEBUG_PRINT_H */

src/dfu/dfu_manager.c

@@ -0,0 +1,238 @@
+/*******************************************************************************
+ * @file    dfu_manager.c
+ * @brief   DFU state, watchdog, and MCUboot image control
+ ******************************************************************************/
+#include <zephyr/kernel.h>
+#include <zephyr/dfu/mcuboot.h>
+#include <zephyr/mgmt/mcumgr/mgmt/callbacks.h>
+#include <hal/nrf_power.h>
+
+#include "main.h"
+#include "dfu_manager.h"
+#include "debug_print.h"
+#include "led_control.h"
+#include "ble_service.h"
+
+#define DFU_STALL_TIMEOUT_SEC   30      // DFU upload stall disconnect threshold
+#define IMG_MGMT_ID_STATE       0U
+#define IMG_MGMT_ID_UPLOAD      1U
+
+static bool dfu_led_active;                       // DFU upload green LED state
+static struct k_work_delayable dfu_watchdog_work; // DFU upload stall watchdog
+
+static void dfu_watchdog_handler(struct k_work *work);
+
+static enum mgmt_cb_return dfu_status_cb(uint32_t event,
+                                         enum mgmt_cb_return prev_status,
+                                         int32_t *rc,
+                                         uint16_t *group,
+                                         bool *abort_more,
+                                         void *data,
+                                         size_t data_size);
+
+static enum mgmt_cb_return smp_cmd_status_cb(uint32_t event,
+                                             enum mgmt_cb_return prev_status,
+                                             int32_t *rc,
+                                             uint16_t *group,
+                                             bool *abort_more,
+                                             void *data,
+                                             size_t data_size);
+
+static struct mgmt_callback dfu_status_callback = {
+    .callback = dfu_status_cb,
+    .event_id = MGMT_EVT_OP_IMG_MGMT_DFU_STARTED |
+                MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK |
+                MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK_WRITE_COMPLETE |
+                MGMT_EVT_OP_IMG_MGMT_DFU_PENDING |
+                MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED,
+};
+
+static struct mgmt_callback smp_cmd_status_callback = {
+    .callback = smp_cmd_status_cb,
+    .event_id = MGMT_EVT_OP_CMD_DONE,
+};
+
+/* DFU watchdog와 mcumgr 콜백 초기화 */
+void dfu_manager_init(void)
+{
+    k_work_init_delayable(&dfu_watchdog_work, dfu_watchdog_handler);
+    mgmt_callback_register(&dfu_status_callback);
+    mgmt_callback_register(&smp_cmd_status_callback);
+}
+
+/* 현재 이미지가 confirm 대기 상태인지 확인 */
+bool dfu_is_confirm_pending_boot(void)
+{
+#if defined(CONFIG_BOOTLOADER_MCUBOOT)
+    return !boot_is_img_confirmed();
+#else
+    return false;
+#endif
+}
+
+/* 실행 중 이미지 confirm 처리 */
+void dfu_confirm_running_image(void)
+{
+#if defined(CONFIG_BOOTLOADER_MCUBOOT)
+    if (!boot_is_img_confirmed())
+    {
+        int err = boot_write_img_confirmed();
+        if (err == 0)
+        {
+            DBG_CORE("[DFU] Running image confirmed\r\n");
+        }
+        else
+        {
+            DBG_ERR("[DFU] Image confirm failed (err %d)\r\n", err);
+        }
+    }
+    else
+    {
+        DBG_CORE("[DFU] Running image already confirmed\r\n");
+    }
+#endif
+}
+
+/* MCUboot swap 상태 문자열 변환 */
+static const char *swap_type_to_str(int swap_type)
+{
+    switch (swap_type)
+    {
+        case BOOT_SWAP_TYPE_NONE:
+            return "none";
+        case BOOT_SWAP_TYPE_TEST:
+            return "test";
+        case BOOT_SWAP_TYPE_PERM:
+            return "perm";
+        case BOOT_SWAP_TYPE_REVERT:
+            return "revert";
+        case BOOT_SWAP_TYPE_FAIL:
+            return "fail";
+        default:
+            return "unknown";
+    }
+}
+
+/* MCUboot 이미지 상태 로그 출력 */
+void dfu_log_mcuboot_state(void)
+{
+#if defined(CONFIG_BOOTLOADER_MCUBOOT)
+    struct mcuboot_img_header header;
+    uint8_t active_slot = boot_fetch_active_slot();
+    int swap_type = mcuboot_swap_type();
+    int err = boot_read_bank_header(active_slot, &header, sizeof(header));
+
+    DBG_CORE("[DFU] active_slot=%u swap_type=%s(%d) confirmed=%d\r\n",
+             active_slot,
+             swap_type_to_str(swap_type),
+             swap_type,
+             boot_is_img_confirmed());
+
+    if (err == 0)
+    {
+        DBG_CORE("[DFU] image version %u.%u.%u+%u size=0x%x\r\n",
+                 header.h.v1.sem_ver.major,
+                 header.h.v1.sem_ver.minor,
+                 header.h.v1.sem_ver.revision,
+                 header.h.v1.sem_ver.build_num,
+                 header.h.v1.image_size);
+    }
+    else
+    {
+        DBG_ERR("[DFU] image header read failed (slot %u, err %d)\r\n",
+                active_slot,
+                err);
+    }
+#endif
+}
+
+/* DFU 업로드 무진행 시 BLE 연결 강제 해제 */
+static void dfu_watchdog_handler(struct k_work *work)
+{
+    ARG_UNUSED(work);
+
+    if (ble_is_connected())
+    {
+        DBG_CORE("[DFU] upload stalled (%ds), forcing disconnect\r\n", DFU_STALL_TIMEOUT_SEC);
+        (void)ble_disconnect_active();
+    }
+}
+
+/* DFU 업로드 상태에 따라 LED와 watchdog 제어 */
+static enum mgmt_cb_return dfu_status_cb(uint32_t event, enum mgmt_cb_return prev_status, int32_t *rc, uint16_t *group, bool *abort_more, void *data, size_t data_size)
+{
+    ARG_UNUSED(prev_status);
+    ARG_UNUSED(rc);
+    ARG_UNUSED(group);
+    ARG_UNUSED(abort_more);
+    ARG_UNUSED(data);
+    ARG_UNUSED(data_size);
+
+    switch (event)
+    {
+        case MGMT_EVT_OP_IMG_MGMT_DFU_STARTED:
+        case MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK:
+        case MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK_WRITE_COMPLETE:
+            dfu_led_active = true;
+            led_ble_solid();
+            k_work_reschedule(&dfu_watchdog_work, K_SECONDS(DFU_STALL_TIMEOUT_SEC));
+            break;
+
+        case MGMT_EVT_OP_IMG_MGMT_DFU_PENDING:
+            dfu_led_active = true;
+            led_ble_solid();
+            k_work_cancel_delayable(&dfu_watchdog_work);
+
+#if NRF_POWER_HAS_GPREGRET
+            nrf_power_gpregret_set(NRF_POWER, DFU_RESUME_GPREGRET_REG, DFU_RESUME_MAGIC);
+#endif
+            break;
+
+        case MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED:
+            k_work_cancel_delayable(&dfu_watchdog_work);
+            if (dfu_led_active)
+            {
+                dfu_led_active = false;
+                led_set_state(LED_STATE_ADVERTISING);
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    return MGMT_CB_OK;
+}
+
+/* DFU 명령 실패 시 LED와 resume 플래그 복구 */
+static enum mgmt_cb_return smp_cmd_status_cb(uint32_t event, enum mgmt_cb_return prev_status, int32_t *rc, uint16_t *group, bool *abort_more, void *data, size_t data_size)
+{
+    ARG_UNUSED(event);
+    ARG_UNUSED(prev_status);
+    ARG_UNUSED(rc);
+    ARG_UNUSED(group);
+    ARG_UNUSED(abort_more);
+
+    if (data == NULL || data_size != sizeof(struct mgmt_evt_op_cmd_arg))
+    {
+        return MGMT_CB_OK;
+    }
+
+    const struct mgmt_evt_op_cmd_arg *cmd = data;
+
+    if (cmd->group == MGMT_GROUP_ID_IMAGE &&
+        (cmd->id == IMG_MGMT_ID_UPLOAD || cmd->id == IMG_MGMT_ID_STATE) &&
+        cmd->err != MGMT_ERR_EOK)
+    {
+        DBG_ERR("[DFU] command failed id=%u err=%d\r\n", cmd->id, cmd->err);
+
+        dfu_led_active = false;
+        led_set_state(LED_STATE_ADVERTISING);
+
+#if NRF_POWER_HAS_GPREGRET
+        nrf_power_gpregret_set(NRF_POWER, DFU_RESUME_GPREGRET_REG, 0U);
+#endif
+    }
+
+    return MGMT_CB_OK;
+}

src/dfu/dfu_manager.h

@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * @file    dfu_manager.h
+ * @brief   DFU state, watchdog, and MCUboot image control
+ ******************************************************************************/
+#ifndef DFU_MANAGER_H__
+#define DFU_MANAGER_H__
+
+#include <stdbool.h>
+
+#define DFU_RESUME_MAGIC        0xD5U
+#define DFU_RESUME_GPREGRET_REG 1U
+
+void dfu_manager_init(void);
+bool dfu_is_confirm_pending_boot(void);
+void dfu_confirm_running_image(void);
+void dfu_log_mcuboot_state(void);
+
+#endif /* DFU_MANAGER_H__ */

src/drivers/imu/imu_i2c.c

@@ -687,9 +687,7 @@ int imu_fifo_read_latest(uint8_t *sample_bytes,
     }
 
     {
-        uint16_t raw_count = record_count;
         record_count = imu_fifo_compact_records(record_count);
-        DBG_PRINTF("[IMU FIFO] compact %u -> %u\r\n", raw_count, record_count);
     }
     if (record_count > max_samples)
     {

src/main.c

@@ -1,65 +1,31 @@
 /*******************************************************************************
  * @file    main.c
  * @brief   VesiScan-Basic
+ * 
+ * - 앱 공통 전역 상태 보관
+ * - 부팅 직후 전원 유지 판단
+ * - NVS 로드 전 기본값 초기화
+ * - 각 모듈 초기화 순서 조립
+ * - main loop 유지
  ******************************************************************************/
 
 #include <zephyr/kernel.h>
-#include <zephyr/drivers/gpio.h>
 #include <zephyr/sys/printk.h>
-#include <zephyr/sys/reboot.h>
-#include <zephyr/dfu/mcuboot.h>
-#include <zephyr/mgmt/mcumgr/mgmt/callbacks.h>
 #include <hal/nrf_power.h>
-#if IS_ENABLED(CONFIG_BT_SMP)
-#include <zephyr/bluetooth/bluetooth.h>
-#include <zephyr/bluetooth/conn.h>
-#endif
 
 #include "main.h"
 #include "debug_print.h"
 #include "power_control.h"
+#include "dfu_manager.h"
 #include "led_control.h"
 #include "ble_service.h"
 #include "battery_adc.h"
-#include "parser.h"
+#include "ble_cmd_queue.h"
 #include "imu_i2c.h"
 #include "piezo_measure.h"
 
 LOG_MODULE_REGISTER(vesiscan, LOG_LEVEL_INF);
 
-#define BLE_CMD_MAX_LEN         256
-#define BLE_CMD_WORKQ_STACK_SZ  8192
-#define DFU_RESUME_MAGIC        0xD5U
-#define DFU_RESUME_GPREGRET_REG 1U
-#define DFU_STALL_TIMEOUT_SEC   30      // DFU 업로드 무진행 시 강제 disconnect 임계
-#define IMG_MGMT_ID_STATE       0U
-#define IMG_MGMT_ID_UPLOAD      1U
-/*
- * BLE 명령 처리 스택
- * - piezo sweep
- * - ADC capture
- * - BLE 응답 패킷 조립
- * - 디버깅 여유분 포함
- */
-#define BLE_CMD_WORKQ_PRIORITY  10
-
-/* Devicetree GPIO Settings */
-#define POWER_HOLD_NODE  DT_NODELABEL(pwr_hold)         // 전원 래치
-#define POWER_BTN_NODE   DT_NODELABEL(button_check)     // 전원 버튼
-
-/* 전원 버튼 상태머신 (5ms 폴링)  */
-#define BOOT_THRESHOLD  350   // 5ms x 400 = 2초 -> 초기화 시간 고려 체감상 2초에 맞춤
-#define BOND_RESET_THRESHOLD    (15000 / POWER_ON_DELAY)   // 전원 ON 상태에서 15초 롱프레스 → 본드 삭제
-
-/* 전원 제어 GPIO */
-static const struct gpio_dt_spec power_hold = GPIO_DT_SPEC_GET(POWER_HOLD_NODE, gpios);
-static const struct gpio_dt_spec power_btn  = GPIO_DT_SPEC_GET(POWER_BTN_NODE, gpios);
-
-/* Timer */
-static struct k_timer m_power_on_delay_timer;   // 전원 버튼 폴링용 (5ms 싱글샷)
-static struct k_timer m_power_off_delay_timer;  // 전원 OFF 지연용 (3초 후 전원 차단)
-
-/* 전역 변수 */
 volatile bool ble_connection_st = false;    // BLE 연결 상태
 volatile bool processing = false;           // 센서 데이터 처리 중 플래그
 bool bond_data_delete = true;               // 본딩 데이터 삭제 요청
@@ -70,193 +36,23 @@ char HW_NO[HW_NO_BUF_SIZE];                 // 하드웨어 번호
 char m_static_passkey[PASSKEY_BUF_SIZE];    // BLE 정적 패스키
 uint8_t m_passkey_changed;                  // 패스키 변경은 출고 후 1회만 허용
 
-static uint16_t cnt_s;                      // 전원 버튼 폴링 카운터 (5ms 단위)
-static bool device_on = false;              // 디바이스 전원 상태 (래치 완료 여부)
-static bool boot_btn_released = false;      // 부팅 후 버튼 놓았는지 여부
-static bool power_btn_suspended;            // 측정 중 전원 버튼 상태머신 일시 정지
-
-/*
- * BLE advertising 제어용 워크 아이템
- * - main_s()에서 k_work_submit()으로 예약하여 사용
- */
 static bool resume_without_power_button;    // 리셋 후 버튼 없이 복귀
 static bool dfu_confirm_pending_boot;       // DFU test 이미지 확인 전 자동 복귀
 static bool dfu_reset_resume_request;       // DFU 완료 리셋 후 자동 복귀
 static uint32_t boot_reset_reason;          // RESETREAS 원본 값
-static struct k_work adv_start_work;        // advertising 시작 work
-static struct k_work adv_stop_work;         // advertising 중지 work
-static struct k_work bond_reset_work;       // 전원 버튼 15초 롱프레스 본드 삭제 work
-static bool dfu_led_active;                 // DFU 업로드 중 초록 LED ON
-static const char *power_off_pending_reason = "none";
-static bool bond_reset_pending;             // 본드 삭제 work 중복 예약 방지
-static struct k_work_delayable dfu_watchdog_work;   // DFU 업로드 무진행 감시 work
-static void dfu_watchdog_handler(struct k_work *work);
 
-static enum mgmt_cb_return dfu_status_cb(uint32_t event,
-                                         enum mgmt_cb_return prev_status,
-                                         int32_t *rc,
-                                         uint16_t *group,
-                                         bool *abort_more,
-                                         void *data,
-                                         size_t data_size);
-
-static enum mgmt_cb_return smp_cmd_status_cb(uint32_t event,
-                                             enum mgmt_cb_return prev_status,
-                                             int32_t *rc,
-                                             uint16_t *group,
-                                             bool *abort_more,
-                                             void *data,
-                                             size_t data_size);
-
-static struct mgmt_callback dfu_status_callback = {
-    .callback = dfu_status_cb,
-    .event_id = MGMT_EVT_OP_IMG_MGMT_DFU_STARTED |
-                MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK |
-                MGMT_EVT_OP_IMG_MGMT_DFU_PENDING |
-                MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED,
-};
-
-static struct mgmt_callback smp_cmd_status_callback = {
-    .callback = smp_cmd_status_cb,
-    .event_id = MGMT_EVT_OP_CMD_DONE,
-};
-
-/*
- * BLE RX 콜백 안에서 무거운 일을 바로 처리하지 않기 위해 별도 work queue를 둠
- * - 명령 하나가 끝날 때까지 다음 명령 drop : 확인 필요
- */
-static struct k_work_q ble_cmd_work_q;
-K_THREAD_STACK_DEFINE(ble_cmd_workq_stack, BLE_CMD_WORKQ_STACK_SZ);
-static struct k_work ble_cmd_work;          // BLE 명령 처리 work
-static struct k_spinlock ble_cmd_lock;      // RX 공유 버퍼 보호
-static uint8_t ble_cmd_buf[BLE_CMD_MAX_LEN];// RX 명령 복사 버퍼
-static uint16_t ble_cmd_len;                // RX 명령 길이
-static bool ble_cmd_pending;                // 처리 대기 명령 있음
-
-static void ble_cmd_work_handler(struct k_work *work)
-{
-    ARG_UNUSED(work);
-
-    // work queue 로컬 복사본
-    uint8_t local_buf[BLE_CMD_MAX_LEN];
-    uint16_t local_len = 0U;
-
-    // 공유 RX 명령 슬롯 보호: 현재 구조는 한 번에 한 명령만 보관
-    k_spinlock_key_t key = k_spin_lock(&ble_cmd_lock);
-    if (ble_cmd_pending)
-    {
-        local_len = ble_cmd_len;
-        memcpy(local_buf, ble_cmd_buf, local_len);
-    }
-    k_spin_unlock(&ble_cmd_lock, key);
-
-    if (local_len == 0U)
-    {
-        DBG_ERR("[BLE RX] worker: empty\r\n");
-        return;
-    }
-
-    // 일반 스레드 문맥 명령 처리
-    //DBG_CORE("[BLE RX] worker dispatch len=%u\r\n", local_len);
-    ble_cmd_dispatch(local_buf, local_len);
-
-    // 명령 처리 완료 표시
-    key = k_spin_lock(&ble_cmd_lock);
-    ble_cmd_pending = false;
-    ble_cmd_len = 0U;
-    k_spin_unlock(&ble_cmd_lock, key);
-}
-
-/* 시스템 워크큐에서 BLE advertising 시작 */
-static void adv_start_work_handler(struct k_work *work)
-{
-    ARG_UNUSED(work);
-    ble_advertising_start();
-}
-
-/* 시스템 워크큐에서 BLE advertising 중지 */
-static void adv_stop_work_handler(struct k_work *work)
-{
-    ARG_UNUSED(work);
-    ble_advertising_stop();
-}
-
-/* 전원 버튼 15초 롱프레스: BLE 본드 삭제 후 리부트 */
-static void bond_reset_work_handler(struct k_work *work)
-{
-    ARG_UNUSED(work);
-
-    DBG_ERR("[BTN] 15s long press -> BLE bond reset\r\n");
-    battery_timer_stop();
-    ble_advertising_stop();
-
-#if IS_ENABLED(CONFIG_BT_SMP)
-    int err = bt_unpair(BT_ID_DEFAULT, NULL);
-    if (err)
-    {
-        DBG_ERR("[BTN] bt_unpair failed err=%d\r\n", err);
-    }
-    else
-    {
-        bond_data_delete = true;
-        DBG_PRINTF("[BTN] BLE bond data deleted\r\n");
-    }
-#else
-    bond_data_delete = true;
-    DBG_PRINTF("[BTN] BLE bond delete skipped (BT_SMP disabled)\r\n");
-#endif
-
-    led_set_state(LED_STATE_BOND_DELETE); // 삭제 완료 확인 주황 LED ON
-    k_msleep(1500);
-    sys_reboot(SYS_REBOOT_COLD);
-}
-
-/* BLE RX 콜백 */
-static void ble_rx_handler(const uint8_t *data, uint16_t len)
-{
-    if (len > BLE_CMD_MAX_LEN)
-    {
-        DBG_ERR("[BLE RX] drop: len=%u exceeds %d\r\n", len, BLE_CMD_MAX_LEN);
-        return;
-    }
-
-    // 공유 RX 명령 슬롯 보호: 현재 구조는 한 번에 한 명령만 보관
-    k_spinlock_key_t key = k_spin_lock(&ble_cmd_lock);
-    if (ble_cmd_pending)
-    {
-        k_spin_unlock(&ble_cmd_lock, key);
-        DBG_ERR("[BLE RX] drop: command busy\r\n");
-        return;
-    }
-
-    // 명령 버퍼 복사
-    memcpy(ble_cmd_buf, data, len);
-    ble_cmd_len = len;
-    ble_cmd_pending = true;
-    k_spin_unlock(&ble_cmd_lock, key);
-
-    // 명령 처리 work 예약
-    int err = k_work_submit_to_queue(&ble_cmd_work_q, &ble_cmd_work);
-    if (err < 0)
-    {
-        // 예약 실패 시 pending 복구
-        key = k_spin_lock(&ble_cmd_lock);
-        ble_cmd_pending = false;
-        ble_cmd_len = 0U;
-        k_spin_unlock(&ble_cmd_lock, key);
-        DBG_ERR("[BLE RX] queue submit fail err=%d\r\n", err);
-    }
-}
-
-/* 전원 유지 (POWER_HOLD) 제어 */
+/* 부팅 후 전원 유지 판단 및 모듈 초기화 순서 조립 */
 static void boot_context_detect(void)
 {
     // 부팅 원인 확인
     boot_reset_reason = nrf_power_resetreas_get(NRF_POWER);
 
-    // DFU 완료 직후 리셋인지 확인
+    // DFU rest (DFU 완료 후 재부팅)
+    // GPREGRET은 reset 후에도 유지되는 작은 상태 표시용 레지스터
 #if NRF_POWER_HAS_GPREGRET
     dfu_reset_resume_request = (nrf_power_gpregret_get(NRF_POWER, DFU_RESUME_GPREGRET_REG) == DFU_RESUME_MAGIC);
+
+    // DFU reset 표시 확인 후 다음 부팅 오판 방지를 위해 정리
     if (dfu_reset_resume_request)
     {
         nrf_power_gpregret_set(NRF_POWER, DFU_RESUME_GPREGRET_REG, 0U);
@@ -265,81 +61,42 @@ static void boot_context_detect(void)
     dfu_reset_resume_request = false;
 #endif
 
-    // 소프트 리셋 계열 자동 복귀
+    // soft reset 후 복귀 (전원 버튼 새 부팅 X)
     resume_without_power_button = (boot_reset_reason & (NRF_POWER_RESETREAS_SREQ_MASK | NRF_POWER_RESETREAS_DOG_MASK | NRF_POWER_RESETREAS_LOCKUP_MASK | NRF_POWER_RESETREAS_RESETPIN_MASK)) != 0U;
 
+    // 다음 부팅 오판 방지를 위해 RESETREAS 플래그 정리
     if (boot_reset_reason != 0U)
     {
-        // RESETREAS 플래그 정리
         nrf_power_resetreas_clear(NRF_POWER, boot_reset_reason);
     }
 }
 
-static void power_hold_init(void)
-{
-#if defined(CONFIG_BOOTLOADER_MCUBOOT)
-    // DFU 이미지 확인 전 전원 유지
-    dfu_confirm_pending_boot = !boot_is_img_confirmed();
-#else
-    dfu_confirm_pending_boot = false;
-#endif
-
-    // 리셋 복귀/DFU 확인 대기 시 즉시 래치
-    gpio_pin_configure_dt(&power_hold, (resume_without_power_button || dfu_confirm_pending_boot || dfu_reset_resume_request) ? GPIO_OUTPUT_ACTIVE : GPIO_OUTPUT_INACTIVE);
-}
-
-/* 전원 ON/OFF 제어 - P0.08 핀으로 물리적 전원 래치/해제 */
-static void power_control_handler(on_off_cont_t device_power_st, const char *reason)
-{
-    if (device_power_st == OFF)
-    {
-        DBG_ERR("[PWR] OFF latch release reason=%s pending=%s device_on=%u btn=%d cnt=%u suspended=%u dfu_adv=%u dfu_confirm=%u dfu_resume=%u\r\n",
-                reason ? reason : "unknown",
-                power_off_pending_reason,
-                device_on ? 1U : 0U,
-                gpio_pin_get_dt(&power_btn),
-                cnt_s,
-                power_btn_suspended ? 1U : 0U,
-                ble_dfu_advertising_is_enabled() ? 1U : 0U,
-                dfu_confirm_pending_boot ? 1U : 0U,
-                dfu_reset_resume_request ? 1U : 0U);
-        gpio_pin_set_dt(&power_hold, 0);    // P0.08 LOW → 전원 래치 해제 → 전원 차단
-    }
-    else
-    {
-        gpio_pin_set_dt(&power_hold, 1);    // P0.08 HIGH → 전원 유지
-    }
-}
-
-/* GPIO 초기화 */
-static void gpio_init(void)
-{
-    gpio_pin_configure_dt(&power_btn, GPIO_INPUT);  // 전원 버튼(P1.08) 입력 설정
-    DBG_PRINTF("[INIT] HW - GPIO OK (POWER BTN=%d)\r\n", gpio_pin_get_dt(&power_btn));
-
-}
-
-/* 기본 설정값 로드 */
+/* NVS 값이 없을 때 사용할 기본값 초기화 (앱 전역 상태 기본값) - NVS 값이 있는 경우 이후 NVS 값으로 덮어씀 */
 static void load_default_config(void)
 {
-    // 기본 문자열 길이 제한
+    // 기본 문자열 길이 계산
     size_t serial_len = strlen(SERIAL_NUMBER);
     size_t hw_len = strlen(HARDWARE_VERSION);
     size_t passkey_len = strlen(DEFAULT_PASSKEY);
 
+    // 버퍼 오버플로우 방지 - 기본 문자열 길이 제한 (긴 경우 잘라내기)
     if (serial_len > SERIAL_NO_LENGTH)
     {
         serial_len = SERIAL_NO_LENGTH;
     }
+
     if (hw_len > HW_NO_LENGTH)
     {
         hw_len = HW_NO_LENGTH;
     }
+
     if (passkey_len > PASSKEY_LENGTH)
     {
         passkey_len = PASSKEY_LENGTH;
     }
 
+    // 복사할 때 버퍼를 먼저 0으로 채우고 복사 -> 문자열 종료 NUL 보장
+    // 기본 Serial Number 복사
     memset(SERIAL_NO, 0, sizeof(SERIAL_NO));
     memcpy(SERIAL_NO, SERIAL_NUMBER, serial_len);
 
@@ -351,429 +108,54 @@ static void load_default_config(void)
     memset(m_static_passkey, 0, sizeof(m_static_passkey));
     memcpy(m_static_passkey, DEFAULT_PASSKEY, passkey_len);
 
-    // NVS 로드 전 기본값은 변경 가능 상태
-    m_passkey_changed = 0U;
+    m_passkey_changed = 0U;  // 패스키 변경 여부 초기화
 
-    // 기본 상태값
-    m_reset_status = 1;
-    bond_data_delete = true;
+    m_reset_status = 1;      // 기본 reset 상태 코드 설정
+    bond_data_delete = true; // 기본 상태는 bond 삭제 완료 삭제로 초기화
 
     DBG_CORE("[INIT] Default (S/N=%s)\r\n", SERIAL_NO);
 }
 
-/* 전원 OFF 타임아웃 콜백 */
-static void t_power_off_timeout_handler(struct k_timer *timer)
-{
-    ARG_UNUSED(timer);
-    DBG_ERR("[PWR] OFF timeout reason=%s\r\n", power_off_pending_reason);
-    led_set_state(LED_STATE_OFF);
-    power_control_handler(OFF, "off-timeout");
-}
-
-/* 슬립 모드 / 전원 OFF: LED 표시 후 3초 뒤 전원 차단 */
-static void power_off_schedule(const char *reason, led_state_t led_state)
-{
-    power_off_pending_reason = reason ? reason : "unknown";
-    //DBG_ERR("[PWR] OFF scheduled reason = %s\r\n", power_off_pending_reason);
-    led_set_state(led_state);
-    k_timer_start(&m_power_off_delay_timer, K_MSEC(POWER_OFF_DELAY), K_NO_WAIT);
-}
-
-void sleep_mode_enter_reason(const char *reason)
-{
-    power_off_schedule(reason, LED_STATE_POWER_ON);
-}
-
-void sleep_mode_enter(void)
-{
-    sleep_mode_enter_reason("sleep_mode_enter");
-}
-
-void device_power_off(void)
-{
-    device_power_off_reason("device_power_off");
-}
-
-void device_power_off_reason(const char *reason)
-{
-    power_off_schedule(reason, LED_STATE_POWER_OFF);
-}
-
-void device_power_keep_on(void)
-{
-    k_timer_stop(&m_power_off_delay_timer);
-    device_on = true;
-    boot_btn_released = (gpio_pin_get_dt(&power_btn) != 1);
-    cnt_s = 0;
-    power_control_handler(ON, "keep-on");
-}
-
-void power_button_suspend(bool suspend)
-{
-    // 측정 시간이 긴 커맨드 처리 중에만 버튼 폴링 판단 잠시 멈춤
-    power_btn_suspended = suspend;
-    cnt_s = 0;
-}
-
-static void main_s(struct k_timer *timer)
-{
-    ARG_UNUSED(timer);
-
-    bool button_pressed = (gpio_pin_get_dt(&power_btn) == 1);
-
-    if (power_btn_suspended)
-    {
-        k_timer_start(&m_power_on_delay_timer, K_MSEC(POWER_ON_DELAY), K_NO_WAIT);
-        return;
-    }
-
-    // 부팅 시퀀스 (OFF → ON)
-    if (!device_on)
-    {
-        if (!button_pressed)    // 버튼 놓음 → 2초 미만이면 전원 OFF
-        {
-            //DBG_PRINTF("[BTN] Short press (%d) -> OFF\r\n", cnt_s);
-            power_control_handler(OFF, "boot-button-released-before-latch");
-            cnt_s = 0;
-        }
-        else    // 버튼 계속 누르고 있음
-        {
-            cnt_s++;
-
-            if (cnt_s == BOOT_THRESHOLD)    // 2초 도달: 래치 + 부팅 완료
-            {
-                device_on = true;
-                // cnt_s는 리셋하지 않음: 부팅 누름을 놓기 전(!boot_btn_released)까지 15초 본드 삭제 카운트를 연속 유지(놓는 순간 아래 분기에서 0으로 리셋)
-                power_control_handler(ON, "button-2s-latch");
-                led_set_state(LED_STATE_ADVERTISING);
-                k_work_submit(&adv_start_work);
-                battery_timer_start();
-                m_reset_status = 1;
-            }
-        }
-    }
-    /* 전원 OFF 시퀀스 (ON → OFF) */
-    else
-    {
-        if (!boot_btn_released) // 부팅 때 누른 버튼을 아직 안 놓음
-        {
-            if (!button_pressed) // 놓음 → 이후부터 새 누름을 전원 OFF로 인식
-            {
-                boot_btn_released = true;
-                cnt_s = 0;
-            }
-            else // 전원 ON부터 계속 유지 중 → 15초 넘으면 본드 삭제 + 리부트
-            {
-                cnt_s++;
-
-                if ((cnt_s >= BOND_RESET_THRESHOLD) && !bond_reset_pending)
-                {
-                    bond_reset_pending = true;
-                    k_work_submit(&bond_reset_work);
-                    return;
-                }
-            }
-        }
-        else if (button_pressed) // 켜진 뒤 새로 누름 → 2초 이상이면 자동 전원 OFF
-        {
-            cnt_s++;
-
-            if (cnt_s >= BOOT_THRESHOLD)
-            {
-                battery_timer_stop();
-                k_work_submit(&adv_stop_work);
-                device_on = false;
-                boot_btn_released = false;
-                cnt_s = 0;
-                sleep_mode_enter_reason("button-long-press");
-                return;
-            }
-        }
-        else // 버튼 놓음 → 카운터 리셋
-        {
-            if (cnt_s > 0)
-            {
-                DBG_PRINTF("[BTN] Short press (%d) -> ignored\r\n", cnt_s);
-            }
-            cnt_s = 0;
-        }
-    }
-
-    k_timer_start(&m_power_on_delay_timer, K_MSEC(POWER_ON_DELAY), K_NO_WAIT);
-}
-
-/* 타이머 초기화 / 시작 */
-static void timers_init(void)
-{
-    // 전원 상태머신 타이머
-    k_timer_init(&m_power_on_delay_timer, main_s, NULL);
-    k_timer_init(&m_power_off_delay_timer, t_power_off_timeout_handler, NULL);
-
-    // BLE advertising work
-    k_work_init(&adv_start_work, adv_start_work_handler);
-    k_work_init(&adv_stop_work, adv_stop_work_handler);
-
-    // 전원 버튼 15초 롱프레스 본드 삭제 work
-    k_work_init(&bond_reset_work, bond_reset_work_handler);
-
-    // DFU 업로드 무진행 감시 work
-    k_work_init_delayable(&dfu_watchdog_work, dfu_watchdog_handler);
-
-    // BLE 명령 처리 work queue
-    k_work_init(&ble_cmd_work, ble_cmd_work_handler);
-    k_work_queue_start(&ble_cmd_work_q, ble_cmd_workq_stack, K_THREAD_STACK_SIZEOF(ble_cmd_workq_stack), BLE_CMD_WORKQ_PRIORITY, NULL);
-
-    // 전원 제어 타이머
-    power_timer_init();
-
-    // DFU 업로드 상태를 LED에 반영
-    mgmt_callback_register(&dfu_status_callback);
-
-    // DFU 명령 실패 시 LED 상태 복구
-    mgmt_callback_register(&smp_cmd_status_callback);
-}
-
-/* 전원 버튼 폴링 시작 (5ms 후 main_s 콜백) */
-static void timers_start(void)
-{
-    k_timer_start(&m_power_on_delay_timer, K_MSEC(POWER_ON_DELAY), K_NO_WAIT);
-}
-
-/* DFU 업로드가 멈춘 채(청크 무진행) 링크만 살아있는 경우, 연결을 강제로 끊어
- * SMP 재광고(10분 타임아웃)로 전환한다. 초록 LED 무한 점등/무한 대기 방지. */
-static void dfu_watchdog_handler(struct k_work *work)
-{
-    ARG_UNUSED(work);
-
-    if (ble_is_connected())
-    {
-        DBG_PRINTF("[DFU] upload stalled (%ds), forcing disconnect\r\n",
-                   DFU_STALL_TIMEOUT_SEC);
-        (void)ble_disconnect_active();
-    }
-}
-
-static enum mgmt_cb_return dfu_status_cb(uint32_t event, enum mgmt_cb_return prev_status, int32_t *rc, uint16_t *group, bool *abort_more, void *data, size_t data_size)
-{
-    ARG_UNUSED(prev_status);
-    ARG_UNUSED(rc);
-    ARG_UNUSED(group);
-    ARG_UNUSED(abort_more);
-    ARG_UNUSED(data);
-    ARG_UNUSED(data_size);
-
-    switch (event)
-    {
-        case MGMT_EVT_OP_IMG_MGMT_DFU_STARTED:
-        case MGMT_EVT_OP_IMG_MGMT_DFU_CHUNK:
-            dfu_led_active = true;
-            led_ble_solid(); // DFU 업로드 중에는 초록 LED ON
-            // 청크가 올 때마다 무진행 감시 타이머 리셋
-            k_work_reschedule(&dfu_watchdog_work, K_SECONDS(DFU_STALL_TIMEOUT_SEC));
-            break;
-
-        case MGMT_EVT_OP_IMG_MGMT_DFU_PENDING:
-            dfu_led_active = true;
-            led_ble_solid(); // 업로드 완료 후 리셋 전까지 초록 LED ON
-            k_work_cancel_delayable(&dfu_watchdog_work); // 업로드 완료: 감시 종료
-
-#if NRF_POWER_HAS_GPREGRET
-        nrf_power_gpregret_set(NRF_POWER, DFU_RESUME_GPREGRET_REG, DFU_RESUME_MAGIC); // DFU 리셋 후 버튼 없이 전원 ON
-#endif
-        break;
-
-    case MGMT_EVT_OP_IMG_MGMT_DFU_STOPPED:
-        k_work_cancel_delayable(&dfu_watchdog_work); // 중단/실패: 감시 종료
-        if (dfu_led_active)
-        {
-            dfu_led_active = false;
-            led_set_state(LED_STATE_ADVERTISING); // 실패나 중단 시 일반 광고 LED로 복귀
-        }
-        break;
-
-    default:
-        break;
-    }
-
-    return MGMT_CB_OK;
-}
-
-static enum mgmt_cb_return smp_cmd_status_cb(uint32_t event, enum mgmt_cb_return prev_status, int32_t *rc, uint16_t *group, bool *abort_more, void *data, size_t data_size)
-{
-    ARG_UNUSED(event);
-    ARG_UNUSED(prev_status);
-    ARG_UNUSED(rc);
-    ARG_UNUSED(group);
-    ARG_UNUSED(abort_more);
-
-    if (data == NULL || data_size != sizeof(struct mgmt_evt_op_cmd_arg))
-    {
-        return MGMT_CB_OK;
-    }
-
-    const struct mgmt_evt_op_cmd_arg *cmd = data;
-
-    // 이미지 업로드/test 명령 실패 시 DFU LED 고정 해제
-    if (cmd->group == MGMT_GROUP_ID_IMAGE &&
-        (cmd->id == IMG_MGMT_ID_UPLOAD || cmd->id == IMG_MGMT_ID_STATE) &&
-        cmd->err != MGMT_ERR_EOK)
-    {
-        DBG_ERR("[DFU] command failed id=%u err=%d\r\n", cmd->id, cmd->err);
-
-        dfu_led_active = false;
-        led_set_state(LED_STATE_ADVERTISING);
-
-        // 실패 후 리셋 복구 표식이 남지 않게 정리
-#if NRF_POWER_HAS_GPREGRET
-        nrf_power_gpregret_set(NRF_POWER, DFU_RESUME_GPREGRET_REG, 0U);
-#endif
-    }
-
-    return MGMT_CB_OK;
-}
-
-static void resume_device_after_soft_reset(void)
-{
-    // 일반 버튼 부팅이면 skip
-    if (!resume_without_power_button && !dfu_confirm_pending_boot && !dfu_reset_resume_request)
-    {
-        return;
-    }
-
-    // 리셋 복귀나 DFU test 부팅은 버튼 없이도 ON 상태로 복구
-    device_on = true;
-    cnt_s = 0;
-    boot_btn_released = (gpio_pin_get_dt(&power_btn) != 1);
-    m_reset_status = 1;
-
-    // 정상 ON 상태 서비스 재시작
-    power_control_handler(ON, "resume-after-reset");
-    led_set_state(LED_STATE_ADVERTISING);
-    battery_timer_start();
-    k_work_submit(&adv_start_work);
-
-    DBG_CORE("[BOOT] Resume after resetreas=0x%08x\r\n", boot_reset_reason);
-}
-
-static void confirm_running_image(void)
-{
-#if defined(CONFIG_BOOTLOADER_MCUBOOT)
-    // 기본 초기화와 BLE 준비가 끝난 뒤 MCUboot revert 방지
-    if (!boot_is_img_confirmed())
-    {
-        int err = boot_write_img_confirmed();
-        if (err == 0)
-        {
-            DBG_CORE("[DFU] Running image confirmed\r\n");
-        }
-        else
-        {
-            DBG_ERR("[DFU] Image confirm failed (err %d)\r\n", err);
-        }
-    }
-    else
-    {
-        DBG_CORE("[DFU] Running image already confirmed\r\n");
-    }
-#endif
-}
-
-static const char *swap_type_to_str(int swap_type)
-{
-    // MCUboot swap 상태 문자열
-    switch (swap_type)
-    {
-        case BOOT_SWAP_TYPE_NONE:
-            return "none";
-        case BOOT_SWAP_TYPE_TEST:
-            return "test";
-        case BOOT_SWAP_TYPE_PERM:
-            return "perm";
-        case BOOT_SWAP_TYPE_REVERT:
-            return "revert";
-        case BOOT_SWAP_TYPE_FAIL:
-            return "fail";
-        default:
-            return "unknown";
-    }
-}
-
-static void log_mcuboot_state(void)
-{
-#if defined(CONFIG_BOOTLOADER_MCUBOOT)
-    // 현재 부팅 슬롯/교체 상태
-    struct mcuboot_img_header header;
-    uint8_t active_slot = boot_fetch_active_slot();
-    int swap_type = mcuboot_swap_type();
-    int err = boot_read_bank_header(active_slot, &header, sizeof(header));
-
-    DBG_CORE("[DFU] active_slot=%u swap_type=%s(%d) confirmed=%d\r\n",
-             active_slot,
-             swap_type_to_str(swap_type),
-             swap_type,
-             boot_is_img_confirmed());
-
-    if (err == 0)
-    {
-        /* 실행 이미지 버전 */
-        DBG_CORE("[DFU] image version %u.%u.%u+%u size=0x%x\r\n",
-                 header.h.v1.sem_ver.major,
-                 header.h.v1.sem_ver.minor,
-                 header.h.v1.sem_ver.revision,
-                 header.h.v1.sem_ver.build_num,
-                 header.h.v1.image_size);
-    }
-    else
-    {
-        DBG_ERR("[DFU] image header read failed (slot %u, err %d)\r\n",
-                active_slot,
-                err);
-    }
-#endif
-}
-
-/* 메인 함수 */
 int main(void)
 {
-    // 리셋/복귀 컨텍스트
     boot_context_detect();
 
-    // 하드웨어 기본 초기화
-    power_hold_init();
-    cnt_s = 0;
+#if defined(CONFIG_BOOTLOADER_MCUBOOT)
+    dfu_confirm_pending_boot = dfu_is_confirm_pending_boot(); // MCUboot test 이미지 상태인지 확인
+#else
+    dfu_confirm_pending_boot = false;
+#endif
 
-    // 버튼 부팅 기본 상태
-    device_on = false;
-    boot_btn_released = false;
-    confirm_running_image();
+    power_control_latch_init(resume_without_power_button || dfu_confirm_pending_boot || dfu_reset_resume_request);
+    power_control_reset_state();
 
     DBG_CORE("\r\n========================================\r\n");
     DBG_CORE(" TEST BUILD %s (Zephyr)\r\n", FIRMWARE_VERSION);
     DBG_CORE(" BUILD TAG: %s\r\n", CONFIG_MCUBOOT_IMGTOOL_SIGN_VERSION);
     DBG_CORE("========================================\r\n");
 
-    DBG_CORE("[INIT] HW Init\r\n");
-    // 기본 하드웨어/센서 초기화
-    gpio_init();
-    timers_init();
-    log_mcuboot_state();
+    // 각 모듈 초기화
+    power_control_init();
+    ble_cmd_queue_init();
+    dfu_manager_init();
+    dfu_log_mcuboot_state();
     load_default_config();
     led_init();
     battery_adc_init();
     battery_timer_init();
     imu_init();
     piezo_config_init();
-    DBG_CORE("[INIT] HW - gpio/timer/config/led/batt/imu/temp/piezo-cfg OK\r\n");
 
-    // BLE 스택 + NUS
-    DBG_CORE("[INIT] BLE Init\r\n");
-    if (ble_service_init(ble_rx_handler) == 0)
+    // BLE Stack/NUS 초기화 (0=성공)
+    if (ble_service_init(ble_cmd_queue_rx_handler) == 0) // BLE RX 콜백은 command queue로 연결
     {
-        DBG_CORE("[INIT] BLE - ble/nus OK\r\n");
-        // 소프트 리셋 후 서비스 복구
-        resume_device_after_soft_reset();
-        // BLE 준비까지 확인한 뒤 DFU test 이미지를 확정
-        confirm_running_image();
+        // 버튼 없이 정상 ON 상태로 복구하는 경우
+        if (resume_without_power_button || dfu_confirm_pending_boot || dfu_reset_resume_request)
+        {
+            power_control_resume_after_reset(boot_reset_reason);
+        }
+        
+        dfu_confirm_running_image(); // BLE 준비까지 확인한 뒤 DFU test 이미지 확정(confirm)
     }
     else
     {
@@ -784,10 +166,10 @@ int main(void)
     DBG_CORE(" READY [%s]\r\n", SERIAL_NO);
     DBG_CORE("========================================\r\n");
 
-    // 전원 버튼 상태머신 시작 (부팅 시 버튼이 눌려있는 상태)
-    timers_start();
+    power_control_start(); // 전원 버튼 상태머신 시작 (부팅 시 버튼이 눌려있는 상태)
 
-    // 메인 루프 - idle
+    // main loop - idle
+    // callback, work queue 기반 동작 유지
     for (;;)
     {
         k_msleep(100);

src/measurement/piezo_measure.c

@@ -199,10 +199,9 @@ int piezo_measure_sweep(void)
     uint16_t samples = cfg->samples;
     uint8_t avg = cfg->avg;
 
-    // 너무 짧은 delay가 들어오면 burst 직후 ADC capture가 겹치므로 최소 delay 보장
-    if (capture_delay_us < PIEZO_BURST_TO_ADC_DELAY_US)
+    if (capture_delay_us < 0)
     {
-        capture_delay_us = PIEZO_BURST_TO_ADC_DELAY_US;
+        capture_delay_us = 0;
     }
 
     DBG_PRINTF("[SWEEP] freq=0x%04X cycles=%u avg=%u delay_us=%u samples=%u\r\n", cfg->freq, cfg->cycles, cfg->avg, cfg->delay_us, cfg->samples);

src/power/power_control.c

@@ -0,0 +1,382 @@
+/*******************************************************************************
+ * @file    power_control.c
+ * @brief   Device power sequence control
+ ******************************************************************************/
+#include <zephyr/kernel.h>
+#include <zephyr/drivers/gpio.h>
+#include <zephyr/sys/reboot.h>
+#if IS_ENABLED(CONFIG_BT_SMP)
+#include <zephyr/bluetooth/bluetooth.h>
+#include <zephyr/bluetooth/conn.h>
+#endif
+
+#include "main.h"
+#include "power_control.h"
+#include "debug_print.h"
+#include "led_control.h"
+#include "ble_service.h"
+#include "battery_adc.h"
+
+#define POWER_HOLD_NODE         DT_NODELABEL(pwr_hold)       // 전원 래치
+#define POWER_BTN_NODE          DT_NODELABEL(button_check)   // 전원 버튼
+#define POWER_LOOP_INTERVAL     20                           // 전원 시퀀스 타이머 간격(ms)
+#define POWER_ON_THRESHOLD      350                          // power button hold threshold(off -> on)
+#define POWER_OFF_THRESHOLD     500                          // power button hold threshold(on -> off)
+#define BOND_RESET_THRESHOLD    (15000 / POWER_ON_DELAY)     // 15s long press bond reset
+
+static const struct gpio_dt_spec power_hold = GPIO_DT_SPEC_GET(POWER_HOLD_NODE, gpios); // 전원 유지 출력
+static const struct gpio_dt_spec power_btn  = GPIO_DT_SPEC_GET(POWER_BTN_NODE, gpios);  // 전원 버튼 입력
+
+static struct k_timer m_power_on_delay_timer;           // 전원 버튼 상태머신 타이머
+static struct k_timer m_power_off_delay_timer;          // 전원 OFF 지연 타이머
+static struct k_timer m_power_timer;                    // 전원 시퀀스 반복 타이머
+
+static struct k_work adv_start_work;                    // advertising 시작 work
+static struct k_work adv_stop_work;                     // advertising 중지 work
+static struct k_work bond_reset_work;                   // 전원 버튼 15초 롱프레스 본드 삭제 work
+
+static uint16_t cnt_s;                                  // power button hold counter
+static bool device_on;                                  // power latch state
+static bool boot_btn_released;                          // 부팅 후 버튼을 놓았는지 여부
+static bool power_btn_suspended;                        // 측정 중 버튼 상태머신 일시 정지
+static const char *power_off_pending_reason = "none";   // 예약된 전원 OFF 사유
+static bool bond_reset_pending;                         // 본드 삭제 work 중복 예약 방지
+static uint8_t p_order;                                 // 전원 시퀀스 단계
+static bool lock_check = false;                         // power sequence lock flag
+
+/* 시스템 워크에서 BLE advertising 시작 */
+static void adv_start_work_handler(struct k_work *work)
+{
+    ARG_UNUSED(work);
+    ble_advertising_start();
+}
+
+/* 시스템 워크에서 BLE advertising 중지 */
+static void adv_stop_work_handler(struct k_work *work)
+{
+    ARG_UNUSED(work);
+    ble_advertising_stop();
+}
+
+/* 전원 버튼 15초 롱프레스: BLE 본드 삭제 후 리부팅 */
+static void bond_reset_work_handler(struct k_work *work)
+{
+    ARG_UNUSED(work);
+
+    DBG_ERR("[BTN] 15s long press -> BLE bond reset\r\n");
+    battery_timer_stop();
+    ble_advertising_stop();
+
+#if IS_ENABLED(CONFIG_BT_SMP)
+    int err = bt_unpair(BT_ID_DEFAULT, NULL);
+    if (err)
+    {
+        DBG_ERR("[BTN] bt_unpair failed err=%d\r\n", err);
+    }
+    else
+    {
+        bond_data_delete = true;
+        DBG_PRINTF("[BTN] BLE bond data deleted\r\n");
+    }
+#else
+    bond_data_delete = true;
+    DBG_PRINTF("[BTN] BLE bond delete skipped (BT_SMP disabled)\r\n");
+#endif
+
+    led_set_state(LED_STATE_BOND_DELETE);
+    k_msleep(1500);
+    sys_reboot(SYS_REBOOT_COLD);
+}
+
+/* 부팅 직후 전원 래치를 유지할지 결정 */
+void power_control_latch_init(bool keep_on)
+{
+    gpio_pin_configure_dt(&power_hold, keep_on ? GPIO_OUTPUT_ACTIVE : GPIO_OUTPUT_INACTIVE);
+}
+
+/* 전원 버튼 상태머신 초기값 */
+void power_control_reset_state(void)
+{
+    cnt_s = 0;
+    device_on = false;
+    boot_btn_released = false;
+    power_btn_suspended = false;
+    bond_reset_pending = false;
+    power_off_pending_reason = "none";
+}
+
+/* POWER_HOLD 핀으로 실제 전원 래치 ON/OFF 제어 */
+static void power_control_handler(on_off_cont_t device_power_st, const char *reason)
+{
+    ARG_UNUSED(reason);
+
+    if (device_power_st == OFF)
+    {
+        gpio_pin_set_dt(&power_hold, 0);
+    }
+    else
+    {
+        gpio_pin_set_dt(&power_hold, 1);
+    }
+}
+
+/* 전원 버튼 GPIO 초기화 */
+static void power_gpio_init(void)
+{
+    gpio_pin_configure_dt(&power_btn, GPIO_INPUT);
+    DBG_PRINTF("[INIT] HW - GPIO OK (POWER BTN=%d)\r\n", gpio_pin_get_dt(&power_btn));
+}
+
+/* 전원 OFF 타임아웃 콜백 */
+static void t_power_off_timeout_handler(struct k_timer *timer)
+{
+    ARG_UNUSED(timer);
+    DBG_ERR("[PWR] OFF timeout reason=%s\r\n", power_off_pending_reason);
+    led_set_state(LED_STATE_OFF);
+    power_control_handler(OFF, "off-timeout");
+}
+
+/* sleep/전원 OFF: LED 표시 후 지연 시간 뒤 전원 차단 */
+static void power_off_schedule(const char *reason, led_state_t led_state)
+{
+    power_off_pending_reason = reason ? reason : "unknown";
+    led_set_state(led_state);
+    k_timer_start(&m_power_off_delay_timer, K_MSEC(POWER_OFF_DELAY), K_NO_WAIT);
+}
+
+/* 사유를 포함한 sleep 모드 진입 요청 */
+void sleep_mode_enter_reason(const char *reason)
+{
+    power_off_schedule(reason, LED_STATE_POWER_ON);
+}
+
+/* 기본 sleep 모드 진입 요청 */
+void sleep_mode_enter(void)
+{
+    sleep_mode_enter_reason("sleep_mode_enter");
+}
+
+/* 기본 전원 OFF 요청 */
+void device_power_off(void)
+{
+    device_power_off_reason("device_power_off");
+}
+
+/* 사유를 포함한 전원 OFF 요청 */
+void device_power_off_reason(const char *reason)
+{
+    power_off_schedule(reason, LED_STATE_POWER_OFF);
+}
+
+/* 외부 명령 처리 후 전원 래치 유지 */
+void device_power_keep_on(void)
+{
+    k_timer_stop(&m_power_off_delay_timer);
+    device_on = true;
+    boot_btn_released = (gpio_pin_get_dt(&power_btn) != 1);
+    cnt_s = 0;
+    power_control_handler(ON, "keep-on");
+}
+
+/* 긴 측정 중 전원 버튼 상태머신 일시 정지 */
+void power_button_suspend(bool suspend)
+{
+    power_btn_suspended = suspend;
+    cnt_s = 0;
+}
+
+/* 전원 버튼 상태머신 */
+static void main_s(struct k_timer *timer)
+{
+    ARG_UNUSED(timer);
+
+    // 버튼 입력은 눌림 상태가 1
+    bool button_pressed = (gpio_pin_get_dt(&power_btn) == 1);
+
+    // 측정 중에는 버튼 판단을 멈추고 다음 주기에 다시 확인
+    if (power_btn_suspended)
+    {
+        k_timer_start(&m_power_on_delay_timer, K_MSEC(POWER_ON_DELAY), K_NO_WAIT);
+        return;
+    }
+
+    // 전원 OFF 상태: 버튼을 충분히 누르면 전원 래치
+    if (!device_on)
+    {
+        if (!button_pressed) // 2초 미만으로 놓으면 전원 유지 실패 처리
+        {
+            power_control_handler(OFF, "boot-button-released-before-latch");
+            cnt_s = 0;
+        }
+        else
+        {
+            cnt_s++;
+
+            if (cnt_s == POWER_ON_THRESHOLD) // 임계 시간 도달 시 전원 ON 확정
+            {
+                device_on = true;
+                power_control_handler(ON, "button-2s-latch");
+                led_set_state(LED_STATE_ADVERTISING);
+                k_work_submit(&adv_start_work);
+                battery_timer_start();
+                m_reset_status = 1;
+            }
+        }
+    }
+    else
+    {
+        // 전원 ON 상태: 부팅 때 누른 버튼을 먼저 놓아야 새 입력으로 봄
+        if (!boot_btn_released)
+        {
+            if (!button_pressed) // 부팅 때 누른 버튼을 놓으면 이후 새 입력으로 판단
+            {
+                boot_btn_released = true;
+                cnt_s = 0;
+            }
+            else
+            {
+                cnt_s++;
+
+                if ((cnt_s >= BOND_RESET_THRESHOLD) && !bond_reset_pending) // 부팅 버튼 15초 유지 시 본드 삭제
+                {
+                    bond_reset_pending = true;
+                    k_work_submit(&bond_reset_work);
+                    return;
+                }
+            }
+        }
+        else if (button_pressed) // ON 상태에서 새로 길게 누르면 전원 OFF
+        {
+            cnt_s++;
+
+            if (cnt_s >= POWER_OFF_THRESHOLD)
+            {
+                battery_timer_stop();
+                k_work_submit(&adv_stop_work);
+                device_on = false;
+                boot_btn_released = false;
+                cnt_s = 0;
+                sleep_mode_enter_reason("button-long-press");
+                return;
+            }
+        }
+        else
+        {
+            // 버튼을 놓으면 짧은 입력은 무시하고 카운터를 초기화한다.
+            if (cnt_s > 0)
+            {
+                DBG_PRINTF("[BTN] Short press (%d) -> ignored\r\n", cnt_s);
+            }
+            cnt_s = 0;
+        }
+    }
+
+    k_timer_start(&m_power_on_delay_timer, K_MSEC(POWER_ON_DELAY), K_NO_WAIT);
+}
+
+/* 전원 시퀀스 타이머 만료 콜백 */
+static void power_loop_expiry(struct k_timer *timer)
+{
+    power_loop(timer);
+}
+
+/* 슬립 진입 전 처리 중 플래그 정리 */
+int device_sleep_mode(void)
+{
+    k_msleep(2);
+    DBG_PRINTF("Device_Sleep_Mode OK!\r\n");
+    k_msleep(10);
+    processing = false;
+    return 0;
+}
+
+/* 최초 전원 활성화 시퀀스 시작 */
+int device_activated(void)
+{
+    p_order = 0;
+    lock_check = true;
+    power_timer_start();
+    return 0;
+}
+
+/* 전원 활성화 단계 처리 - 필요 시 다음 타이머 예약 */
+void power_loop(struct k_timer *timer)
+{
+    power_timer_stop();
+
+    // 센서 초기화는 각 측정 함수에서 필요 시 수행
+    p_order = 2;
+
+    if (p_order < 2)
+    {
+        p_order++;
+        power_timer_start();
+    }
+    else
+    {
+        DBG_PRINTF("[PWR] Device Activated OK!\r\n");
+    }
+}
+
+/* 소프트 리셋/복귀 후 전원 시퀀스 다시 시작 */
+int device_reactivated(void)
+{
+    // 필요 시 복귀 전용 초기화 추가
+    k_msleep(10);
+    lock_check = true;
+    p_order = 0;
+    power_timer_start();
+    return 0;
+}
+
+/* 전원 시퀀스 타이머 1회 예약 */
+void power_timer_start(void)
+{
+    k_timer_start(&m_power_timer, K_MSEC(POWER_LOOP_INTERVAL), K_NO_WAIT);
+}
+
+/* 예약된 전원 시퀀스 타이머 중지 */
+void power_timer_stop(void)
+{
+    k_timer_stop(&m_power_timer);
+}
+
+/* 전원 시퀀스 타이머 콜백 등록 */
+void power_timer_init(void)
+{
+    k_timer_init(&m_power_timer, power_loop_expiry, NULL);
+}
+
+/* 전원 관련 타이머/work 초기화 */
+void power_control_init(void)
+{
+    power_gpio_init();
+    k_timer_init(&m_power_on_delay_timer, main_s, NULL);
+    k_timer_init(&m_power_off_delay_timer, t_power_off_timeout_handler, NULL);
+    k_work_init(&adv_start_work, adv_start_work_handler);
+    k_work_init(&adv_stop_work, adv_stop_work_handler);
+    k_work_init(&bond_reset_work, bond_reset_work_handler);
+    power_timer_init();
+}
+
+/* 전원 버튼 상태머신 시작 */
+void power_control_start(void)
+{
+    k_timer_start(&m_power_on_delay_timer, K_MSEC(POWER_ON_DELAY), K_NO_WAIT);
+}
+
+/* soft reset/DFU reset/test image 부팅 시 버튼 없이 정상 ON 상태로 복구 */
+void power_control_resume_after_reset(uint32_t reset_reason)
+{
+    device_on = true;
+    cnt_s = 0;
+    boot_btn_released = (gpio_pin_get_dt(&power_btn) != 1);
+    m_reset_status = 1;
+
+    power_control_handler(ON, "resume-after-reset");
+    led_set_state(LED_STATE_ADVERTISING);
+    battery_timer_start();
+    k_work_submit(&adv_start_work);
+
+    DBG_CORE("[BOOT] Resume after resetreas=0x%08x\r\n", reset_reason);
+}

src/power/power_control.h

@@ -5,8 +5,17 @@
 #ifndef POWER_CONTROL_H__
 #define POWER_CONTROL_H__
 
+#include <stdint.h>
+#include <stdbool.h>
+#include <zephyr/kernel.h>
+
 #include "main.h"
 
+void power_control_latch_init(bool keep_on);
+void power_control_reset_state(void);
+void power_control_init(void);
+void power_control_start(void);
+void power_control_resume_after_reset(uint32_t reset_reason);
 int device_sleep_mode(void);
 int device_activated(void);
 int device_reactivated(void);

src/power_control.c

@@ -1,83 +0,0 @@
-/*******************************************************************************
- * @file    power_control.c
- * @brief   Device power sequence control
- *
- * Power-up sequence state machine with k_timer (single-shot 20ms intervals)
- ******************************************************************************/
-#include <zephyr/kernel.h>
-#include "main.h"
-#include "power_control.h"
-#include "debug_print.h"
-
-#define POWER_LOOP_INTERVAL 20  /* ms */
-
-static struct k_timer m_power_timer;
-static uint8_t p_order;
-static bool lock_check = false;
-
-extern volatile bool processing;
-
-static void power_loop_expiry(struct k_timer *timer)
-{
-    power_loop(timer);
-}
-
-int device_sleep_mode(void)
-{
-    k_msleep(2);
-    DBG_PRINTF("Device_Sleep_Mode OK!\r\n");
-    k_msleep(10);
-    processing = false;
-    return 0;
-}
-
-int device_activated(void)
-{
-    p_order = 0;
-    lock_check = true;
-    power_timer_start();
-    return 0;
-}
-
-void power_loop(struct k_timer *timer)
-{
-    power_timer_stop();
-
-    // Sensor init not needed - imu_read_direct() handles it per measurement
-    p_order = 2;
-
-    if (p_order < 2)
-    {
-        p_order++;
-        power_timer_start();
-    }
-    else
-    {
-        DBG_PRINTF("[PWR] Device Activated OK!\r\n");
-    }
-}
-
-int device_reactivated(void)
-{
-    // sw_i2c_init_once() will be added in Stage 3
-    k_msleep(10);
-    lock_check = true;
-    p_order = 0;
-    power_timer_start();
-    return 0;
-}
-
-void power_timer_start(void)
-{
-    k_timer_start(&m_power_timer, K_MSEC(POWER_LOOP_INTERVAL), K_NO_WAIT);
-}
-
-void power_timer_stop(void)
-{
-    k_timer_stop(&m_power_timer);
-}
-
-void power_timer_init(void)
-{
-    k_timer_init(&m_power_timer, power_loop_expiry, NULL);
-}

sysbuild/hci_ipc.conf

@@ -1,3 +1,3 @@
-CONFIG_BT_CTLR_TX_PWR_PLUS_4=y
+CONFIG_BT_CTLR_TX_PWR_PLUS_8=y
 CONFIG_BT_CTLR_TX_PWR_DYNAMIC_CONTROL=y
 CONFIG_BT_CTLR_DATA_LENGTH_MAX=251

sysbuild/mcuboot.conf

@@ -1 +1,20 @@
 CONFIG_GPIO_HOGS=y
+
+# Keep MCUboot LOG enabled to satisfy MCUboot default Kconfig choices,
+# but disable console/log output backends.
+CONFIG_LOG=y
+CONFIG_LOG_DEFAULT_LEVEL=0
+CONFIG_MCUBOOT_LOG_LEVEL_OFF=y
+
+CONFIG_USE_SEGGER_RTT=y
+CONFIG_CONSOLE=n
+CONFIG_RTT_CONSOLE=n
+CONFIG_LOG_BACKEND_RTT=n
+CONFIG_LOG_BACKEND_SHOW_COLOR=n
+
+CONFIG_LOG_BACKEND_UART=n
+CONFIG_UART_CONSOLE=n
+
+# security boot
+CONFIG_REBOOT=y
+CONFIG_DISABLE_FLASH_PATCH=y