piezo_measure 파일 분리

- parser.c: BLE 커맨드 파싱/측정 함수 호출/응담 패킷 생성 및 전송
- piezo.c: Piezo 관련 GPIO 제어
- piezo_measure.c: 실제 측정 시퀀스

src/app_nvs.h

@@ -7,7 +7,7 @@
 
 #include <stdbool.h>
 
-#include "parser.h"
+#include "piezo_measure.h"
 
 typedef bool (*app_nvs_piezo_validate_fn)(const piezo_config_t *cfg);
 typedef void (*app_nvs_piezo_log_fn)(const char *prefix, const piezo_config_t *cfg);

src/measurement/piezo_measure.c

@@ -0,0 +1,376 @@
+/*******************************************************************************
+ * @file    piezo_measure.c
+ * @brief   Piezo echo measurement sequencing
+ ******************************************************************************/
+#include <zephyr/kernel.h>
+#include <errno.h>
+#include <string.h>
+
+#include "piezo_measure.h"
+#include "app_nvs.h"
+#include "debug_print.h"
+
+#define PIEZO_CFG_FREQ_DEFAULT       1
+#define PIEZO_CFG_CYCLES_DEFAULT     7
+#define PIEZO_CFG_DELAY_DEFAULT      10
+#define PIEZO_CFG_SAMPLES_DEFAULT    100
+#define PIEZO_CFG_AVG_DEFAULT        3
+
+#define PIEZO_CFG_AVG_MAX            10
+#define PIEZO_CFG_SAMPLES_MIN        80
+#define PIEZO_CFG_SAMPLES_MAX        117
+#define PIEZO_CFG_DELAY_MAX_US       50
+#define PIEZO_POST_SELECT_SETTLE_US  500
+#define PIEZO_AVG_INTER_BURST_GAP_US 500
+#define PIEZO_DUMMY_CAPTURE_COUNT    5
+
+static uint16_t piezo_channels[PIEZO_NUM_CHANNELS][PIEZO_MEASURE_MAX_SAMPLES];
+static uint16_t echo_capture[PIEZO_MEASURE_MAX_SAMPLES];
+static uint32_t echo_accum[PIEZO_MEASURE_MAX_SAMPLES];
+
+static piezo_config_t g_piezo_config = {
+    .freq = PIEZO_CFG_FREQ_DEFAULT,
+    .cycles = PIEZO_CFG_CYCLES_DEFAULT,
+    .avg = PIEZO_CFG_AVG_DEFAULT,
+    .delay_us = PIEZO_CFG_DELAY_DEFAULT,
+    .samples = PIEZO_CFG_SAMPLES_DEFAULT,
+};
+
+bool piezo_config_validate(const piezo_config_t *cfg)
+{
+    if (cfg == NULL)
+    {
+        return false;
+    }
+
+    if (cfg->freq != PIEZO_CFG_FREQ_DEFAULT)
+    {
+        return false;
+    }
+
+    if ((cfg->cycles < 3U) || (cfg->cycles > 7U))
+    {
+        return false;
+    }
+
+    if ((cfg->avg == 0U) || (cfg->avg > PIEZO_CFG_AVG_MAX))
+    {
+        return false;
+    }
+
+    if (cfg->delay_us > PIEZO_CFG_DELAY_MAX_US)
+    {
+        return false;
+    }
+
+    if ((cfg->samples < PIEZO_CFG_SAMPLES_MIN) ||
+        (cfg->samples > PIEZO_CFG_SAMPLES_MAX))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+const piezo_config_t *piezo_config_get(void)
+{
+    return &g_piezo_config;
+}
+
+int piezo_config_init(void)
+{
+    int err = app_nvs_init(&g_piezo_config, piezo_config_validate, NULL);
+    if (err)
+    {
+        return err;
+    }
+
+    return 0;
+}
+
+int piezo_config_set(const piezo_config_t *cfg)
+{
+    if (!piezo_config_validate(cfg))
+    {
+        return -EINVAL;
+    }
+
+    g_piezo_config = *cfg;
+    return app_nvs_save_piezo(&g_piezo_config);
+}
+
+const uint16_t *piezo_measure_channel_buffer(uint8_t channel)
+{
+    if (channel >= PIEZO_NUM_CHANNELS)
+    {
+        return NULL;
+    }
+
+    return piezo_channels[channel];
+}
+
+const uint16_t *piezo_measure_single_buffer(void)
+{
+    return echo_capture;
+}
+
+int piezo_measure_start_session(void)
+{
+    DBG_PRINTF("[MBB] piezo session start\r\n");
+
+    int err = piezo_init();
+    if (err)
+    {
+        DBG_PRINTF("[PIEZO] init fail err=%d\r\n", err);
+        return ECHO_STATUS_PIEZO;
+    }
+
+    piezo_power_on();
+    k_msleep(PIEZO_POWER_STABILIZE_MS);
+
+    err = echo_adc_init();
+    if (err)
+    {
+        DBG_PRINTF("[ECHO] init fail err=%d\r\n", err);
+        return ECHO_STATUS_ADC_INIT;
+    }
+
+    err = echo_adc_wake();
+    if (err)
+    {
+        DBG_PRINTF("[ECHO] wake fail err=%d\r\n", err);
+        return ECHO_STATUS_ADC_INIT;
+    }
+
+    DBG_PRINTF("[MBB] piezo session ready\r\n");
+    return ECHO_STATUS_OK;
+}
+
+int piezo_measure_sweep(void)
+{
+    const piezo_config_t *cfg = piezo_config_get();
+    uint16_t capture_delay_us = cfg->delay_us;
+
+    if (capture_delay_us < PIEZO_BURST_TO_ADC_DELAY_US)
+    {
+        capture_delay_us = PIEZO_BURST_TO_ADC_DELAY_US;
+    }
+
+    for (uint8_t ch = 0; ch < PIEZO_NUM_CHANNELS; ch++)
+    {
+        DBG_PRINTF("[MBB] sweep ch=%d start\r\n", ch);
+
+        int err = piezo_select_channel(ch);
+        if (err)
+        {
+            DBG_PRINTF("[PIEZO] mux fail ch=%d err=%d\r\n", ch, err);
+            return ECHO_STATUS_MUX;
+        }
+
+        k_busy_wait(PIEZO_POST_SELECT_SETTLE_US);
+
+        err = echo_adc_wake();
+        if (err)
+        {
+            DBG_PRINTF("[ECHO] dummy read fail ch=%d err=%d\r\n", ch, err);
+            return ECHO_STATUS_CAPTURE;
+        }
+
+        for (uint8_t dummy = 0; dummy < PIEZO_DUMMY_CAPTURE_COUNT; dummy++)
+        {
+            k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
+            piezo_burst_sw((uint8_t)cfg->cycles);
+            k_busy_wait(capture_delay_us);
+
+            err = echo_adc_capture(echo_capture, cfg->samples);
+            if (err)
+            {
+                DBG_PRINTF("[ECHO] dummy capture fail ch=%d dummy=%d err=%d\r\n", ch, dummy, err);
+                return ECHO_STATUS_CAPTURE;
+            }
+        }
+
+        memset(echo_accum, 0, sizeof(echo_accum));
+
+        for (uint16_t avg = 0; avg < cfg->avg; avg++)
+        {
+            if (avg > 0U)
+            {
+                k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
+            }
+
+            unsigned int key = irq_lock();
+            piezo_burst_sw((uint8_t)cfg->cycles);
+            k_busy_wait(capture_delay_us);
+
+            err = echo_adc_capture(echo_capture, cfg->samples);
+            irq_unlock(key);
+            if (err)
+            {
+                DBG_PRINTF("[ECHO] capture fail ch=%d avg=%d err=%d\r\n", ch, avg, err);
+                return ECHO_STATUS_CAPTURE;
+            }
+
+            for (uint16_t i = 0; i < cfg->samples; i++)
+            {
+                echo_accum[i] += echo_capture[i];
+            }
+        }
+
+        for (uint16_t i = 0; i < cfg->samples; i++)
+        {
+            piezo_channels[ch][i] = (uint16_t)(echo_accum[i] / cfg->avg);
+        }
+
+        DBG_PRINTF("[MBB] sweep ch=%d done\r\n", ch);
+    }
+
+    DBG_PRINTF("[MBB] sweep done\r\n");
+    return ECHO_STATUS_OK;
+}
+
+int piezo_measure_single_capture(uint8_t cycles,
+                                 uint16_t delay_us,
+                                 uint16_t num_samples,
+                                 uint16_t averaging,
+                                 uint8_t channel)
+{
+    if (channel >= PIEZO_NUM_CHANNELS)
+    {
+        return ECHO_STATUS_MUX;
+    }
+
+    if ((num_samples == 0U) || (num_samples > PIEZO_MEASURE_MAX_SAMPLES))
+    {
+        return ECHO_STATUS_CAPTURE;
+    }
+
+    if (averaging == 0U)
+    {
+        averaging = 1U;
+    }
+
+    int err = piezo_select_channel(channel);
+    if (err)
+    {
+        return ECHO_STATUS_MUX;
+    }
+
+    k_busy_wait(PIEZO_POST_SELECT_SETTLE_US);
+
+    err = echo_adc_wake();
+    if (err)
+    {
+        return ECHO_STATUS_CAPTURE;
+    }
+
+    for (uint8_t dummy = 0; dummy < PIEZO_DUMMY_CAPTURE_COUNT; dummy++)
+    {
+        k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
+        piezo_burst_sw(cycles);
+        k_busy_wait(delay_us);
+
+        err = echo_adc_capture(echo_capture, num_samples);
+        if (err)
+        {
+            return ECHO_STATUS_CAPTURE;
+        }
+    }
+
+    memset(echo_accum, 0, sizeof(echo_accum));
+
+    for (uint16_t avg = 0; avg < averaging; avg++)
+    {
+        if (avg > 0U)
+        {
+            k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
+        }
+
+        unsigned int key = irq_lock();
+        piezo_burst_sw(cycles);
+        k_busy_wait(delay_us);
+
+        err = echo_adc_capture(echo_capture, num_samples);
+        irq_unlock(key);
+        if (err)
+        {
+            return ECHO_STATUS_CAPTURE;
+        }
+
+        for (uint16_t i = 0; i < num_samples; i++)
+        {
+            echo_accum[i] += echo_capture[i];
+        }
+    }
+
+    for (uint16_t i = 0; i < num_samples; i++)
+    {
+        echo_capture[i] = (uint16_t)(echo_accum[i] / averaging);
+    }
+
+    return ECHO_STATUS_OK;
+}
+
+int piezo_measure_adc_only_capture(uint16_t num_samples,
+                                   uint16_t averaging,
+                                   uint8_t channel)
+{
+    if (channel >= PIEZO_NUM_CHANNELS)
+    {
+        return ECHO_STATUS_MUX;
+    }
+
+    if ((num_samples == 0U) || (num_samples > PIEZO_MEASURE_MAX_SAMPLES))
+    {
+        return ECHO_STATUS_CAPTURE;
+    }
+
+    if (averaging == 0U)
+    {
+        averaging = 1U;
+    }
+
+    int err = piezo_select_channel(channel);
+    if (err)
+    {
+        return ECHO_STATUS_MUX;
+    }
+
+    k_busy_wait(PIEZO_POST_SELECT_SETTLE_US);
+
+    err = echo_adc_wake();
+    if (err)
+    {
+        return ECHO_STATUS_CAPTURE;
+    }
+
+    memset(echo_accum, 0, sizeof(echo_accum));
+
+    for (uint16_t avg = 0; avg < averaging; avg++)
+    {
+        if (avg > 0U)
+        {
+            k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
+        }
+
+        unsigned int key = irq_lock();
+        err = echo_adc_capture(echo_capture, num_samples);
+        irq_unlock(key);
+        if (err)
+        {
+            return ECHO_STATUS_CAPTURE;
+        }
+
+        for (uint16_t i = 0; i < num_samples; i++)
+        {
+            echo_accum[i] += echo_capture[i];
+        }
+    }
+
+    for (uint16_t i = 0; i < num_samples; i++)
+    {
+        echo_capture[i] = (uint16_t)(echo_accum[i] / averaging);
+    }
+
+    return ECHO_STATUS_OK;
+}

src/measurement/piezo_measure.h

@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * @file    piezo_measure.h
+ * @brief   Piezo echo measurement sequencing
+ ******************************************************************************/
+#ifndef PIEZO_MEASURE_H__
+#define PIEZO_MEASURE_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "echo_adc.h"
+#include "piezo.h"
+
+#define PIEZO_MEASURE_MAX_SAMPLES ECHO_ADC_MAX_SAMPLES
+
+#define ECHO_STATUS_OK        0x0000
+#define ECHO_STATUS_PIEZO     0x0001
+#define ECHO_STATUS_ADC_INIT  0x0002
+#define ECHO_STATUS_MUX       0x0003
+#define ECHO_STATUS_CAPTURE   0x0004
+#define ECHO_STATUS_BATT      0x0005
+#define ECHO_STATUS_IMU       0x0006
+#define ECHO_STATUS_TEMP      0x0007
+
+typedef struct
+{
+    uint16_t freq;
+    uint16_t cycles;
+    uint16_t avg;
+    uint16_t delay_us;
+    uint16_t samples;
+} piezo_config_t;
+
+int piezo_config_init(void);
+bool piezo_config_validate(const piezo_config_t *cfg);
+const piezo_config_t *piezo_config_get(void);
+int piezo_config_set(const piezo_config_t *cfg);
+
+int piezo_measure_start_session(void);
+int piezo_measure_sweep(void);
+int piezo_measure_single_capture(uint8_t cycles,
+                                 uint16_t delay_us,
+                                 uint16_t num_samples,
+                                 uint16_t averaging,
+                                 uint8_t channel);
+int piezo_measure_adc_only_capture(uint16_t num_samples,
+                                   uint16_t averaging,
+                                   uint8_t channel);
+
+const uint16_t *piezo_measure_channel_buffer(uint8_t channel);
+const uint16_t *piezo_measure_single_buffer(void);
+
+#endif /* PIEZO_MEASURE_H__ */

src/parser.c

@@ -21,43 +21,16 @@
 #include "ble_service.h"
 #include "battery_adc.h"
 #include "led_control.h"
-#include "echo_adc.h"
 #include "imu_i2c.h"
 #include "piezo.h"
+#include "piezo_measure.h"
 
 /*==============================================================================
- * Piezo / echo measurement constants
+ * Piezo / echo response state
  *============================================================================*/
-#define PIEZO_AVERAGE_COUNT   10
-#define ECHO_STATUS_OK        0x0000
-#define ECHO_STATUS_PIEZO     0x0001
-#define ECHO_STATUS_ADC_INIT  0x0002
-#define ECHO_STATUS_MUX       0x0003
-#define ECHO_STATUS_CAPTURE   0x0004
-#define ECHO_STATUS_BATT      0x0005
-#define ECHO_STATUS_IMU       0x0006
-#define ECHO_STATUS_TEMP      0x0007
-
-#define PIEZO_CFG_FREQ_DEFAULT       1
-#define PIEZO_CFG_CYCLES_DEFAULT     7
-#define PIEZO_CFG_DELAY_DEFAULT      10
-#define PIEZO_CFG_SAMPLES_DEFAULT    100
-#define PIEZO_CFG_AVG_DEFAULT        3
-
-#define PIEZO_CFG_AVG_MAX            10
-#define PIEZO_CFG_SAMPLES_MIN        80
-#define PIEZO_CFG_SAMPLES_MAX        117
-#define PIEZO_CFG_DELAY_MAX_US       50
-#define PIEZO_POST_SELECT_SETTLE_US  500
-#define PIEZO_AVG_INTER_BURST_GAP_US 500
-#define PIEZO_DUMMY_CAPTURE_COUNT    5
-
-static uint16_t piezo_channels[PIEZO_NUM_CHANNELS][ECHO_ADC_MAX_SAMPLES];
-static uint16_t echo_capture[ECHO_ADC_MAX_SAMPLES];
-static uint32_t echo_accum[ECHO_ADC_MAX_SAMPLES];
 static uint8_t tx_u16_buf[8];
 static uint8_t tx_imu_buf[18];
-static uint8_t tx_echo_buf[4 + 2 + 2 + (ECHO_ADC_MAX_SAMPLES * 2) + 2];
+static uint8_t tx_echo_buf[4 + 2 + 2 + (PIEZO_MEASURE_MAX_SAMPLES * 2) + 2];
 static uint8_t tx_bundle_buf[22];
 static uint8_t tx_cfg_buf[16];
 static uint8_t tx_ascii_buf[4 + HW_NO_LENGTH + 2];
@@ -65,66 +38,6 @@ static uint8_t tx_id_buf[4 + HW_NO_LENGTH + SERIAL_NO_LENGTH + SERIAL_NO_LENGTH
 static uint8_t tx_rim_samples[IMU_FIFO_RIM_TARGET_SAMPLES * IMU_FIFO_SAMPLE_BYTES];
 static uint8_t tx_rim_buf[4 + 2 + (IMU_FIFO_RIM_TARGET_SAMPLES * IMU_FIFO_SAMPLE_BYTES) + 2];
 static uint8_t g_echo_session;
-static piezo_config_t g_piezo_config = {
-    .freq = PIEZO_CFG_FREQ_DEFAULT,
-    .cycles = PIEZO_CFG_CYCLES_DEFAULT,
-    .avg = PIEZO_CFG_AVG_DEFAULT,
-    .delay_us = PIEZO_CFG_DELAY_DEFAULT,
-    .samples = PIEZO_CFG_SAMPLES_DEFAULT,
-};
-
-static bool piezo_config_validate(const piezo_config_t *cfg)
-{
-    if (cfg == NULL)
-    {
-        return false;
-    }
-
-    if (cfg->freq != PIEZO_CFG_FREQ_DEFAULT)
-    {
-        return false;
-    }
-
-    if ((cfg->cycles < 3U) || (cfg->cycles > 7U))
-    {
-        return false;
-    }
-
-    if ((cfg->avg == 0U) || (cfg->avg > PIEZO_CFG_AVG_MAX))
-    {
-        return false;
-    }
-
-    if (cfg->delay_us > PIEZO_CFG_DELAY_MAX_US)
-    {
-        return false;
-    }
-
-    if ((cfg->samples < PIEZO_CFG_SAMPLES_MIN) ||
-        (cfg->samples > PIEZO_CFG_SAMPLES_MAX))
-    {
-        return false;
-    }
-
-    return true;
-}
-
-const piezo_config_t *piezo_config_get(void)
-{
-    return &g_piezo_config;
-}
-
-int piezo_config_init(void)
-{
-    int err = app_nvs_init(&g_piezo_config, piezo_config_validate, NULL);
-    if (err)
-    {
-        return err;
-    }
-
-    return 0;
-}
-
 static void reboot_after_response(void)
 {
     k_msleep(100);
@@ -400,273 +313,12 @@ static void send_response_piezo_config(const char *tag, uint16_t freq, uint16_t
     ble_data_send(buf, sizeof(tx_cfg_buf));
 }
 
-static int start_piezo_session(void)
-{
-    DBG_PRINTF("[MBB] piezo session start\r\n");
-
-    int err = piezo_init();
-    if (err)
-    {
-        DBG_PRINTF("[PIEZO] init fail err=%d\r\n", err);
-        return ECHO_STATUS_PIEZO;
-    }
-
-    piezo_power_on();
-    k_msleep(PIEZO_POWER_STABILIZE_MS);
-
-    err = echo_adc_init();
-    if (err)
-    {
-        DBG_PRINTF("[ECHO] init fail err=%d\r\n", err);
-        return ECHO_STATUS_ADC_INIT;
-    }
-
-    err = echo_adc_wake();
-    if (err)
-    {
-        DBG_PRINTF("[ECHO] wake fail err=%d\r\n", err);
-        return ECHO_STATUS_ADC_INIT;
-    }
-
-    DBG_PRINTF("[MBB] piezo session ready\r\n");
-    return ECHO_STATUS_OK;
-}
-
-static int perform_piezo_sweep(void)
-{
-    const piezo_config_t *cfg = piezo_config_get();
-    uint16_t capture_delay_us = cfg->delay_us;
-
-    if (capture_delay_us < PIEZO_BURST_TO_ADC_DELAY_US)
-    {
-        capture_delay_us = PIEZO_BURST_TO_ADC_DELAY_US;
-    }
-
-    for (uint8_t ch = 0; ch < PIEZO_NUM_CHANNELS; ch++)
-    {
-        DBG_PRINTF("[MBB] sweep ch=%d start\r\n", ch);
-
-        int err = piezo_select_channel(ch);
-        if (err)
-        {
-            DBG_PRINTF("[PIEZO] mux fail ch=%d err=%d\r\n", ch, err);
-            return ECHO_STATUS_MUX;
-        }
-
-        k_busy_wait(PIEZO_POST_SELECT_SETTLE_US);
-
-        err = echo_adc_wake();
-        if (err)
-        {
-            DBG_PRINTF("[ECHO] dummy read fail ch=%d err=%d\r\n", ch, err);
-            return ECHO_STATUS_CAPTURE;
-        }
-
-        for (uint8_t dummy = 0; dummy < PIEZO_DUMMY_CAPTURE_COUNT; dummy++)
-        {
-            k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
-            piezo_burst_sw((uint8_t)cfg->cycles);
-            k_busy_wait(capture_delay_us);
-
-            err = echo_adc_capture(echo_capture, cfg->samples);
-            if (err)
-            {
-                DBG_PRINTF("[ECHO] dummy capture fail ch=%d dummy=%d err=%d\r\n", ch, dummy, err);
-                return ECHO_STATUS_CAPTURE;
-            }
-        }
-
-        memset(echo_accum, 0, sizeof(echo_accum));
-
-        for (uint16_t avg = 0; avg < cfg->avg; avg++)
-        {
-            if (avg > 0U)
-            {
-                k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
-            }
-
-            unsigned int key = irq_lock();
-            piezo_burst_sw((uint8_t)cfg->cycles);
-            k_busy_wait(capture_delay_us);
-
-            err = echo_adc_capture(echo_capture, cfg->samples);
-            irq_unlock(key);
-            if (err)
-            {
-                DBG_PRINTF("[ECHO] capture fail ch=%d avg=%d err=%d\r\n", ch, avg, err);
-                return ECHO_STATUS_CAPTURE;
-            }
-
-            for (uint16_t i = 0; i < cfg->samples; i++)
-            {
-                echo_accum[i] += echo_capture[i];
-            }
-        }
-
-        for (uint16_t i = 0; i < cfg->samples; i++)
-        {
-            piezo_channels[ch][i] = (uint16_t)(echo_accum[i] / cfg->avg);
-        }
-
-        DBG_PRINTF("[MBB] sweep ch=%d done\r\n", ch);
-    }
-
-    DBG_PRINTF("[MBB] sweep done\r\n");
-    return ECHO_STATUS_OK;
-}
-
-static int perform_single_piezo_capture(uint8_t cycles,
-                                        uint16_t delay_us,
-                                        uint16_t num_samples,
-                                        uint16_t averaging,
-                                        uint8_t channel)
-{
-    if (channel >= PIEZO_NUM_CHANNELS)
-    {
-        return ECHO_STATUS_MUX;
-    }
-
-    if ((num_samples == 0U) || (num_samples > ECHO_ADC_MAX_SAMPLES))
-    {
-        return ECHO_STATUS_CAPTURE;
-    }
-
-    if (averaging == 0U)
-    {
-        averaging = 1U;
-    }
-
-    int err = piezo_select_channel(channel);
-    if (err)
-    {
-        return ECHO_STATUS_MUX;
-    }
-
-    k_busy_wait(PIEZO_POST_SELECT_SETTLE_US);
-
-    err = echo_adc_wake();
-    if (err)
-    {
-        return ECHO_STATUS_CAPTURE;
-    }
-
-    for (uint8_t dummy = 0; dummy < PIEZO_DUMMY_CAPTURE_COUNT; dummy++)
-    {
-        k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
-        piezo_burst_sw(cycles);
-        k_busy_wait(delay_us);
-
-        err = echo_adc_capture(echo_capture, num_samples);
-        if (err)
-        {
-            return ECHO_STATUS_CAPTURE;
-        }
-    }
-
-    memset(echo_accum, 0, sizeof(echo_accum));
-
-    for (uint16_t avg = 0; avg < averaging; avg++)
-    {
-        if (avg > 0U)
-        {
-            k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
-        }
-
-        unsigned int key = irq_lock();
-        piezo_burst_sw(cycles);
-        k_busy_wait(delay_us);
-
-        err = echo_adc_capture(echo_capture, num_samples);
-        irq_unlock(key);
-        if (err)
-        {
-            return ECHO_STATUS_CAPTURE;
-        }
-
-        for (uint16_t i = 0; i < num_samples; i++)
-        {
-            echo_accum[i] += echo_capture[i];
-        }
-    }
-
-    for (uint16_t i = 0; i < num_samples; i++)
-    {
-        echo_capture[i] = (uint16_t)(echo_accum[i] / averaging);
-    }
-
-    return ECHO_STATUS_OK;
-}
-
 /*==============================================================================
  * 커맨드 핸들러
  *============================================================================*/
 
 /* msn? → 배터리 전압 측정 → rsn: + mV */
 
-static int perform_adc_only_capture(uint16_t num_samples,
-                                    uint16_t averaging,
-                                    uint8_t channel)
-{
-    if (channel >= PIEZO_NUM_CHANNELS)
-    {
-        return ECHO_STATUS_MUX;
-    }
-
-    if ((num_samples == 0U) || (num_samples > ECHO_ADC_MAX_SAMPLES))
-    {
-        return ECHO_STATUS_CAPTURE;
-    }
-
-    if (averaging == 0U)
-    {
-        averaging = 1U;
-    }
-
-    int err = piezo_select_channel(channel);
-    if (err)
-    {
-        return ECHO_STATUS_MUX;
-    }
-
-    k_busy_wait(PIEZO_POST_SELECT_SETTLE_US);
-
-    err = echo_adc_wake();
-    if (err)
-    {
-        return ECHO_STATUS_CAPTURE;
-    }
-
-    memset(echo_accum, 0, sizeof(echo_accum));
-
-    for (uint16_t avg = 0; avg < averaging; avg++)
-    {
-        if (avg > 0U)
-        {
-            k_busy_wait(PIEZO_AVG_INTER_BURST_GAP_US);
-        }
-
-        unsigned int key = irq_lock();
-        err = echo_adc_capture(echo_capture, num_samples);
-        irq_unlock(key);
-        if (err)
-        {
-            return ECHO_STATUS_CAPTURE;
-        }
-
-        for (uint16_t i = 0; i < num_samples; i++)
-        {
-            echo_accum[i] += echo_capture[i];
-        }
-    }
-
-    for (uint16_t i = 0; i < num_samples; i++)
-    {
-        echo_capture[i] = (uint16_t)(echo_accum[i] / averaging);
-    }
-
-    return ECHO_STATUS_OK;
-}
-
 static int cmd_msn(const uint8_t *data, uint8_t data_len)
 {
     ARG_UNUSED(data);
@@ -968,9 +620,9 @@ static int cmd_mec(const uint8_t *data, uint8_t data_len)
 
     ARG_UNUSED(freq_option);
 
-    if (num_samples > ECHO_ADC_MAX_SAMPLES)
+    if (num_samples > PIEZO_MEASURE_MAX_SAMPLES)
     {
-        num_samples = ECHO_ADC_MAX_SAMPLES;
+        num_samples = PIEZO_MEASURE_MAX_SAMPLES;
     }
     if ((cycles < 3U) || (cycles > 7U))
     {
@@ -984,15 +636,15 @@ static int cmd_mec(const uint8_t *data, uint8_t data_len)
     processing = true;
     power_button_suspend(true);
 
-    int status = start_piezo_session();
+    int status = piezo_measure_start_session();
     if (status == ECHO_STATUS_OK)
     {
-        status = perform_single_piezo_capture((uint8_t)cycles, delay_us, num_samples, averaging, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS));
+        status = piezo_measure_single_capture((uint8_t)cycles, delay_us, num_samples, averaging, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS));
     }
 
     if (status == ECHO_STATUS_OK)
     {
-        send_response_echo(session, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS), echo_capture, num_samples);
+        send_response_echo(session, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS), piezo_measure_single_buffer(), num_samples);
     }
 
     piezo_power_off();
@@ -1021,9 +673,9 @@ static int cmd_mad(const uint8_t *data, uint8_t data_len)
     get_data_u16_be(data, data_len, 4, &averaging);
     get_data_u16_be(data, data_len, 5, &piezo_ch);
 
-    if (num_samples > ECHO_ADC_MAX_SAMPLES)
+    if (num_samples > PIEZO_MEASURE_MAX_SAMPLES)
     {
-        num_samples = ECHO_ADC_MAX_SAMPLES;
+        num_samples = PIEZO_MEASURE_MAX_SAMPLES;
     }
     if (averaging == 0U)
     {
@@ -1033,15 +685,15 @@ static int cmd_mad(const uint8_t *data, uint8_t data_len)
     processing = true;
     power_button_suspend(true);
 
-    int status = start_piezo_session();
+    int status = piezo_measure_start_session();
     if (status == ECHO_STATUS_OK)
     {
-        status = perform_adc_only_capture(num_samples, averaging, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS));
+        status = piezo_measure_adc_only_capture(num_samples, averaging, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS));
     }
 
     if (status == ECHO_STATUS_OK)
     {
-        send_response_echo(session, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS), echo_capture, num_samples);
+        send_response_echo(session, (uint8_t)(piezo_ch % PIEZO_NUM_CHANNELS), piezo_measure_single_buffer(), num_samples);
     }
 
     piezo_power_off();
@@ -1075,17 +727,17 @@ static int cmd_maa(const uint8_t *data, uint8_t data_len)
     processing = true;
     power_button_suspend(true);
 
-    int status = start_piezo_session();
+    int status = piezo_measure_start_session();
     if (status == ECHO_STATUS_OK)
     {
-        status = perform_piezo_sweep();
+        status = piezo_measure_sweep();
     }
 
     if (status == ECHO_STATUS_OK)
     {
         for (uint8_t ch = 0; ch < PIEZO_NUM_CHANNELS; ch++)
         {
-            send_response_echo(session, ch, piezo_channels[ch], piezo_config_get()->samples);
+            send_response_echo(session, ch, piezo_measure_channel_buffer(ch), piezo_config_get()->samples);
         }
     }
 
@@ -1133,10 +785,10 @@ static int cmd_mbb(const uint8_t *data, uint8_t data_len)
     power_button_suspend(true);
     DBG_PRINTF("[MBB] cmd start\r\n");
 
-    int status = start_piezo_session();
+    int status = piezo_measure_start_session();
     if (status == ECHO_STATUS_OK)
     {
-        status = perform_piezo_sweep();
+        status = piezo_measure_sweep();
     }
 
     int batt_mv = -1;
@@ -1189,7 +841,7 @@ static int cmd_mbb(const uint8_t *data, uint8_t data_len)
         {
             /* reb: 채널별 raw echo 파형 */
             DBG_PRINTF("[MBB] tx reb ch=%d\r\n", ch);
-            send_response_echo(session, ch, piezo_channels[ch], piezo_config_get()->samples);
+            send_response_echo(session, ch, piezo_measure_channel_buffer(ch), piezo_config_get()->samples);
         }
     }
 
@@ -1233,19 +885,19 @@ static int cmd_mtb(const uint8_t *data, uint8_t data_len)
 
     if (status == ECHO_STATUS_OK)
     {
-        status = start_piezo_session();
+        status = piezo_measure_start_session();
     }
 
     if (status == ECHO_STATUS_OK)
     {
-        status = perform_piezo_sweep();
+        status = piezo_measure_sweep();
     }
 
     if (status == ECHO_STATUS_OK)
     {
         for (uint8_t ch = 0; ch < PIEZO_NUM_CHANNELS; ch++)
         {
-            send_response_echo(session, ch, piezo_channels[ch], piezo_config_get()->samples);
+            send_response_echo(session, ch, piezo_measure_channel_buffer(ch), piezo_config_get()->samples);
         }
     }
 
@@ -1312,15 +964,15 @@ static int cmd_mcs(const uint8_t *data, uint8_t data_len)
         return 1;
     }
 
-    g_piezo_config = cfg;
+    int err = piezo_config_set(&cfg);
-    int err = app_nvs_save_piezo(&g_piezo_config);
     if (err)
     {
         send_response_piezo_config("rcs:", 0xFFFD, cfg.cycles, cfg.avg, cfg.delay_us, cfg.samples);
         return 1;
     }
 
-    send_response_piezo_config("rcs:", g_piezo_config.freq, g_piezo_config.cycles, g_piezo_config.avg, g_piezo_config.delay_us, g_piezo_config.samples);
+    const piezo_config_t *saved_cfg = piezo_config_get();
+    send_response_piezo_config("rcs:", saved_cfg->freq, saved_cfg->cycles, saved_cfg->avg, saved_cfg->delay_us, saved_cfg->samples);
     return 1;
 }
 

src/parser.h

@@ -9,17 +9,6 @@
 
 #include <stdint.h>
 
-typedef struct
-{
-    uint16_t freq;
-    uint16_t cycles;
-    uint16_t avg;
-    uint16_t delay_us;
-    uint16_t samples;
-} piezo_config_t;
-
-int piezo_config_init(void);
-const piezo_config_t *piezo_config_get(void);
 int ble_cmd_dispatch(const uint8_t *buf, uint16_t len);
 
 #endif /* CMD_PARSER_H__ */