/******************************************************************************* * @file battery_saadc.c * @author CandyPops Co. * @version V1.0.0 * @date 2022-09-05 * @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 #include #include "nrf.h" #include "boards.h" #include "app_error.h" #include "nrf_drv_saadc.h" #include "nrf_drv_timer.h" #include "ble_nus.h" #include "nrf_log.h" #include "main.h" #include "app_timer.h" //#include "fstorage.h" #include "battery_saadc.h" #include "main_timer.h" #include "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) /**@brief Macro to convert the result of ADC conversion in millivolts. * * @param[in] ADC_VALUE ADC result. * * @retval Result converted to millivolts. */ #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; // main.c // 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 extern bool motion_raw_data_enabled ; extern bool ble_got_new_data; extern bool motion_data_once ; /**@brief Function for handling the ADC interrupt. * * @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; } /* 805 uV/LSB 스케일링: raw x 805 = uV, /1000 = mV */ int32_t mv = (int32_t)raw_adc * MV_PER_ADC_STEP; // 단위: 805 uV mv /= 1000; /* 0~3500mV 범위로 클램핑하여 유효 범위 보장 */ if (mv < 0) { mv = 0; } if (mv > 3500) { mv = 3500; } 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) { /* 버퍼에서 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); /* info4(전체 센서 수집) 모드일 때 글로벌 변수에 저장 */ if(info4 == true) { info_p1 = p1_mV; info_p2 = p2_mV; } /* 다음 변환을 위해 버퍼 재등록 */ APP_ERROR_CHECK(nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, 2)); /* SAADC 해제 — 배터리/온도 측정과 하드웨어를 공유하므로 사용 후 반드시 해제 */ nrf_drv_saadc_uninit(); nrf_drv_saadc_channel_uninit(0); nrf_drv_saadc_channel_uninit(1); /* 결과 전송: 명령 소스에 따라 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); // 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); } } } /** * @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; /* 분압 보정 후 최종 전압 */ 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(3500mV) 이하인지 확인 */ 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 */ DBG_PRINTF("Save FDS parameters and then Power OFF\r\n"); 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 모드: 전체 센서 수집(mbb) 중 배터리 값 저장 === */ else if (info4 == true) { info_batt = batt_lvl_in_milli_volt_1; } /* === 일반 모드: 단독 배터리 측정 요청(msn)에 대한 응답 전송 === */ 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); //data_tx_handler(ble_tx_buffer); } } } } /** * @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); err_code = nrf_drv_saadc_channel_init(0, &ch0_cfg); if (err_code != NRF_SUCCESS && err_code != NRF_ERROR_INVALID_STATE) { DBG_PRINTF("SAADC ch0 init err=%d\r\n", err_code); return; } err_code = nrf_drv_saadc_channel_init(1, &ch1_cfg); if (err_code != NRF_SUCCESS && err_code != NRF_ERROR_INVALID_STATE) { DBG_PRINTF("SAADC ch1 init err=%d\r\n", err_code); 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); return; } } /** * @brief 배터리 전압 1회 측정 시작 * * SAADC를 배터리용으로 설정 후 샘플링을 트리거한다. * 결과는 battery_event_handler 콜백에서 비동기로 처리된다. */ void battery_level_meas(void) { ret_code_t err_code; 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(); err_code = nrf_drv_saadc_sample(); 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(); /* 배터리 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)); } /** @brief 배터리 모니터링 타이머 정지 */ void battery_timer_stop(void) { 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)); }