코드 정리

- 주석 영문으로 변경 - Allman 스타일로 통일
2026-04-16 12:01:51 +09:00
parent c98d9ae14e
commit 2861cb9815
35 changed files with 2406 additions and 2557 deletions
--- a/project/ble_peripheral/ble_app_bladder_patch/system/power/power_control.c
+++ b/project/ble_peripheral/ble_app_bladder_patch/system/power/power_control.c
@@ -3,24 +3,24 @@
 //=========power_control.c====================
 *******************************************************************************
 *
- * [모듈 개요]
- * 디바이스 전원 시퀀스를 관리하는 모듈 (전원 켜기 / 끄기 / 슬립).
+ * [Module overview]
+ * Device power sequence manager (power on / off / sleep).
 *
- * [전원 켜기 흐름]
+ * [Power-on flow]
 *   device_activated()
- *     → power_loop 타이머 시작 → 즉시 완료 (센서 초기화 불필요)
- *     → 센서(IMU)는 측정 명령 시 imu_read_direct()가 자체 처리
+ *     -> Start power_loop timer -> completes immediately (no sensor init needed)
+ *     -> Sensor (IMU) is handled by imu_read_direct() at measurement time
 *
- * [슬립 모드]
+ * [Sleep mode]
 *   device_sleep_mode()
- *     → processing 플래그 해제
+ *     -> Clear processing flag
 *
- * [재활성화]
+ * [Reactivation]
 *   device_reactivated()
- *     → I2C 재초기화 후 전원 시퀀스를 처음부터 다시 시작
+ *     -> Re-init I2C then restart power sequence from the beginning
 *
- * [타이머]
- *   싱글샷 모드 app_timer, 20ms 간격으로 power_loop 호출
+ * [Timer]
+ *   Single-shot app_timer, calls power_loop at 20ms interval
 *
 ******************************************************************************/
 #include <stdbool.h>
@@ -38,53 +38,53 @@
 #include "i2c_manager.h"


-/* 전원 시퀀스용 싱글샷 타이머 인스턴스 */
+/* Single-shot timer instance for power sequence */
 APP_TIMER_DEF(m_power_timer_id);

-/* 전원 시퀀스 상태머신의 타이머 간격 (20ms) */
+/* Power sequence state machine timer interval (20ms) */
 // 2025-12-08 change to #define POWER_LOOP_INTERVAL 30 -> 20
 #define POWER_LOOP_INTERVAL 20

-/* 전원 시퀀스 현재 단계 (0: I2C 초기화, 1: 예약, 2: 완료) */
+/* Power sequence current step (0: I2C init, 1: reserved, 2: complete) */
 static uint8_t p_order;

-/* 데이터 처리 중 플래그 (외부 모듈에서 선언) */
+/* Data processing flag (declared in external module) */
 extern volatile bool processing;

-/* 전원 시퀀스 잠금 플래그 (true = 전원 시퀀스 진행 중) */
+/* Power sequence lock flag (true = sequence in progress) */
 bool lock_check = false;

 /**
- * @brief 디바이스 슬립 모드 진입
+ * @brief Enter device sleep mode
 *
- * 데이터 처리 플래그(processing)를 해제하여
- * 메인 루프가 더 이상 센서 데이터를 처리하지 않도록 한다.
+ * Clears the processing flag so the main loop stops
+ * processing sensor data.
 *
- * @return 0 (항상 성공)
+ * @return 0 (always succeeds)
 */
 int device_sleep_mode(void){
 	int rc = 0;
 	nrf_delay_ms(2);
 	DBG_PRINTF("Device_Sleep_Mode OK!\r\n");
 	nrf_delay_ms(10);
-	processing = false;           /* 데이터 처리 플래그 해제 → 센서 처리 중단 */
+	processing = false;           /* Clear processing flag -> stop sensor handling */
 	return rc;
 }


 /**
- * @brief 디바이스 전원 켜기 (전원 시퀀스 시작)
+ * @brief Power on device (start power sequence)
 *
- * 전원 시퀀스 단계를 0으로 초기화하고, 잠금 플래그를 설정한 뒤
- * 타이머를 시작하여 power_loop() 상태머신을 구동한다.
+ * Resets the sequence step to 0, sets the lock flag, and starts
+ * the timer to drive the power_loop() state machine.
 *
- * @return 0 (항상 성공)
+ * @return 0 (always succeeds)
 */
 int device_activated(void){
 	int rc = 0;
-	p_order = 0;           /* 상태머신 시작 단계 (Step 0: I2C 초기화) */
-	lock_check =true;      /* 전원 시퀀스 진행 중 잠금 */
-	power_timer_start();   /* 20ms 후 power_loop() 첫 호출 */
+	p_order = 0;           /* State machine start step (Step 0: I2C init) */
+	lock_check =true;      /* Lock: power sequence in progress */
+	power_timer_start();   /* First power_loop() call after 20ms */

 	return rc;
 }
@@ -101,60 +101,60 @@ int device_activated(void){
 *   2: Complete
 */
 /*
- * 전원 시퀀스 상태머신 (20ms 싱글샷 타이머 콜백).
+ * Power sequence state machine (20ms single-shot timer callback).
 *
- * [실행 흐름]
- *   1) 타이머 콜백 진입 → 타이머 정지 (싱글샷이므로)
- *   2) 현재 p_order에 해당하는 초기화 단계 실행
- *   3) p_order < 2이면 다음 단계로 진행하고 타이머 재시작
- *   4) p_order == 2이면 전원 시퀀스 완료
+ * [Execution flow]
+ *   1) Timer callback entry -> stop timer (single-shot)
+ *   2) Execute init step for current p_order
+ *   3) If p_order < 2, advance to next step and restart timer
+ *   4) If p_order == 2, power sequence complete
 *
- * 센서 초기화 불필요 — imu_read_direct()가 매 측정 시 자체 처리
+ * No sensor init needed -- imu_read_direct() handles it per measurement.
 */
 void power_loop(void *p_context)
 {
    UNUSED_PARAMETER(p_context);

-    power_timer_stop();   /* 현재 타이머 정지 (싱글샷 → 수동 재시작 필요) */
+    power_timer_stop();   /* Stop current timer (single-shot, manual restart needed) */

-    /* 센서 초기화 불필요 — imu_read_direct()가 매 측정 시 자체 처리 */
-    /* 추후 전원 시퀀스 단계가 필요하면 여기에 switch(p_order) 추가 */
+    /* No sensor init needed -- imu_read_direct() handles it per measurement */
+    /* Add switch(p_order) here if future power sequence steps are needed */
    p_order = 2;

    /* Advance to next step or finish */
-    /* 다음 단계로 진행하거나, 시퀀스 완료 처리 */
+    /* Advance to next step or finish sequence */
    if (p_order < 2) {
-        p_order++;             /* 다음 단계로 이동 */
-        power_timer_start();   /* 20ms 후 다음 단계 실행 */
+        p_order++;             /* Move to next step */
+        power_timer_start();   /* Execute next step after 20ms */
    } else {
-        /* 전원 시퀀스 전체 완료 */
+        /* Power sequence fully complete */
        DBG_PRINTF("[PWR] Device Activated OK!\r\n");
    }
 }


 /**
- * @brief 디바이스 재활성화 (슬립 복귀 시)
+ * @brief Reactivate device (on wake from sleep)
 *
- * I2C를 재초기화하고, 전원 시퀀스를 처음부터 다시 시작한다.
- * 슬립 모드에서 깨어날 때 호출된다.
+ * Re-initializes I2C and restarts the power sequence from the beginning.
+ * Called when waking from sleep mode.
 *
- * @return 0 (항상 성공)
+ * @return 0 (always succeeds)
 */
 int device_reactivated(void){
 	int rc = 0;
-	sw_i2c_init_once();    /* I2C 버스 재초기화 */
-	nrf_delay_ms(10);      /* 안정화 대기 */
-	lock_check = true;     /* 전원 시퀀스 진행 중 잠금 */
-	p_order = 0;           /* 상태머신을 Step 0부터 재시작 */
-	power_timer_start();   /* 20ms 후 power_loop() 시작 */
+	sw_i2c_init_once();    /* Re-initialize I2C bus */
+	nrf_delay_ms(10);      /* Stabilization delay */
+	lock_check = true;     /* Lock: power sequence in progress */
+	p_order = 0;           /* Restart state machine from Step 0 */
+	power_timer_start();   /* Start power_loop() after 20ms */
 	return rc;
 }

 /**
- * @brief 전원 시퀀스 타이머 시작
+ * @brief Start power sequence timer
 *
- * 싱글샷 모드로 POWER_LOOP_INTERVAL(20ms) 후 power_loop()를 호출한다.
+ * Single-shot mode; calls power_loop() after POWER_LOOP_INTERVAL (20ms).
 */
 void power_timer_start(void)
 {
@@ -163,7 +163,7 @@ void power_timer_start(void)


 /**
- * @brief 전원 시퀀스 타이머 정지
+ * @brief Stop power sequence timer
 */
 void power_timer_stop(void)
 {
@@ -173,10 +173,10 @@ void power_timer_stop(void)


 /**
- * @brief 전원 시퀀스 타이머 초기화 (앱 시작 시 1회 호출)
+ * @brief Initialize power sequence timer (call once at app startup)
 *
- * 싱글샷 모드 타이머를 생성하고, 콜백으로 power_loop()를 등록한다.
- * 싱글샷이므로 매 단계마다 power_timer_start()로 수동 재시작해야 한다.
+ * Creates a single-shot timer with power_loop() as callback.
+ * Must manually restart via power_timer_start() after each step.
 */
 void power_timer_init(void)  //active start
 {
--- a/project/ble_peripheral/ble_app_bladder_patch/system/power/power_control.h
+++ b/project/ble_peripheral/ble_app_bladder_patch/system/power/power_control.h
@@ -6,16 +6,16 @@
 * @brief
 *******************************************************************************
 *
- * [헤더 개요]
- * 디바이스 전원 시퀀스 관리 모듈의 공용 인터페이스 헤더.
+ * [Header overview]
+ * Public interface header for the device power sequence manager.
 *
- * [주요 함수 요약]
- *   device_activated()     : 전원 켜기 → power_loop 상태머신 시작
- *   device_sleep_mode()    : 슬립 모드 진입 (처리 중단)
- *   device_reactivated()   : 슬립 복귀 → 전원 시퀀스 재시작
- *   power_loop()           : 20ms 간격 전원 시퀀스 상태머신 콜백
- *   power_timer_start/stop : 전원 시퀀스 타이머 제어
- *   power_timer_init()     : 전원 시퀀스 타이머 초기화 (앱 시작 시 1회)
+ * [Key functions]
+ *   device_activated()     : Power on -> start power_loop state machine
+ *   device_sleep_mode()    : Enter sleep mode (stop processing)
+ *   device_reactivated()   : Wake from sleep -> restart power sequence
+ *   power_loop()           : 20ms power sequence state machine callback
+ *   power_timer_start/stop : Power sequence timer control
+ *   power_timer_init()     : Initialize power sequence timer (call once at startup)
 *
 ******************************************************************************/

@@ -24,25 +24,25 @@

 #include "main.h"

-/** @brief 디바이스 슬립 모드 진입 (processing 해제) */
+/** @brief Enter device sleep mode (clears processing flag) */
 int device_sleep_mode(void);

-/** @brief 디바이스 전원 켜기 (전원 시퀀스 상태머신 시작) */
+/** @brief Power on device (start power sequence state machine) */
 int device_activated(void);

-/** @brief 디바이스 재활성화 (슬립 복귀 시 I2C 재초기화 후 시퀀스 재시작) */
+/** @brief Reactivate device (re-init I2C and restart sequence on wake from sleep) */
 int device_reactivated(void);

-/** @brief 전원 시퀀스 상태머신 (20ms 타이머 콜백, Step 0→1→2) */
+/** @brief Power sequence state machine (20ms timer callback, Step 0->1->2) */
 void power_loop(void * p_context);	/* For x ms */

-/** @brief 전원 시퀀스 타이머 시작 (20ms 싱글샷) */
+/** @brief Start power sequence timer (20ms single-shot) */
 void power_timer_start(void);

-/** @brief 전원 시퀀스 타이머 정지 */
+/** @brief Stop power sequence timer */
 void power_timer_stop(void);;

-/** @brief 전원 시퀀스 타이머 초기화 (앱 시작 시 1회 호출) */
+/** @brief Initialize power sequence timer (call once at app startup) */
 void power_timer_init(void);
 #endif //_POWER_CONTROL_H_