VesiScan-Basic-firmware-test/project/ble_peripheral/ble_app_bladder_patch/battery_saadc.c

/*******************************************************************************
 * @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 <stdint.h>
#include <string.h>
#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(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 */
					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 모드: 전체 센서 수집 중 배터리 값 저장 === */
		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);
				//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();   /* SAADC 압력센서 2채널 초기화 */

    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();        /* 배터리 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));
}