jh.chun/VesiScan-Basic-firmware-test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

레거시 cmd_parse.c 제거 및 dr_cmd_parser 직접 호출 구조로 전환

Browse Source 
- main.c에서 received_command_process() 대신 dr_cmd_parser() 직접 호출
- cmd_parse.c 전역변수/함수(SERIAL_NO, HW_NO, param_error 등) main.c로 이동
- g_plat 초기화를 main.c 초기화 구간으로 이동, log를 RTT 출력으로 연결
- 미사용 명령 삭제: mta, mtr, mst, mxz, myz, mpn, mdc
- cmd_parse.c/h 삭제, 참조하던 5개 파일 include 정리

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
jhChun
2026-03-17 15:45:33 +09:00
parent e7f3c5b02b
commit 36c17d79c6
10 changed files with 2596 additions and 2994 deletions
Download Patch File Download Diff File Expand all files Collapse all files

221
project/ble_peripheral/ble_app_bladder_patch/battery_saadc.c
View File

@@ -3,11 +3,31 @@
* @author CandyPops Co.
* @version V1.0.0
* @date 2022-09-05
* @brief
* @brief
******************************************************************************/
/*******************************************************************************
* [모듈 개요] 배터리 전압 및 압력센서 ADC 측정 모듈
*
* nRF52840의 SAADC(Successive Approximation ADC)를 사용하여 다음을 수행한다:
* 1) 배터리 전압 측정 (AIN2 채널, 1/3 프리스케일링)
* - 5초 주기 타이머(battery_loop)로 반복 측정
* - 저전압(3100mV 이하) 10회 연속 감지 시 자동 전원 OFF
* - info4 모드(전체 센서 수집)에서는 info_batt에 저장 후 온도 측정으로 전환
* 2) 압력센서 2채널 측정 (AIN7=P1, AIN4=P2)
* - 12bit ADC 값을 mV로 변환하여 BLE 또는 UART로 전송
*
* 배터리 전압 변환 공식:
* 전압(mV) = ADC값 x (600mV / 1023) x 6 x 1.42 (분압 저항 보정 계수)
*
* 압력센서 전압 변환 공식:
* 전압(mV) = ADC값 x 0.805(uV/LSB) / 1000, 범위 0~3500mV 클램핑
*
* info4 모드 순서: 배터리 -> 온도(go_temp) -> IMU(motion_raw_data_enabled)
******************************************************************************/
#include "sdk_common.h"
#include <stdint.h>
#include <string.h>
#include "nrf.h"
@@ -22,15 +42,18 @@
//#include "fstorage.h"
#include "battery_saadc.h"
#include "main_timer.h"
#include <cmd_parse.h>
#include "main.h" /* 2026-03-17: cmd_parse.h 삭제 → main.h */
#include "debug_print.h"
/* SAADC 내부 기준전압 600mV */
#define BATTERY_REF_VOLTAGE_IN_MILLIVOLTS 600 /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
/* 1/3 프리스케일링 보상 계수 (입력 전압을 1/3로 분압하므로 x3, 추가 x2 = 총 x6) */
#define BATTERY_PRE_SCALING_COMPENSATION 6 /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
/* 10비트 ADC 최대 디지털 값 */
#define BATTERY_ADC_RES_10BITS 1023 /**< Maximum digital value for 10-bit ADC conversion. */
//#define PRESSURE_RESULT_IN_MILLI_VOLTS(adc) ((adc * 3600) / 1023)
#define PRESSURE_OFFSET_DEFAULT 0 // ?? offset. ?? ? ??? ?? ??.
#define MV_PER_ADC_STEP 805 // ? 0.805mV per 1 LSB (nRF 12bit + scaling)
#define PRESSURE_OFFSET_DEFAULT 0 // 압력 offset. 캘리브레이션 시 사용 가능
#define MV_PER_ADC_STEP 805 // 약 0.805mV per 1 LSB (nRF 12bit + scaling)
/**@brief Macro to convert the result of ADC conversion in millivolts.
*
* @param[in] ADC_VALUE ADC result.
@@ -40,29 +63,41 @@
#define BATTERY_RESULT_IN_MILLI_VOLTS(ADC_VALUE)\
((((ADC_VALUE) * BATTERY_REF_VOLTAGE_IN_MILLIVOLTS) / BATTERY_ADC_RES_10BITS) * BATTERY_PRE_SCALING_COMPENSATION)
/* 배터리 측정용 더블 버퍼 (SAADC가 비동기로 교대 사용) */
static nrf_saadc_value_t adc_bufs[2];
/* 압력센서 2채널 ADC 버퍼 [0]=AIN7(P1), [1]=AIN4(P2) */
static int16_t pressure_adc_buf[2]; //cj add 25/11/19
static uint16_t convert_adc_to_mV(int16_t raw_adc); //cj add 25/11/19
/* 배터리 모니터링 반복 타이머 정의 */
APP_TIMER_DEF(m_battery_loop_timer_id);
/* 배터리 측정 주기: 5초 (밀리초 단위) */
#define BATTERY_LOOP_INTERVAL 5000
/* 저전압 체크 플래그 — battery_loop에서 true로 설정, 핸들러에서 소비 */
bool low_battery_check = false;
/* info4: 전체 센서 데이터 수집 모드 플래그 (cmd_parse에서 설정) */
extern bool info4; //cmd_parse
// cj add edit 25/11/24
/* info4 모드에서 압력센서 측정값을 임시 저장하는 변수 (mV 단위) */
volatile uint16_t info_p1;
volatile uint16_t info_p2;
extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
/* true가 되면 main_timer에서 전원 OFF 시퀀스 실행 */
extern bool go_device_power_off;
/* 다른 작업(IMU 등) 처리 중이면 true — 배터리 측정 스킵용 */
extern volatile bool processing;
/* 현재 명령 소스: CMD_UART 또는 CMD_BLE */
extern which_cmd_t cmd_type_t;
extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
/* info4 모드에서 배터리 전압을 임시 저장 (mV 단위) */
volatile uint16_t info_batt; //48_c
/* info4 순차 측정 제어 플래그: go_batt→go_temp→motion */
extern bool go_temp; //
extern bool go_batt; //cmd_parse
@@ -74,15 +109,27 @@ extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
/**
* @brief 압력센서 ADC 원시값을 밀리볼트(mV)로 변환
*
* 변환 공식: mV = raw_adc x 805(uV/LSB) / 1000
* 결과를 0~3500mV 범위로 클램핑하여 이상치 방지
*
* @param raw_adc SAADC에서 읽은 원시 ADC 값 (12bit)
* @return 변환된 전압값 (mV), 0~3500 범위
*/
static uint16_t convert_adc_to_mV(int16_t raw_adc)
{
/* 음수 ADC 값은 0으로 처리 (노이즈 등으로 발생 가능) */
if (raw_adc < 0)
raw_adc = 0;
int32_t mv = (int32_t)raw_adc * MV_PER_ADC_STEP; // ?: 805 uV
/* 805 uV/LSB 스케일링: raw x 805 = uV, /1000 = mV */
int32_t mv = (int32_t)raw_adc * MV_PER_ADC_STEP; // 단위: 805 uV
mv /= 1000;
// ===== (3) 0~3500mV ??? ???? ?? ?? =====
/* 0~3500mV 범위로 클램핑하여 유효 범위 보장 */
if (mv < 0)
mv = 0;
@@ -92,49 +139,61 @@ extern uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] ;
return (uint16_t)mv;
}
/**
* @brief 압력센서 2채널 ADC 완료 콜백
*
* SAADC 변환 완료 시 호출된다.
* AIN7(P1)과 AIN4(P2) 두 채널의 ADC 값을 mV로 변환한 뒤,
* info4 모드이면 글로벌 변수에 저장하고, 아니면 BLE/UART로 즉시 전송한다.
* 변환 후 SAADC를 해제하여 다른 ADC 측정(배터리, 온도)과 공유한다.
*/
void pressure_all_event_handler(nrf_drv_saadc_evt_t const * p_event)
{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
int16_t p1_adc = p_event->data.done.p_buffer[0]; // AIN7
int16_t p2_adc = p_event->data.done.p_buffer[1]; // AIN4
/* 버퍼에서 2채널 ADC 원시값 추출 */
int16_t p1_adc = p_event->data.done.p_buffer[0]; // AIN7 (압력센서1)
int16_t p2_adc = p_event->data.done.p_buffer[1]; // AIN4 (압력센서2)
/* ADC 원시값 → 밀리볼트 변환 */
uint16_t p1_mV = convert_adc_to_mV(p1_adc);
uint16_t p2_mV = convert_adc_to_mV(p2_adc);
// PD Full mode(info4=true)When info_p1/info_p2 to Update
/* info4(전체 센서 수집) 모드일 때 글로벌 변수에 저장 */
if(info4 == true)
{
info_p1 = p1_mV;
info_p2 = p2_mV;
}
// Re-buffer
/* 다음 변환을 위해 버퍼 재등록 */
APP_ERROR_CHECK(nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, 2));
// uninit
/* SAADC 해제 — 배터리/온도 측정과 하드웨어를 공유하므로 사용 후 반드시 해제 */
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
nrf_drv_saadc_channel_uninit(1);
// UART send
/* 결과 전송: 명령 소스에 따라 UART 또는 BLE로 전송 */
if(cmd_type_t == CMD_UART)
{
DBG_PRINTF("P1:%d P2:%d\r\n", p1_mV, p2_mV);
}
/* BLE 모드이고 info4가 아닌 경우(단독 압력 측정) → BLE 바이너리 전송 */
else if(cmd_type_t == CMD_BLE && info4 == false)
{
DBG_PRINTF("P1:%d P2:%d\r\n", p1_mV, p2_mV);
DBG_PRINTF("P1:%d P2:%d\r\n", p1_mV, p2_mV);
// uint16_t len = sprintf((char*)ble_bin_buffer,
// "rpn:%04x,%04x", p1_mV, p2_mV);
/* 2채널 압력값을 "rpn:" 헤더와 함께 바이너리 포맷으로 BLE 전송 */
uint16_t result_data[2];
result_data[0] = p1_mV;
result_data[1] = p2_mV;
format_data(ble_bin_buffer, "rpn:", result_data,2);
dr_binary_tx_safe(ble_bin_buffer,4);
}
}
}
@@ -142,34 +201,54 @@ void pressure_all_event_handler(nrf_drv_saadc_evt_t const * p_event)
/**
* @brief 배터리 전압 ADC 완료 콜백
*
* SAADC 변환 완료 시 호출된다.
* ADC 값을 실제 배터리 전압(mV)으로 변환하고, 동작 모드에 따라:
* - 저전압 체크 모드: 3100mV 이하 10회 연속이면 자동 전원 OFF
* - info4 모드: info_batt에 저장 후 온도 측정(go_temp)으로 전환
* - 일반 모드: BLE 또는 UART로 즉시 전송
*
* 전압 변환: ADC값 x (600/1023) x 6 = 기본 전압, x 1.42 = 분압 보정 후 실제 전압
*/
void battery_event_handler( nrf_drv_saadc_evt_t const * p_event )
{
/* 저전압 연속 감지 카운터 (static으로 호출 간 유지) */
static uint8_t low_battery_cnt = 0;
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
nrf_saadc_value_t register_val = 0;
uint16_t batt_lvl_in_milli_volt_0 = 0;
uint16_t batt_lvl_in_milli_volt_1 = 0;
uint16_t batt_lvl_in_milli_volt_0 = 0; /* 보정 전 전압 */
uint16_t batt_lvl_in_milli_volt_1 = 0; /* 분압 보정 후 최종 전압 */
uint32_t err_code = 0;
/* ADC 변환 결과 읽기 */
register_val = p_event->data.done.p_buffer[0];
/* 다음 변환을 위해 버퍼 재등록 */
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, 1);
APP_ERROR_CHECK(err_code);
/* SAADC 해제 — 다른 ADC 측정(온도, 압력)과 하드웨어 공유 */
nrf_drv_saadc_uninit();
nrf_drv_saadc_channel_uninit(0);
/* ADC값 → mV 변환 (매크로: ADC x 600/1023 x 6) */
batt_lvl_in_milli_volt_0 = BATTERY_RESULT_IN_MILLI_VOLTS(register_val);
/* 분압 저항 보정 계수 1.42 적용 → 실제 배터리 전압 */
batt_lvl_in_milli_volt_1 = (batt_lvl_in_milli_volt_0) *1.42;
/* === 저전압 체크 모드 (battery_loop 타이머에서 설정) === */
if(low_battery_check == true) {
low_battery_check = false;
/* 배터리 전압이 LOW_BATTERY_VOLTAGE(3100mV) 이하인지 확인 */
if(batt_lvl_in_milli_volt_1 <= LOW_BATTERY_VOLTAGE) {
/* 10회 연속 저전압 감지 시 전원 OFF 시퀀스 시작 */
if(low_battery_cnt >= 10) {
low_battery_cnt = 0;
/*go to power off and fds save */
@@ -177,25 +256,28 @@ void battery_event_handler( nrf_drv_saadc_evt_t const * p_event )
go_device_power_off = true;
main_timer_start();
}else{
/* 아직 10회 미만 — 카운터 증가 후 경고 출력 */
low_battery_cnt++;
DBG_PRINTF("WARNING!!! low_battery cnt = %d, Batt = %d(mV)\r\n", low_battery_cnt, batt_lvl_in_milli_volt_1);
}
}
}
}
/* === info4 모드: 전체 센서 수집 중 배터리 값 저장 === */
else if (info4 == true){
info_batt = batt_lvl_in_milli_volt_1;
DBG_PRINTF("INFOTn%d\r\n\r\n", batt_lvl_in_milli_volt_1);
}
/* === 일반 모드: 단독 배터리 측정 요청에 대한 응답 전송 === */
else {
if(cmd_type_t == CMD_UART) {
DBG_PRINTF("Tn%d\r\n\r\n", batt_lvl_in_milli_volt_1);
} else if(cmd_type_t == CMD_BLE) {
/* "rsn:" 헤더와 함께 배터리 전압을 바이너리로 BLE 전송 */
single_format_data(ble_bin_buffer, "rsn:", batt_lvl_in_milli_volt_1);
dr_binary_tx_safe(ble_bin_buffer,3);
@@ -203,45 +285,65 @@ void battery_event_handler( nrf_drv_saadc_evt_t const * p_event )
}
}
}
/* info4 모드: 배터리 측정 완료 → 다음 단계(온도 측정)로 전환 */
if (info4 == true){
go_batt =false;
go_temp = true;
main_timer_start();
go_batt =false; /* 배터리 측정 완료 표시 */
go_temp = true; /* 온도 측정 시작 플래그 설정 */
main_timer_start(); /* 메인 타이머 시작 → 온도 측정 트리거 */
}
}
/**@brief Function for configuring ADC to do battery level conversion.
/**
* @brief SAADC를 배터리 전압 측정용으로 설정
*
* AIN2 채널을 싱글엔드(SE) 모드, 1/3 프리스케일링으로 초기화한다.
* 더블 버퍼(adc_bufs[0], [1])를 등록하여 연속 측정이 가능하도록 한다.
* 콜백: battery_event_handler
*/
static void battery_configure(void)
{
/* SAADC 드라이버 초기화 (기본 설정 + 배터리 이벤트 핸들러 등록) */
ret_code_t err_code = nrf_drv_saadc_init(NULL, battery_event_handler);
APP_ERROR_CHECK(err_code);
/* AIN2 채널 설정: 싱글엔드 입력, 1/3 프리스케일링 (기본값) */
nrf_saadc_channel_config_t config =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN2);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
/* 더블 버퍼 등록 — SAADC가 교대로 사용하여 데이터 손실 방지 */
err_code = nrf_drv_saadc_buffer_convert(&adc_bufs[0], 1);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(&adc_bufs[1], 1);
APP_ERROR_CHECK(err_code);
}
/**
* @brief SAADC를 압력센서 2채널 측정용으로 설정
*
* AIN7(압력센서1)과 AIN4(압력센서2)를 싱글엔드 모드로 초기화한다.
* 이미 초기화된 상태(NRF_ERROR_INVALID_STATE)는 무시하여 안전하게 처리한다.
* 콜백: pressure_all_event_handler
*/
void pressure_all_configure(void)
{
ret_code_t err_code;
/* SAADC 드라이버 초기화 (이미 초기화된 경우 무시) */
err_code = nrf_drv_saadc_init(NULL, pressure_all_event_handler);
if (err_code != NRF_SUCCESS && err_code != NRF_ERROR_INVALID_STATE) {
DBG_PRINTF("SAADC init err=%d\r\n", err_code);
return;
}
/* 채널 0: AIN7 (압력센서1, P1) */
nrf_saadc_channel_config_t ch0_cfg =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN7);
/* 채널 1: AIN4 (압력센서2, P2) */
nrf_saadc_channel_config_t ch1_cfg =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN4);
@@ -257,6 +359,7 @@ void pressure_all_configure(void)
return;
}
/* 2채널 ADC 버퍼 등록 ([0]=P1, [1]=P2) */
err_code = nrf_drv_saadc_buffer_convert(pressure_adc_buf, 2);
if (err_code != NRF_SUCCESS) {
DBG_PRINTF("SAADC buf conv err=%d\r\n", err_code);
@@ -264,53 +367,75 @@ void pressure_all_configure(void)
}
}
/**
* @brief 배터리 전압 1회 측정 시작
*
* SAADC를 배터리용으로 설정 후 샘플링을 트리거한다.
* 결과는 battery_event_handler 콜백에서 비동기로 처리된다.
*/
void battery_level_meas(void)
{
ret_code_t err_code;
battery_configure();
err_code = nrf_drv_saadc_sample();
battery_configure(); /* SAADC 배터리용 초기화 */
err_code = nrf_drv_saadc_sample(); /* ADC 샘플링 트리거 (비동기) */
APP_ERROR_CHECK(err_code);
}
/**
* @brief 압력센서 2채널 1회 측정 시작
*
* SAADC를 압력센서 2채널용으로 설정 후 샘플링을 트리거한다.
* 결과는 pressure_all_event_handler 콜백에서 비동기로 처리된다.
*/
void pressure_all_level_meas(void) //add cj add 25/11/19
{
ret_code_t err_code;
pressure_all_configure(); // 2
pressure_all_configure(); /* SAADC 압력센서 2채널 초기화 */
err_code = nrf_drv_saadc_sample();
err_code = nrf_drv_saadc_sample(); /* ADC 샘플링 트리거 (비동기) */
APP_ERROR_CHECK(err_code);
}
/**
* @brief 배터리 모니터링 타이머 콜백 (5초 주기)
*
* 다른 작업(IMU 등) 처리 중이면 측정을 건너뛴다.
* 그렇지 않으면 저전압 체크 플래그를 설정하고 배터리 측정을 시작한다.
*/
void battery_loop(void * p_context) /* For 1sec */
{
UNUSED_PARAMETER(p_context);
/* 다른 센서 처리 중이면 배터리 측정 스킵 (충돌 방지) */
if(processing==true)
{
{
processing = false ; // add 20241218
//low_battery_check = true;
return;}
else{
low_battery_check = true;
battery_level_meas();
low_battery_check = true; /* 저전압 감지 모드로 측정 */
battery_level_meas(); /* 배터리 ADC 1회 측정 시작 */
}
}
/** @brief 배터리 모니터링 타이머 시작 (5초 반복) */
void battery_timer_start(void)
{
APP_ERROR_CHECK(app_timer_start(m_battery_loop_timer_id, APP_TIMER_TICKS(BATTERY_LOOP_INTERVAL), NULL));
APP_ERROR_CHECK(app_timer_start(m_battery_loop_timer_id, APP_TIMER_TICKS(BATTERY_LOOP_INTERVAL), NULL));
}
/** @brief 배터리 모니터링 타이머 정지 */
void battery_timer_stop(void)
{
APP_ERROR_CHECK(app_timer_stop(m_battery_loop_timer_id));
APP_ERROR_CHECK(app_timer_stop(m_battery_loop_timer_id));
}
/** @brief 배터리 모니터링 타이머 초기화 (반복 모드, 콜백: battery_loop) */
void battery_timer_init(void)
{
APP_ERROR_CHECK(app_timer_create(&m_battery_loop_timer_id, APP_TIMER_MODE_REPEATED, battery_loop));
APP_ERROR_CHECK(app_timer_create(&m_battery_loop_timer_id, APP_TIMER_MODE_REPEATED, battery_loop));
}