From: p15692025051 <846603105@qq.com> Date: Tue, 8 Aug 2023 03:12:30 +0000 (+0800) Subject: 添加hx3918驱动 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=c3c519c284c5280291b0da11e3021aea1e00f08b;p=mirrors%2FASR1603_G5.git 添加hx3918驱动 --- diff --git a/2.sdk/Helios_SDK/components/HX3918/HX3918.mk b/2.sdk/Helios_SDK/components/HX3918/HX3918.mk new file mode 100644 index 00000000..bf9a959f --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/HX3918.mk @@ -0,0 +1,35 @@ +NAME := HX3918 + +include config/$(KCONFIG_CONFIG) + +GLOBAL_INCS = include + +$(NAME)_SRCS += \ + hx3918.c \ + hx3918_check_touch.c \ + hx3918_factory_test.c \ + hx3918_hrs_agc.c \ + hx3918_hrv_agc.c \ + hx3918_prox.c \ + hx3918_spo2_agc.c + +GLOBAL_INCS += \ + . \ + +ifeq ($(CONFIG_HX3918), y) + +$(NAME)_ARCHIVES := \ + lib/gcc_3918lib_hrs_spo2_20230731_v0.1.a + +endif + + +$(NAME)_CFLAGS = \ + -Wno-error \ + -Wno-unused-but-set-variable + + + +$(NAME)_COMPONENTS = peripheral + + diff --git a/2.sdk/Helios_SDK/components/HX3918/HX3918_option.in b/2.sdk/Helios_SDK/components/HX3918/HX3918_option.in new file mode 100644 index 00000000..cf8ad16a --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/HX3918_option.in @@ -0,0 +1,9 @@ +config HX3918 + bool "Enable HX3918" + default y +help + This is HX3918 support. + + + + diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918.c b/2.sdk/Helios_SDK/components/HX3918/hx3918.c new file mode 100644 index 00000000..edf89aa4 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918.c @@ -0,0 +1,1134 @@ + +#include +#include +#include +#include +#include +#include "hx3918.h" + +#include "helios_gpio.h" +#include "helios_iic.h" +#include "helios_lcd.h" +#include "helios_fs.h" +#include "helios_pin.h" +#include "helios_debug.h" + +#define HX3918_ADDR 0x44 +#define HX3918_DEBUG 1 +#if HX3918_DEBUG == 1 +#define HX3918_LOG(msg, ...) custom_log("HX3918", msg, ##__VA_ARGS__) +#endif +//#include "tyhx_hrs_custom.h" +#ifdef SAR_ALG_LIB +#include "hx3918_prox.h" +#endif + +#ifdef HRS_ALG_LIB +#include "hx3918_hrs_agc.h" +#include "tyhx_hrs_alg.h" + +#ifdef SPO2_ALG_LIB +#include "hx3918_spo2_agc.h" +#include "tyhx_spo2_alg.h" +#endif + +#ifdef HRV_ALG_LIB +#include "hx3918_hrv_agc.h" +#include "tyhx_hrv_alg.h" +#endif + +#ifdef CHECK_TOUCH_LIB +#include "hx3918_check_touch.h" +#endif +#include "hx3918_factory_test.h" + + + +#ifdef SPO2_VECTOR +#include "spo2_vec.h" +uint32_t spo2_send_cnt = 0; +int32_t red_buf_vec[8]; +int32_t ir_buf_vec[8]; +int32_t green_buf_vec[8]; +#endif + +#ifdef HR_VECTOR +#include "hr_vec.h" +uint32_t hrs_send_cnt = 0; +int32_t PPG_buf_vec[8]; +#endif + +#ifdef HRV_TESTVEC +#include "hrv_testvec.h" +#endif + +#ifdef GSENSER_DATA +//#include "lis3dh_drv.h" +#endif +tyhx_hrsresult_t hrsresult; + +#ifdef GSENSER_DATA +volatile int16_t gsen_fifo_x[32]; //ppg time 330ms..330/40 = 8.25 +volatile int16_t gsen_fifo_y[32]; +volatile int16_t gsen_fifo_z[32]; +#else +int16_t gen_dummy[32] = {0}; +#endif +//SPO2 agc +const uint8_t hx3918_spo2_agc_green_idac = GREEN_AGC_OFFSET; +const uint8_t hx3918_spo2_agc_red_idac = RED_AGC_OFFSET; +const uint8_t hx3918_spo2_agc_ir_idac = IR_AGC_OFFSET; +//hrs agc +const uint8_t hx3918_hrs_agc_idac = HR_GREEN_AGC_OFFSET; +//hrv agc +const uint8_t hx3918_hrv_agc_idac = HR_GREEN_AGC_OFFSET; + +const uint8_t red_led_max_init = 200; +const uint8_t ir_led_max_init = 200; +const uint8_t green_led_max_init = 150; + +uint8_t low_vbat_flag =0; +//WORK_MODE_T work_mode_flag = HRS_MODE; + +const uint16_t static_thre_val = 150; +const uint8_t gsen_lv_val = 0; + +//HRS_INFRARED_THRES +const int32_t hrs_ir_unwear_thres = 3000; +const int32_t hrs_ir_wear_thres = 4000; +//HRV_INFRARED_THRES +const int32_t hrv_ir_unwear_thres = 3000; +const int32_t hrv_ir_wear_thres = 4000; +//SPO2_INFRARED_THRES +const uint8_t spo2_check_unwear_oft = 10; +const int32_t spo2_ir_wear_thres = 2000; +//CHECK_WEAR_MODE_THRES +const int32_t check_mode_unwear_thre = 3000; +const int32_t check_mode_wear_thre = 4000; +//const int32_t check_mode_sar_thre = 6000; + +//const int32_t sar_unwear_thres = 2000; +//const int32_t sar_wear_thres = 3000; + +uint8_t alg_ram[11 * 1024] __attribute__((aligned(4))); +ppg_sensor_data_t ppg_s_dat; +uint8_t read_fifo_first_flg = 0; +hrs_sports_mode_t hrs_mode = NORMAL_MODE; +#endif + +//////// spo2 para and switches +const uint8_t COUNT_BLOCK_NUM = 50; //delay the block of some single good signal after a series of bad signal +const uint8_t SPO2_LOW_XCORR_THRE = 30; //(64*xcorr)'s square below this threshold, means error signal +const uint8_t SPO2_CALI = 1; //spo2_result cali mode +const uint8_t XCORR_MODE = 1; //xcorr mode switch +const uint8_t QUICK_RESULT = 1; //come out the spo2 result quickly ;0 is normal,1 is quick +const uint16_t MEAN_NUM = 32; //the length of smooth-average ;the value of MEAN_NUM can be given only 256 and 512 +const uint8_t G_SENSOR = 0; //if =1, open the gsensor mode +const uint8_t SPO2_GSEN_POW_THRE = 150; //gsen pow judge move, range:0-200; +const uint32_t SPO2_BASE_LINE_INIT = 135000; //spo2 baseline init, = 103000 + ratio(a variable quantity,depends on different cases)*SPO2_SLOPE +const int32_t SOP2_DEGLITCH_THRE = 100000; //remove signal glitch over this threshold +const int32_t SPO2_REMOVE_JUMP_THRE = 100000; //remove signal jump over this threshold +const uint32_t SPO2_SLOPE = 50000; //increase this slope, spo2 reduce more +const uint16_t SPO2_LOW_CLIP_END_TIME = 1500; //low clip mode before this data_cnt, normal clip mode after this +const uint16_t SPO2_LOW_CLIP_DN = 150; //spo2 reduce 0.15/s at most in low clip mode +const uint16_t SPO2_NORMAL_CLIP_DN = 500; //spo2 reduce 0.5/s at most in normal clip mode +const uint8_t SPO2_LOW_SNR_THRE = 40; //snr below this threshold, means error signal +const uint16_t IR_AC_TOUCH_THRE = 200; //AC_min*0.3 +const uint16_t IR_FFT_POW_THRE = 200; //fft_pow_min +const uint8_t SLOPE_PARA_MAX = 30; +const uint8_t SLOPE_PARA_MIN = 3; + +WORK_MODE_T work_mode_flag = HRV_MODE; +void display_refresh(void) +{ + +} +void hx3918_delay_us(uint32_t us) +{ +#ifdef TYHX_DEMO + nrf_delay_us(us); +#endif + if(us < 1000) + us =1000; + Helios_msleep(us/1000); +} + +void hx3918_delay(uint32_t ms) +{ +#ifdef TYHX_DEMO + nrf_delay_ms(ms); +#endif + Helios_msleep(ms); +} + +//Timer interrupt 40ms repeat mode +void gsen_read_timeout_handler(void * p_context) +{ + hx3918_agc_Int_handle(); +#ifdef GSEN_40MS_TIMMER + hx3918_gesensor_Int_handle(); +#endif + +#ifdef LAB_TEST_INT_MODE + if(work_mode_flag == LAB_TEST_MODE)// add ericy 20210127 + { + hx3690l_lab_test_read(); + } +#endif +} + + +bool hx3918_write_reg(uint8_t addr, uint8_t data) +{ +#ifdef TYHX_DEMO + uint8_t data_buf[2]; + data_buf[0] = addr; + data_buf[1] = data; + twi_pin_switch(1); + twi_master_transfer(0x88, data_buf, 2, true); //write +#endif + if(HELIOS_I2C_Write(0, HX3918_ADDR, &addr, 1, &data, 1) != 0) + { + + //GH301x_LOG("hal_gh30x_i2c_write:error\r\n"); + } + return true; +} + +uint8_t hx3918_read_reg(uint8_t addr) +{ + uint8_t data_buf = 0; +#ifdef TYHX_DEMO + twi_pin_switch(1); + twi_master_transfer(0x88, &addr, 1, false); //write + twi_master_transfer(0x89, &data_buf, 1, true);//read +#endif + if(HELIOS_I2C_Read(0, HX3918_ADDR, &addr, 1, (void*)&data_buf, 1, 0) != 0) + { + //GH301x_LOG("hal_gh30x_i2c_read:error\r\n"); + + } + return data_buf; +} + +bool hx3918_brust_read_reg(uint8_t addr, uint8_t *buf, uint8_t length) +{ +#ifdef TYHX_DEMO + twi_pin_switch(1); + twi_master_transfer(0x88, &addr, 1, false); //write + twi_master_transfer(0x89, buf, length, true); //read +#endif + if(HELIOS_I2C_Read(0, HX3918_ADDR, &addr, 1, (void*)buf, length, 0) != 0) + { + //GH301x_LOG("hal_gh30x_i2c_read:error\r\n"); + + } + return true; +} +int hx3918_ppg_timer = 0; +char hx3918_ppg_timerout_flag = 0; +void hx3918_ppg_timerout_cb(void) +{ + hx3918_ppg_timerout_flag = 1; +} +void hx3918_ppg_timer_cfg(bool en) //320ms +{ + if(en) + { + if(hx3918_ppg_timer == 0) + hx3918_ppg_timer = Helios_Timer_init( (void* )hx3918_ppg_timerout_cb, NULL); + Helios_Timer_Start(hx3918_ppg_timer, 320, 1); + + } + else + { + if(hx3918_ppg_timer != 0) + { + Helios_Timer_Stop(hx3918_ppg_timer); + } + } + +} +int hx3918_agc_timer = 0; +char hx3918_agc_timerout_flag = 0; +void hx3918_agc_timerout_cb(void) +{ + hx3918_agc_timerout_flag = 1; +} +/* 40ms void agc_timeout_handler(void * p_context) */ +void hx3918_agc_timer_cfg(bool en) +{ + if(en) + { + if(hx3918_agc_timer == 0) + hx3918_agc_timer = Helios_Timer_init( (void* )hx3918_agc_timerout_cb, NULL); + Helios_Timer_Start(hx3918_agc_timer, 40, 1); + } + else + { + if(hx3918_agc_timer != 0) + { + Helios_Timer_Stop(hx3918_agc_timer); + } + } + +} +#if defined(INT_MODE) +void hx3918_gpioint_cfg(bool en) +{ + if(en) + { + hx3918_gpioint_enable(); + } + else + { + hx3918_gpioint_disable(); + } + +} +#endif + +uint8_t hx3918_chip_id = 0; +bool hx3918_chip_check(void) +{ + uint8_t i = 0; + + for(i=0; i<10; i++) + { + hx3918_write_reg(0x01, 0x00); + hx3918_delay(5); + hx3918_chip_id = hx3918_read_reg(0x00); + if (hx3918_chip_id == 0x27) + { + HX3918_LOG("chip id = 0x%x check ok \r\n",hx3918_chip_id); + return true; + } + } + HX3918_LOG("hx3918_chip_check fail\r\n"); + return false; +} + +uint8_t hx3918_read_fifo_size(void) +{ + uint8_t fifo_num_temp = 0; + fifo_num_temp = hx3918_read_reg(0x40)&0x7f; // ericy 230529 + + return fifo_num_temp; +} +uint16_t hx3918_read_fifo_data(int32_t *buf, uint8_t phase_num, uint8_t sig) +{ + uint8_t data_flg_start = 0; + uint8_t data_flg_end = 0; + uint8_t databuf[3]; + uint32_t ii=0; + uint16_t data_len = 0; + uint16_t fifo_data_length = 0; + uint16_t fifo_read_length = 0; + uint16_t fifo_read_bytes = 0; + uint16_t fifo_out_length = 0; + uint16_t fifo_out_count = 0; + uint8_t fifo_data_buf[200] = {0}; + + data_len = hx3918_read_reg(0x40);// ericy 230529 + fifo_data_length = data_len; + //HX3918_LOG("data_len: %d\r\n",data_len); + if(fifo_data_length<2*phase_num) + { + return 0; + } + fifo_read_length = ((fifo_data_length-phase_num)/phase_num)*phase_num; + fifo_read_bytes = fifo_read_length*3; + if(read_fifo_first_flg == 1) + { + hx3918_brust_read_reg(0x41, databuf, 3); // ericy 230529 + read_fifo_first_flg = 0; + } + hx3918_brust_read_reg(0x41, fifo_data_buf, fifo_read_bytes); // ericy 230529 +// for(ii=0; ii>5)&0x03); + } + data_flg_start = (fifo_data_buf[2]>>5)&0x03; + data_flg_end = (fifo_data_buf[fifo_read_bytes-1]>>5)&0x03; + fifo_out_length = fifo_read_length; + if(data_flg_start>0) + { + fifo_out_length = fifo_read_length-phase_num+data_flg_start; + for(ii=0; ii>1; + gsen_fifo_y[9] = gsen_buf.AXIS_Y>>1; + gsen_fifo_z[9] = gsen_buf.AXIS_Z>>1; + //SEGGER_RTT_printf(0,"gsen_x=%d gsen_y=%d gsen_z=%d\r\n", \ + gsen_fifo_x[9],gsen_fifo_y[9],gsen_fifo_z[9]); +#endif +} + +void agc_timeout_handler(void * p_context) +{ +#ifdef TIMMER_MODE + switch (work_mode_flag) + { + case HRS_MODE: + { +#ifdef HRS_ALG_LIB + HRS_CAL_SET_T cal; + cal = PPG_hrs_agc(); + if(cal.work) + { + //AGC_LOG("AGC: led_drv=%d,ledDac=%d,ambDac=%d,ledstep=%d,rf=%d\r\n", \ + cal.led_cur, cal.led_idac, cal.amb_idac,cal.led_step,cal.ontime); + } +#endif + break; + } + case LIVING_MODE: + { +#ifdef HRS_ALG_LIB + HRS_CAL_SET_T cal; + cal = PPG_hrs_agc(); + if(cal.work) + { + //AGC_LOG("AGC: led_drv=%d,ledDac=%d,ambDac=%d,ledstep=%d,rf=%d\r\n", \ + cal.led_cur, cal.led_idac, cal.amb_idac,cal.led_step,cal.ontime); + } +#endif + break; + } + case HRV_MODE: + { +#ifdef HRV_ALG_LIB + HRV_CAL_SET_T cal; + cal = PPG_hrv_agc(); + if(cal.work) + { + //AGC_LOG("AGC: led_drv=%d,ledDac=%d,ambDac=%d,ledstep=%d,rf=%d\r\n", \ + cal.led_cur, cal.led_idac, cal.amb_idac,cal.led_step,cal.ontime); + } +#endif + break; + } + case SPO2_MODE: + { +#ifdef SPO2_ALG_LIB + SPO2_CAL_SET_T cal; + cal = PPG_spo2_agc(); + if(cal.work) + { + //AGC_LOG("AGC: Rled_drv=%d,Irled_drv=%d,RledDac=%d,IrledDac=%d,ambDac=%d,Rledstep=%d,Irledstep=%d,Rrf=%d,Irrf=%d,\r\n", \ + cal.red_cur, cal.ir_cur,cal.red_idac,cal.ir_idac,cal.amb_idac,cal.red_led_step,cal.red_led_step,cal.ontime,cal.state); + } +#endif + break; + } + case LAB_TEST_MODE: + { +#ifdef LAB_TEST + hx3918_lab_test_Int_handle(); +#endif + } + default: + break; + } +#endif +} + +//void ppg_timeout_handler(void * p_context) +void heart_rate_meas_timeout_handler(void * p_context) +{ + hx3918_ppg_Int_handle(); +} + +void hx3918_ppg_Int_handle(void) +{ + #if defined(INT_MODE) + hx3918_agc_Int_handle(); + #endif + + switch(work_mode_flag) + { + case HRS_MODE: + #ifdef HRS_ALG_LIB + hx3918_hrs_ppg_Int_handle(); + #endif + break; + + case SPO2_MODE: + #ifdef SPO2_ALG_LIB + hx3918_spo2_ppg_Int_handle(); + #endif + break; + + case HRV_MODE: + #ifdef HRV_ALG_LIB + hx3918_hrv_ppg_Int_handle(); + #endif + break; + + case WEAR_MODE: + #ifdef CHECK_TOUCH_LIB + hx3918_wear_ppg_Int_handle(); + #endif + break; + + case LAB_TEST_MODE: + #ifdef LAB_TEST + hx3918_lab_test_Int_handle(); + #endif + + default: + break; + } + +} + +#ifdef HRS_ALG_LIB +void hx3918_hrs_ppg_Int_handle(void) +{ + uint8_t ii=0; + hrs_results_t alg_results = {MSG_HRS_ALG_NOT_OPEN,0,0,0,0}; + hx3918_hrs_wear_msg_code_t hrs_wear_status = MSG_HRS_INIT; + int32_t *PPG_buf = &(ppg_s_dat.green_data[0]); + int32_t *ir_buf = &(ppg_s_dat.ir_data[0]); + uint8_t *count = &(ppg_s_dat.count); + int16_t gsen_fifo_x_send[32]= {0}; + int16_t gsen_fifo_y_send[32]= {0}; + int16_t gsen_fifo_z_send[32]= {0}; + HRS_CAL_SET_T cal= get_hrs_agc_status(); +#ifdef BP_CUSTDOWN_ALG_LIB + bp_results_t bp_alg_results ; +#endif +#ifdef HR_VECTOR + for(ii=0; ii<8; ii++) + { + PPG_buf_vec[ii] = hrm_input_data[hrs_send_cnt+ii]; + gsen_fifo_x[ii] = gsen_input_data_x[hrs_send_cnt+ii]; + gsen_fifo_y[ii] = gsen_input_data_y[hrs_send_cnt+ii]; + gsen_fifo_z[ii] = gsen_input_data_z[hrs_send_cnt+ii]; + } + hrs_send_cnt = hrs_send_cnt+8; + *count = 8; + tyhx_hrs_alg_send_data(PPG_buf_vec,*count, 0, gsen_fifo_x, gsen_fifo_y, gsen_fifo_z); +#else + if(hx3918_hrs_read(&ppg_s_dat) == NULL) + { + return; + } +#ifndef GSEN_40MS_TIMMER + readFifoByHrsModule(); +#endif + for(ii=0; ii<*count; ii++) + { +#ifdef GSENSER_DATA + gsen_fifo_x_send[ii] = gsen_fifo_x[32-*count+ii]; + gsen_fifo_y_send[ii] = gsen_fifo_y[32-*count+ii]; + gsen_fifo_z_send[ii] = gsen_fifo_z[32-*count+ii]; +#endif + //HX3918_LOG("%d %d %d %d %d %d\r\n", PPG_buf[ii],ir_buf[ii],gsen_fifo_x[ii],gsen_fifo_y[ii],gsen_fifo_z[ii],hrs_s_dat.agc_green); + } + hrs_wear_status = hx3918_hrs_get_wear_status(); + hrsresult.wearstatus = hrs_wear_status; + HX3918_result_set_wear_status(hrs_wear_status); + + if(hrs_wear_status == MSG_HRS_WEAR) + { + tyhx_hrs_alg_send_data(PPG_buf, *count, gsen_fifo_x_send, gsen_fifo_y_send, gsen_fifo_z_send); + } +#endif + alg_results = tyhx_hrs_alg_get_results(); + hrsresult.lastesthrs = alg_results.hr_result; + HX3918_result_set_heart_rate(hrsresult.lastesthrs); + // HX3918_LOG("Hr=%d",alg_results.hr_result); +#ifdef HRS_BLE_APP + { + rawdata_vector_t rawdata; + for(ii=0; ii<*count; ii++) + { + rawdata.vector_flag = HRS_VECTOR_FLAG; + rawdata.data_cnt = alg_results.data_cnt-*count+ii; + rawdata.hr_result = alg_results.hr_result; + rawdata.red_raw_data = PPG_buf[ii]; + rawdata.ir_raw_data = gdiff[0]; + rawdata.gsensor_x = gsen_fifo_x[ii]; + rawdata.gsensor_y = gsen_fifo_y[ii]; + rawdata.gsensor_z = gsen_fifo_z[ii]; + rawdata.red_cur = cal.led_cur; + rawdata.ir_cur = alg_results.hrs_alg_status; + + ble_rawdata_vector_push(rawdata); + } + } + ble_rawdata_send_handler(); +#endif +} + +#ifdef CHECK_LIVING_LIB +void hx3918_living_Int_handle(void) +{ + + uint8_t ii=0; + hx3918_living_results_t living_alg_results = {MSG_LIVING_NO_WEAR,0,0,0}; + + int32_t *PPG_buf = &(ppg_s_dat.green_data[0]); + uint8_t *count = &(ppg_s_dat.count); + hx3918_hrs_wear_msg_code_t hrs_wear_status = MSG_HRS_NO_WEAR; + int16_t gsen_fifo_x_send[32]= {0}; + int16_t gsen_fifo_y_send[32]= {0}; + int16_t gsen_fifo_z_send[32]= {0}; + + if(hx3918_hrs_read(&ppg_s_dat) == NULL) + { + return; + } +#ifndef GSEN_40MS_TIMMER + readFifoByHrsModule(); +#endif + for(ii=0; ii<*count; ii++) + { + gsen_fifo_x_send[ii] = gsen_fifo_x[32-*count+ii]; + gsen_fifo_y_send[ii] = gsen_fifo_y[32-*count+ii]; + gsen_fifo_z_send[ii] = gsen_fifo_z[32-*count+ii]; + //HX3918_LOG("%d/%d %d %d %d %d %d %d\r\n",1+ii,*count,PPG_buf[ii],ir_buf[ii],gsen_fifo_x[ii],gsen_fisignal_qualityfo_y[ii],gsen_fifo_z[ii],hrs_s_dat.agc_green); + } + + living_alg_results = hx3918_living_get_results(); + //HX3918_LOG("%d %d %d %d\r\n",living_alg_results.data_cnt,living_alg_results.motion_status,living_alg_results.signal_quality,living_alg_results.wear_status); + +} +#endif + + +#ifdef SPO2_ALG_LIB +void hx3918_spo2_ppg_Int_handle(void) +{ + uint8_t ii=0; + spo2_results_t alg_results = {MSG_SPO2_ALG_NOT_OPEN,MSG_SPO2_LIVING_INITIAL,0,0,0,0,0,0,1,0,0,0,0}; + SPO2_CAL_SET_T cal=get_spo2_agc_status(); + hx3918_spo2_wear_msg_code_t spo2_wear_status = MSG_SPO2_INIT; + int32_t *green_buf = &(ppg_s_dat.green_data[0]); + int32_t *red_buf = &(ppg_s_dat.red_data[0]); + int32_t *ir_buf = &(ppg_s_dat.ir_data[0]); + uint8_t *count = &(ppg_s_dat.count); + int16_t gsen_fifo_x_send[32]= {0}; + int16_t gsen_fifo_y_send[32]= {0}; + int16_t gsen_fifo_z_send[32]= {0}; +#ifdef SPO2_DATA_CALI + int32_t red_data_cali, ir_data_cali; +#endif + +#ifdef SPO2_VECTOR + for(ii=0; ii<8; ii++) + { + red_buf_vec[ii] = vec_red_data[spo2_send_cnt+ii]; + ir_buf_vec[ii] = vec_ir_data[spo2_send_cnt+ii]; + green_buf_vec[ii] = vec_green_data[spo2_send_cnt+ii]; + } + spo2_send_cnt = spo2_send_cnt+8; + *count = 8; + for(ii=0; ii<10; ii++) + { + gsen_fifo_x[ii] = vec_red_data[spo2_send_cnt1+ii];; + gsen_fifo_y[ii] = vec_ir_data[spo2_send_cnt1+ii];; + gsen_fifo_z[ii] = vec_green_data[spo2_send_cnt1+ii];; + } + spo2_send_cnt1 = spo2_send_cnt1+10; + hx3918_spo2_alg_send_data(red_buf_vec, ir_buf_vec, green_buf_vec, *count, gsen_fifo_x, gsen_fifo_y, gsen_fifo_z); +#else + if(hx3918_spo2_read(&ppg_s_dat) == NULL) + { + return; + } +#ifndef GSEN_40MS_TIMMER + readFifoByHrsModule(); +#endif + for(ii=0; ii<*count; ii++) + { + HX3918_LOG("%d/%d %d %d %d %d %d %d %d\r\n" ,1+ii,*count,\ + red_buf[ii],ir_buf[ii],green_buf[ii],cal.red_idac,cal.ir_idac,cal.red_cur,cal.ir_cur); + } + spo2_wear_status = hx3918_spo2_get_wear_status(); + hrsresult.wearstatus = spo2_wear_status; + HX3918_result_set_wear_status(spo2_wear_status); + if(spo2_wear_status == MSG_SPO2_WEAR) + { + if(*count){ + tyhx_spo2_alg_send_data(red_buf, ir_buf, green_buf, cal.red_idac, cal.ir_idac, cal.green_idac, gsen_fifo_x_send, gsen_fifo_y_send, gsen_fifo_z_send, *count); + } + } +#endif + + alg_results = tyhx_spo2_alg_get_results(); + hrsresult.lastestspo2 = alg_results.spo2_result; + HX3918_result_set_blood_oxygen(hrsresult.lastestspo2); + HX3918_LOG("SPO2=%d\r\n",alg_results.spo2_result); + +#ifdef HRS_BLE_APP + { + rawdata_vector_t rawdata; + for(ii=0; ii<*count; ii++) + { +#ifdef SPO2_DATA_CALI + ir_data_cali = hx3918_ir_data_cali(ir_buf[ii]); + red_data_cali = hx3918_red_data_cali(red_buf[ii]); + rawdata.red_raw_data = red_data_cali; + rawdata.ir_raw_data = ir_data_cali; +#else + rawdata.red_raw_data = red_buf[ii]; + rawdata.ir_raw_data = ir_buf[ii]; +#endif + rawdata.vector_flag = SPO2_VECTOR_FLAG; + //rawdata.data_cnt = alg_results.data_cnt-*count+ii; + rawdata.data_cnt = cal.green_idac; + rawdata.hr_result = alg_results.spo2_result; +// rawdata.gsensor_x = gsen_fifo_x[ii]; +// rawdata.gsensor_y = gsen_fifo_y[ii]; +// rawdata.gsensor_z = gsen_fifo_z[ii]; + rawdata.gsensor_x = green_buf[ii]>>5; + rawdata.gsensor_y = cal.red_idac; + rawdata.gsensor_z = cal.ir_idac; + rawdata.red_cur = cal.red_cur; + rawdata.ir_cur = cal.ir_cur; + ble_rawdata_vector_push(rawdata); + } + } + ble_rawdata_send_handler(); +#endif +} +#endif + +#ifdef HRV_ALG_LIB +hrv_sensor_data_t hrv_s_dat; +void hx3918_hrv_ppg_Int_handle(void) +{ + uint8_t ii=0; + hrv_results_t alg_hrv_results= {MSG_HRV_ALG_NOT_OPEN,0,0,0,0,0}; + int32_t *PPG_buf = &(hrv_s_dat.ppg_data[0]); + uint8_t *count = &(hrv_s_dat.count); + hx3918_hrv_wear_msg_code_t wear_mode; + +#ifdef HRV_TESTVEC + int32_t hrm_raw_data; + hrm_raw_data = vec_data[vec_data_cnt]; + vec_data_cnt++; + alg_hrv_results = hx3918_hrv_alg_send_data(hrm_raw_data, 0, 0); +#else + if(hx3918_hrv_read(&hrv_s_dat) == NULL) + { + return; + } + for(ii=0; ii<*count; ii++) + { + //HX3918_LOG("[Hrv_Test]:%d/%d %d\r\n" ,1+ii,*count,PPG_buf[ii]); + } + wear_mode = hx3918_hrv_get_wear_status(); + HX3918_result_set_wear_status(wear_mode); + //hrsresult.wearstatus = wear_mode; + if(wear_mode==MSG_HRV_WEAR) + { + alg_hrv_results = tyhx_hrv_alg_send_bufdata(PPG_buf, *count, gen_dummy, gen_dummy,gen_dummy); + //hrsresult.lastesthrv = alg_hrv_results .hrv_result; + HX3918_result_set_hrv(alg_hrv_results.hrv_result); + HX3918_LOG("Hrv result:= %d\r\n",alg_hrv_results.hrv_result); + } +#endif + +#ifdef HRS_BLE_APP + { + rawdata_vector_t rawdata; + + HRS_CAL_SET_T cal= get_hrs_agc_status(); + for(ii=0; ii<*count; ii++) + { + rawdata.vector_flag = HRS_VECTOR_FLAG; + rawdata.data_cnt = 0; + rawdata.hr_result = alg_hrv_results.hrv_result; + rawdata.red_raw_data = PPG_buf[ii]; + rawdata.ir_raw_data = 0; + rawdata.gsensor_x = gsen_fifo_x[ii]; + rawdata.gsensor_y = gsen_fifo_y[ii]; + rawdata.gsensor_z = gsen_fifo_z[ii]; + rawdata.red_cur = cal.led_cur; + rawdata.ir_cur = 0; + ble_rawdata_vector_push(rawdata); + } + } + ble_rawdata_send_handler(); +#endif +} +#endif + + +#ifdef CHECK_TOUCH_LIB +void hx3918_wear_ppg_Int_handle(void) +{ + uint8_t count = 0; + uint8_t ii = 0; + hx3918_wear_msg_code_t hx3918_check_mode_status = MSG_NO_WEAR; + count = hx3918_check_touch_read(&ppg_s_dat); + hx3918_check_mode_status = hx3918_check_touch(ppg_s_dat.s_buf,count); + hrsresult.wearstatus = hx3918_check_mode_status; + if((count)&&(hrsresult.wearstatus == 0)) + { + //HX3918_LOG("count = %d, ir = %d\r\n",count,ppg_s_dat.s_buf[count-1]); + hx3918_auto_cali_backgroud(ppg_s_dat.s_buf[count-1]); + + } + //hx3918_ai_tune_nv(lp[0],bl[0]); + //HX3918_LOG("[hx3918_wear_ppg_Int_handle] ir result = %d, final result = %d\r\n",hx3918_check_mode_status,wear_result_by_IRandProx); +#ifdef HRS_BLE_APP + { + rawdata_vector_t rawdata; + //for(ii=0; ii<*count; ii++) + //app_ctrl_test = true; + { + rawdata.vector_flag = HRS_VECTOR_FLAG; + rawdata.data_cnt = 0; + rawdata.hr_result = 0; + rawdata.red_raw_data = 0; + rawdata.ir_raw_data = lp[0]; + rawdata.gsensor_x = bl[0]; + rawdata.gsensor_y = gdiff[1]; + rawdata.gsensor_z = nv_base_data[0]; + rawdata.red_cur = ai_tune_cnt[0]; + rawdata.ir_cur = ai_tune_cnt[1]; + + ble_rawdata_vector_push(rawdata); + } + } + ble_rawdata_send_handler(); +#endif + +} +#endif + + +void hx3918_lab_test_Int_handle(void) +{ +#ifdef LAB_TEST +#if defined(TIMMER_MODE) + uint32_t data_buf[4]; + hx3918_lab_test_read_packet(data_buf); + //HX3918_LOG("%d %d %d %d\r\n", data_buf[0], data_buf[1], data_buf[2], data_buf[3]); +#else + uint8_t count = 0; + int32_t buf[32]; + count = hx3918_read_fifo_data(buf, 2, 1); + for (uint8_t i=0; i +#include + + +//#include "tyhx_mems.h" +//#define DEBUG_PPG_ONLY // 只用IR 判断佩带和非佩戴, 靠近感应功能关闭, 但是HX3918_PROX.C要合入编译 +/********************* alg_swi ********************* +HRS_ALG_LIB 心率功能 +SPO2_ALG_LIB 血氧功能 +HRV_ALG_LIB HRV功能 +CHECK_TOUCH_LIB 纯佩戴功能(非心率血氧模式) +CHECK_LIVING_LIB 纯物体识别功能(非心率血氧模式) +BP_CUSTDOWN_ALG_LIB 血压功能 + +TIMMER_MODE 定时器模式, 读PPG数据, 默认采用定时器模式 +INT_MODE 中断模式,读PPG数据 + +DEMO_MI demo相关配置, 客户关闭, 在下面else里进行配置 +HRS_BLE_APP DEMO蓝牙控制宏, 客户关闭 +SPO2_DATA_CALI 血氧DC补偿模式, 客户关闭 +HRS_DEBUG 调试宏, 根据平台定义打印函数 +AGC_DEBUG 调试宏, 根据平台定义打印函数 +GSEN_40MS_TIMMER DEMO调试使用, 客户关闭 +NEW_GSEN_SCHME DEMO调试使用, 客户关闭 +*/ +#define HRS_ALG_LIB +#define SPO2_ALG_LIB +//#define HRV_ALG_LIB +#define CHECK_TOUCH_LIB +//#define CHECK_LIVING_LIB +#define BP_CUSTDOWN_ALG_LIB + + + +//**************** read_data_mode ******************// +#define TIMMER_MODE //timmer read fifo +//#define INT_MODE //fifo_all_most_full +//#define TYHX_DEMO // for ty demo +//****************** gsen_cgf *********************// +//#define GSENSER_DATA +#define GSEN_40MS_TIMMER +#define NEW_GSEN_SCHME + +//****************** other_cgf ********************// +#define EVB +//#define TWON3IN1LED +//#define EVB +//#define INT_FLOATING +//#define HRS_BLE_APP +//#define SPO2_DATA_CALI + +//***************** vecter_swi ********************// +//#define SPO2_VECTOR +//#define HR_VECTOR +//#define HRV_TESTVEC + +//**************** lab_test_mode ******************// +//#define LAB_TEST +//#define LAB_TEST_AGC + +//****************** print_swi ********************// +//#define TYHX_LOG +// #define AGC_DEBUG +// #define HRS_DEBUG + +//**************************************************// + +#ifdef TYHX_LOG +#define TYHX_LOG(...) SEGGER_RTT_printf(0,__VA_ARGS__) +#else +#define TYHX_LOG(...) +#endif + +#ifdef AGC_DEBUG +#define AGC_LOG(...) SEGGER_RTT_printf(0,__VA_ARGS__) +#else +#define AGC_LOG(...) +#endif + +#ifdef HRS_DEBUG +#define DEBUG_PRINTF(...) SEGGER_RTT_printf(0,__VA_ARGS__) +#else +#define DEBUG_PRINTF(...) +#endif + + +//#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) +typedef struct +{ + uint16_t lastesthrs; //?????????? + uint8_t lastestspo2; //???? + uint8_t lastesthrv; //HRV?? + uint16_t wearstatus; + uint32_t living_data_cnt; + uint8_t living_signal_quality; + uint8_t living_motion_status; + int32_t leak_green; + int32_t leak_red; + int32_t leak_ir; + int32_t card_green; + int32_t card_red; + int32_t card_ir; + uint8_t hrv_tired_value; + uint8_t hrv_spirit_pressure; + uint8_t hr_living; + uint32_t hr_living_qu; + uint32_t hr_living_std; + uint8_t living_status; //living_status +} tyhx_hrsresult_t; + +#if defined(DEMO_COMMON) + #define HRS4100_IIC_CLK 30 + #define HRS4100_IIC_SDA 0 + #define LIS3DH_IIC_CLK 18 + #define LIS3DH_IIC_SDA 16 + #define EXT_INT_PIN 1 + #define GREEN_LED_SLE 1 + #define RED_LED_SLE 4 + #define IR_LED_SLE 2 + #define RED_AGC_OFFSET 12 + #define IR_AGC_OFFSET 12 + #define GREEN_AGC_OFFSET 8 + #define HR_GREEN_AGC_OFFSET 8 + #define BIG_SCREEN +#elif defined(TWON3IN1LED) + #define HRS4100_IIC_CLK 30 + #define HRS4100_IIC_SDA 0 + #define LIS3DH_IIC_CLK 18 + #define LIS3DH_IIC_SDA 16 + #define EXT_INT_PIN 1 + #define GREEN_LED_SLE 2 + #define RED_LED_SLE 4 + #define IR_LED_SLE 1 + #define RED_AGC_OFFSET 12 + #define IR_AGC_OFFSET 12 + #define GREEN_AGC_OFFSET 8 + #define HR_GREEN_AGC_OFFSET 8 + #define BIG_SCREEN +#elif defined(DEMO_NEW) + #define HRS4100_IIC_CLK 0 + #define HRS4100_IIC_SDA 30 + #define LIS3DH_IIC_CLK 18 + #define LIS3DH_IIC_SDA 16 + #define EXT_INT_PIN 1 + #define GREEN_LED_SLE 1 + #define RED_LED_SLE 2 + #define IR_LED_SLE 4 + #define RED_AGC_OFFSET 50 + #define IR_AGC_OFFSET 50 + #define HR_GREEN_AGC_OFFSET 4 + #define BIG_SCREEN + +#elif defined(DEMO_BAND) + #define HRS4100_IIC_CLK 4 + #define HRS4100_IIC_SDA 3 + #define LIS3DH_IIC_CLK 14 + #define LIS3DH_IIC_SDA 12 + #define EXT_INT_PIN 7 + #define GREEN_LED_SLE 0 + #define RED_LED_SLE 2 + #define IR_LED_SLE 1 + #define RED_AGC_OFFSET 64 + #define IR_AGC_OFFSET 64 + #define GREEN_AGC_OFFSET 8 + #define HR_GREEN_AGC_OFFSET 8 + +#elif defined(DEMO_GT01) + #define HRS4100_IIC_CLK 5 + #define HRS4100_IIC_SDA 6 + #define LIS3DH_IIC_CLK 14 + #define LIS3DH_IIC_SDA 12 + #define EXT_INT_PIN 7 + #define GREEN_LED_SLE 1 + #define RED_LED_SLE 4 + #define IR_LED_SLE 2 + #define RED_AGC_OFFSET 32 + #define IR_AGC_OFFSET 32 + #define GREEN_AGC_OFFSET 8 + #define BIG_SCREEN + +#elif defined(EVB) + #define HRS4100_IIC_CLK 9 + #define HRS4100_IIC_SDA 10 + #define LIS3DH_IIC_CLK 13 + #define LIS3DH_IIC_SDA 14 + #define EXT_INT_PIN 11 + #define GREEN_LED_SLE 1 + #define RED_LED_SLE 4 + #define IR_LED_SLE 2 + #define RED_AGC_OFFSET 64 + #define IR_AGC_OFFSET 64 + #define GREEN_AGC_OFFSET 8 + #define HR_GREEN_AGC_OFFSET 10 + +#else + #define HRS4100_IIC_CLK 9 + #define HRS4100_IIC_SDA 10 + #define LIS3DH_IIC_CLK 13 + #define LIS3DH_IIC_SDA 14 + #define EXT_INT_PIN 11 + #define GREEN_LED_SLE 1 + #define RED_LED_SLE 4 + #define IR_LED_SLE 2 + #define RED_AGC_OFFSET 64 + #define IR_AGC_OFFSET 64 + #define GREEN_AGC_OFFSET 8 + +#endif + + +typedef enum { + PPG_INIT, + PPG_OFF, + PPG_LED_OFF, + CAL_INIT, + CAL_OFF, + RECAL_INIT +} hx3918_mode_t; + +typedef enum { + SENSOR_OK, + SENSOR_OP_FAILED, +} SENSOR_ERROR_T; + +typedef enum { + HRS_MODE, + SPO2_MODE, + WEAR_MODE, + HRV_MODE, + LIVING_MODE, + LAB_TEST_MODE, + FT_LEAK_LIGHT_MODE, + FT_GRAY_CARD_MODE, + FT_INT_TEST_MODE, + NULL_MODE, + close_MODE +} WORK_MODE_T; + +typedef struct { + uint8_t count; + int32_t green_data[32]; + int32_t red_data[16]; + int32_t ir_data[16]; + int32_t s_buf[64]; + int32_t sar_data; + uint8_t green_cur; + uint8_t red_cur; + uint8_t ir_cur; + uint8_t green_offset; + uint8_t red_offset; + uint8_t ir_offset; +}ppg_sensor_data_t; + +typedef enum { + MSG_LIVING_NO_WEAR, + MSG_LIVING_WEAR +} hx3918_living_wear_msg_code_t; + +typedef enum { + MSG_NO_WEAR, + MSG_WEAR +} hx3918_wear_msg_code_t; + +typedef struct { + hx3918_living_wear_msg_code_t wear_status; + uint32_t data_cnt; + uint8_t signal_quality; + uint8_t motion_status; +} hx3918_living_results_t; + +typedef struct { + int32_t p1_noise; + int32_t p2_noise; + int32_t p3_noise; + int32_t p4_noise; +}NOISE_PS_T; + + + +extern uint8_t alg_ram[11*1024]; +extern uint8_t hx3918_chip_id; + +extern WORK_MODE_T work_mode_flag; + +void hx_set_touch_mode(uint8_t current_mode); +uint16_t hx3918_read_fifo_data(int32_t *buf, uint8_t phase_num, uint8_t sig); +void read_data_packet(int32_t *ps_data); +void hx3918_delay_us(uint32_t us); +void hx3918_delay(uint32_t ms); +bool hx3918_write_reg(uint8_t addr, uint8_t data); +bool hx3918_write_reg(uint8_t addr, uint8_t data); +uint8_t hx3918_read_reg(uint8_t addr); +bool hx3918_brust_read_reg(uint8_t addr , uint8_t *buf, uint8_t length); +bool hx3918_chip_check(void); +uint8_t hx3918_read_fifo_size(void); +void hx3918_ppg_off(void); +void hx3918_ppg_on(void); +void hx3918_ppg_timer_cfg(bool en); +void hx3918_agc_timer_cfg(bool en); +void hx3918_gpioint_cfg(bool en); +bool hx3918_init(WORK_MODE_T mode); +void hx3918_agc_Int_handle(void); +void hx3918_gesensor_Int_handle(void); +void hx3918_spo2_ppg_init(void); +void hx3918_spo2_ppg_Int_handle(void); +void hx3918_wear_ppg_Int_handle(void); +void hx3918_ft_hrs_Int_handle(void); +void hx3918_ft_spo2_Int_handle(void); +void hx3918_hrs_ppg_init(void); +void hx3918_hrs_ppg_Int_handle(void); +void hx3918_hrv_ppg_Int_handle(void); +void hx3918_living_Int_handle(void); +//void hx3918_gesensor_Int_handle(void); +void hx3918_ppg_Int_handle(void); +uint32_t hx3918_timers_start(void); +uint32_t hx3918_timers_stop(void); +uint32_t hx3918_gpioint_init(void); + +uint32_t hx3918_gpioint_enable(void); +uint32_t hx3918_gpioint_disable(void); +uint32_t hx3918_40ms_timers_start(void); +uint32_t hx3918_40ms_timers_stop(void); + +void hx3918_vin_check(uint16_t led_vin); + +#ifdef LAB_TEST +void hx3918_lab_test_init(void); +void hx3918_test_alg_cfg(void); +SENSOR_ERROR_T hx3918_lab_test_enable(void); +void hx3918_lab_test_Int_handle(void); +void hx3918_lab_test_read_packet(uint32_t *data_buf); +#endif + +#ifdef CHECK_TOUCH_LIB +hx3918_wear_msg_code_t hx3918_check_touch(int32_t *ir_data, uint8_t data_len); +SENSOR_ERROR_T hx3918_check_touch_enable(void); +#endif + +bool hx3918_living_send_data(int32_t *new_raw_data, uint8_t dat_len, uint32_t green_data_als, int16_t *gsen_data_x, int16_t *gsen_data_y, int16_t *gsen_data_z); +hx3918_living_results_t hx3918_living_get_results(void); +void agc_timeout_handler(void * p_context); +void heart_rate_meas_timeout_handler(void * p_context); + +int16_t hx3918xxx_read_two_reg_low_triple(uint8_t addh, uint8_t addl); +void display_refresh(void); +extern char hx3918_ppg_timerout_flag ; +extern char hx3918_agc_timerout_flag ; +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_check_touch.c b/2.sdk/Helios_SDK/components/HX3918/hx3918_check_touch.c new file mode 100644 index 00000000..0b18834b --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_check_touch.c @@ -0,0 +1,260 @@ +#include +#include +#include +#include +#include + +//#include "twi_master.h" +//#include "hx3918.h" +//#include "SEGGER_RTT.h" + +//#include "tyhx_hrs_custom.h" +#include "hx3918.h" +#include "hx3918_check_touch.h" +#include "hx3918_prox.h" +//#include "segger_rtt.h" + +hx3918_wear_msg_code_t hx3918_wear_status = MSG_NO_WEAR; +hx3918_wear_msg_code_t hx3918_wear_status_pre = MSG_NO_WEAR; +extern const int32_t check_mode_unwear_thre; +extern const int32_t check_mode_wear_thre; +extern const int32_t check_mode_sar_thre; +uint8_t notouch_cnt = 0; +uint8_t touch_cnt = 0; +extern uint8_t read_fifo_first_flg; + +#ifdef CHECK_TOUCH_LIB +void hx3918_check_touch_init(void) //20200615 ericy ppg fs=25hz, phase3 conversion ready interupt en +{ + uint16_t sample_rate = 10; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps0_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps1_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps2_enable=0; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps3_enable=0; /*ps1_enable , 1 mean enable ; 0 mean disable */ + + uint8_t ps0_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps1_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps2_osr = 0; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps3_osr = 0; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 0; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + /***********led open enable***********/ + + uint8_t ps0_led_en_i2c=1; + uint8_t ps1_led_en_i2c=0; + uint8_t ps2_led_en_i2c=0; + uint8_t ps3_led_en_i2c=0; + + uint8_t ps0_ofidac_en_i2c=1; + uint8_t ps1_ofidac_en_i2c=1; + uint8_t ps2_ofidac_en_i2c=1; + uint8_t ps3_ofidac_en_i2c=1; + + uint8_t dccancel_ps0 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =64; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =0; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =0; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =0; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint8_t led_en_begin =1; // 0 = 2 ; 1 = 4 ; 2 = 8 ; 3 = 16 ; + uint8_t afe_reset = 1; //* 0 = 32clk ; 1 = 64clk ; 2 = 128clk ; 3 = 256clk(d) ; + uint8_t en2rst_delay =3; // pen 2 rst delay 0 = 128,256, 512, 1024 + uint8_t init_wait_delay = 2; /* 0 = 800 ; 1 = 1600; 2 = 3200 ; 3 = 6400(d) */ + + uint8_t ps1_interval_i2c =0; // ps2/ps3 + + uint8_t thres_int =1; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + + uint8_t ldrsel_ps0 =IR_LED_SLE; + uint8_t ldrsel_ps1 =0; + uint8_t ldrsel_ps2 =0; + uint8_t ldrsel_ps3 =0; + + /***********cap *********/ + uint8_t intcapsel_ps3 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps2 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps1 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps0 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + + uint8_t ps0_led_on_time=8; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=8; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=0; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=0; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + uint8_t force_adc_clk_sel=0; + uint8_t force_adc_clk_cfg =0; + uint8_t force_PEN =0; //phase enable + uint8_t force_PEN_cfg =0; + uint8_t force_LED_EN =0; + uint8_t force_LED_EN_cfg =0; + uint8_t force_CKAFEINT_sel =0; + uint8_t force_CKAFEINT_cfg =0; + + hx3918_write_reg(0X16, (ps3_enable<<3| ps2_enable<<2|ps1_enable<<1|ps0_enable)); + hx3918_write_reg(0X17, (ps3_osr<<6| ps2_osr<<4|ps1_osr<<2|ps0_osr)); + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); + hx3918_write_reg(0X1a, (ps1_interval_i2c)); + hx3918_write_reg(0X1b, led_en_begin<<6|afe_reset<<4|en2rst_delay <<2|init_wait_delay); + //hx3918_write_reg(0X1b, 0x03); + hx3918_write_reg(0X1c, ps0_led_on_time); + hx3918_write_reg(0X1d, ps1_led_on_time); + hx3918_write_reg(0X1e, ps2_led_on_time); + hx3918_write_reg(0X1f, ps3_led_on_time); + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel)); + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|ps0_ofidac_en_i2c<<3|ps1_ofidac_en_i2c<<2|ps2_ofidac_en_i2c<<1|ps3_ofidac_en_i2c)); + hx3918_write_reg(0X24, (intcapsel_ps0<<4|intcapsel_ps1)); + hx3918_write_reg(0X25, (intcapsel_ps2<<4|intcapsel_ps3)); + hx3918_write_reg(0X26, leddrive_ps0); + hx3918_write_reg(0X27, leddrive_ps1); + hx3918_write_reg(0X28, leddrive_ps2); + hx3918_write_reg(0X29, leddrive_ps3); + hx3918_write_reg(0X2a, (ldrsel_ps0<<4|ldrsel_ps1)); + hx3918_write_reg(0X2b, (ldrsel_ps2<<4|ldrsel_ps3)); + hx3918_write_reg(0X2c, dccancel_ps0); + hx3918_write_reg(0X2d, dccancel_ps1); + hx3918_write_reg(0X2e, dccancel_ps2); + hx3918_write_reg(0X2f, dccancel_ps3); + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); + hx3918_write_reg(0X4e, (force_adc_clk_sel<<7|force_adc_clk_cfg<<6|force_PEN<<5|force_PEN_cfg<<4|force_LED_EN<<3| + force_LED_EN_cfg<<2|force_CKAFEINT_sel<<1|force_CKAFEINT_cfg)); + + hx3918_write_reg(0X6d, 0x00); + hx3918_write_reg(0XF0, 0x22); + hx3918_write_reg(0xF1, 0x28); + hx3918_write_reg(0xF2, 0x04); + hx3918_write_reg(0xF3, 0x70); + hx3918_write_reg(0xF4, 0x32); + hx3918_write_reg(0xF5, 0x89); + hx3918_write_reg(0xF6, 0x2b); + hx3918_write_reg(0xF7, 0x85); + hx3918_write_reg(0xF8, 0x27); + hx3918_write_reg(0xF9, 0x00); + hx3918_write_reg(0xFA, 0x88); + hx3918_write_reg(0xFB, 0x40); + hx3918_write_reg(0Xf6, 0X2b); + +#if defined(TIMMER_MODE) + hx3918_write_reg(0x3d,0x83); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3e,0x20); //watermark + hx3918_write_reg(0x3c,0x1f); // int_width_i2c + hx3918_write_reg(0X37, 0x00); // int sel,01=prf int,04=enable almost full int + hx3918_write_reg(0X3b, 0x00); + hx3918_write_reg(0X3b, 0x10); +#else ///////////INT Mode + hx3918_write_reg(0x3d,0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3c,0x1f); // int_width_i2c + hx3918_write_reg(0X37, 0x04); // int sel,01=prf ,04=enable almost full +#endif + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); + hx3918_prox_init(); + read_fifo_first_flg = 1; +} + +void hx3918_check_touch_open(void) +{ + notouch_cnt = 0; + touch_cnt = 0; + hx3918_wear_status = MSG_NO_WEAR; +} + +SENSOR_ERROR_T hx3918_check_touch_enable(void) +{ + if (!hx3918_chip_check()) + { + AGC_LOG("hx3918 check id failed!\r\n"); + return SENSOR_OP_FAILED; + } + AGC_LOG("hx3918 check id success!\r\n"); + + hx3918_check_touch_open(); + hx3918_check_touch_init(); + hx3918_ppg_timer_cfg(true); + + return SENSOR_OK; +} + +hx3918_wear_msg_code_t hx3918_check_touch(int32_t *ir_data, uint8_t data_len) +{ + uint8_t ii; + TYHX_LOG("\r\n check touch ir data: "); + for(ii=0; iicheck_mode_wear_thre) + { + if(notouch_cnt>0) + { + notouch_cnt--; + } + if(touch_cnt>=5) + { + hx3918_wear_status = MSG_WEAR; + touch_cnt=5; + } + else + { + touch_cnt++; + } + } + else if(ir_data[ii]0) + { + touch_cnt--; + } + if(notouch_cnt>=5) + { + hx3918_wear_status = MSG_NO_WEAR; + notouch_cnt=5; + } + else + { + notouch_cnt++; + } + } + } + TYHX_LOG("\r\n"); + return hx3918_wear_status; +} + +uint8_t hx3918_check_touch_read(ppg_sensor_data_t *s_dat) +{ + int32_t *s_buf = &(s_dat->s_buf[0]); + //int32_t *sar_lp_data = &s_dat->sar_data; + uint8_t data_count = 0; + + data_count = hx3918_read_fifo_data(s_buf,1,1); + //*sar_lp_data = hx3918_read_sar_data(); + s_dat->count = data_count; + + return data_count; +} + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_check_touch.h b/2.sdk/Helios_SDK/components/HX3918/hx3918_check_touch.h new file mode 100644 index 00000000..ee6a48e6 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_check_touch.h @@ -0,0 +1,17 @@ +#ifndef _hx3918_CHECK_TOUCH_H_ +#define _hx3918_CHECK_TOUCH_H_ + +#include +#include +#include "hx3918.h" +//#include "tyhx_hrs_custom.h" + + + +uint8_t hx3918_check_touch_read(ppg_sensor_data_t *s_dat); +SENSOR_ERROR_T hx3918_check_touch_enable(void); +uint8_t hx3918_check_touch_read(ppg_sensor_data_t *s_dat); +hx3918_wear_msg_code_t hx3690l_check_touch_send_data(int32_t *ir_data, uint8_t count); +hx3918_wear_msg_code_t check_touch_alg(int32_t ir_data); + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_factory_test.c b/2.sdk/Helios_SDK/components/HX3918/hx3918_factory_test.c new file mode 100644 index 00000000..9652f6a5 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_factory_test.c @@ -0,0 +1,499 @@ +#include +#include +#include +#include +#include + +#include "hx3918.h" +#include "hx3918_factory_test.h" + +void hx3918_factory_ft_card_test_config(void)//»Ò¿¨10mm¸ß¶È²âÊÔÅäÖà +{ + uint16_t sample_rate = 25; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps0_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps1_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps2_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps3_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + + uint8_t ps0_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps1_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps2_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps3_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 0; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + /***********led open enable***********/ + + uint8_t ps0_led_en_i2c=1; + uint8_t ps1_led_en_i2c=1; + uint8_t ps2_led_en_i2c=1; + uint8_t ps3_led_en_i2c=1; + + uint8_t ps0_ofidac_en_i2c=1; + uint8_t ps1_ofidac_en_i2c=1; + uint8_t ps2_ofidac_en_i2c=1; + uint8_t ps3_ofidac_en_i2c=1; + + uint8_t dccancel_ps0 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =0; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =32; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =32; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =32; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint8_t led_en_begin =1; // 0 = 2 ; 1 = 4 ; 2 = 8 ; 3 = 16 ; + uint8_t afe_reset = 1; //* 0 = 32clk ; 1 = 64clk ; 2 = 128clk ; 3 = 256clk(d) ; + uint8_t en2rst_delay =3; // pen 2 rst delay 0 = 128,256, 512, 1024 + uint8_t init_wait_delay = 2; /* 0 = 800 ; 1 = 1600; 2 = 3200 ; 3 = 6400(d) */ + + uint8_t ps1_interval_i2c =0; // ps2/ps3 + + uint8_t thres_int =1; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + + uint8_t ldrsel_ps0 =0; + uint8_t ldrsel_ps1 =GREEN_LED_SLE; + uint8_t ldrsel_ps2 =RED_LED_SLE; + uint8_t ldrsel_ps3 =IR_LED_SLE; + + /***********cap *********/ + uint8_t intcapsel_ps3 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps2 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps1 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps0 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + + uint8_t ps0_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + uint8_t force_adc_clk_sel=0; + uint8_t force_adc_clk_cfg =0; + uint8_t force_PEN =0; //phase enable + uint8_t force_PEN_cfg =0; + uint8_t force_LED_EN =0; + uint8_t force_LED_EN_cfg =0; + uint8_t force_CKAFEINT_sel =0; + uint8_t force_CKAFEINT_cfg =0; + + hx3918_write_reg(0X16, (ps3_enable<<3| ps2_enable<<2|ps1_enable<<1|ps0_enable)); + hx3918_write_reg(0X17, (ps3_osr<<6| ps2_osr<<4|ps1_osr<<2|ps0_osr)); + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); + hx3918_write_reg(0X1a, (ps1_interval_i2c)); + hx3918_write_reg(0X1b, led_en_begin<<6|afe_reset<<4|en2rst_delay <<2|init_wait_delay); + hx3918_write_reg(0X1c, ps0_led_on_time); + hx3918_write_reg(0X1d, ps1_led_on_time); + hx3918_write_reg(0X1e, ps2_led_on_time); + hx3918_write_reg(0X1f, ps3_led_on_time); + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel)); + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|ps0_ofidac_en_i2c<<3|ps1_ofidac_en_i2c<<2|ps2_ofidac_en_i2c<<1|ps3_ofidac_en_i2c)); + hx3918_write_reg(0X24, (intcapsel_ps0<<4|intcapsel_ps1)); + hx3918_write_reg(0X25, (intcapsel_ps2<<4|intcapsel_ps3)); + hx3918_write_reg(0X26, leddrive_ps0); + hx3918_write_reg(0X27, leddrive_ps1); + hx3918_write_reg(0X28, leddrive_ps2); + hx3918_write_reg(0X29, leddrive_ps3); + hx3918_write_reg(0X2a, (ldrsel_ps0<<4|ldrsel_ps1)); + hx3918_write_reg(0X2b, (ldrsel_ps2<<4|ldrsel_ps3)); + hx3918_write_reg(0X2c, dccancel_ps0); + hx3918_write_reg(0X2d, dccancel_ps1); + hx3918_write_reg(0X2e, dccancel_ps2); + hx3918_write_reg(0X2f, dccancel_ps3); + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); + hx3918_write_reg(0X4e, (force_adc_clk_sel<<7|force_adc_clk_cfg<<6|force_PEN<<5|force_PEN_cfg<<4|force_LED_EN<<3| + force_LED_EN_cfg<<2|force_CKAFEINT_sel<<1|force_CKAFEINT_cfg)); + + hx3918_write_reg(0X6d, 0x00); + hx3918_write_reg(0XF0, 0x22); + hx3918_write_reg(0xF1, 0x28); + hx3918_write_reg(0xF2, 0x04); + hx3918_write_reg(0xF3, 0x70); + hx3918_write_reg(0xF4, 0x32); + hx3918_write_reg(0xF5, 0x89); + hx3918_write_reg(0xF6, 0x2b); + hx3918_write_reg(0xF7, 0x85); + hx3918_write_reg(0xF8, 0x27); + hx3918_write_reg(0xF9, 0x00); + hx3918_write_reg(0xFA, 0x88); + hx3918_write_reg(0xFB, 0x40); + hx3918_write_reg(0Xf6, 0X2b); + + hx3918_write_reg(0x3d, 0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3e, 0x20); //watermark + hx3918_write_reg(0x3c, 0x1f); // int_width_i2c + hx3918_write_reg(0X37, 0x00); // int sel,01=prf int,04=enable almost full int + hx3918_write_reg(0X3b, 0x00); + hx3918_write_reg(0X3b, 0x10); + + hx3918_write_reg(0x4d, 0x01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0x4d, 0x00); //release + hx3918_delay(5); +} + +void hx3918_factory_ft_leak_light_test_config(void)//©¹â²âÊÔÅäÖà +{ + uint16_t sample_rate = 25; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps0_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps1_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps2_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps3_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + + uint8_t ps0_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps1_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps2_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps3_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 0; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + /***********led open enable***********/ + + uint8_t ps0_led_en_i2c=1; + uint8_t ps1_led_en_i2c=1; + uint8_t ps2_led_en_i2c=1; + uint8_t ps3_led_en_i2c=1; + + uint8_t ps0_ofidac_en_i2c=1; + uint8_t ps1_ofidac_en_i2c=1; + uint8_t ps2_ofidac_en_i2c=1; + uint8_t ps3_ofidac_en_i2c=1; + + uint8_t dccancel_ps0 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =0; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =64; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =64; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =64; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint8_t led_en_begin =1; // 0 = 2 ; 1 = 4 ; 2 = 8 ; 3 = 16 ; + uint8_t afe_reset = 1; //* 0 = 32clk ; 1 = 64clk ; 2 = 128clk ; 3 = 256clk(d) ; + uint8_t en2rst_delay =3; // pen 2 rst delay 0 = 128,256, 512, 1024 + uint8_t init_wait_delay = 2; /* 0 = 800 ; 1 = 1600; 2 = 3200 ; 3 = 6400(d) */ + + uint8_t ps1_interval_i2c =0; // ps2/ps3 + + uint8_t thres_int =1; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + + uint8_t ldrsel_ps0 =0; + uint8_t ldrsel_ps1 =GREEN_LED_SLE; + uint8_t ldrsel_ps2 =RED_LED_SLE; + uint8_t ldrsel_ps3 =IR_LED_SLE; + + /***********cap *********/ + uint8_t intcapsel_ps3 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps2 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps1 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps0 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + + uint8_t ps0_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + uint8_t force_adc_clk_sel=0; + uint8_t force_adc_clk_cfg =0; + uint8_t force_PEN =0; //phase enable + uint8_t force_PEN_cfg =0; + uint8_t force_LED_EN =0; + uint8_t force_LED_EN_cfg =0; + uint8_t force_CKAFEINT_sel =0; + uint8_t force_CKAFEINT_cfg =0; + + hx3918_write_reg(0X16, (ps3_enable<<3| ps2_enable<<2|ps1_enable<<1|ps0_enable)); + hx3918_write_reg(0X17, (ps3_osr<<6| ps2_osr<<4|ps1_osr<<2|ps0_osr)); + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); + hx3918_write_reg(0X1a, (ps1_interval_i2c)); + hx3918_write_reg(0X1b, led_en_begin<<6|afe_reset<<4|en2rst_delay <<2|init_wait_delay); + hx3918_write_reg(0X1c, ps0_led_on_time); + hx3918_write_reg(0X1d, ps1_led_on_time); + hx3918_write_reg(0X1e, ps2_led_on_time); + hx3918_write_reg(0X1f, ps3_led_on_time); + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel)); + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|ps0_ofidac_en_i2c<<3|ps1_ofidac_en_i2c<<2|ps2_ofidac_en_i2c<<1|ps3_ofidac_en_i2c)); + hx3918_write_reg(0X24, (intcapsel_ps0<<4|intcapsel_ps1)); + hx3918_write_reg(0X25, (intcapsel_ps2<<4|intcapsel_ps3)); + hx3918_write_reg(0X26, leddrive_ps0); + hx3918_write_reg(0X27, leddrive_ps1); + hx3918_write_reg(0X28, leddrive_ps2); + hx3918_write_reg(0X29, leddrive_ps3); + hx3918_write_reg(0X2a, (ldrsel_ps0<<4|ldrsel_ps1)); + hx3918_write_reg(0X2b, (ldrsel_ps2<<4|ldrsel_ps3)); + hx3918_write_reg(0X2c, dccancel_ps0); + hx3918_write_reg(0X2d, dccancel_ps1); + hx3918_write_reg(0X2e, dccancel_ps2); + hx3918_write_reg(0X2f, dccancel_ps3); + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); + hx3918_write_reg(0X4e, (force_adc_clk_sel<<7|force_adc_clk_cfg<<6|force_PEN<<5|force_PEN_cfg<<4|force_LED_EN<<3| + force_LED_EN_cfg<<2|force_CKAFEINT_sel<<1|force_CKAFEINT_cfg)); + + hx3918_write_reg(0X6d, 0x00); + hx3918_write_reg(0XF0, 0x22); + hx3918_write_reg(0xF1, 0x28); + hx3918_write_reg(0xF2, 0x04); + hx3918_write_reg(0xF3, 0x70); + hx3918_write_reg(0xF4, 0x32); + hx3918_write_reg(0xF5, 0x89); + hx3918_write_reg(0xF6, 0x2b); + hx3918_write_reg(0xF7, 0x85); + hx3918_write_reg(0xF8, 0x27); + hx3918_write_reg(0xF9, 0x00); + hx3918_write_reg(0xFA, 0x88); + hx3918_write_reg(0xFB, 0x40); + hx3918_write_reg(0Xf6, 0X2b); + + hx3918_write_reg(0x3d, 0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3e, 0x20); //watermark + hx3918_write_reg(0x3c, 0x1f); // int_width_i2c + hx3918_write_reg(0X37, 0x00); // int sel,01=prf int,04=enable almost full int + hx3918_write_reg(0X3b, 0x00); + hx3918_write_reg(0X3b, 0x10); + + hx3918_write_reg(0x4d, 0x01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0x4d, 0x00); //release + hx3918_delay(5); +} + +void hx3918_factory_ft_int_test_config(void)//ÖжϲâÊÔÅäÖà +{ +} + +bool hx3918_factory_test_read(int32_t *ps_data) +{ + uint8_t databuf1[6] = {0}; + uint8_t databuf2[6] = {0}; + int32_t P1 = 0, P2 = 0, P4 = 0, P3 = 0; + hx3918_brust_read_reg(0x02, databuf1, 6); + hx3918_brust_read_reg(0x08, databuf2, 6); + + P1 = ((databuf1[0]) | (databuf1[1] << 8) | (databuf1[2] << 16)); + P2 = ((databuf1[3]) | (databuf1[4] << 8) | (databuf1[5] << 16)); + P3 = ((databuf2[0]) | (databuf2[1] << 8) | (databuf2[2] << 16)); + P4 = ((databuf2[3]) | (databuf2[4] << 8) | (databuf2[5] << 16)); + + ps_data[0] = P1 ; + ps_data[1] = P2 ; + ps_data[2] = P3 ; + ps_data[3] = P4 ; + DEBUG_PRINTF("p1,p2,p3,p4 %d %d %d %d\r\n", P1, P2, P3, P4); + return true; +} + +bool hx3918_chip_check_id(void) +{ + uint8_t i = 0; + uint8_t chip_idf =0; + for(i=0; i<10; i++) + { + hx3918_write_reg(0x01, 0x00); + hx3918_delay(5); + chip_idf = hx3918_read_reg(0x00); + if (chip_idf == 0x27) + { + return true; + } + } + return false; +} + +factory_result_t hx3918_factroy_test(uint32_t test_mode) +{ + factory_result_t factory_reslts = {0,0,0}; + int32_t green_buffer[4] = {0,0,0,0}; + int32_t red_buffer[4] = {0,0,0,0}; + int32_t ir_buffer[4] = {0,0,0,0}; + int32_t ps_data[4]= {0,0,0,0}; + + int32_t green_led_data= 0; + int32_t red_led_data= 0; + int32_t ir_led_data= 0; + + int32_t green_psdif[4] = {0,0,0,0}; + int32_t red_psdif[4] = {0,0,0,0}; + int32_t ir_psdif[4] = {0,0,0,0}; + + int32_t green_final = 0; + int32_t red_final = 0; + int32_t ir_final = 0; + int32_t testdata_temp = 0; + + uint8_t ii = 0; + uint8_t jj = 0; + + if (hx3918_chip_check_id() == false) + { + return factory_reslts; + } + + switch(test_mode) + { + case LEAK_LIGHT_TEST: + hx3918_factory_ft_leak_light_test_config(); + break; + case GRAY_CARD_TEST: + hx3918_factory_ft_card_test_config(); + break; + case FT_INT_TEST: + hx3918_factory_ft_int_test_config(); + break; + default: + break; + } + hx3918_delay(100); + if(test_mode==FT_INT_TEST) + { + return factory_reslts; + } + + for(ii=0; ii<4; ii++) //40ms read data + { + hx3918_delay(40); + hx3918_factory_test_read(ps_data); + green_led_data = ps_data[1] - ps_data[0]; + red_led_data = ps_data[2] - ps_data[0]; + ir_led_data = ps_data[3] - ps_data[0]; + green_buffer[ii] = green_led_data; + ir_buffer[ii] = ir_led_data; + red_buffer[ii] = red_led_data; + } + + for(ii=0; ii<3; ii++) + { + for(jj=0; jj<3-ii; jj++) + { + if(green_buffer[jj]>=green_buffer[jj+1]) + { + testdata_temp = green_buffer[jj]; + green_buffer[jj] = green_buffer[jj+1]; + green_buffer[jj+1] = testdata_temp; + } + + if(red_buffer[jj]>=red_buffer[jj+1]) + { + testdata_temp = red_buffer[jj]; + red_buffer[jj] = red_buffer[jj+1]; + red_buffer[jj+1] = testdata_temp; + } + if(ir_buffer[jj]>=ir_buffer[jj+1]) + { + testdata_temp = ir_buffer[jj]; + ir_buffer[jj] = ir_buffer[jj+1]; + ir_buffer[jj+1] = testdata_temp; + } + } + } + + if(test_mode == LEAK_LIGHT_TEST) + { + hx3918_write_reg(0X2a, 0x00); + hx3918_write_reg(0X2b, 0x00); + hx3918_delay(100); + for(ii=0; ii<4; ii++) //40ms read data + { + hx3918_delay(40); + hx3918_factory_test_read(ps_data); + green_led_data = ps_data[1] - ps_data[0]; + red_led_data = ps_data[2] - ps_data[0]; + ir_led_data = ps_data[3] - ps_data[0]; + green_psdif[ii] = green_led_data; + ir_psdif[ii] = ir_led_data; + red_psdif[ii] = red_led_data; + } + for(jj=0; jj<3-ii; jj++) + { + if(green_psdif[jj]>=green_psdif[jj+1]) + { + testdata_temp = green_psdif[jj]; + green_psdif[jj] = green_psdif[jj+1]; + green_psdif[jj+1] = testdata_temp; + } + + if(red_psdif[jj]>=red_psdif[jj+1]) + { + testdata_temp = red_psdif[jj]; + red_psdif[jj] = red_psdif[jj+1]; + red_psdif[jj+1] = testdata_temp; + } + if(ir_psdif[jj]>=ir_psdif[jj+1]) + { + testdata_temp = ir_psdif[jj]; + ir_psdif[jj] = ir_psdif[jj+1]; + ir_psdif[jj+1] = testdata_temp; + } + } + } + + switch(test_mode) + { + case LEAK_LIGHT_TEST: + green_final = (green_buffer[1]+green_buffer[2])/2-(green_psdif[1]+green_psdif[2])/2; + red_final = (red_buffer[1]+red_buffer[2])/2-(red_psdif[1]+red_psdif[2])/2; + ir_final = (ir_buffer[1]+ir_buffer[2])/2-(ir_psdif[1]+ir_psdif[2])/2; + break; + case GRAY_CARD_TEST: + green_final = (green_buffer[1]+green_buffer[2])/2; + red_final = (red_buffer[1]+red_buffer[2])/2; + ir_final = (ir_buffer[1]+ir_buffer[2])/2; + break; + default: + break; + } + if(green_final<0) + { + green_final = 0; + } + if(red_final<0) + { + red_final = 0; + } + if(ir_final<0) + { + ir_final = 0; + } + factory_reslts.green_data_final = green_final; + factory_reslts.red_data_final = red_final; + factory_reslts.ir_data_final = ir_final; + DEBUG_PRINTF("%d %d %d\r\n",factory_reslts.green_data_final, factory_reslts.red_data_final,factory_reslts.ir_data_final); + return factory_reslts; +} diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_factory_test.h b/2.sdk/Helios_SDK/components/HX3918/hx3918_factory_test.h new file mode 100644 index 00000000..a15cfb4e --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_factory_test.h @@ -0,0 +1,41 @@ +#ifndef _hx3918_FACTORY_TEST_H_ +#define _hx3918_FACTORY_TEST_H_ + +#include +#include + +#define FT_OPEN_G_LED_LTH 3000 +#define FT_OPEN_R_LED_LTH 3000 +#define FT_OPEN_IR_LED_LTH 3000 + +#define FT_CARD_G_LED_HTH 200000 +#define FT_CARD_R_LED_HTH 400000 +#define FT_CARD_IR_LED_HTH 400000 + +typedef enum { + LEAK_LIGHT_TEST = 1, + GRAY_CARD_TEST = 2, + FT_INT_TEST = 3 +} TEST_MODE_t; + +typedef struct { + int32_t green_data_final; + int32_t red_data_final; + int32_t ir_data_final; +} factory_result_t; + + +//void hx3918_factory_test_config(void); +void hx3918_factory_ft_leak_light_test_config(void); +void hx3918_factory_ft_card_test_config(void); +void hx3918_factory_ft_int_test_config(void); + +bool hx3918_factory_test_read(int32_t *ps_data); +factory_result_t hx3918_factroy_test(uint32_t test_mode); + + +#endif // _hx3918_FACTORY_TEST_H_ + + + + diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_hrs_agc.c b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrs_agc.c new file mode 100644 index 00000000..60d6afda --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrs_agc.c @@ -0,0 +1,737 @@ +#include +#include +#include +#include +#include + +//#include "tyhx_hrs_custom.h" + +#include "hx3918.h" +#include "hx3918_hrs_agc.h" +#include "tyhx_hrs_alg.h" +#include "hx3918_prox.h" + +#ifdef HRS_ALG_LIB + +extern uint8_t hx3918_hrs_agc_idac; +extern uint8_t green_led_max_init; +extern uint8_t low_vbat_flag; +extern uint8_t read_fifo_first_flg; + +extern const int32_t hrs_ir_unwear_thres; +extern const int32_t hrs_ir_wear_thres; +extern const int32_t sar_unwear_thres; +extern const int32_t sar_wear_thres; + +static uint8_t s_ppg_state = 0; +static uint8_t s_cal_state = 0; +static int32_t agc_buf[4] = {0}; + +static uint8_t cal_delay = CAL_DELAY_COUNT; +static HRS_CAL_SET_T calReg; + +static hx3918_hrs_wear_msg_code_t hrs_wear_status = MSG_HRS_INIT; +static hx3918_hrs_wear_msg_code_t hrs_wear_status_pre = MSG_HRS_INIT; + +static uint8_t no_touch_cnt = 0; + +void hx3918_hrs_ppg_init(void) //20200615 ericy ppg fs=25hz, phase3 conversion ready interupt en +{ + uint16_t sample_rate = 25; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps0_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps1_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps2_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps3_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + + uint8_t ps0_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps1_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps2_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps3_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 2; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + /***********led open enable***********/ + + uint8_t ps0_led_en_i2c=1; + uint8_t ps1_led_en_i2c=0; + uint8_t ps2_led_en_i2c=1; + uint8_t ps3_led_en_i2c=0; + + uint8_t ps0_ofidac_en_i2c=1; + uint8_t ps1_ofidac_en_i2c=1; + uint8_t ps2_ofidac_en_i2c=1; + uint8_t ps3_ofidac_en_i2c=1; + + uint8_t dccancel_ps0 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =64; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =0; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =0; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =0; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint8_t led_en_begin =1; // 0 = 2 ; 1 = 4 ; 2 = 8 ; 3 = 16 ; + uint8_t afe_reset = 1; //* 0 = 32clk ; 1 = 64clk ; 2 = 128clk ; 3 = 256clk(d) ; + uint8_t en2rst_delay =3; // pen 2 rst delay 0 = 128,256, 512, 1024 + uint8_t init_wait_delay = 2; /* 0 = 800 ; 1 = 1600; 2 = 3200 ; 3 = 6400(d) */ + + uint8_t ps1_interval_i2c =0; // ps2/ps3 + + uint8_t thres_int =1; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + + uint8_t ldrsel_ps0 =IR_LED_SLE; + uint8_t ldrsel_ps1 =0; + uint8_t ldrsel_ps2 =GREEN_LED_SLE; + uint8_t ldrsel_ps3 =0; + + /***********cap *********/ + uint8_t intcapsel_ps3 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps2 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps1 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps0 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + + uint8_t ps0_led_on_time=16; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=16; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + uint8_t force_adc_clk_sel=0; + uint8_t force_adc_clk_cfg =0; + uint8_t force_PEN =0; //phase enable + uint8_t force_PEN_cfg =0; + uint8_t force_LED_EN =0; + uint8_t force_LED_EN_cfg =0; + uint8_t force_CKAFEINT_sel =0; + uint8_t force_CKAFEINT_cfg =0; + + hx3918_write_reg(0X16, (ps3_enable<<3| ps2_enable<<2|ps1_enable<<1|ps0_enable)); + hx3918_write_reg(0X17, (ps3_osr<<6| ps2_osr<<4|ps1_osr<<2|ps0_osr)); + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); + hx3918_write_reg(0X1a, (ps1_interval_i2c)); + hx3918_write_reg(0X1b, led_en_begin<<6|afe_reset<<4|en2rst_delay <<2|init_wait_delay); + //hx3918_write_reg(0X1b, 0x03); + hx3918_write_reg(0X1c, ps0_led_on_time); + hx3918_write_reg(0X1d, ps1_led_on_time); + hx3918_write_reg(0X1e, ps2_led_on_time); + hx3918_write_reg(0X1f, ps3_led_on_time); + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel)); + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|ps0_ofidac_en_i2c<<3|ps1_ofidac_en_i2c<<2|ps2_ofidac_en_i2c<<1|ps3_ofidac_en_i2c)); + hx3918_write_reg(0X24, (intcapsel_ps0<<4|intcapsel_ps1)); + hx3918_write_reg(0X25, (intcapsel_ps2<<4|intcapsel_ps3)); + hx3918_write_reg(0X26, leddrive_ps0); + hx3918_write_reg(0X27, leddrive_ps1); + hx3918_write_reg(0X28, leddrive_ps2); + hx3918_write_reg(0X29, leddrive_ps3); + hx3918_write_reg(0X2a, (ldrsel_ps0<<4|ldrsel_ps1)); + hx3918_write_reg(0X2b, (ldrsel_ps2<<4|ldrsel_ps3)); + hx3918_write_reg(0X2c, dccancel_ps0); + hx3918_write_reg(0X2d, dccancel_ps1); + hx3918_write_reg(0X2e, dccancel_ps2); + hx3918_write_reg(0X2f, dccancel_ps3); + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); + hx3918_write_reg(0X4e, (force_adc_clk_sel<<7|force_adc_clk_cfg<<6|force_PEN<<5|force_PEN_cfg<<4|force_LED_EN<<3| + force_LED_EN_cfg<<2|force_CKAFEINT_sel<<1|force_CKAFEINT_cfg)); + + hx3918_write_reg(0X6d, 0x00); + hx3918_write_reg(0XF0, 0x22); + hx3918_write_reg(0xF1, 0x28); + hx3918_write_reg(0xF2, 0x04); + hx3918_write_reg(0xF3, 0x70); + hx3918_write_reg(0xF4, 0x32); + hx3918_write_reg(0xF5, 0x89); + hx3918_write_reg(0xF6, 0x2b); + hx3918_write_reg(0xF7, 0x85); + hx3918_write_reg(0xF8, 0x27); + hx3918_write_reg(0xF9, 0x00); + hx3918_write_reg(0xFA, 0x88); + hx3918_write_reg(0xFB, 0x40); + hx3918_write_reg(0Xf6, 0X2b); + +#if defined(TIMMER_MODE) + hx3918_write_reg(0x3d, 0x83); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3e, 0x20); //watermark + hx3918_write_reg(0x3c, 0x1f); // int_width_i2c + hx3918_write_reg(0X37, 0x00); // int sel,01=prf int,04=enable almost full int + hx3918_write_reg(0X3b, 0x00); + hx3918_write_reg(0X3b, 0x10); +#else ///////////INT Mode + hx3918_write_reg(0x3d, 0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3c, 0x1f); // int_width_i2c + hx3918_write_reg(0x37, 0x04); // int sel,01=prf ,04=enable almost full +#endif + + hx3918_write_reg(0x4d, 0x01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0x4d, 0x00); //release + hx3918_delay(5); + read_fifo_first_flg = 1; +} + +void Init_hrs_PPG_Calibration_Routine(HRS_CAL_SET_T *calR) +{ + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + + calR->led_idac = 0; + calR->amb_idac = 0; + calR->ontime = 5; + calR->led_cur = HRS_CAL_INIT_LED; + calR->state = hrsCalStart; + calR->int_cnt = 0; + calR->cur255_cnt = 0; + if(low_vbat_flag==1) + { + calR->led_max_cur = green_led_max_init>>1; + } + else + { + calR->led_max_cur = green_led_max_init; + } +} + +void Restart_hrs_PPG_Calibration_Routine(HRS_CAL_SET_T *calR) +{ + calR->flag = CAL_FLG_LED_DAC; + calR->state = hrsCalLed; + calR->int_cnt = 0; +} + +hx3918_hrs_wear_msg_code_t hx3918_hrs_wear_mode_check(int32_t infrared_data) +{ + int32_t check_thre = 0; + if(hrs_wear_status == MSG_HRS_NO_WEAR) + { + check_thre = hrs_ir_wear_thres; + } + else + { + check_thre = hrs_ir_unwear_thres; + } + + if(infrared_data < check_thre) + { + if(no_touch_cnt < NO_TOUCH_CHECK_NUM) + { + no_touch_cnt++; + } + if(no_touch_cnt >= NO_TOUCH_CHECK_NUM) + { + hrs_wear_status = MSG_HRS_NO_WEAR; + } + } + else if(infrared_data >= check_thre) + { + if(no_touch_cnt>0) + { + no_touch_cnt--; + } + if(no_touch_cnt == 0) + { + hrs_wear_status = MSG_HRS_WEAR; + } + } + //AGC_LOG("hrs wear: ir=%d, %x\r\n",infrared_data,hx3918_read_reg(0x6a)); + //AGC_LOG("hrs wearstates: hrs_wear_status_pre=%d,hrs_wear_status=%d\r\n",\ + //hrs_wear_status_pre,hrs_wear_status); + + //hrs_wear_status = hx3918_get_wear_result(hrs_wear_status); + TYHX_LOG("[hx3918_hrs_wear_mode_check end] final result = %d\r\n",hrs_wear_status); + if(hrs_wear_status_pre != hrs_wear_status) + { + hrs_wear_status_pre = hrs_wear_status; + if(hrs_wear_status == MSG_HRS_NO_WEAR) + { + hx3918_hrs_low_power(); + } + else if(hrs_wear_status == MSG_HRS_WEAR) + { + tyhx_hrs_alg_open_deep(); + hx3918_hrs_set_mode(PPG_INIT); + hx3918_hrs_set_mode(CAL_INIT); + } + } + return hrs_wear_status; +} + +/* +hx3918_hrs_wear_msg_code_t hx3918_hrs_check_unwear(int32_t infrared_data) +{ + AGC_LOG("infrared_data=%d,hrs_wear_status=%d\r\n",infrared_data,hrs_wear_status); + if(infrared_data < hrs_ir_unwear_thres) + { + if(no_touch_cnt == NO_TOUCH_CHECK_NUM) + { + hrs_wear_status = MSG_HRS_NO_WEAR; + if(hrs_wear_status_pre != hrs_wear_status) + { + hx3918_hrs_low_power(); + } + } + else + { + no_touch_cnt++; + } + } + else + { + no_touch_cnt = 0; + } + hrs_wear_status_pre = hrs_wear_status; + return hrs_wear_status; +} +*/ +void PPG_hrs_Calibration_Routine(HRS_CAL_SET_T *calR, int32_t led, int32_t amb) +{ + switch(calR->state) + { + case hrsCalStart: + calR->state = hrsLedCur; + break; + + case hrsLedCur: + if(amb>280000) + { + calR->amb_idac = (amb-280000)/10000; + } + else + { + calR->amb_idac = 0; + } + if(led>amb+128) + { + calR->led_step = (led-amb)/HRS_CAL_INIT_LED; + calR->led_cur = 5000*(hx3918_hrs_agc_idac+calR->amb_idac)/calR->led_step; + if(calR->led_cur>calR->led_max_cur) + { + calR->led_cur = calR->led_max_cur; + } + calR->led_idac = hx3918_hrs_agc_idac>>1; + calR->ontime = 64; + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + calR->state = hrsCalLed; + } + else + { + calR->led_cur = calR->led_max_cur; + calR->led_idac = hx3918_hrs_agc_idac>>1; + calR->ontime = 64; + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + calR->state = hrsCalLed; + } + break; + + case hrsCalLed: + if(led>350000 && calR->led_idac<=120) + { + calR->led_idac = calR->led_idac + 1; + calR->state = hrsCalLed; + } + else if(led<150000 && calR->led_idac>=1) + { + calR->led_idac = calR->led_idac - 1; + calR->state = hrsCalLed; + } + else + { + calR->state = hrsCalFinish; + } + calR->flag = CAL_FLG_LED_DAC; + break; + + default: + break; + + } + AGC_LOG("AGC: led_drv=%d,ledDac=%d,ambDac=%d,ledstep=%d,ontime=%d,state=%d\r\n",\ + calR->led_cur, calR->led_idac, calR->amb_idac,calR->led_step,calR->ontime,calR->state); +} + +HRS_CAL_SET_T PPG_hrs_agc(void) +{ + int32_t led_val, amb_val; + calReg.work = false; + if (!s_cal_state) + { + return calReg; + } + +#ifdef INT_MODE + calReg.int_cnt ++; + if(calReg.int_cnt < 4) + { + return calReg; + } + calReg.int_cnt = 0; + hx3918_gpioint_cfg(false); +#endif + calReg.work = true; + + read_data_packet(agc_buf); + led_val = agc_buf[2]; + amb_val = agc_buf[3]; + + AGC_LOG("cal dat led_val=%d,amb_val=%d \r\n", led_val, amb_val); + + PPG_hrs_Calibration_Routine(&calReg, led_val, amb_val); + + if (calReg.state == hrsCalFinish) + { + hx3918_hrs_set_mode(CAL_OFF); + } + else + { + hx3918_hrs_updata_reg(); + } + #if defined(INT_MODE) + hx3918_gpioint_cfg(true); + #endif + + return calReg; +} + +void hx3918_hrs_cal_init(void) // 20200615 ericy afe cali online +{ + uint16_t sample_rate = 100; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + uint8_t thres_int =0; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<15:8> default 0x03 + hx3918_write_reg(0x3d,0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); //default 0x0f + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); //Delay for reset time +} + +void hx3918_hrs_cal_off(void) // 20200615 ericy afe cali offline +{ + uint16_t sample_rate = 25; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t thres_int =0; //thres int enable + uint8_t data_rdy_int =0; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<15:8> default 0x03 + + hx3918_write_reg(0x3d, 0x83); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); //default 0x0f + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); //Delay for reset time + #if DEBUG_PPG_ONLY + hx3918_prox_init(); + #endif + read_fifo_first_flg = 1; +} + +void hx3918_hrs_low_power(void) +{ + uint16_t sample_rate = 10; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 0; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + uint8_t ps0_led_en_i2c=1; + uint8_t ps1_led_en_i2c=0; + uint8_t ps2_led_en_i2c=0; + uint8_t ps3_led_en_i2c=0; + + uint8_t dccancel_ps0 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =64; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =0; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =0; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =0; //LEDDRIVE_PS3 0~255 = 0~200ma + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<11:8> default 0x03 + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel) ); + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|0x0f)); + + hx3918_write_reg(0X26, leddrive_ps0); + hx3918_write_reg(0X27, leddrive_ps1); + hx3918_write_reg(0X28, leddrive_ps2); + hx3918_write_reg(0X29, leddrive_ps3); + + hx3918_write_reg(0X2c, dccancel_ps0); + hx3918_write_reg(0X2d, dccancel_ps1); + hx3918_write_reg(0X2e, dccancel_ps2); + hx3918_write_reg(0X2f, dccancel_ps3); + + hx3918_write_reg(0x4d, 0x01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0x4d, 0x00); //release + hx3918_delay(5); + + calReg.led_cur = 0; + #if DEBUG_PPG_ONLY + hx3918_prox_init(); + #endif + read_fifo_first_flg = 1; + AGC_LOG(" chip go to low power mode \r\n" ); + +} + +void hx3918_hrs_updata_reg(void) +{ + if (calReg.flag & CAL_FLG_LED_DR) + { + hx3918_write_reg(0X28, calReg.led_cur); + } + + if (calReg.flag & CAL_FLG_LED_DAC) + { + hx3918_write_reg(0X2e, (uint8_t)calReg.led_idac); + } + + if (calReg.flag & CAL_FLG_AMB_DAC) + { + hx3918_write_reg(0X2f, (uint8_t)calReg.amb_idac); + } + + if (calReg.flag & CAL_FLG_RF) + { + hx3918_write_reg(0X1e, calReg.ontime); //3918 p2 + hx3918_write_reg(0X1f, calReg.ontime); //3918 p3 + } +} + +void hx3918_hrs_set_mode(uint8_t mode_cmd) +{ + switch (mode_cmd) + { + case PPG_INIT: + hx3918_hrs_ppg_init(); + #if defined(TIMMER_MODE) + hx3918_ppg_timer_cfg(true); + #else + hx3918_gpioint_cfg(true); + #endif + s_ppg_state = 1; + AGC_LOG("ppg init mode\r\n"); + break; + + case PPG_OFF: + hx3918_ppg_off(); + s_ppg_state = 0; + AGC_LOG("ppg off mode\r\n"); + break; + + case PPG_LED_OFF: + hx3918_hrs_low_power(); + s_ppg_state = 0; + AGC_LOG("ppg led off mode\r\n"); + break; + + case CAL_INIT: + Init_hrs_PPG_Calibration_Routine(&calReg); + hx3918_hrs_cal_init(); + hx3918_hrs_updata_reg(); + #if defined(TIMMER_MODE) + hx3918_agc_timer_cfg(true); + #endif + s_cal_state = 1; + AGC_LOG("cal init mode\r\n"); + break; + + case RECAL_INIT: + Restart_hrs_PPG_Calibration_Routine(&calReg); + hx3918_hrs_cal_init(); + hx3918_hrs_updata_reg(); + #if defined(TIMMER_MODE) + hx3918_agc_timer_cfg(true); + #endif + s_cal_state = 1; + AGC_LOG("Recal init mode\r\n"); + break; + + case CAL_OFF: + #if defined(TIMMER_MODE) + hx3918_agc_timer_cfg(false); + #endif + hx3918_hrs_cal_off(); + s_cal_state = 0; + AGC_LOG("cal off mode\r\n"); + break; + + default: + break; + } +} + +SENSOR_ERROR_T hx3918_hrs_enable(void) +{ + if (!hx3918_chip_check()) + { + TYHX_LOG("hx3918 check id failed!\r\n"); + return SENSOR_OP_FAILED; + } + else + { + TYHX_LOG("hx3918 check id success!\r\n"); + } + if (s_ppg_state) + { + TYHX_LOG("ppg already on!\r\n"); + return SENSOR_OP_FAILED; + } + if(!tyhx_hrs_alg_open()) + { + TYHX_LOG("hrs alg open fail,or dynamic ram not enough!\r\n"); + } + + hrs_wear_status = MSG_HRS_INIT; + hrs_wear_status_pre = MSG_HRS_INIT; + hx3918_hrs_set_mode(PPG_INIT); + TYHX_LOG("hx3918 enable!\r\n"); + + return SENSOR_OK; +} + +void hx3918_hrs_disable(void) +{ +#if defined(TIMMER_MODE) + hx3918_ppg_timer_cfg(false); + hx3918_agc_timer_cfg(false); + #elif defined(INT_MODE) + hx3918_gpioint_cfg(false); + #endif + hx3918_hrs_set_mode(PPG_OFF); + s_ppg_state = 0; + s_cal_state = 0; + tyhx_hrs_alg_close(); +} + +void hx3918_hrs_data_reset(void) +{ + s_ppg_state = 0; + s_cal_state = 0; + tyhx_hrs_alg_close(); +} + +hx3918_hrs_wear_msg_code_t hx3918_hrs_get_wear_status(void) +{ + return hrs_wear_status; +} + +HRS_CAL_SET_T get_hrs_agc_status(void) +{ + HRS_CAL_SET_T cal; + cal.flag = calReg.flag; + cal.int_cnt = calReg.int_cnt; + cal.led_cur = calReg.led_cur; + cal.led_idac = calReg.led_idac; + cal.amb_idac = calReg.amb_idac; + cal.ontime = calReg.ontime; + cal.led_step = calReg.led_step; + cal.state = calReg.state; + return cal; +} + +uint8_t hx3918_hrs_read(ppg_sensor_data_t * s_dat) +{ + int32_t PPG_src_data; + int32_t Ir_src_data; + bool recal = false; + int32_t *PPG_buf = &(s_dat->green_data[0]); + int32_t *ir_buf = &(s_dat->ir_data[0]); + int32_t *s_buf = &(s_dat->s_buf[0]); + s_dat->green_cur = calReg.led_cur; + //int32_t *sar_lp_data = &s_dat->sar_data; + int32_t ps_data[4]= {0}; + int32_t ps_green_data = 0; + uint8_t data_count = 0; + + if (!s_ppg_state || s_cal_state) + { + return NULL; + } + + read_data_packet(ps_data); + ps_green_data = ps_data[2]; + + data_count = hx3918_read_fifo_data(s_buf,2,1); + s_dat->count = data_count; + TYHX_LOG("\r\n hrs ir data: "); + for (uint8_t i=0; i400000) + { + recal = true; + + if(hrs_wear_status==MSG_HRS_NO_WEAR) + { + recal = false; + } + } + if (recal) + { + cal_delay--; + + if (cal_delay <= 0) + { + cal_delay = CAL_DELAY_COUNT; + hx3918_hrs_set_mode(RECAL_INIT); + } + } + else + { + cal_delay = CAL_DELAY_COUNT; + } + return 1; +} +#endif + + + + diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_hrs_agc.h b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrs_agc.h new file mode 100644 index 00000000..f6579013 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrs_agc.h @@ -0,0 +1,68 @@ +#ifndef _hx3918_agc_H_ +#define _hx3918_agc_H_ +#include +#include +#include "hx3918.h" + +#define CAL_DELAY_COUNT (3) + +#define CAL_FLG_LED_DR 0x01 +#define CAL_FLG_LED_DAC 0x02 +#define CAL_FLG_AMB_DAC 0x04 +#define CAL_FLG_RF 0x08 + +#define HRS_CAL_INIT_LED 64 +#define NO_TOUCH_CHECK_NUM 2 + + +typedef enum { + hrsCalStart, + hrsLedCur, + hrsCalLed, + hrsCalFinish, +}HRS_STATE_T; + +typedef struct { + uint8_t flag; + bool work; + uint8_t int_cnt; + uint8_t cur255_cnt; + uint16_t led_cur; + uint8_t led_idac; + uint8_t amb_idac; + uint8_t ontime; + uint16_t led_step; + uint8_t state; + uint8_t led_max_cur; +} HRS_CAL_SET_T; + +typedef enum { + MSG_HRS_NO_WEAR, + MSG_HRS_WEAR, + MSG_HRS_INIT +} hx3918_hrs_wear_msg_code_t; + +void Init_hrs_PPG_Calibration_Routine(HRS_CAL_SET_T *calR); +void Restart_hrs_PPG_Calibration_Routine(HRS_CAL_SET_T *calR); +void PPG_hrs_Calibration_Routine(HRS_CAL_SET_T *calR, int32_t led, int32_t amb); +HRS_CAL_SET_T PPG_hrs_agc(void); +void hx3918_hrs_cal_init(void); +void hx3918_hrs_cal_off(void); + +void hx3918_hrs_low_power(void); +void hx3918_hrs_normal_power(void); +void hx3918_hrs_updata_reg(void); +void hx3918_hrs_set_mode(uint8_t mode_cmd); +SENSOR_ERROR_T hx3918_hrs_enable(void); +void hx3918_hrs_disable(void); +hx3918_hrs_wear_msg_code_t hx3918_hrs_get_wear_status(void); +uint8_t hx3918_hrs_read(ppg_sensor_data_t * s_dat); +bool hx3918_hrs_init(void); + +hx3918_hrs_wear_msg_code_t hx3918_hrs_wear_mode_check(int32_t infrared_data); +//hx3918_hrs_wear_msg_code_t hx3918_hrs_check_unwear(int32_t infrared_data); +hx3918_hrs_wear_msg_code_t hx3918_hrs_check_wear(void); +HRS_CAL_SET_T get_hrs_agc_status(void); +void hx3918_hrs_data_reset(void); + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_hrv_agc.c b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrv_agc.c new file mode 100644 index 00000000..1c4964c3 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrv_agc.c @@ -0,0 +1,956 @@ +#include +#include +#include +#include +#include + +//#include "tyhx_hrs_custom.h" +#include "hx3918_hrs_agc.h" +#include "hx3918_hrv_agc.h" +#include "tyhx_hrv_alg.h" +#include "hx3918_prox.h" +//#ifdef TYHX_DEMO +//#include "twi_master.h" +//#include "SEGGER_RTT.h" +//#endif + +#ifdef HRV_ALG_LIB + +extern const uint8_t hx3918_hrs_agc_idac; +extern const uint8_t green_led_max_init; +extern uint8_t low_vbat_flag; +extern uint8_t read_fifo_first_flg; + +//hrv_INFRARED_THRES +extern const int32_t hrv_ir_unwear_thres; +extern const int32_t hrv_ir_wear_thres; + +static uint8_t s_ppg_state = 0; +static uint8_t s_cal_state = 0; +static int32_t agc_buf[4] = {0}; + +static uint8_t cal_delay = CAL_DELAY_COUNT; +static HRV_CAL_SET_T calReg; +// +static hx3918_hrv_wear_msg_code_t hrv_wear_status = MSG_HRV_NO_WEAR; +static hx3918_hrv_wear_msg_code_t hrv_wear_status_pre = MSG_HRV_NO_WEAR; + +static uint8_t no_touch_cnt = 0; + +void hx3918_hrv_ppg_init(void) //20200615 ericy ppg fs=25hz, phase3 conversion ready interupt en +{ + /* start cfg*/ + uint16_t sample_rate = 125; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps0_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps1_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps2_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps3_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + + uint8_t ps0_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps1_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps2_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps3_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 0; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + /***********led open enable***********/ + + uint8_t ps0_led_en_i2c=1; + uint8_t ps1_led_en_i2c=0; + uint8_t ps2_led_en_i2c=1; + uint8_t ps3_led_en_i2c=0; + + uint8_t ps0_ofidac_en_i2c=1; + uint8_t ps1_ofidac_en_i2c=1; + uint8_t ps2_ofidac_en_i2c=1; + uint8_t ps3_ofidac_en_i2c=1; + + uint8_t dccancel_ps0 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =0; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =0; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =64; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =0; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint16_t thres_level =0; + uint8_t led_en_begin =1; // 0 = 2 ; 1 = 4 ; 2 = 8 ; 3 = 16 ; + uint8_t afe_reset = 1; //* 0 = 32clk ; 1 = 64clk ; 2 = 128clk ; 3 = 256clk(d) ; + uint8_t en2rst_delay =3; // pen 2 rst delay 0 = 128,256, 512, 1024 + uint8_t init_wait_delay = 2; /* 0 = 800 ; 1 = 1600; 2 = 3200 ; 3 = 6400(d) */ + + uint8_t ps1_interval_i2c =0; // ps2/ps3 + + uint8_t thres_int =1; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + + uint8_t ldrsel_ps0 =1; //ps0 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + uint8_t ldrsel_ps1 =0; //ps1 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + uint8_t ldrsel_ps2 =2; //ps1 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + uint8_t ldrsel_ps3 =0; //ps1 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + + /***********cap *********/ + uint8_t intcapsel_ps3 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps2 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps1 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps0 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + + uint8_t ps0_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=16; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=16; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + uint8_t force_adc_clk_sel=0; + uint8_t force_adc_clk_cfg =0; + uint8_t force_PEN =0; //phase enable + uint8_t force_PEN_cfg =0; + uint8_t force_LED_EN =0; + uint8_t force_LED_EN_cfg =0; + uint8_t force_CKAFEINT_sel =0; + uint8_t force_CKAFEINT_cfg =0; + + uint8_t PDBIASEN =0; + uint8_t PDILOADEN =0; + + /***********************sar*****************************/ + uint8_t odr_short =1; + + uint8_t ch0_cfg =3; + uint8_t ch1_cfg =12; + uint8_t ch2_cfg =48; + + uint8_t ch0_range=1; // 000=1.25pF 001=2.5pF 010=3.75pF 011=5pF 100=0.625pF + uint8_t ch1_range=1; // 000=1.25pF 001=2.5pF 010=3.75pF 011=5pF 100=0.625pF + uint8_t ch2_range=1; // 000=1.25pF 001=2.5pF 010=3.75pF 011=5pF 100=0.625pF + + uint8_t ch0_avg_num=1; // 000 =1; 001 = 2;.default;010= 4;011= 8; 100= 16;101= 32; + uint8_t ch1_avg_num=1; + uint8_t ch2_avg_num=1; + + uint8_t ch0_wram_num=0; + + uint8_t ch0_osr_num=2; // 000= 16;001=32;010=64;011=128;100=256; + uint8_t ch1_osr_num=2; // 000= 16;001=32;010=64;011=128;100=256; + uint8_t ch2_osr_num=2; // 000= 16;001=32;010=64;011=128;100=256; + + uint8_t c0_offset_dac=0; + uint8_t c1_offset_dac=0; + uint8_t c2_offset_dac=0; + + uint8_t sar_sample_num=8; + + uint8_t sar_integ_num=8; + + uint8_t ch_num_sel=0; + + hx3918_write_reg(0X16, (ps3_enable<<3| ps2_enable<<2|ps1_enable<<1|ps0_enable)); //default 0x00 + hx3918_write_reg(0X17, (ps3_osr<<6| ps2_osr<<4|ps1_osr<<2|ps0_osr)); //default 0x00 + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<11:8> default 0x03 + hx3918_write_reg(0X1a, (ps1_interval_i2c)); //default 0x00 + hx3918_write_reg(0X1b, led_en_begin<<6|afe_reset<<4|en2rst_delay <<2|init_wait_delay); // led_en_num*8 //default 0x00 + //hx3918_write_reg(0X1b, 0x03); + hx3918_write_reg(0X1c, ps0_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1d, ps1_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1e, ps2_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1f, ps3_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel) ); //default 0x00 + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); //default 0x00 + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|ps0_ofidac_en_i2c<<3|ps1_ofidac_en_i2c<<2|ps2_ofidac_en_i2c<<1|ps3_ofidac_en_i2c)); // led_en offset_en + hx3918_write_reg(0X24, (intcapsel_ps0<<4|intcapsel_ps1)); //default 0x00 + hx3918_write_reg(0X25, (intcapsel_ps2<<4|intcapsel_ps3)); //default 0x00 + hx3918_write_reg(0X26, leddrive_ps0); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X27, leddrive_ps1); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X28, leddrive_ps2); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X29, leddrive_ps3); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X2a, (ldrsel_ps0<<4|ldrsel_ps1)); //default 0x00 + hx3918_write_reg(0X2b, (ldrsel_ps2<<4|ldrsel_ps3)); //default 0x00 + hx3918_write_reg(0X2c, dccancel_ps0 ); //default 0x00 + hx3918_write_reg(0X2d, dccancel_ps1 ); //default 0x00 + hx3918_write_reg(0X2e, dccancel_ps2 ); //default 0x00 + hx3918_write_reg(0X2f, dccancel_ps3); //default 0x00 + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); + hx3918_write_reg(0X4e, (force_adc_clk_sel<<7|force_adc_clk_cfg<<6|force_PEN<<5|force_PEN_cfg<<4|force_LED_EN<<3| + force_LED_EN_cfg<<2|force_CKAFEINT_sel<<1|force_CKAFEINT_cfg)); //default 0x00 + + hx3918_write_reg(0X54, odr_short); + hx3918_write_reg(0X55,ch0_cfg); // ch0 single input cs0=p + hx3918_write_reg(0X56,ch0_cfg>>8); // + hx3918_write_reg(0X57,ch1_cfg); // ch1 dif input cs0=p cs1=n + hx3918_write_reg(0X58,ch1_cfg>>8); // + hx3918_write_reg(0X59,ch2_cfg); // ch2 single input cs2=p + hx3918_write_reg(0X5a,ch2_cfg>>8); // + hx3918_write_reg(0X5b,(ch1_range<<4|ch0_range)); + hx3918_write_reg(0X5c, ch2_range); + hx3918_write_reg(0X5d, (ch0_avg_num<<5|ch0_osr_num<<2|ch0_wram_num)); + hx3918_write_reg(0X5e, (ch2_osr_num<<4|ch0_osr_num)); + hx3918_write_reg(0X5f, (ch2_avg_num<<4|ch1_avg_num)); + hx3918_write_reg(0X60, c0_offset_dac); + hx3918_write_reg(0X61, c0_offset_dac>>8); + hx3918_write_reg(0X62, c1_offset_dac); + hx3918_write_reg(0X63, c1_offset_dac>>8); + hx3918_write_reg(0X64, c2_offset_dac); + hx3918_write_reg(0X65, c2_offset_dac>>8); + hx3918_write_reg(0X66, sar_sample_num); + hx3918_write_reg(0X67, sar_sample_num>>8); + hx3918_write_reg(0X68, sar_integ_num); + hx3918_write_reg(0X69, sar_integ_num>>8); + hx3918_write_reg(0X6a, ch_num_sel); + + hx3918_write_reg(0X6d, 0x00); + hx3918_write_reg(0XF0, 0x22); + hx3918_write_reg(0xF1, 0x28); + hx3918_write_reg(0xF2, 0x04); + hx3918_write_reg(0xF3, 0x70); + hx3918_write_reg(0xF4, 0xb2); + hx3918_write_reg(0xF5, 0x89); + hx3918_write_reg(0xF6, 0x2b); + hx3918_write_reg(0xF7, 0x81); + hx3918_write_reg(0xF8, 0x27); + hx3918_write_reg(0xF9, 0x00); + hx3918_write_reg(0xFA, 0x88); + hx3918_write_reg(0xFB, 0x40); + hx3918_write_reg(0Xf6, 0X2b); + +#if defined(TIMMER_MODE) + hx3918_write_reg(0x3d,0x84); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3e,0x20); //watermark + hx3918_write_reg(0x3c,0x1f); // int_width_i2c + hx3918_write_reg(0X37, 0x00); // int sel,01=prf int,04=enable almost full int + hx3918_write_reg(0X3b, 0x00); + hx3918_write_reg(0X3b, 0x10); +#else ///////////INT Mode + hx3918_write_reg(0x3d,0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3c,0x1f); // int_width_i2c + hx3918_write_reg(0X37, 0x04); // int sel,01=prf ,04=enable almost full +#endif + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); + hx3918_prox_init(); + read_fifo_first_flg = 1; +} + +hx3918_hrv_wear_msg_code_t hx3918_hrv_wear_mode_check(int32_t infrared_data) +{ + if(infrared_data > hrv_ir_wear_thres) + { + if(no_touch_cnt < NO_TOUCH_CHECK_NUM) + { + no_touch_cnt++; + } + if(no_touch_cnt >= NO_TOUCH_CHECK_NUM) + { + hrv_wear_status = MSG_HRV_WEAR; + } + } + else if(infrared_data < hrv_ir_unwear_thres) + { + if(no_touch_cnt>0) + { + no_touch_cnt--; + } + if(no_touch_cnt == 0) + { + hrv_wear_status = MSG_HRV_NO_WEAR; + } + } + + if(hrv_wear_status_pre != hrv_wear_status) + { + hrv_wear_status_pre = hrv_wear_status; + //TYHX_LOG("[hx3918_hrv_wear_mode_check start] ir wear result = %d\r\n",hrv_wear_status); + //hrv_wear_status = hx3918_get_wear_result(hrv_wear_status); + TYHX_LOG("[hx3918_hrv_wear_mode_check end] final result = %d\r\n",hrv_wear_status); + if(hrv_wear_status_pre == MSG_HRV_NO_WEAR) + { + hx3918_hrv_low_power(); + } + else if(hrv_wear_status_pre == MSG_HRV_WEAR) + { + tyhx_hrv_alg_open_deep(); + hx3918_hrv_set_mode(PPG_INIT); + hx3918_hrv_set_mode(CAL_INIT); + } + } + + return hrv_wear_status; +} + +void Init_hrv_PPG_Calibration_Routine(HRV_CAL_SET_T *calR,uint8_t led) +{ + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + + calR->led_idac = 8; + calR->amb_idac = 8; + calR->ontime = 5; //int cap=2 ontime=5 1ofidac=9000 code + calR->led_cur = HRS_CAL_INIT_LED; + calR->state = hrsCalStart; + calR->int_cnt = 0; + calR->cur255_cnt = 0; + if(low_vbat_flag==1) + { + calR->led_max_cur = green_led_max_init>>1; + } + else + { + calR->led_max_cur = green_led_max_init; + } +} + +void Restart_hrv_PPG_Calibration_Routine(HRV_CAL_SET_T *calR) +{ + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + calR->state = hrvCalLed; + calR->int_cnt = 0; +} + +void PPG_hrv_Calibration_Routine(HRV_CAL_SET_T *calR, int32_t led, int32_t amb) +{ + switch(calR->state) + { + case hrvCalStart: + calR->state = hrvLedCur; + break; + + case hrvLedCur: + if(amb>280000) + { + calR->amb_idac = (amb-280000)/10000; + } + else + { + calR->amb_idac = 0; + } + if(led>amb+128) + { + calR->led_step = (led-amb)/HRV_CAL_INIT_LED; + calR->led_cur = 10000*(hx3918_hrs_agc_idac+calR->amb_idac)/calR->led_step; + if(calR->led_cur>calR->led_max_cur) + { + calR->led_cur = calR->led_max_cur; + } + calR->led_idac = 0; + calR->ontime = 32; + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + calR->state = hrvCalLed; + } + else + { + calR->led_cur = calR->led_max_cur; + calR->led_idac = 0; + calR->ontime = 32; + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + calR->state = hrvCalLed; + } + break; + + case hrvCalLed: + if(led>320000 && calR->led_idac<=120) + { + calR->led_idac = calR->led_idac + 1; + calR->state = hrvCalLed; + } + else if(led<200000 && calR->led_idac>=1) + { + calR->led_idac = calR->led_idac - 1; + calR->state = hrvCalLed; + } + else + { + calR->state = hrvCalFinish; + } + calR->flag = CAL_FLG_LED_DAC; + break; + + default: + break; + + } + AGC_LOG("AGC: led_drv=%d,ledDac=%d,ambDac=%d,ledstep=%d,ontime=%d,state=%d\r\n",\ + calR->led_cur, calR->led_idac, calR->amb_idac,calR->led_step,calR->ontime,calR->state); +} + +HRV_CAL_SET_T PPG_hrv_agc(void) +{ + int32_t led_val, amb_val; + calReg.work = false; + if (!s_cal_state) + { + return calReg; + } + +#ifdef INT_MODE + calReg.int_cnt ++; + if(calReg.int_cnt < 8) + { + return calReg; + } + calReg.int_cnt = 0; + hx3918_gpioint_cfg(false); +#endif + calReg.work = true; + + read_data_packet(agc_buf); + led_val = agc_buf[0]; + amb_val = agc_buf[1]; + + AGC_LOG("cal dat led_val=%d,amb_val=%d \r\n", led_val, amb_val); + + PPG_hrv_Calibration_Routine(&calReg, led_val, amb_val); + + if (calReg.state == hrvCalFinish) + { + hx3918_hrv_set_mode(CAL_OFF); +#if defined(TIMMER_MODE) +#else + hx3918_gpioint_cfg(true); +#endif + } + else + { + hx3918_hrv_updata_reg(); +#if defined(INT_MODE) + hx3918_gpioint_cfg(true); +#endif + } + return calReg; +} + + + +void hx3918_hrv_cal_init(void) // 20200615 ericy afe cali online +{ + uint16_t sample_rate = 100; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + uint8_t thres_int =0; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<15:8> default 0x03 + + + hx3918_write_reg(0x3d,0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); //default 0x0f + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); //Delay for reset time +} + +void hx3918_hrv_cal_off(void) // 20200615 ericy afe cali offline +{ + uint16_t sample_rate = 125; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + +// if(ps0_avg_flg==0) +// { +// ps1_cp_avg_num_sel= 0; +// ps0_cp_avg_num_sel= 0; +// } +// else +// { +// ps1_cp_avg_num_sel= 0; +// ps0_cp_avg_num_sel= 2; +// } + uint8_t thres_int =0; //thres int enable + uint8_t data_rdy_int =0; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + uint8_t databuf[3] = {0}; + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<15:8> default 0x03 + + hx3918_write_reg(0x3d,0x84); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); //default 0x0f + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); //Delay for reset time + #if DEBUG_PPG_ONLY + hx3918_prox_init(); + #endif + read_fifo_first_flg = 1; +} + +void hx3918_hrv_low_power(void) +{ + /* start cfg*/ + /*****************PPG***************************/ + uint16_t sample_rate = 10; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps0_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps1_enable=0; /*ps1_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps2_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps3_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + + uint8_t ps0_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps1_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps2_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps3_osr = 1; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 0; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + /***********led open enable***********/ + + uint8_t ps0_led_en_i2c=0; + uint8_t ps1_led_en_i2c=0; + uint8_t ps2_led_en_i2c=1; + uint8_t ps3_led_en_i2c=0; + + uint8_t ps0_ofidac_en_i2c=1; + uint8_t ps1_ofidac_en_i2c=1; + uint8_t ps2_ofidac_en_i2c=1; + uint8_t ps3_ofidac_en_i2c=1; + + uint8_t dccancel_ps0 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =8; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =0; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =0; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =64; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =0; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint16_t thres_level =0; + +// uint8_t adc_self = 0; //adc self test 1:enable 0:disable + + uint8_t led_en_begin =1; // 0 = 2 ; 1 = 4 ; 2 = 8 ; 3 = 16 ; + uint8_t afe_reset = 1; //* 0 = 32clk ; 1 = 64clk ; 2 = 128clk ; 3 = 256clk(d) ; + uint8_t en2rst_delay =3; // pen 2 rst delay 0 = 128,256, 512, 1024 + uint8_t init_wait_delay = 2; /* 0 = 800 ; 1 = 1600; 2 = 3200 ; 3 = 6400(d) */ + + + uint8_t ps1_interval_i2c =0; // ps2/ps3 + + uint8_t thres_int =1; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + + uint8_t ldrsel_ps0 =0; //ps0 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + uint8_t ldrsel_ps1 =0; //ps1 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + uint8_t ldrsel_ps2 =2; //ps1 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + uint8_t ldrsel_ps3 =0; //ps1 LDR SELECT 01:ldr0-GLED 02:ldr1-IR 04:ldr2-RLED + + /***********cap *********/ + uint8_t intcapsel_ps3 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps2 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps1 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps0 =2; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + + uint8_t ps0_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=32; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=16; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=16; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + uint8_t force_adc_clk_sel=0; + uint8_t force_adc_clk_cfg =0; + uint8_t force_PEN =0; //phase enable + uint8_t force_PEN_cfg =0; + uint8_t force_LED_EN =0; + uint8_t force_LED_EN_cfg =0; + uint8_t force_CKAFEINT_sel =0; + uint8_t force_CKAFEINT_cfg =0; + + uint8_t PDBIASEN =0; + uint8_t PDILOADEN =0; + + /***********************sar*****************************/ + uint8_t odr_short =1; + + uint8_t ch0_cfg =3; + uint8_t ch1_cfg =12; + uint8_t ch2_cfg =48; + + uint8_t ch0_range=1; // 000=1.25pF 001=2.5pF 010=3.75pF 011=5pF 100=0.625pF + uint8_t ch1_range=1; // 000=1.25pF 001=2.5pF 010=3.75pF 011=5pF 100=0.625pF + uint8_t ch2_range=1; // 000=1.25pF 001=2.5pF 010=3.75pF 011=5pF 100=0.625pF + + uint8_t ch0_avg_num=1; // 000 =1; 001 = 2;.default;010= 4;011= 8; 100= 16;101= 32; + uint8_t ch1_avg_num=1; + uint8_t ch2_avg_num=1; + + uint8_t ch0_wram_num=0; + + uint8_t ch0_osr_num=2; // 000= 16;001=32;010=64;011=128;100=256; + uint8_t ch1_osr_num=2; // 000= 16;001=32;010=64;011=128;100=256; + uint8_t ch2_osr_num=2; // 000= 16;001=32;010=64;011=128;100=256; + + uint8_t c0_offset_dac=0; + uint8_t c1_offset_dac=0; + uint8_t c2_offset_dac=0; + + uint8_t sar_sample_num=8; + + uint8_t sar_integ_num=8; + + uint8_t ch_num_sel=0; + + hx3918_write_reg(0X16, (ps3_enable<<3| ps2_enable<<2|ps1_enable<<1|ps0_enable)); //default 0x00 + hx3918_write_reg(0X17, (ps3_osr<<6| ps2_osr<<4|ps1_osr<<2|ps0_osr)); //default 0x00 + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<11:8> default 0x03 + hx3918_write_reg(0X1a, (ps1_interval_i2c)); //default 0x00 + hx3918_write_reg(0X1b, led_en_begin<<6|afe_reset<<4|en2rst_delay <<2|init_wait_delay); // led_en_num*8 //default 0x00 + //hx3918_write_reg(0X1b, 0x03); + hx3918_write_reg(0X1c, ps0_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1d, ps1_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1e, ps2_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1f, ps3_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel) ); //default 0x00 + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); //default 0x00 + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|ps0_ofidac_en_i2c<<3|ps1_ofidac_en_i2c<<2|ps2_ofidac_en_i2c<<1|ps3_ofidac_en_i2c)); // led_en offset_en + hx3918_write_reg(0X24, (intcapsel_ps0<<4|intcapsel_ps1)); //default 0x00 + hx3918_write_reg(0X25, (intcapsel_ps2<<4|intcapsel_ps3)); //default 0x00 + hx3918_write_reg(0X26, leddrive_ps0); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X27, leddrive_ps1); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X28, leddrive_ps2); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X29, leddrive_ps3); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X2a, (ldrsel_ps0<<4|ldrsel_ps1)); //default 0x00 + hx3918_write_reg(0X2b, (ldrsel_ps2<<4|ldrsel_ps3)); //default 0x00 + hx3918_write_reg(0X2c, dccancel_ps0 ); //default 0x00 + hx3918_write_reg(0X2d, dccancel_ps1 ); //default 0x00 + hx3918_write_reg(0X2e, dccancel_ps2 ); //default 0x00 + hx3918_write_reg(0X2f, dccancel_ps3); //default 0x00 + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); + hx3918_write_reg(0X4e, (force_adc_clk_sel<<7|force_adc_clk_cfg<<6|force_PEN<<5|force_PEN_cfg<<4|force_LED_EN<<3| + force_LED_EN_cfg<<2|force_CKAFEINT_sel<<1|force_CKAFEINT_cfg)); //default 0x00 +// hx3918_write_reg(0X52, (adc_self<<2|second_time_en<<1)); //default 0x00 +// hx3918_write_reg(0Xc0, 0x18); +// hx3918_write_reg(0Xc2, 0x0a); +//// hx3918_write_reg(0Xc3, (PDBIASEN<<5|PDILOADEN<<4)); //default 0x27 +// hx3918_write_reg(0Xc3, 0X27); + hx3918_write_reg(0X54, odr_short); + hx3918_write_reg(0X55,ch0_cfg); // ch0 single input cs0=p + hx3918_write_reg(0X56,ch0_cfg>>8); // + hx3918_write_reg(0X57,ch1_cfg); // ch1 dif input cs0=p cs1=n + hx3918_write_reg(0X58,ch1_cfg>>8); // + hx3918_write_reg(0X59,ch2_cfg); // ch2 single input cs2=p + hx3918_write_reg(0X5a,ch2_cfg>>8); // + hx3918_write_reg(0X5b,(ch1_range<<4|ch0_range)); + hx3918_write_reg(0X5c, ch2_range); + hx3918_write_reg(0X5d, (ch0_avg_num<<5|ch0_osr_num<<2|ch0_wram_num)); + hx3918_write_reg(0X5e, (ch2_osr_num<<4|ch0_osr_num)); + hx3918_write_reg(0X5f, (ch2_avg_num<<4|ch1_avg_num)); + hx3918_write_reg(0X60, c0_offset_dac); + hx3918_write_reg(0X61, c0_offset_dac>>8); + hx3918_write_reg(0X62, c1_offset_dac); + hx3918_write_reg(0X63, c1_offset_dac>>8); + hx3918_write_reg(0X64, c2_offset_dac); + hx3918_write_reg(0X65, c2_offset_dac>>8); + hx3918_write_reg(0X66, sar_sample_num); + hx3918_write_reg(0X67, sar_sample_num>>8); + hx3918_write_reg(0X68, sar_integ_num); + hx3918_write_reg(0X69, sar_integ_num>>8); + hx3918_write_reg(0X6a, ch_num_sel); + + hx3918_write_reg(0X6d, 0x00); + hx3918_write_reg(0XF0, 0x22); + hx3918_write_reg(0xF1, 0x28); + hx3918_write_reg(0xF2, 0x04); + hx3918_write_reg(0xF3, 0x70); + hx3918_write_reg(0xF4, 0xb2); + hx3918_write_reg(0xF5, 0x89); + hx3918_write_reg(0xF6, 0x2b); + hx3918_write_reg(0xF7, 0x81); + hx3918_write_reg(0xF8, 0x27); + hx3918_write_reg(0xF9, 0x00); + hx3918_write_reg(0xFA, 0x88); + hx3918_write_reg(0xFB, 0x40); + hx3918_write_reg(0Xf6, 0X2b); + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); + calReg.led_cur = 0; + #if DEBUG_PPG_ONLY + hx3918_prox_init(); + #endif +// hx3918_ppg_timer_cfg(false); +// hx3918_agc_timer_cfg(false); +// hx3918_gpioint_cfg(true); + AGC_LOG(" chip go to low power mode \r\n" ); +} + +void hx3918_hrv_updata_reg(void) +{ + if (calReg.flag & CAL_FLG_LED_DR) + { + hx3918_write_reg(0X26, calReg.led_cur); // 3918 + } + + if (calReg.flag & CAL_FLG_LED_DAC) + { + hx3918_write_reg(0X2c, (uint8_t)calReg.led_idac); //3918 +// hx3918_write_reg(0X19, (uint8_t)(calReg.led_idac>>8)); + } + + if (calReg.flag & CAL_FLG_AMB_DAC) + { + hx3918_write_reg(0X2d, (uint8_t)calReg.amb_idac); // 3918 +// hx3918_write_reg(0X1b, (uint8_t)(calReg.amb_idac>>8)); + } + + if (calReg.flag & CAL_FLG_RF) + { + hx3918_write_reg(0X1c, calReg.ontime); //3918 p0 + hx3918_write_reg(0X1d, calReg.ontime); //3918 p1 + hx3918_write_reg(0X1e, calReg.ontime); //3918 p2 + hx3918_write_reg(0X1f, calReg.ontime); //3918 p3 + } +} + +void hx3918_hrv_set_mode(uint8_t mode_cmd) +{ + switch (mode_cmd) + { + case PPG_INIT: + hx3918_hrv_ppg_init(); +#if defined(TIMMER_MODE) + hx3918_ppg_timer_cfg(true); +#if defined(GSEN_40MS_TIMMER) + hx3918_agc_timer_cfg(true); +#endif +#else + hx3918_gpioint_cfg(true); +#endif + s_ppg_state = 1; + + AGC_LOG("ppg init mode\r\n"); + break; + + case PPG_OFF: + hx3918_ppg_off(); + s_ppg_state = 0; + AGC_LOG("ppg off mode\r\n"); + break; + + case PPG_LED_OFF: + hx3918_hrv_low_power(); + s_ppg_state = 0; + AGC_LOG("ppg led off mode\r\n"); + break; + + case CAL_INIT: + Init_hrv_PPG_Calibration_Routine(&calReg, 64); + hx3918_hrv_cal_init(); + hx3918_hrv_updata_reg(); +#if defined(TIMMER_MODE) +#if defined(GSEN_40MS_TIMMER) +#else + hx3918_agc_timer_cfg(true); +#endif +#endif + //AGC_LOG("init %x,%x \r\n", hx3918_read_reg(0x23),hx3918_read_reg(0x24)); + s_cal_state = 1; + AGC_LOG("cal init mode\r\n"); + break; + + case RECAL_INIT: + Restart_hrv_PPG_Calibration_Routine(&calReg); + hx3918_hrv_cal_init(); + hx3918_hrv_updata_reg(); +#if defined(TIMMER_MODE) +#if defined(GSEN_40MS_TIMMER) +#else + hx3918_agc_timer_cfg(true); +#endif +#endif + s_cal_state = 1; + AGC_LOG("Recal init mode\r\n"); + break; + + case CAL_OFF: +#if defined(TIMMER_MODE) +#if defined(GSEN_40MS_TIMMER) +#else + hx3918_agc_timer_cfg(false); +#endif +#endif + hx3918_hrv_cal_off(); + s_cal_state = 0; + AGC_LOG("cal off mode\r\n"); + break; + + default: + break; + } +} + +SENSOR_ERROR_T hx3918_hrv_enable(void) +{ + if (!hx3918_chip_check()) + { + AGC_LOG("hx3918 check id failed!\r\n"); + return SENSOR_OP_FAILED; + } + + AGC_LOG("hx3918 check id success!\r\n"); + + if (s_ppg_state) + { + AGC_LOG("ppg already on!\r\n"); + return SENSOR_OP_FAILED; + } + if(!tyhx_hrv_alg_open()) + { + AGC_LOG("hrv alg open fail,or dynamic ram not enough!\r\n"); + } + + hrv_wear_status = MSG_HRV_INIT; + hrv_wear_status_pre = MSG_HRV_INIT; + + hx3918_hrv_set_mode(PPG_INIT); + + AGC_LOG("hx3918 enable!\r\n"); + + return SENSOR_OK; +} + + +void hx3918_hrv_disable(void) +{ + hx3918_ppg_timer_cfg(false); + hx3918_agc_timer_cfg(false); + + hx3918_hrv_set_mode(PPG_OFF); + s_ppg_state = 0; + s_cal_state = 0; + tyhx_hrv_alg_close(); + + AGC_LOG("hx3918 disable!\r\n"); +} + +void hx3918_hrv_data_reset(void) +{ + s_ppg_state = 0; + s_cal_state = 0; + tyhx_hrv_alg_close(); +} + +hx3918_hrv_wear_msg_code_t hx3918_hrv_get_wear_status(void) +{ + return hrv_wear_status; +} + +hx3918_hrv_wear_msg_code_t hx3918_hrv_get_wear_status_pre(void) +{ + return hrv_wear_status_pre; +} + +HRV_CAL_SET_T get_hrv_agc_status(void) +{ + HRV_CAL_SET_T cal; + cal.flag = calReg.flag; + cal.int_cnt = calReg.int_cnt; + cal.led_cur = calReg.led_cur; + cal.led_idac = calReg.led_idac; + cal.amb_idac = calReg.amb_idac; + cal.ontime = calReg.ontime; + cal.led_step = calReg.led_step; + cal.state = calReg.state; + return cal; +} + +uint8_t hx3918_hrv_read(hrv_sensor_data_t * s_dat) +{ + int32_t PPG_src_data; + int32_t Ir_src_data; + bool recal = false; +// uint8_t size = 0; +// uint8_t size_byte = 0; + int32_t *PPG_buf = &(s_dat->ppg_data[0]); + int32_t *ir_buf = &(s_dat->ir_data[0]); + int32_t *s_buf = &(s_dat->s_buf[0]); + s_dat->agc_green = calReg.led_cur; + int32_t ps_data[4]= {0}; + int32_t ps_green_data = 0; + uint8_t data_count = 0; + if (!s_ppg_state || s_cal_state) + { + return NULL; + } + + read_data_packet(ps_data); + Ir_src_data = ps_data[2]-ps_data[3]; + ps_green_data = ps_data[0]; + hx3918_hrv_wear_mode_check(Ir_src_data); + //DEBUG_PRINTF("%d %d %d %d\r\n" ,ps_data[0],ps_data[1],ps_data[2],ps_data[3]); + + data_count = hx3918_read_fifo_data(s_buf,1,1); + //DEBUG_PRINTF("ppg data size: %d %d\r\n", data_count,hrs_phase_num); + s_dat->count = data_count; + for (uint8_t i=0; i350000) + { + recal = true; + + if(hrv_wear_status==MSG_HRV_NO_WEAR) + { + recal = false; + } + } + if (recal) + { + cal_delay--; + + if (cal_delay <= 0) + { + cal_delay = CAL_DELAY_COUNT; + hx3918_hrv_set_mode(RECAL_INIT); + } + } + else + { + cal_delay = CAL_DELAY_COUNT; + } + return 1; +} + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_hrv_agc.h b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrv_agc.h new file mode 100644 index 00000000..fc2f8827 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_hrv_agc.h @@ -0,0 +1,80 @@ +#ifndef _HX3918_HRV_AGC_H_ +#define _HX3918_HRV_AGC_H_ +#include +#include +#include "hx3918.h" + +#define CAL_DELAY_COUNT (3) + +#define CAL_FLG_LED_DR 0x01 +#define CAL_FLG_LED_DAC 0x02 +#define CAL_FLG_AMB_DAC 0x04 +#define CAL_FLG_RF 0x08 + +#define HRV_CAL_INIT_LED 16 +#define NO_TOUCH_CHECK_NUM 2 + + +typedef enum { + hrvCalStart, + hrvLedCur, + hrvCalLed, + hrvCalLed2, + hrvCalFinish, +}HRV_STATE_T; + +typedef struct { + uint8_t count; + int32_t ppg_data[32]; + int32_t ir_data[32]; + int32_t s_buf[32]; + uint32_t als; + uint32_t agc_green; +}hrv_sensor_data_t; + +typedef enum { + MSG_HRV_NO_WEAR, + MSG_HRV_WEAR, + MSG_HRV_INIT +} hx3918_hrv_wear_msg_code_t; + +typedef struct { + uint8_t flag; + bool work; + uint8_t int_cnt; + uint8_t cur255_cnt; + uint8_t led_cur; + uint8_t led_idac; + uint8_t amb_idac; + uint8_t ontime; + uint16_t led_step; + uint8_t state; + uint8_t led_max_cur; +} HRV_CAL_SET_T; + +void Init_hrv_PPG_Calibration_Routine(HRV_CAL_SET_T *calR,uint8_t led); +void Restart_hrv_PPG_Calibration_Routine(HRV_CAL_SET_T *calR); +void PPG_hrv_Calibration_Routine(HRV_CAL_SET_T *calR, int32_t led, int32_t amb); +HRV_CAL_SET_T PPG_hrv_agc(void); + +void hx3918_hrv_cal_init(void); +void hx3918_hrv_cal_off(void); +uint8_t hx3918_read_fifo_size(void); +void read_hrv_data_packet(int32_t *buf); +void read_hrv_ir_packet(int32_t *buf); + +void hx3918_hrv_low_power(void); +void hx3918_hrv_normal_power(void); +void hx3918_hrv_updata_reg(void); +void hx3918_hrv_set_mode(uint8_t mode_cmd); +SENSOR_ERROR_T hx3918_hrv_enable(void); +void hx3918_hrv_disable(void); +hx3918_hrv_wear_msg_code_t hx3918_hrv_get_wear_status(void); +uint8_t hx3918_hrv_read(hrv_sensor_data_t * s_dat); +bool hx3918_hrv_init(void); + +hx3918_hrv_wear_msg_code_t hx3918_hrv_wear_mode_check(int32_t infrared_data); +HRV_CAL_SET_T get_hrv_agc_status(void); +void hx3918_hrv_data_reset(void); + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_prox.c b/2.sdk/Helios_SDK/components/HX3918/hx3918_prox.c new file mode 100644 index 00000000..7fc00e6e --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_prox.c @@ -0,0 +1,829 @@ +/***************************************************************************** + * @file hx90xx.c + * @author + * @date + * @Emial + * @brief HX3918 module +******************************************************************************/ + +#include +#include +#include +#include + +#include "hx3918_prox.h" +#include "hx3918.h" + +#ifdef TYHX_DEMO +#include "nordic_common.h" +#include "nrf.h" +#include "app_error.h" +#include "ble_hci.h" +#include "ble_gap.h" +#include "ble_err.h" +#include "nrf_gpio.h" +#include "nrf_drv_gpiote.h" +#include "nrf_delay.h" +#include "segger_rtt.h" +#include "twi_master.h" +#include "app_timer.h" +#endif + +/* ²úÆ·ÐèÒª¸Ä¶¯µÄµØ·½ +#define HX3918_IR_AIR 7000 //HX3918 ¶Ô¿Õ²âÊÔÅå´÷IRµÄÖµ·¶Î§,СÓÚÕâ¸öÖµ´ú±í¶Ô¿Õ +#define NORMALWEARDIFF 6000 //HX3918 ¿¿½ü¸ÐÓ¦Åå´÷ʱ¸ÐÓ¦µÄ½á¹û, Ò»°ãÊÇ¿íËÉÅå´÷½á¹û +hx_set_wear_detect_mode(NORMAL_WEAR_MODE) // ÔÚÊÖ±íÆ½³£²âÊÔÅå´÷Óà +hx_set_wear_detect_mode(SLEEP_WEAR_MODE) //ÔÚÊÖ±í¼ì²âµ½½øÈë˯ÃߺóÐèÒªµ÷Óà +*/ + +/* --------------------------------³ÌÐò˵Ã÷------------------------------------------------------------ +1. ±¾³ÌÐòHX3918×÷ΪÅå´÷¸ÐÓ¦²¿·ÖµÄ¿ØÖƳÌÐò +2. HX3918 ÄÚÖÃ3ͨµÀCAP´«¸ÐÆ÷; +3. ¶ÁÈ¡µÄRAW DATAÊÇ×îԭʼµÄÄ£ÄâÁ¿×ª»»¹ýÀ´µÄÊý×ÖÁ¿, + LPÊǾ­¹ýÒ»´ÎÂ˲¨À´µÄ(Â˳ý¸ßƵ»·¾³ÔëÉù), + BLÊÇRAW¾­¹ýÁ½´ÎÂ˲¨À´µÄ£¨Â˳ýµÍƵÔëÉù°üº¬Î¶ȡ¢Êª¶È¡¢Ñ¹Á¦´øÀ´µÄÆ¯ÒÆ£©£¬ +4. ÓÐÁ½ÖÖ¹¤×÷ģʽ¹©Êµ¼ÊʹÓÃÑ¡Ôñ, + Ïà¶Ôֵģʽ, ¿ª»úºó,оƬ×ÔУ׼¸ÐÓ¦Öµµ½0¸½½ü, ¿¿½üºÍÔ¶Àë,LP-BL»á²úÉúÒ»¸ö´óµÄ²îÖµ, Ïà¶Ôֵģʽ; + ¾ø¶Ôֵģʽ,ÐèÒªÓû§ÔÚ¹¤³§µÄʱºò, ²ú²â³ÌÐòÒª¼Ç¼ÊÖ±í¶Ô¿ÕµÄÒ»¸öBASEÖµ(LPÖµ), ºóÃæÓÃLP-BASEÖµÀ´×öÅжÏ; + Ïà¶ÔֵģʽÁ÷³ÌÉÔ΢¼òµ¥, µ«ÊÇÒòΪÉϵç»á×ÔÎÒУ׼, ËùÒÔÅå´÷×Å¿ª»úÎÞ·¨¼ì²âÅå´÷Çé¿ö. ¾ø¶ÔֵģʽÎÞ´ËÎÊÌâ. +5. hx3918_chip_id ÊÇоƬIDµÄ±äÁ¿, ÕýÈ·µÄIDÖµÊÇ0x27, ÒòΪHX3918 ÊÇPPGºÍCAP, ÓÃÕâ¸ö±äÁ¿ÅжÏÊDz»ÊÇоƬÒѾ­Éϵç, + ÇÒPPG²¿·ÖÒѾ­³õʼ»¯, Èç¹ûµÈÓÚ0X27, Õâ±ß¿ØÖƲ»ÐèÒªÉϵçϵç, Èç¹ûÅöµ½²ú²âģʽ,CAP´«¸ÐÆ÷ÐèÒªµ¥¶À¹¤×÷, + PPG²¿·ÖûÓÐͬʱ±»³õʼ»¯, ËùÒÔ¶Áµ½µÄhx3918_chip_id = 0, ÄÇÕâÀï¾ÍÊÇ»á¼ÓÉÏоƬµÄÉÏÏÂµç¿ØÖÆ +6. ×¢ÒâCSxºÍCHx, CSxÊÇÖ¸ÍⲿPAD½Óµ½Ð¾Æ¬µÄ¶ÔÓ¦CS¹Ü½Å. CHÊÇÖ¸ÄÚ²¿²É¼¯Êý¾ÝµÄ3¸öͨµÀ, CSx¿ÉÅäÖÃÔÚ²»Í¬µÄCHÉÏ; +-------------------------------- -------------------------------- -----------------------------------*/ +#define ANALOG_DIFF //Ä£Äâ²î·Ö, Ò»°ãÓÃÕâÖÖģʽ +//#define DIGITAL_DIFF //Êý×Ö²î·Ö + +#ifdef ANALOG_DIFF +//#define INDEPENDDENT_CH // ¶ÀÁ¢Í¨µÀºê¶¨Òå, ¾ÍÊÇÒ»¸öPAD¶ÔÓ¦Ò»¸öCH +#define DIFFERENCE_CH //²î·ÖͨµÀ¶¨Òå, Á½¸öPAD×÷Ϊһ¸öCHµÄ²î·ÖÕý¶ËºÍ¸º¶Ë, °¤×Ÿ첲µÄÅå´÷ΪÕý¶Ë +#endif + +extern uint8_t hx3918_chip_id; // оƬID, Ó¦¸ÃµÈÓÚ0x27 +int16_t nv_wear_offset[2] = {0}; // оƬ²ú²âУ׼µÄÁ½¸öͨµÀµÄOFFSETÖµ, Öµ¼Ç¼ÔÚfashÀïÃæ +int16_t nv_base_data[2] = {0}; // оƬ²ú²âУ׼µÄÁ½¸öͨµÀµÄ¶Ô¿ÕLPÖµ, Öµ¼Ç¼ÔÚflashÀïÃæ +uint32_t ai_tune_cnt[2] = {0}; //ai_tune_cnt[0] ¼Ç¼nv_base ×ÔѧϰÏòϸüеĴÎÊý, +//extern uint16_t sendcnt; // À¶ÑÀÊý¾Ý²É¼¯¼ÆÊý, Õâ¸öÊDzÉÊýÓõÄ, ¿ÉÒÔ²»Óà +int16_t gdiff[2] = {0}; // gdiff[0], gdiff[1] ·Ö±ð±£´æCH0, CH1µÄ½á¹û +int16_t lp[2] = {0}; +int16_t bl[2] = {0}; + +//flash ¶Áд±äÁ¿, ÒÀ´Î¼Ç¼nv_wear_offset[0],nv_wear_offset[1],nv_base_data[0],nv_base_data[1],ai_tune_cnt[0],ai_tune_cnt[1] +uint32_t fds_read[6] = {0}; //¶Á³öflash ´æ´¢Êý¾ÝµÄ±äÁ¿; +uint32_t fds_write[6] = {0}; //дflashµÄ±äÁ¿, flashÀïÃæ·Ö±ð¼Ç¼ + + + +//prox_work_mode = RELATIVE_MODE, Ïà¶Ôֵģʽ, ²âÁ¿½á¹û = LP-BL +//prox_work_mode = ABSOLUTE_MODE, ¾ø¶Ôֵģʽ, ²âÁ¿½á¹û = LP - NV_BASE; +uint8_t prox_work_mode = RELATIVE_MODE; +uint8_t is_factory_mode = 0; // ²ú²âģʽ, ÓÃÀ´¶ÁÈ¡Õû»ú¶Ô¿ÕʱOFFSETºÍ¶Ô¿ÕµÄnv_baseÖµ; +uint8_t wear_detect_mode = NORMAL_WEAR_MODE; + + + + +/** + * set touch detect mode + * @param current_mode ÉèÖõŤ×÷ģʽ + */ +void hx_set_wear_detect_mode(uint8_t current_mode) +{ + if(current_mode>SLEEP_WEAR_MODE) + { + TYHX_LOG("wear mode set fail , exceed the limit\r\n"); + return; + } + wear_detect_mode = current_mode; + +} + + +/** + * ¶ÁÒ»×é16bit Êý¾ÝÖµ + * @param addh ¼Ä´æÆ÷µØÖ· + * @param addl ¼Ä´æÆ÷µØÖ· +*/ +int16_t hx3918_read_two_reg_low_triple(uint8_t addh, uint8_t addl) +{ + uint8_t val_l = 0; + uint8_t val_h = 0; + uint8_t val_m= 0; + int32_t data = 0; + val_l = hx3918_read_reg(addl-1); + val_m = hx3918_read_reg(addl); + val_h = hx3918_read_reg(addh); + data =((val_l>>4) | (val_m<<4)|((val_h & 0x0f) << 12)) ; + if (data > 32767) + return (int16_t)(data - 65536); + else + return (int16_t)data; +} + +/** + * оƬÉϵç, ¶ÔÓ¦µÄµçÔ´¿ØÖƹܽŸúʵ¼Êµç·Ïà¹Ø,¸ù¾Ýʵ¼Êµç·×öºÃ¿ØÖÆ +* @param NULL +*/ +void hx3918_power_up(void) +{ +#ifdef TYHX_DEMO + nrf_gpio_pin_set(4); + nrf_delay_ms(100); +#endif +} + +/** + * оƬϵç, ¶ÔÓ¦µÄµçÔ´¿ØÖƹܽŸúʵ¼Êµç·Ïà¹Ø,¸ù¾Ýʵ¼Êµç·×öºÃ¿ØÖÆ +* @param NULL +*/ +void hx3918_power_down(void) +{ +#ifdef TYHX_DEMO + nrf_gpio_pin_clear(4); + nrf_delay_ms(100); +#endif +} + +/** + * Ð¾Æ¬ÖØÐÂÉϵç +* @param NULL +*/ +void hx3918_power_restart(void) +{ + hx3918_power_down(); + hx3918_power_up(); +} + +/** + * HX3918 ¶ÁоƬID +* @param NULL +*/ +uint8_t hx3918_check_device_id(void) +{ + return hx3918_read_reg(0x00); +} + + +/** + * HX3918 дOFFSETµÄÖµ +* @param offset_value дOFFSETµÄÖµ +* @param chx_offset ͨµÀ0/1/2 Ñ¡Ôñ +*/ +void hx3918_write_offset(uint16_t offset_value, uint8_t chx_offset) +{ + uint8_t write_val = 0; + uint8_t byte_high =0, byte_low = 0; + + byte_high = 0x61 + chx_offset*2; + byte_low = 0x60 + chx_offset*2; + write_val = ((uint8_t)(offset_value >> 8))&0xF; + hx3918_write_reg(byte_high,write_val); + write_val = (uint8_t)offset_value; + hx3918_write_reg(byte_low,write_val); + +} + +/** + * HX3918дOFFSETµÄÖµ, ÓÃÔÚ²ú²â³ÌÐòÀïÃæµÄOFFSET¶ÁÈ¡ +* @param offset_value дOFFSETµÄÖµ +* @param chx_offset ͨµÀ0/1/2 Ñ¡Ôñ +*/ +static int16_t readlp_after_writeoffset(int16_t offset,uint8_t chx_offset) +{ + int16_t lpout; + hx3918_write_offset(offset,chx_offset); + hx3918_delay(32); + lpout = hx3918_read_diff_lp(chx_offset); + hx3918_delay(33); + lpout = hx3918_read_diff_lp(chx_offset); + return lpout; +} + +/** + * HX3918 ¶ÁOFFSETµÄÖµ +* @param chx_offset ͨµÀ0/1/2 Ñ¡Ôñ +*/ +uint16_t hx3918_read_offset(uint8_t chx_offset) +{ + uint16_t writeoffset = 0; + int16_t lp=0; + uint16_t offset = 0; + uint16_t recordoffset = 0; + uint16_t mid; + static uint8_t cnt = 0; + hx3918_write_reg(0x8F,0x07); //offset_dac_en_i2c + recordoffset = 1020; + cnt = 0; + while(writeoffset<=recordoffset) + { + mid =(writeoffset+recordoffset)/2; + lp = readlp_after_writeoffset(mid,chx_offset); + + if(hx_abs(lp)>1300) + { + if(lp>1300) + { + writeoffset = mid+1; + } + else + { + recordoffset = mid-1; + } + cnt ++; + } + else + { + offset = mid; + TYHX_LOG(" final ch=%d,offset =%d lp=%d\r\n",chx_offset,offset,lp); + break; + } + //TYHX_LOG(" ch=%d,lp =%d,writeoffset=%d,recordoffset=%d\r\n",chx_offset,lp,writeoffset,recordoffset); + } + return offset; +} + + +/** + * HX3918¶ÁÈ¡raw data »òÕßbaseline data //¶ÁÈ¡µÄÊÇraw»¹ÊÇbl ͨ¹ý0x38 ¼Ä´æÆ÷ÉèÖà +* @param chx_raw ͨµÀ0/1/2 Ñ¡Ôñ +*/ +int16_t hx3918_read_raw_bl(uint8_t chx_raw) +{ + int16_t raw = 0; + uint8_t byte_high =0, byte_low = 0; + + byte_high = 0xBE + chx_raw*3; + byte_low = 0xBD + chx_raw*3; + + raw = hx3918_read_two_reg_low_triple(byte_high,byte_low); + return raw; +} + + +/** + * HX3918 ¶ÁÈ¡LP data »òÕßdiff data //¶ÁÈ¡µÄÊÇlp»¹ÊÇdiffͨ¹ý0x38 ¼Ä´æÆ÷ÉèÖà +* @param chx_raw ͨµÀ0/1/2 Ñ¡Ôñ +*/ +int16_t hx3918_read_diff_lp(uint8_t chx_diff) +{ + int16_t diff = 0; + uint8_t byte_high =0, byte_low = 0; + + byte_high = 0xC7+ chx_diff*3; + byte_low = 0xC6 + chx_diff*3; + + diff = hx3918_read_two_reg_low_triple(byte_high,byte_low); + return diff; +} + +/** + * HX3918 ÉèÖýӽüãÐÖµºÍÔ¶ÀëãÐÖµ +* @param chx ͨµÀ0/1/2 Ñ¡Ôñ +* @param high_thres ½Ó½üãÐÖµ +* @param low_thres Ô¶ÀëãÐÖµ +* @param base_data +*/ +void hx3918_config_thres(uint8_t chx,int16_t high_thres, int16_t low_thres, int16_t base_data) +{ + + if ((low_thres + base_data) <= 0) + { + return; + } + int16_t thres = 0; + thres = (high_thres + base_data)/32; + hx3918_write_reg(0x9D+1*chx, (thres&0x00FF)); + hx3918_write_reg(0xA0+1*chx, (thres&0xFF00)>>8); + thres = (low_thres + base_data)/32; + hx3918_write_reg(0xA5+1*chx, (thres&0x00FF)); + hx3918_write_reg(0xA8+1*chx, (thres&0xFF00)>>8); +} + + +/** + * HX3918 init +* @param NULL +*/ +bool hx3918_prox_reg_init(void) +{ + bool write_ok = true; + +#ifdef ANALOG_DIFF + if (hx3918_chip_id != PROX_CHIPID) + { + TYHX_LOG("100hz\r\n"); + write_ok &= hx3918_write_reg(0x18,0x40); //prf =100HZ + write_ok &= hx3918_write_reg(0x19,0x01); // + } + write_ok &= hx3918_write_reg(0x6a,0x00); //CH0~N disable + write_ok &= hx3918_write_reg(0x51,0x00); //default?? + write_ok &= hx3918_write_reg(0x52,0x02); //default?? + write_ok &= hx3918_write_reg(0x53,0x00); //default?? + + +#ifdef INDEPENDDENT_CH //ÓÉʵ¼ÊÓ²¼þ¾ö¶¨, Òª¿´µç·ͼ + write_ok &= hx3918_write_reg(0x55,0x0C); //CS1->CH0 + write_ok &= hx3918_write_reg(0x57,0x30); //CS2->CH1 +#elif defined(DIFFERENCE_CH) //ÓÉʵ¼ÊÓ²¼þ¾ö¶¨, Òª¿´µç·ͼ + write_ok &= hx3918_write_reg(0x55,0x2c); //CS1->CH0[P],CS2->CH0[N] + write_ok &= hx3918_write_reg(0x57,0x30); //CS2->CH1 +#endif + write_ok &= hx3918_write_reg(0x56,0x00); //default + write_ok &= hx3918_write_reg(0x58,0x00); //default + write_ok &= hx3918_write_reg(0x59,0x00); //CH2 + write_ok &= hx3918_write_reg(0x5A,0x00); //CH2 + +#ifdef FULL25PF + write_ok &= hx3918_write_reg(0x5B,0x11); //full range = 2.5pf 0x11=2.5pf 0x22 = 3.75pf, 0x33 = 5pf +#elif defined(FULL375PF) + write_ok &= hx3918_write_reg(0x5B,0x22); //full range = 2.5pf 0x11=2.5pf 0x22 = 3.75pf, 0x33 = 5pf +#elif defined(FULL50PF) + write_ok &= hx3918_write_reg(0x5B,0x33); //full range = 2.5pf 0x11=2.5pf 0x22 = 3.75pf, 0x33 = 5pf +#endif + write_ok &= hx3918_write_reg(0x5D,0x25); //OSR AVG + write_ok &= hx3918_write_reg(0x5E,0x11); //OSR AVG + write_ok &= hx3918_write_reg(0x5F,0x01); //OSR AVG + + write_ok &= hx3918_write_reg(0x66,0x08); //²ÉÑùʱ¼ä + write_ok &= hx3918_write_reg(0x67,0x00); // + write_ok &= hx3918_write_reg(0x68,0x08); //»ý·Öʱ¼ä + write_ok &= hx3918_write_reg(0x69,0x00); // + + write_ok &= hx3918_write_reg(0x6E,0x11); //LP alpha + write_ok &= hx3918_write_reg(0x77,0x70); //output Ñ¡ÔñLPºÍBL + + write_ok &= hx3918_write_reg(0x7A,0x07); //²¹³¥µçÈÝУ׼´¥·¢ÉèÖÃ=16384 + +#ifdef INDEPENDDENT_CH + + prox_work_mode = RELATIVE_MODE; + +#endif + if (prox_work_mode == RELATIVE_MODE) + { + TYHX_LOG("RELATIVE_MODE\r\n"); + write_ok &= hx3918_write_reg(0x70,0xaa); + write_ok &= hx3918_write_reg(0x72,0x40); + write_ok &= hx3918_write_reg(0x73,0x04); + write_ok &= hx3918_write_reg(0x90,0x77); + write_ok &= hx3918_write_reg(0x8F,0x00); + write_ok &= hx3918_write_reg(0x95,0x00); + hx3918_config_thres(CH0,CH0_HIGH_DIFF, CH0_LOW_DIFF,0); // wear0 + hx3918_config_thres(CH1,CH1_HIGH_DIFF, CH1_LOW_DIFF,0); // wear0 + } + else + { + TYHX_LOG("ABSOLUTE_MODE\r\n"); + write_ok &= hx3918_write_reg(0x70,0x22); + write_ok &= hx3918_write_reg(0x72,0x20); + write_ok &= hx3918_write_reg(0x73,0x02); + write_ok &= hx3918_write_reg(0x90,0x07); + write_ok &= hx3918_write_reg(0x8F,0x07); + write_ok &= hx3918_write_reg(0x95,0x0a); + hx3918_write_offset(nv_wear_offset[0], CH0_OFFSET); + hx3918_write_offset(nv_wear_offset[1], CH1_OFFSET); + hx3918_config_thres(CH0,CH0_HIGH_DIFF, CH0_LOW_DIFF,nv_base_data[0]); // wear0 + hx3918_config_thres(CH1,CH1_HIGH_DIFF, CH1_LOW_DIFF,nv_base_data[1]); // wear0 + hx3918_write_reg(0x7A,0x17); + } + write_ok &= hx3918_write_reg(0x6a,0x03); //CH0, CH1 enable +#endif + hx3918_delay(50); + return write_ok; +} + + +//À¶ÑÀ·¢ËÍÊý¾Ý¸øAPP +//extern uint32_t sendDataToClient(int16_t sendnum1,int16_t sendnum2,int16_t sendnum3,int16_t sendnum4); + +/** + * hx3918 »ñÈ¡¿¿½ü¸ÐÓ¦µÄ½á¹û,½á¹û=0, prox¸ÐÓ¦µÄ½á¹ûΪ·ÇÅå´÷, =1 Åå´÷ +* @param NULL +*/ +uint8_t hx3918_report_prox_status(void) +{ + + + lp[0] = hx3918_read_diff_lp(LP0); + bl[0] = hx3918_read_raw_bl(BL0); + + lp[1] = hx3918_read_diff_lp(LP1); + bl[1] = hx3918_read_raw_bl(BL1); + + if (prox_work_mode == RELATIVE_MODE) + { + gdiff[0] = lp[0]- bl[0]; + gdiff[1] = lp[1]- bl[1]; + } + else + { + gdiff[0] = lp[0]- nv_base_data[0]; + gdiff[1] = lp[1]- nv_base_data[1]; + } + //sendDataToClient(lp[0],bl[0],lp[1],bl[1]); + if(prox_work_mode==ABSOLUTE_MODE) + { + TYHX_LOG("[absolute mode] %d %d %d %d %d %d\r\n",lp[0],bl[0],lp[1],bl[1],gdiff[0],nv_base_data[0]); + } + else + { + TYHX_LOG("[relatvie mode] %d %d %d %d %d %d\r\n",lp[0],bl[0],lp[1],bl[1],gdiff[0],nv_base_data[0]); + } + +#ifdef TEMP_COMPENSATION //ζȲ¹³¥ + //Õâ¸öÊÇÓ¦¶Ô¸ßλ·¾³ÒªÇó, ²»Óôò¿ª, Òª¿´¿´¾ßÌåÇé¿ö, + if(gdiff[1]>20000) + { + gdiff[0] = gdiff[0]*0.9; // Èç¹ûËæ×ŸßÎÂ,¸ÐÓ¦ÖµÉÏÉý,Ϊ0.9, ¸ÐӦֵϽµ¸ÄΪ1.1 + } +#endif + + if(gdiff[0]=SLEEPWEARTHRES)&&(wear_detect_mode == SLEEP_WEAR_MODE )) + { + return prox_detect; + } + return prox_no_detect; + } + else + { + return prox_detect; + } + +} + +/** + * hx3918 ´Óflash¶ÁÈ¡¶Ô¿ÕУ׼ºóµÄOFFSETºÍNV_BASE +* @param NULL +*/ +void hx3918_read_nv(void) +{ + + //´Óflash¶ÁÈ¡6¸öÖµ, ·Ö±ðÊÇÒÔǰ±£´æµÄÖµ; Õâ¸öº¯ÊýÓû§ÐèÒª×Ô¼ºÍê³É, flash´æ´¢µÄλÖò»Äܱ»Óû§²Ù×÷ɾµô + //flash_fds_data_get(6); + nv_wear_offset[0] = fds_read[0]; + nv_wear_offset[1] = fds_read[1]; + nv_base_data[0] = fds_read[2]; + nv_base_data[1] = fds_read[3]; + ai_tune_cnt[0] = fds_read[4]; + ai_tune_cnt[1] = fds_read[5]; + + TYHX_LOG("[hx3918_read_nv]\r\n"); + TYHX_LOG("OFF[0]: %d, OFF[1]:%d\r\n",nv_wear_offset[0],nv_wear_offset[1]); + TYHX_LOG("BASE[0]: %d, BASE[1]:%d\r\n",nv_base_data[0],nv_base_data[1]); + TYHX_LOG("ai_tune_cnt[0]: %d, ai_tune_cnt[1]:%d\r\n",ai_tune_cnt[0],ai_tune_cnt[1]); + + //Èç¹ûflash¼Ç¼µÄÖµ´óÓÚÉÏÏÞ, ÔòÈÿ¿½ü¸ÐÓ¦½øÈëÏà¶Ôֵģʽ + if(nv_wear_offset[0] > 1020) + { + nv_wear_offset[0] = 0xffff; + nv_base_data[0] = 0; + } + + if (nv_wear_offset[0] == 0 && nv_base_data[0] == 0) + { + nv_wear_offset[0] = 0xFFFF; + } + if (nv_wear_offset[0] == 0xFFFF || is_factory_mode == 1 ) + { + prox_work_mode = RELATIVE_MODE;//Ïà¶Ôֵģʽ + } + else + { + prox_work_mode = ABSOLUTE_MODE;//¾ø¶Ôֵģʽ + } +} + +/** + * hx3918 ¿¿½ü¸ÐÓ¦³õʼ»¯, ͨ¹ý¶Ôhx3918_chip_id ÅжÏ,À´ÅжϿ¿½ü¸ÐÓ¦ÊǶÀÁ¢¹¤×÷»¹ÊǸúPPGÒ»Æð¹¤×÷ +* @param NULL +*/ +bool hx3918_prox_init(void) +{ +#ifdef DEBUG_PPG_ONLY + return true; +#endif + int32_t i = 0; + bool ret = false; + //sendcnt = 0; + TYHX_LOG("[hx3918_prox_init]prox device_id is : 0x%.2x !\r\n", hx3918_chip_id); + if (hx3918_chip_id != PROX_CHIPID) + { + hx3918_power_restart(); + //i2c_hrs_init(); + //twi_master_init(); + hx3918_read_nv(); + hx3918_ppg_on(); + hx3918_prox_reg_init(); + for (i = 0; i<5; i++) + { + hx3918_chip_id = hx3918_check_device_id(); + TYHX_LOG(" power restart ,prox device_id is : 0x%.2x !\r\n", hx3918_chip_id); + if (hx3918_chip_id == PROX_CHIPID) + { + break; + } + } + + if(hx3918_chip_id == 0) + { + TYHX_LOG("no proximity device\r\n"); + //i2c_hrs_uninit(); + + hx3918_power_down(); + } + } + else + { + hx3918_chip_id = hx3918_check_device_id(); + TYHX_LOG("read prox device_id is : 0x%.2x !\r\n", hx3918_chip_id); + hx3918_read_nv(); + hx3918_prox_reg_init(); + } + hx3918_delay(50); + return ret; +} + + +/** + * hx3918 ¿¿½ü¸ÐÓ¦³õʼ»¯, ͨ¹ý¶Ôhx3918_chip_id ÅжÏ,À´ÅжϿ¿½ü¸ÐÓ¦ÊǶÀÁ¢¹¤×÷»¹ÊǸúPPGÒ»Æð¹¤×÷ +* @param NULL +*/ +bool hx3918_prox_factory_init(void) +{ +#ifdef DEBUG_PPG_ONLY + return true; +#endif + int32_t i = 0; + bool ret = false; + + hx3918_chip_id = 0; + + hx3918_power_restart(); + //i2c_hrs_init(); + prox_work_mode = RELATIVE_MODE; + hx3918_ppg_on(); + hx3918_prox_reg_init(); + for (i = 0; i<5; i++) + { + hx3918_chip_id = hx3918_check_device_id(); + TYHX_LOG(" power restart ,prox device_id is : 0x%.2x !\r\n", hx3918_chip_id); + if (hx3918_chip_id == PROX_CHIPID) + { + break; + } + } + if(hx3918_chip_id == 0) + { + TYHX_LOG("no proximity device\r\n"); + //i2c_hrs_uninit(); + hx3918_power_down(); + } + hx3918_delay(50); + return ret; +} + + +/** + * hx3918 ¿¿½ü¸ÐÓ¦²¿·Ö ¹¤³§²ú²â³ÌÐò, Ð轫ÊÖ±íÐü¿Õ»òÕßÔ¶ÀëÆäËû¿ÉÄÜÓ°ÏìµçÈÝÖµµÄÎïÌå. +* @param NULL +*/ +void hx3918_prox_factory_hanging_cali(void) +{ + uint16_t offset0 = 0; + uint16_t offset1 = 0; + int16_t lp[2] = {0}; + //uint8_t device_id = 0x00; + + is_factory_mode = 1; + hx3918_prox_factory_init(); + hx3918_delay(50);//delay 100ms + + offset0 = hx3918_read_offset(CH0_OFFSET); + offset1 = hx3918_read_offset(CH1_OFFSET); + + + lp[0] = hx3918_read_diff_lp(LP0); + lp[1] = hx3918_read_diff_lp(LP1); + + TYHX_LOG("offset0,offset1= %d %d\r\n", offset0,offset1); + +#ifdef INDEPENDDENT_CH + if((offset0-offset1)<100) + { + TYHX_LOG("ERR, resize cap of ch0\r\n"); + } + +#endif + nv_wear_offset[0] = offset0; + nv_wear_offset[1] = offset1; + nv_base_data[0] = lp[0]; + nv_base_data[1] = lp[1]; + TYHX_LOG("base0,base1= %d %d\r\n", lp[0],lp[1]); + +#ifdef DIFFERENCE_CH + //½«²î·ÖÊý¾Ý¶Áµ½µÄOFFSET, NV_BASE¼Ç¼µ½FLASHÀïÃæ, У׼´æ´¢°Ñ×ÔѧϰµÄ¼Ç¼ҲÐèÒªÇåµôÖØÐ¼ÆËã + ai_tune_cnt[0] = 0; + ai_tune_cnt[1] = 0; + hx3918_factory_cali_save_nv(); +#endif + hx3918_ppg_off(); + is_factory_mode = 0; + +} + +/** + * hx3918 ¿¿½ü¸ÐÓ¦²¿·Ö ¹¤³§²ú²â³ÌÐò, Ð轫ÊÖ±íÐü¿Õ»òÕßÔ¶ÀëÆäËû¿ÉÄÜÓ°ÏìµçÈÝÖµµÄÎïÌå. +* @param NULL +*/ +void hx3918_factory_cali_save_nv(void) +{ + + fds_write[0] = nv_wear_offset[0]; + fds_write[1] = nv_wear_offset[1]; + + fds_write[2] = nv_base_data[0]; + fds_write[3] = nv_base_data[1]; + + fds_write[4] = ai_tune_cnt[0]; + fds_write[5] = ai_tune_cnt[1]; + + TYHX_LOG("[hx3918_factory_cali_save_nv]"); + for(int i=0; i<6; i++) + { + TYHX_LOG("%d ",fds_write[i]); + } + //flash_fds_data_write(6); +} + +/** + * ×îÖÕÓÃIRºÍPROX×ÛºÏÀ´ÅжÏÅå´÷½á¹û +* @param ppg_wear, PPG²¿·ÖÓÃIR¼ì²âµÄ½á¹û +*/ +bool hx3918_get_wear_result(uint8_t ppg_wear) +{ + uint8_t prox_result; + if(ppg_wear == 0) + { + prox_result = hx3918_report_prox_status(); + return false; + } + else + { +#ifdef DEBUG_PPG_ONLY + return true; +#endif + prox_result = hx3918_report_prox_status(); + if(prox_result == 0) + { + return false; + } + else + { + return true; + } + } +} + +/** + * HX3918 ×ÔÎÒУ׼ºǫִ́ÐгÌÐò, Åöµ½ÒòΪż·¢ÐÔµÄÒòÄÚ²¿½á¹¹µÈ±ä»¯ÒýÆð¿¿½ü¸ÐÓ¦µÄ¶Ô¿Õ»ù×¼Öµ·¢Éú´óµÄ±ä»¯, + * ÊÖ±í¶ÔÔÚ·ÇÅå´÷ʱ, ¿ÉÖ´ÐÐÒ»´Î¿¿½ü¸ÐÓ¦µÄ×ÔÎÒУ׼. + ´¥·¢Ìõ¼þ, µ±IR¼ì²âΪ¶Ô¿Õ, ÇÒµ±Ç°LPµÍÓÚ-3000, ´¥·¢ºǫ́У׼. Õâ¸ö³ÌÐòÔÚ¼ì²âÅå´÷µÄº¯ÊýÖб»µ÷Óà +* @param irval ÔÚÅå´÷¼ì²âģʽʱ²âÊÔµ½µÄÖµ +*/ +void hx3918_auto_cali_backgroud(int32_t irval) +{ + uint8_t prox_result; + + if(irval>HX3918_IR_AIR) + return; + prox_result = hx3918_report_prox_status(); + + if(prox_result == prox_no_detect) + { + if((nv_base_data[0]=FILTERLEN) + { + max = pData[0]; + min = max; + sum = 0; + for(int i=0; imax) + { + max = pData[i]; //Ò»¸öÑ­»·Ö®ºómax¾ÍÊÇ×î´óµÄÖµ + } + + if(pData[i]=FILTERLEN) + { + lpresult = MedianFilter(lp_filter,FILTERLEN); + blresult = MedianFilter(bl_filter,FILTERLEN); + TYHX_LOG("lp =%d, bl = %d, receivercnt=%d\r\n",lpresult,blresult,receivercnt); + if((blresult>=ONAIRTHRESLOW) && (blresult<=ONAIRTHRESHIGH)&&(lpresult>=ONAIRTHRESLOW) && (lpresult<=ONAIRTHRESHIGH)) + { + if((hx_abs(blresult -nv_base_data[0] )>=DIFFDETECT) &&(hx_abs(lpresult-blresult)<=100)) + { + differ = blresult-nv_base_data[0]; + TYHX_LOG("detect lp =%d, bl = %d, nv_base=%d\r\n",lpresult,blresult,nv_base_data[0]); + nv_base_data[0] += (differ/2); + hx3918_config_thres(CH0,CH0_HIGH_DIFF, CH0_LOW_DIFF,nv_base_data[0]); // wear0 + get_record_time = app_timer_cnt_get(); + flashrecordupdate = true; + } + } + } + if(flashrecordupdate)//¼ä¸ô2·ÖÖÓÈç¹ûÓÐÐèÒª¼Ç¼flashÒ»´Î, ·ÀÖ¹ÖØ¸´Ð´flash, Õâ¸öʱ¼äÓɸ÷×ÔÆ½Ì¨´¦Àí. + { + get_new_time = app_timer_cnt_get(); //»»Ëã³ÉÃë; + if (get_new_time >= get_record_time)// + { + get_new_time = ((get_new_time - get_record_time) )>>15; + } + else + { + get_new_time = ((get_new_time + 16777216 - get_record_time) ) >>15; + } + get_new_time *=2; + if(get_new_time>=120)//120 Ãë + { + ai_tune_cnt[0]++; + TYHX_LOG("write nv_base=%d, updata cnt = %d\r\n",nv_base_data[0],ai_tune_cnt[0] ); + hx3918_factory_cali_save_nv(); + flashrecordupdate = false; + get_new_time = 0; + } + } + } +} + + + + + diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_prox.h b/2.sdk/Helios_SDK/components/HX3918/hx3918_prox.h new file mode 100644 index 00000000..1b2d3317 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_prox.h @@ -0,0 +1,115 @@ +/** + ****************************************************************************** + * @file : hx3918_PROX.h + * @version : v1.0 + * @brief : +*/ +#ifndef __HX3918_PROX_H_ +#define __HX3918_PROX_H_ + +#include +#include + + +#define CH0 0 +#define CH1 1 +#define CH2 2 + + +#define CH0_OFFSET 0 +#define CH1_OFFSET 1 +#define CH2_OFFSET 2 + + +#define RAW0 0 +#define RAW1 1 +#define RAW2 2 + +#define BL0 0 +#define BL1 1 +#define BL2 2 + + +#define LP0 0 +#define LP1 1 +#define LP2 2 + + +#define DIFF0 0 +#define DIFF1 1 +#define DIFF2 2 + + +#define hx_min(x,y) ( (x)>(y)?(y):(x) ) +#define hx_abs(x) ((x)>0?(x):(-(x))) + +#define RELATIVE_MODE 0 +#define ABSOLUTE_MODE 1 + +#define PROX_CHIPID 0x27 + +#define HX3918_IR_AIR 6000 //СÓÚÕâ¸öÖµ´ú±íÍÑÍó + +#define NORMALWEARDIFF 12000 //Õý³£Åå´÷²âÊÔµ½µÄƽ¾ùÖµ, ¿íËÉÅå´÷ +#define WEARTHRES NORMALWEARDIFF/2 //ÆÕͨÅå´÷ãÐÖµ +#define SLEEPWEARTHRES NORMALWEARDIFF*0.3 //˯ÃßÅå´÷ãÐÖµ + +#define AUTOCALITHRES -3000 //ºǫ́×Ô¶¯Ð£×¼LPºÍBLãÐÖµ +#define ONAIRTHRESLOW -2500 //¶Ô¿ÕµÄLP BL ×îСֵ +#define ONAIRTHRESHIGH 1300 //¶Ô¿ÕµÄLP BL ×î´óÖµ + +#define DIFFDETECT 200 //BL ºÍ NV_BASE ±È½ÏµÄ²îÖµ + +#define CH0_HIGH_DIFF SLEEPWEARTHRES +#define CH0_LOW_DIFF SLEEPWEARTHRES*0.7 +#define CH1_HIGH_DIFF SLEEPWEARTHRES +#define CH1_LOW_DIFF SLEEPWEARTHRES*0.7 + + +typedef enum +{ + prox_no_detect = 0, // ¿¿½ü¸ÐӦûÓмì²âµ½ + prox_detect =1, // ¿¿½ü¸ÐÓ¦¼ì²âµ½ +} prox_result_t; + +typedef enum { + NORMAL_WEAR_MODE = 0,// + SLEEP_WEAR_MODE = 1,// +} wear_mode_t; + + + + +extern int16_t gdiff[2]; +extern int16_t lp[2]; +extern int16_t bl[2]; +extern int16_t nv_base_data[2]; +extern uint32_t ai_tune_cnt[2]; +extern int16_t nv_wear_offset[2]; + +extern uint32_t fds_read[6]; //flash ¶Á +extern uint32_t fds_write[6];//flash д +extern uint8_t wear_detect_mode; + + + +void hx3918_power_up(void); +void hx3918_power_down(void); +void hx3918_power_restart(void); +uint8_t hx3918_check_device_id(void); +bool hx3918_prox_reg_init(void); +uint8_t hx3918_report_prox_status(void); + +void hx3918_prox_factory_hanging_cali(void); +bool hx3918_prox_init(void); +void hx3918_factory_cali_save_nv(void); +int16_t hx3918_read_diff_lp(uint8_t chx_diff); +bool hx3918_get_wear_result(uint8_t ppg_wear); +void hx3918_auto_cali_backgroud(int32_t irval); +//void hx3918_ai_tune_nv(int16_t prevlp,bool chargetstate); +void hx3918_ai_tune_nv(int16_t prevlp,int16_t prevbl); +//void hx3918_ai_tune_nv(int32_t irval,int16_t prevlp,int16_t prevbl); +bool hx3918_prox_factory_init(void); +void hx_set_wear_detect_mode(uint8_t current_mode); + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_spo2_agc.c b/2.sdk/Helios_SDK/components/HX3918/hx3918_spo2_agc.c new file mode 100644 index 00000000..438e1737 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_spo2_agc.c @@ -0,0 +1,976 @@ +#include +#include +#include +#include +#include + +#include "hx3918.h" +#include "hx3918_spo2_agc.h" +#include "tyhx_spo2_alg.h" +#include "tyhx_hrs_alg.h" +//#include "tyhx_hrs_custom.h" +#include "hx3918_prox.h" + +#ifdef SPO2_ALG_LIB +extern const uint8_t hx3918_spo2_agc_green_idac; // 6,7,8... +extern const uint8_t hx3918_spo2_agc_red_idac; // 6,7,8... +extern const uint8_t hx3918_spo2_agc_ir_idac; // 6,7,8... +extern const uint8_t green_led_max_init; +extern const uint8_t red_led_max_init; +extern const uint8_t ir_led_max_init; +extern uint8_t low_vbat_flag; + +extern const uint8_t spo2_check_unwear_oft; +extern const int32_t spo2_ir_wear_thres; +extern const int32_t sar_unwear_thres; +extern const int32_t sar_wear_thres; +extern uint8_t read_fifo_first_flg; + +static uint8_t s_ppg_state = 0; +static uint8_t s_cal_state = 0; +static int32_t agc_buf[4] = {0}; + +static uint8_t cal_delay = CAL_DELAY_COUNT; +static SPO2_CAL_SET_T calReg; + +static hx3918_spo2_wear_msg_code_t spo2_wear_status = MSG_SPO2_INIT; +static hx3918_spo2_wear_msg_code_t spo2_wear_status_pre = MSG_SPO2_INIT; + +void hx3918_spo2_ppg_init(void) //2023 3918 +{ + uint16_t sample_rate = 25; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps0_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps1_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps2_enable=1; /*ps0_enable , 1 mean enable ; 0 mean disable */ + uint8_t ps3_enable=1; /*ps1_enable , 1 mean enable ; 0 mean disable */ + + uint8_t ps0_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps1_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps2_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + uint8_t ps3_osr = 3; /* 0 = 128 ; 1 = 256 ; 2 = 512 ; 3 = 1024 */ + + uint8_t ps3_cp_avg_num_sel= 2; + uint8_t ps2_cp_avg_num_sel= 1; + uint8_t ps1_cp_avg_num_sel= 3; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + uint8_t ps0_led_en_i2c=0; + uint8_t ps1_led_en_i2c=1; + uint8_t ps2_led_en_i2c=1; + uint8_t ps3_led_en_i2c=1; + + uint8_t ps0_ofidac_en_i2c=1; + uint8_t ps1_ofidac_en_i2c=1; + uint8_t ps2_ofidac_en_i2c=1; + uint8_t ps3_ofidac_en_i2c=1; + + uint8_t dccancel_ps0 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =0; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =0; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =0; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =64; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint8_t led_en_begin =1; // 0 = 2 ; 1 = 4 ; 2 = 8 ; 3 = 16 ; + uint8_t afe_reset = 1; //* 0 = 32clk ; 1 = 64clk ; 2 = 128clk ; 3 = 256clk(d) ; + uint8_t en2rst_delay =3; // pen 2 rst delay 0 = 128,256, 512, 1024 + uint8_t init_wait_delay = 2; /* 0 = 800 ; 1 = 1600; 2 = 3200 ; 3 = 6400(d) */ + + uint8_t ps1_interval_i2c =0; // ps2/ps3 + + uint8_t thres_int =1; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + uint8_t ldrsel_ps0 =0; + uint8_t ldrsel_ps1 =RED_LED_SLE; + uint8_t ldrsel_ps2 =GREEN_LED_SLE; + uint8_t ldrsel_ps3 =IR_LED_SLE; + + /***********cap *********/ + uint8_t intcapsel_ps3 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps2 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps1 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + uint8_t intcapsel_ps0 =5; //00=4fp 01=8pf 02=12pf 03=16pf 04=20pf 05=24pf 06=28pf 07=32pf 08=36pf 09=40pf 10=44pf 11=48pf 12=52pf 13=56pf 14=60pf + + uint8_t ps0_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + uint8_t force_adc_clk_sel=0; + uint8_t force_adc_clk_cfg =0; + uint8_t force_PEN =0; + uint8_t force_PEN_cfg =0; + uint8_t force_LED_EN =0; + uint8_t force_LED_EN_cfg =0; + uint8_t force_CKAFEINT_sel =0; + uint8_t force_CKAFEINT_cfg =0; + + hx3918_write_reg(0X16, (ps3_enable<<3| ps2_enable<<2|ps1_enable<<1|ps0_enable)); //default 0x00 + hx3918_write_reg(0X17, (ps3_osr<<6| ps2_osr<<4|ps1_osr<<2|ps0_osr)); //default 0x00 + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<11:8> default 0x03 + hx3918_write_reg(0X1a, (ps1_interval_i2c)); //default 0x00 + hx3918_write_reg(0X1b, led_en_begin<<6|afe_reset<<4|en2rst_delay <<2|init_wait_delay); // led_en_num*8 //default 0x00 + //hx3918_write_reg(0X1b, 0x03); + hx3918_write_reg(0X1c, ps0_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1d, ps1_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1e, ps2_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X1f, ps3_led_on_time); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel) ); //default 0x00 + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); //default 0x00 + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|ps0_ofidac_en_i2c<<3|ps1_ofidac_en_i2c<<2|ps2_ofidac_en_i2c<<1|ps3_ofidac_en_i2c)); // led_en offset_en + hx3918_write_reg(0X24, (intcapsel_ps0<<4|intcapsel_ps1)); //default 0x00 + hx3918_write_reg(0X25, (intcapsel_ps2<<4|intcapsel_ps3)); //default 0x00 + hx3918_write_reg(0X26, leddrive_ps0); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X27, leddrive_ps1); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X28, leddrive_ps2); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X29, leddrive_ps3); // led_en_num*8 //default 0x00 + hx3918_write_reg(0X2a, (ldrsel_ps0<<4|ldrsel_ps1)); //default 0x00 + hx3918_write_reg(0X2b, (ldrsel_ps2<<4|ldrsel_ps3)); //default 0x00 + hx3918_write_reg(0X2c, dccancel_ps0 ); //default 0x00 + hx3918_write_reg(0X2d, dccancel_ps1 ); //default 0x00 + hx3918_write_reg(0X2e, dccancel_ps2 ); //default 0x00 + hx3918_write_reg(0X2f, dccancel_ps3); //default 0x00 + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); + hx3918_write_reg(0X4e, (force_adc_clk_sel<<7|force_adc_clk_cfg<<6|force_PEN<<5|force_PEN_cfg<<4|force_LED_EN<<3| + force_LED_EN_cfg<<2|force_CKAFEINT_sel<<1|force_CKAFEINT_cfg)); //default 0x00 + + hx3918_write_reg(0X6d, 0x00); + hx3918_write_reg(0XF0, 0x22); + hx3918_write_reg(0xF1, 0x28); + hx3918_write_reg(0xF2, 0x04); + hx3918_write_reg(0xF3, 0x70); + hx3918_write_reg(0xF4, 0x32); + hx3918_write_reg(0xF5, 0x89); + hx3918_write_reg(0xF6, 0x2b); + hx3918_write_reg(0xF7, 0x85); + hx3918_write_reg(0xF8, 0x27); + hx3918_write_reg(0xF9, 0x00); + hx3918_write_reg(0xFA, 0x88); + hx3918_write_reg(0xFB, 0x40); + hx3918_write_reg(0Xf6, 0X2b); + +#if defined(TIMMER_MODE) + hx3918_write_reg(0x3d,0x80); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3e,0x20); //watermark + hx3918_write_reg(0x3c,0x1f); // int_width_i2c + hx3918_write_reg(0X37,0x00); // int sel,01=prf int,04=enable almost full int + hx3918_write_reg(0X3b,0x00); + hx3918_write_reg(0X3b,0x10); +#else ///////////INT Mode + hx3918_write_reg(0x3d,0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0x3c,0x1f); // int_width_i2c + hx3918_write_reg(0X37,0x04); // int sel,01=prf ,04=enable almost full +#endif + + hx3918_write_reg(0X4d,0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d,0X00); //release + hx3918_delay(5); + + read_fifo_first_flg = 1; + +} + +void Init_Spo2_PPG_Calibration_Routine(SPO2_CAL_SET_T *calR) +{ + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + calR->red_idac = 0; + calR->ir_idac = 0; + calR->green_idac = 0; + calR->amb_idac = 0; + calR->ontime = 5; + calR->green_cur = SPO2_CAL_INIT_LED_GREEN; + calR->red_cur = SPO2_CAL_INIT_LED_RED; + calR->ir_cur = SPO2_CAL_INIT_LED_IR; + calR->state = sCalStart; + calR->int_cnt = 0; + calR->cur255_cnt =0; + calR->green_led_step =0; + calR->red_led_step =0; + calR->ir_led_step =0; + if(low_vbat_flag == 1) + { + calR->green_max_cur = (green_led_max_init*3)>>2; + calR->red_max_cur = (red_led_max_init*3)>>2; + calR->ir_max_cur = (ir_led_max_init*3)>>2; + } + else + { + calR->green_max_cur = green_led_max_init; + calR->red_max_cur = red_led_max_init; + calR->ir_max_cur = ir_led_max_init; + } +} + +void Restart_Spo2_PPG_Calibration_Routine(SPO2_CAL_SET_T *calR) +{ + calR->flag = CAL_FLG_LED_DAC; + calR->state = sCalLed; + calR->int_cnt = 0; +} + +bool hx3918_spo2_check_unwear(void) +{ + if(calReg.ir_idac < spo2_check_unwear_oft) + { + spo2_wear_status = MSG_SPO2_NO_WEAR; + if(spo2_wear_status_pre != MSG_SPO2_NO_WEAR) + { + spo2_wear_status_pre = MSG_SPO2_NO_WEAR; + hx3918_spo2_low_power(); + return true; + } + } + return false; +} + +bool hx3918_spo2_check_wear(int32_t infrared_data) +{ + if(infrared_data > spo2_ir_wear_thres ) + { + + spo2_wear_status = MSG_SPO2_WEAR; + //TYHX_LOG("[hx3918_spo2_check_wear start] ir wear result = %d\r\n",spo2_wear_status); + //spo2_wear_status = hx3918_get_wear_result(spo2_wear_status); + TYHX_LOG("[hx3918_spo2_check_wear end] final result = %d\r\n",spo2_wear_status); + if(spo2_wear_status_pre != MSG_SPO2_WEAR) + { + AGC_LOG("hx3918_spo2_check_wear ir = %d\r\n", infrared_data); + spo2_wear_status_pre = MSG_SPO2_WEAR; + tyhx_spo2_alg_open_deep(); + hx3918_spo2_set_mode(PPG_INIT); + hx3918_spo2_set_mode(CAL_INIT); + return true; + } + } + return false; +} + + +void PPG_Spo2_Calibration_Routine(SPO2_CAL_SET_T *calR, int32_t amb, int32_t green_led, int32_t r_led, int32_t ir_led) +{ + int32_t r_led_temp = 0, ir_led_temp = 0, green_led_temp = 0; + TYHX_LOG("AGC_before: green_cur=%d,red_cur=%d,ir_cur=%d,green_idac=%d,red_idac=%d,ir_idac=%d,green_step=%d,red_step=%d,ir_step=%d,state=%d\r\n",\ + calR->green_cur,calR->red_cur,calR->ir_cur,calR->green_idac,calR->red_idac,calR->ir_idac,calR->green_led_step,calR->red_led_step,calR->ir_led_step,calR->state); + switch(calR->state) + { + case sCalStart: + calR->state = sCalLedCur; + break; + + case sCalLedCur: + if(spo2_wear_status == MSG_SPO2_NO_WEAR) + { + calR->state = sCalFinish; + break; + } + calR->amb_idac = 0; + if(green_led>amb+128) + { + calR->green_led_step = (green_led-amb)/SPO2_CAL_INIT_LED_GREEN; + green_led_temp = 5000*(hx3918_spo2_agc_green_idac+calR->amb_idac)/calR->green_led_step; + if(green_led_temp>calR->green_max_cur) + { + green_led_temp = calR->green_max_cur; + } + calR->green_cur = green_led_temp; + calR->green_idac = hx3918_spo2_agc_green_idac>>1; + } + if(r_led>amb+128) + { + calR->red_led_step = (r_led-amb)/SPO2_CAL_INIT_LED_RED; + r_led_temp = 10000*(hx3918_spo2_agc_red_idac+calR->amb_idac)/calR->red_led_step; + if(r_led_temp>calR->red_max_cur) + { + r_led_temp = calR->red_max_cur; + } + calR->red_cur = r_led_temp; + calR->red_idac = hx3918_spo2_agc_red_idac>>1; + } + if(ir_led>amb+128) + { + calR->ir_led_step = (ir_led-amb)/SPO2_CAL_INIT_LED_IR; + ir_led_temp = 10000*(hx3918_spo2_agc_ir_idac+calR->amb_idac)/calR->ir_led_step; + if(ir_led_temp>calR->ir_max_cur) + { + ir_led_temp = calR->ir_max_cur; + } + calR->ir_cur = ir_led_temp; + calR->ir_idac = hx3918_spo2_agc_ir_idac>>1; + } + calR->ontime = 64; + calR->flag = CAL_FLG_LED_DR|CAL_FLG_LED_DAC|CAL_FLG_AMB_DAC|CAL_FLG_RF; + calR->state = sCalLed; + break; + + case sCalLed: + if(green_led>450000 && calR->green_idac < 200) + { + calR->green_idac = calR->green_idac+2; + } + + if(r_led>450000 && calR->red_idac < 200) + { + calR->red_idac = calR->red_idac+2; + } + + if(ir_led>450000 && calR->ir_idac < 200) + { + calR->ir_idac = calR->ir_idac+2; + } + + if(green_led<=450000 && ir_led<=450000 && r_led<=450000) + { + calR->state = sCalLed2; + } + else if(calR->green_idac >= 200 || calR->ir_idac >= 200 || calR->red_idac >= 200) + { + calR->state = sCalFinish; + } + else + { + calR->state = sCalLed; + } + calR->flag = CAL_FLG_LED_DAC; + break; + + case sCalLed2: + if(green_led>350000 && calR->green_idac < 200) + { + calR->green_idac = calR->green_idac+1; + } + else if(green_led<150000 && calR->green_idac > 0) + { + calR->green_idac = calR->green_idac-1; + } + + if(r_led>350000 && calR->red_idac < 200) + { + calR->red_idac = calR->red_idac+1; + } + else if(r_led<150000 && calR->red_idac > 0) + { + calR->red_idac = calR->red_idac-1; + } + + if(ir_led>350000 && calR->ir_idac < 200) + { + calR->ir_idac = calR->ir_idac+1; + } + else if(ir_led<150000 && calR->ir_idac > 0) + { + calR->ir_idac = calR->ir_idac-1; + } + + if(green_led<350000 && green_led>150000 && ir_led<350000 && ir_led>150000 && r_led<350000 && r_led>150000) + { + calR->state = sCalFinish; + } + else if(calR->green_idac >= 200 || calR->ir_idac >= 200 || calR->red_idac >= 200) + { + calR->state = sCalFinish; + } + else + { + calR->state = sCalLed2; + } + calR->flag = CAL_FLG_LED_DAC; + break; + + default: + break; + } + TYHX_LOG("AGC_after: green_cur=%d,red_cur=%d,ir_cur=%d,green_idac=%d,red_idac=%d,ir_idac=%d,green_step=%d,red_step=%d,ir_step=%d,state=%d\r\n",\ + calR->green_cur,calR->red_cur,calR->ir_cur,calR->green_idac,calR->red_idac,calR->ir_idac,calR->green_led_step,calR->red_led_step,calR->ir_led_step,calR->state); +} + +SPO2_CAL_SET_T PPG_spo2_agc(void) +{ + int32_t r_led_val; + int32_t amb_val; + int32_t ir_led_val; + int32_t green_led_val; + + calReg.work = false; + if (!s_cal_state) + { + return calReg; + } + + #ifdef INT_MODE + calReg.int_cnt ++; + if(calReg.int_cnt < 8) + { + return calReg; + } + calReg.int_cnt = 0; + hx3918_gpioint_cfg(false); + #endif + + calReg.work = true; + read_data_packet(agc_buf); + amb_val = agc_buf[0]; + green_led_val = agc_buf[2]; + r_led_val = agc_buf[1]; + ir_led_val = agc_buf[3]; + + TYHX_LOG("cal dat amb=%d,g=%d,r=%d,ir=%d\r\n", amb_val, green_led_val, r_led_val, ir_led_val); + PPG_Spo2_Calibration_Routine(&calReg, amb_val,green_led_val,r_led_val,ir_led_val); + + if (calReg.state == sCalFinish) + { + hx3918_spo2_set_mode(CAL_OFF); + } + else + { + hx3918_spo2_updata_reg(); + } + #if defined(INT_MODE) + hx3918_gpioint_cfg(true); + #endif + return calReg; +} + + +void hx3918_spo2_cal_init(void) // 20200615 ericy afe cali offline +{ + uint16_t sample_rate = 100; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + uint8_t thres_int =0; //thres int enable + uint8_t data_rdy_int =8; //[3]:ps1_data2 [2]:ps1_data1 [1]:ps0_data2 [0]:ps0_data1 + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<15:8> default 0x03 + hx3918_write_reg(0x3d,0x00); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + hx3918_write_reg(0X36, (thres_int<<4|data_rdy_int)); //default 0x0f + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); //Delay for reset time + +} + +void hx3918_spo2_cal_off(void) // 20200615 ericy afe cali offline +{ + uint16_t sample_rate = 25; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<15:8> default 0x03 + hx3918_write_reg(0x3d,0x80); //bits<3:0> fifo data sel, 0000 = p1;0001= p2;0010=p3;0011=p4;bits<7> fifo enble + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); //Delay for reset time + #if DEBUG_PPG_ONLY + hx3918_prox_init(); + #endif + read_fifo_first_flg = 1; +} + +void hx3918_spo2_read_data(int32_t *buf) // 20200615 ericy read reg_data phase1 and phase3 +{ + uint8_t databuf1[6] = {0}; + uint8_t databuf2[6] = {0}; + uint32_t P1 = 0,P2 = 0,P3 = 0,P4 =0 ; + + hx3918_brust_read_reg(0x03, databuf1, 6); + hx3918_brust_read_reg(0x09, databuf2, 6); + + P1 = ((databuf1[0])|(databuf1[1]<<8)|(databuf1[2]<<16)); + P3 = ((databuf1[3])|(databuf1[4]<<8)|(databuf1[5]<<16)); + P4 = ((databuf2[0])|(databuf2[1]<<8)|(databuf2[2]<<16)); + P2 = ((databuf2[3])|(databuf2[4]<<8)|(databuf2[5]<<16)); + + buf[0] = P1; + buf[1] = P2; + buf[2] = P3; + buf[3] = P4; +} + +void hx3918_spo2_low_power(void) +{ + uint16_t sample_rate = 10; /*config the data rate of chip alps2_fm ,uint is Hz*/ + uint32_t prf_clk_num = 32000/sample_rate; /*period in clk num, num = Fclk/fs */ + + uint8_t ps3_cp_avg_num_sel= 0; + uint8_t ps2_cp_avg_num_sel= 0; + uint8_t ps1_cp_avg_num_sel= 0; + uint8_t ps0_cp_avg_num_sel= 0; + + uint8_t ps3_avg_num_sel_i2c=0; + uint8_t ps2_avg_num_sel_i2c=0; + uint8_t ps1_avg_num_sel_i2c=0; + uint8_t ps0_avg_num_sel_i2c=0; + + uint8_t ps0_led_en_i2c=0; + uint8_t ps1_led_en_i2c=0; + uint8_t ps2_led_en_i2c=0; + uint8_t ps3_led_en_i2c=1; + + uint8_t dccancel_ps0 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps1 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps2 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + uint8_t dccancel_ps3 =0; //offset idac BIT[9:0] 0 31.25nA, 1023 32uA, step 31.25nA + + uint8_t leddrive_ps0 =0; //LEDDRIVE_PS0 0~255 = 0~200ma + uint8_t leddrive_ps1 =0; //LEDDRIVE_PS1 0~255 = 0~200ma + uint8_t leddrive_ps2 =0; //LEDDRIVE_PS2 0~255 = 0~200ma + uint8_t leddrive_ps3 =64; //LEDDRIVE_PS3 0~255 = 0~200ma + + uint8_t ps0_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps1_led_on_time=0; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps2_led_on_time=0; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + uint8_t ps3_led_on_time=64; /* 0 = 32clk2=8us ; 8 = 64clk=16us; 16=128clk=32us ; 32 = 256clk=64us ; + 64 = 512clk=128us ; 128= 1024clk=256us; 256= 2048clk=512us*/ + + hx3918_write_reg(0X18, (uint8_t)prf_clk_num); // prf bit<7:0>6 default 0x00 + hx3918_write_reg(0X19, (uint8_t)(prf_clk_num>>8)); // prf bit<11:8> default 0x03 + + hx3918_write_reg(0X1c, ps0_led_on_time); + hx3918_write_reg(0X1d, ps1_led_on_time); + hx3918_write_reg(0X1e, ps2_led_on_time); + hx3918_write_reg(0X1f, ps3_led_on_time); + hx3918_write_reg(0X20, (ps3_cp_avg_num_sel<<6|ps2_cp_avg_num_sel<<4|ps1_cp_avg_num_sel<<2|ps0_cp_avg_num_sel) ); + hx3918_write_reg(0X21, (ps3_avg_num_sel_i2c<<6|ps2_avg_num_sel_i2c<<4|ps1_avg_num_sel_i2c<<2|ps0_avg_num_sel_i2c)); + hx3918_write_reg(0X23, (ps0_led_en_i2c<<7|ps1_led_en_i2c<<6|ps2_led_en_i2c<<5|ps3_led_en_i2c<<4|0x0f)); + hx3918_write_reg(0X26, leddrive_ps0); + hx3918_write_reg(0X27, leddrive_ps1); + hx3918_write_reg(0X28, leddrive_ps2); + hx3918_write_reg(0X29, leddrive_ps3); + hx3918_write_reg(0X2c, dccancel_ps0); + hx3918_write_reg(0X2d, dccancel_ps1); + hx3918_write_reg(0X2e, dccancel_ps2); + hx3918_write_reg(0X2f, dccancel_ps3); + + hx3918_write_reg(0X4d, 0X01); //soft reset + hx3918_delay(5); + hx3918_write_reg(0X4d, 0X00); //release + hx3918_delay(5); + #if DEBUG_PPG_ONLY + hx3918_prox_init(); + #endif + read_fifo_first_flg = 1; + AGC_LOG(" chip go to low power mode \r\n" ); +} + +void hx3918_spo2_updata_reg(void) +{ + if (calReg.flag & CAL_FLG_LED_DR) + { + hx3918_write_reg(0X28, calReg.green_cur); + hx3918_write_reg(0X27, calReg.red_cur); + hx3918_write_reg(0X29, calReg.ir_cur); + } + + if (calReg.flag & CAL_FLG_LED_DAC) + { + hx3918_write_reg(0X2e, (uint8_t)calReg.green_idac); + hx3918_write_reg(0X2d, (uint8_t)calReg.red_idac); + hx3918_write_reg(0X2f, (uint8_t)calReg.ir_idac); + } + + if (calReg.flag & CAL_FLG_AMB_DAC) + { + hx3918_write_reg(0X2c, (uint8_t)calReg.amb_idac); + } + + if (calReg.flag & CAL_FLG_RF) + { + hx3918_write_reg(0X1c, calReg.ontime); //3918 p1 + hx3918_write_reg(0X1d, calReg.ontime); //3918 p1 + hx3918_write_reg(0X1e, calReg.ontime); //3918 p2 + hx3918_write_reg(0X1f, calReg.ontime); //3918 p3 + } + hx3918_delay(10); +} +void hx3918_spo2_set_mode(uint8_t mode_cmd) +{ + switch (mode_cmd) + { + case PPG_INIT: + hx3918_spo2_ppg_init(); + #if defined(TIMMER_MODE) + hx3918_ppg_timer_cfg(true); + #else + hx3918_gpioint_cfg(true); + #endif + s_ppg_state = 1; + AGC_LOG("ppg init mode\r\n"); + break; + + case PPG_OFF: + hx3918_ppg_off(); + s_ppg_state = 0; + AGC_LOG("ppg off mode\r\n"); + break; + + case PPG_LED_OFF: + hx3918_spo2_low_power(); + s_ppg_state = 0; + AGC_LOG("ppg led off mode\r\n"); + break; + + case CAL_INIT: + Init_Spo2_PPG_Calibration_Routine(&calReg); + hx3918_spo2_cal_init(); + hx3918_spo2_updata_reg(); + #if defined(TIMMER_MODE) + hx3918_agc_timer_cfg(true); + #endif + s_cal_state = 1; + AGC_LOG("cal init mode\r\n"); + break; + + case RECAL_INIT: + Restart_Spo2_PPG_Calibration_Routine(&calReg); + hx3918_spo2_cal_init(); + hx3918_spo2_updata_reg(); + #if defined(TIMMER_MODE) + hx3918_agc_timer_cfg(true); + #endif + s_cal_state = 1; + AGC_LOG("recal init mode\r\n"); + break; + + case CAL_OFF: + #if defined(TIMMER_MODE) + hx3918_agc_timer_cfg(false); + #endif + hx3918_spo2_cal_off(); + s_cal_state = 0; + AGC_LOG("cal off mode\r\n"); + break; + + default: + break; + } +} + +SENSOR_ERROR_T hx3918_spo2_enable(void) +{ + if (!hx3918_chip_check()) + { + AGC_LOG("hx3690l check id failed!\r\n"); + return SENSOR_OP_FAILED; + } + TYHX_LOG("hx3690l check id success!\r\n"); + + if (s_ppg_state) + { + AGC_LOG("ppg already on!\r\n"); + return SENSOR_OP_FAILED; + } + + if(!tyhx_spo2_alg_open()) + { + AGC_LOG("spo2 alg open fail,or dynamic ram not enough!\r\n"); + return SENSOR_OP_FAILED; + } + spo2_wear_status = MSG_SPO2_INIT; + spo2_wear_status_pre = MSG_SPO2_INIT; + hx3918_spo2_set_mode(PPG_INIT); + AGC_LOG("hx3690l enable!\r\n"); + + return SENSOR_OK; +} + +void hx3918_spo2_disable(void) +{ + #if defined(TIMMER_MODE) + hx3918_ppg_timer_cfg(false); + hx3918_agc_timer_cfg(false); + #elif defined(INT_MODE) + hx3918_gpioint_cfg(false); + #endif + hx3918_spo2_set_mode(PPG_OFF); + s_ppg_state = 0; + s_cal_state = 0; + tyhx_spo2_alg_close(); + AGC_LOG("hx3690l disable!\r\n"); +} + +void hx3918_spo2_data_reset(void) +{ + s_ppg_state = 0; + s_cal_state = 0; + tyhx_spo2_alg_close(); +} + +hx3918_spo2_wear_msg_code_t hx3918_spo2_get_wear_status(void) +{ + return spo2_wear_status; +} + +SPO2_CAL_SET_T get_spo2_agc_status(void) +{ + SPO2_CAL_SET_T cal; + cal.flag = calReg.flag; + cal.int_cnt = calReg.int_cnt; + cal.green_cur = calReg.green_cur; + cal.red_cur = calReg.red_cur; + cal.ir_cur = calReg.ir_cur; + cal.green_idac = calReg.green_idac; + cal.red_idac = calReg.red_idac; + cal.ir_idac = calReg.ir_idac; + cal.amb_idac = calReg.amb_idac; + cal.ontime = calReg.ontime; + cal.green_led_step = calReg.green_led_step; + cal.red_led_step = calReg.red_led_step; + cal.ir_led_step = calReg.ir_led_step; + cal.state = calReg.state; + return cal; +} + +uint8_t hx3918_spo2_read(ppg_sensor_data_t * s_dat) +{ + int32_t Red_src_data; + int32_t Ir_src_data; + int32_t Green_src_data; + int32_t Amb_data; + bool recal = false; + int32_t *green_buf = &(s_dat->green_data[0]); + int32_t *red_buf = &(s_dat->red_data[0]); + int32_t *ir_buf = &(s_dat->ir_data[0]); + int32_t *s_buf = &(s_dat->s_buf[0]); + //int32_t *sar_lp_data = &s_dat->sar_data; + s_dat->green_cur = calReg.green_cur; + s_dat->red_cur = calReg.red_cur; + s_dat->ir_cur = calReg.ir_cur; + uint8_t data_count = 0; + if (!s_ppg_state || s_cal_state) + { + return NULL; + } + data_count = hx3918_read_fifo_data(s_buf,4,1); + //*sar_lp_data = hx3918_read_sar_data(); + s_dat->count = data_count; + TYHX_LOG("\r\n spo2 ir data: "); + for (uint8_t i=0; i400000 || Red_src_data<100000 || Red_src_data>400000 || Ir_src_data<100000 || Ir_src_data>400000) + { + recal = true; + if(spo2_wear_status==MSG_SPO2_NO_WEAR) + { + recal = false; + } + } + } + TYHX_LOG("\r\n"); + if (recal) + { + cal_delay--; + if (cal_delay <= 0) + { + cal_delay = CAL_DELAY_COUNT; + hx3918_spo2_set_mode(RECAL_INIT); + } + } + else + { + cal_delay = CAL_DELAY_COUNT; + } + return 1; +} + +#ifdef SPO2_DATA_CALI +static int32_t red_data_fifo[4] = {0}; +static int32_t ir_data_fifo[4] = {0}; +static int32_t red_dc_temp = 0; +static int32_t ir_dc_temp = 0; +static int32_t red_data_pre = 0; +static int32_t ir_data_pre = 0; +static int32_t red_jump_delta = 0; +static int32_t ir_jump_delta = 0; +static int32_t cali_data_cnt = 0; + +void hx3918_spo2_data_cali_init(void) +{ + int ii=0; + for(ii=0; ii<4; ii++) + { + red_data_fifo[ii] = 0; + ir_data_fifo[ii] = 0; + } + red_dc_temp = 0; + ir_dc_temp = 0; + red_data_pre = 0; + ir_data_pre = 0; + red_jump_delta = 0; + ir_jump_delta = 0; + cali_data_cnt = 0; +} + +int32_t hx3918_red_data_cali(int32_t red_new_raw_data) +{ + uint8_t ii; + int32_t red_data_final; + int32_t red_data_cali; + hx3918_spo2_wear_msg_code_t touch_status; + touch_status = hx3918_spo2_get_wear_status(); + if(touch_status == MSG_SPO2_NO_WEAR) + { + cali_data_cnt = 0; + red_data_cali = red_new_raw_data; + for(ii=0; ii<4; ii++) + { + red_data_fifo[ii] = 0; + } + red_dc_temp = 0; + } + else + { + for(ii=3; ii>0; ii--) + { + red_data_fifo[ii] = red_data_fifo[ii-1]; + } + red_data_fifo[0] = red_new_raw_data; + if(cali_data_cnt>=25) + { + if ((((red_data_fifo[1] - red_data_fifo[2]) > SOP2_DEGLITCH_THRE) && ((red_data_fifo[1] - red_new_raw_data) > SOP2_DEGLITCH_THRE)) || \ + (((red_data_fifo[1] - red_data_fifo[2]) < -SOP2_DEGLITCH_THRE) && ((red_data_fifo[1] - red_new_raw_data) < -SOP2_DEGLITCH_THRE))) + { + red_new_raw_data = red_data_fifo[2]; + red_data_fifo[1] = red_data_fifo[2]; + } + else + { + red_new_raw_data = red_data_fifo[1]; + } + if ((abs((red_new_raw_data - red_jump_delta) - red_data_pre) > SPO2_REMOVE_JUMP_THRE)) + { + red_jump_delta = red_new_raw_data - red_data_pre; + } + red_data_cali = red_new_raw_data - red_jump_delta; + red_data_pre = red_data_cali; + } + else + { + red_data_cali = red_data_fifo[1]; + red_data_pre = red_data_fifo[1]; + } + } + if(cali_data_cnt<=30) + { + red_dc_temp = red_data_cali; + red_data_final = red_new_raw_data; + } + else + { + red_dc_temp = (red_dc_temp*31 + red_data_cali)>>5; + red_data_final = red_data_cali - red_dc_temp + 2608*50*hx3918_spo2_agc_red_idac; + } + return red_data_final; +} +int32_t hx3918_ir_data_cali(int32_t ir_new_raw_data) +{ + uint8_t ii; + int32_t ir_data_final; + int32_t ir_data_cali; + hx3918_spo2_wear_msg_code_t touch_status; + touch_status = hx3918_spo2_get_wear_status(); + if(touch_status == MSG_SPO2_NO_WEAR) + { + cali_data_cnt = 0; + ir_data_cali = ir_new_raw_data; + for(ii=0; ii<4; ii++) + { + ir_data_fifo[ii] = 0; + } + ir_dc_temp = 0; + } + else + { + for(ii=3; ii>0; ii--) + { + ir_data_fifo[ii] = ir_data_fifo[ii-1]; + } + ir_data_fifo[0] = ir_new_raw_data; + cali_data_cnt++; + if(cali_data_cnt>=25) + { + if ((((ir_data_fifo[1] - ir_data_fifo[2]) > SOP2_DEGLITCH_THRE) && ((ir_data_fifo[1] - ir_new_raw_data) > SOP2_DEGLITCH_THRE)) || \ + (((ir_data_fifo[1] - ir_data_fifo[2]) < -SOP2_DEGLITCH_THRE) && ((ir_data_fifo[1] - ir_new_raw_data) < -SOP2_DEGLITCH_THRE))) + { + ir_new_raw_data = ir_data_fifo[2]; + ir_data_fifo[1] = ir_data_fifo[2]; + } + else + { + ir_new_raw_data = ir_data_fifo[1]; + } + if ((abs((ir_new_raw_data - ir_jump_delta) - ir_data_pre) > SPO2_REMOVE_JUMP_THRE)) + { + ir_jump_delta = ir_new_raw_data - ir_data_pre; + } + ir_data_cali = ir_new_raw_data - ir_jump_delta; + ir_data_pre = ir_data_cali; + } + else + { + ir_data_cali = ir_data_fifo[1]; + ir_data_pre = ir_data_fifo[1]; + } + } + if(cali_data_cnt<=30) + { + ir_dc_temp = ir_data_cali; + ir_data_final = ir_new_raw_data; + } + else + { + ir_dc_temp = (ir_dc_temp*31 + ir_data_cali)>>5; + ir_data_final = ir_data_cali - ir_dc_temp + 2608*50*hx3918_spo2_agc_ir_idac; + } + return ir_data_final; +} +#endif + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/hx3918_spo2_agc.h b/2.sdk/Helios_SDK/components/HX3918/hx3918_spo2_agc.h new file mode 100644 index 00000000..04f0c8a3 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/hx3918_spo2_agc.h @@ -0,0 +1,90 @@ +#ifndef _HX3918_SPO2_AGC_H_ +#define _HX3918_SPO2_AGC_H_ +#include +#include +#include "hx3918.h" + +#define CAL_DELAY_COUNT (3) + +#define CAL_FLG_LED_DR 0x01 +#define CAL_FLG_LED_DAC 0x02 +#define CAL_FLG_AMB_DAC 0x04 +#define CAL_FLG_RF 0x08 + +#define SPO2_CAL_INIT_LED_GREEN 64 +#define SPO2_CAL_INIT_LED_RED 64 +#define SPO2_CAL_INIT_LED_IR 64 + + +typedef enum { + sCalStart, + sCalLedCur, + sCalLed, + sCalLed2, + sCalFinish, +} SPO2_STATE_T; + +typedef enum { + MSG_SPO2_NO_WEAR, + MSG_SPO2_WEAR, + MSG_SPO2_INIT +} hx3918_spo2_wear_msg_code_t; + +typedef struct { + uint8_t red_offset_idac; + uint8_t ir_offset_idac; + uint8_t green_offset_idac; + uint16_t spo2_start_cnt; +} hx3918_spo2_agcpara_t; + +typedef struct { + uint8_t flag; + bool work; + uint8_t int_cnt; + uint8_t cur255_cnt; + uint8_t green_idac; + uint8_t red_idac; + uint8_t ir_idac; + uint8_t amb_idac; + uint16_t green_cur; + uint16_t red_cur; + uint16_t ir_cur; + uint8_t ontime; + uint32_t green_led_step; + uint32_t red_led_step; + uint32_t ir_led_step; + uint8_t state; + uint8_t green_max_cur; + uint8_t red_max_cur; + uint8_t ir_max_cur; +} SPO2_CAL_SET_T; + + +void Init_Spo2_PPG_Calibration_Routine(SPO2_CAL_SET_T *calR); +void Restart_spo2_PPG_Calibration_Routine(SPO2_CAL_SET_T *calR); +void PPG_Spo2_Calibration_Routine(SPO2_CAL_SET_T *calR, int32_t amb, int32_t green_led, int32_t r_led, int32_t ir_led); +SPO2_CAL_SET_T PPG_spo2_agc(void); + +void hx3918_spo2_cal_init(void); +void hx3918_spo2_cal_off(void); + +void read_spo2_data_packet(int32_t *buf); +void read_spo2_ir_packet(int32_t *buf); +void hx3918_spo2_read_data(int32_t *buf); + +void hx3918_spo2_low_power(void); +void hx3918_spo2_normal_power(void); + +void hx3918_spo2_updata_reg(void); +void hx3918_spo2_set_mode(uint8_t mode_cmd); +SENSOR_ERROR_T hx3918_spo2_enable(void); +void hx3918_spo2_disable(void); +hx3918_spo2_wear_msg_code_t hx3918_spo2_get_wear_status(void); +uint8_t hx3918_spo2_read(ppg_sensor_data_t * s_dat); +uint8_t hx3918_spo2_read_data_packet(int32_t *s_buf); +bool hx3918_spo2_check_unwear(void); +bool hx3918_spo2_check_wear(int32_t infrared_data); +SPO2_CAL_SET_T get_spo2_agc_status(void); +void hx3918_spo2_data_reset(void); + +#endif diff --git a/2.sdk/Helios_SDK/components/HX3918/lib/gcc_3918lib_hrs_spo2_20230731_v0.1.a b/2.sdk/Helios_SDK/components/HX3918/lib/gcc_3918lib_hrs_spo2_20230731_v0.1.a new file mode 100644 index 00000000..c67d00bc Binary files /dev/null and b/2.sdk/Helios_SDK/components/HX3918/lib/gcc_3918lib_hrs_spo2_20230731_v0.1.a differ diff --git a/2.sdk/Helios_SDK/components/HX3918/tyhx_hrs_alg.h b/2.sdk/Helios_SDK/components/HX3918/tyhx_hrs_alg.h new file mode 100644 index 00000000..7aea5f90 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/tyhx_hrs_alg.h @@ -0,0 +1,117 @@ +#ifndef _TYHX_HRS_ALG_H_ +#define _TYHX_HRS_ALG_H_ +#endif + +#include +// /* portable 8-bit unsigned integer */ +// typedef unsigned char uint8_t; +// /* portable 8-bit signed integer */ +// typedef signed char int8_t; +// /* portable 16-bit unsigned integer */ +// typedef unsigned short int uint16_t; +// /* portable 16-bit signed integer */ +// typedef signed short int int16_t; +// /* portable 32-bit unsigned integer */ +// typedef unsigned int uint32_t; +// /* portable 32-bit signed integer */ +// typedef signed int int32_t; + +#ifndef bool +#define bool unsigned char +#endif +#ifndef true +#define true 1 +#endif +#ifndef false +#define false 0 +#endif + + +#ifdef HRS_ALG_LIB + +typedef enum { + NORMAL_MODE, + RIDE_MODE, + WALK_MODE, + JUMP_MODE, + ALLDAY_HR_MODE, + HIGH_POW_MODE +} hrs_sports_mode_t; + +typedef enum { + MSG_HRS_ALG_NOT_OPEN, + MSG_HRS_ALG_OPEN, + MSG_HRS_READY, + MSG_HRS_ALG_TIMEOUT, +} hrs_alg_msg_code_t; + +typedef enum { + MSG_LIVING_INITIAL, + MSG_LIVING_TRUE, + MSG_LIVING_FAIL +} living_msg_code_t; + +typedef struct { + hrs_alg_msg_code_t hrs_alg_status; + living_msg_code_t living_status; + uint32_t data_cnt; + uint8_t hr_result; + uint16_t cal_result; + uint8_t hr_result_qual; + uint32_t hr_result_std; +} hrs_results_t; + +typedef struct { + uint32_t data_cnt; + uint8_t motion_status; + uint32_t gsen_pow; + int8_t up_clip; + int8_t dn_clip; + uint8_t runrun_cnt; +} HRS_ALG_INFO_T; + +#ifdef BP_CUSTDOWN_ALG_LIB +typedef enum { + MSG_BP_ALG_NOT_OPEN = 0x01, + MSG_BP_NO_TOUCH = 0x02, + MSG_BP_PPG_LEN_TOO_SHORT = 0x03, + MSG_BP_READY = 0x04, + MSG_BP_ALG_TIMEOUT = 0x05, + MSG_BP_SETTLE = 0x06 +} bp_msg_code_t; + +typedef struct { + uint8_t age; + uint8_t height; + uint8_t weight; + uint8_t gender; + uint8_t ref_sbp; + uint8_t ref_dbp; +} bp_exinf_t; + +typedef struct { + bp_msg_code_t bp_alg_status; + uint8_t sbp; + uint8_t dbp; + uint32_t data_cnt; + uint8_t hr_result; + bool object_flg; +} bp_results_t; + + +void tyhx_bp_set_exinf(uint8_t age, uint8_t height, uint8_t weight, uint8_t gender, uint8_t ref_sbp, uint8_t ref_dbp); +void tyhx_bp_age_fn(uint8_t hr_result, bp_exinf_t body_s); +void tyhx_restart_bp_cal(void); +bp_results_t tyhx_alg_get_bp_results(void); +#endif //BP_CUSTDOWN_ALG_LIB + +bool tyhx_hrs_alg_open(void); +bool tyhx_hrs_alg_open_deep(void); +void tyhx_hrs_alg_close(void); +bool tyhx_hrs_alg_send_data(int32_t *new_raw_data,uint8_t dat_len, int16_t *gsen_data_x, int16_t *gsen_data_y, int16_t *gsen_data_z); +bool tyhx_hrs_alg(int32_t new_raw_data, int16_t gsen_data_x, int16_t gsen_data_y, int16_t gsen_data_z); +hrs_results_t tyhx_hrs_alg_get_results(void); +void tyhx_hrs_set_alg_para(hrs_sports_mode_t sports_mode, uint16_t static_thre_val, uint8_t gsen_fun_lv_val); +void tyhx_hrs_set_living(uint8_t mode, uint8_t qu_thre, uint8_t st_thre); +HRS_ALG_INFO_T tyhx_get_hrs_alg_info(void); +#endif //HRS_ALG_LIB diff --git a/2.sdk/Helios_SDK/components/HX3918/tyhx_hrv_alg.h b/2.sdk/Helios_SDK/components/HX3918/tyhx_hrv_alg.h new file mode 100644 index 00000000..37bd4d84 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/tyhx_hrv_alg.h @@ -0,0 +1,64 @@ +#ifndef _TYHX_HRV_ALG_H_ +#define _TYHX_HRV_ALG_H_ +#endif + +#include + +// /* portable 8-bit unsigned integer */ +// typedef unsigned char uint8_t; +// /* portable 8-bit signed integer */ +// typedef signed char int8_t; +// /* portable 16-bit unsigned integer */ +// typedef unsigned short int uint16_t; +// /* portable 16-bit signed integer */ +// typedef signed short int int16_t; +// /* portable 32-bit unsigned integer */ +// typedef unsigned int uint32_t; +// /* portable 32-bit signed integer */ +// typedef signed int int32_t; + +#ifndef bool +#define bool unsigned char +#endif +#ifndef true +#define true 1 +#endif +#ifndef false +#define false 0 +#endif + +#define HRV_GLITCH_THRES 20000 +#define HRV_GSEN_POW_THRE 150 + +#ifdef HRV_ALG_LIB + +typedef enum { + MSG_HRV_ALG_NOT_OPEN, + MSG_HRV_ALG_OPEN, + MSG_HRV_READY, + MSG_HRV_ALG_TIMEOUT, +} hrv_alg_msg_code_t; + +typedef struct { + hrv_alg_msg_code_t hrv_alg_status; + uint32_t data_cnt; + uint8_t hrv_result; + uint32_t hrv_peak; + uint8_t spirit_pressure; + uint8_t p_m; + uint8_t screen_up; + uint8_t motion; + uint8_t signal_quality; +} hrv_results_t; + + +void tyhx_hrv_alg(int32_t new_raw_data); +bool tyhx_hrv_alg_open(void); +bool tyhx_hrv_alg_open_deep(void); +void tyhx_hrv_alg_close(void); +void kfft(double *pr,double *pi,int n,int k,double *fr,double *fi); + +hrv_results_t tyhx_hrv_alg_send_data(int32_t new_raw_data, int32_t green_data_als, int32_t infrared_data); +hrv_results_t tyhx_hrv_alg_send_bufdata(int32_t *new_raw_data, uint8_t count, int16_t *gsen_data_x, int16_t *gsen_data_y, int16_t *gsen_data_z); +#endif //HRV_ALG_LIB + diff --git a/2.sdk/Helios_SDK/components/HX3918/tyhx_spo2_alg.h b/2.sdk/Helios_SDK/components/HX3918/tyhx_spo2_alg.h new file mode 100644 index 00000000..dfe662a7 --- /dev/null +++ b/2.sdk/Helios_SDK/components/HX3918/tyhx_spo2_alg.h @@ -0,0 +1,164 @@ +#ifndef _SPO2_ALG_H_ +#define _SPO2_ALG_H_ +#endif +#include + +//version:3.3.17 + +//#include "tyhx_spo2_alg_para.h" + + +// /* portable 8-bit unsigned integer */ +// typedef unsigned char uint8_t; +// /* portable 8-bit signed integer */ +// typedef signed char int8_t; +// /* portable 16-bit unsigned integer */ +// typedef unsigned short int uint16_t; +// /* portable 16-bit signed integer */ +// typedef signed short int int16_t; +// /* portable 32-bit unsigned integer */ +// typedef unsigned int uint32_t; +// /* portable 32-bit signed integer */ +// typedef signed int int32_t; + +#ifndef bool +#define bool unsigned char +#endif + +#ifndef true +#define true 1 +#endif +#ifndef false +#define false 0 +#endif + + +#ifdef SPO2_ALG_LIB + +typedef enum { + MSG_SPO2_ALG_NOT_OPEN, + MSG_SPO2_ALG_OPEN, + MSG_SPO2_READY, + MSG_SPO2_ALG_TIMEOUT, + MSG_SPO2_END +} spo2_alg_msg_code_t; + +typedef enum { + MSG_SPO2_LIVING_INITIAL, + MSG_SPO2_LIVING_TRUE, + MSG_SPO2_LIVING_FAIL +} spo2_living_code_t; + +typedef enum { + SPO2_NORMAL_MODE, + SPO2_ALLDAY_MODE +} spo2_mode_t; + +typedef struct { + spo2_alg_msg_code_t spo2_alg_status; + spo2_living_code_t spo2_living_status; + uint32_t data_cnt; + uint8_t spo2_result; + uint8_t hr_result; + uint8_t block_cnt; + uint8_t ir_quality; + uint16_t reliable_score_result; + + uint8_t screen_up; + uint8_t motion; + uint8_t poor_signal; + + uint8_t signal_snr; + uint32_t signal_std; + +} spo2_results_t; + +typedef struct { + uint8_t screen_up; + uint8_t motion; + uint8_t poor_signal; +} spo2_gesture_recognize_t; + +typedef struct { + uint32_t data_cnt; + int32_t red_new_raw_data; + int32_t ir_new_raw_data; + int32_t green_new_raw_data; + int32_t ir_iir_data_filter_out; + int32_t ir_data_smooth; + int32_t red_iir_data_filter_out; + int32_t red_data_smooth; + uint8_t ir_offset_50; + uint8_t red_offset_50; + uint8_t green_offset_50; + int32_t ir_dc; + int32_t red_dc; + int32_t green_dc; + int32_t ir_data_o2_128; + int32_t red_data_o2_128; + int32_t green_data_o2_128; + int16_t red_ir_dc; + int16_t red_green_dc; + int16_t ir_green_dc; + int16_t ir_fft_snr; + int8_t motion_status; + uint8_t xcorr_max; + int16_t COUNT_IN_judge; + uint8_t spo2_result; + uint8_t count_block; + int32_t SaO2_data_temp; +} spo2_debug_t; + +typedef struct { + uint8_t red_offset_idac; + uint8_t ir_offset_idac; + uint8_t green_offset_idac; + uint16_t spo2_start_cnt; +} spo2_agcpara_t; + +typedef struct { + uint8_t XCORR_MODE; + uint8_t QUICK_RESULT; +} spo2_switch_t; + +typedef struct { + uint8_t SPO2_LOW_XCORR_THRE; + uint8_t SPO2_LOW_SNR_THRE; + uint8_t COUNT_BLOCK_NUM; + uint32_t SPO2_BASE_LINE_INIT; + uint32_t SPO2_SLOPE; + uint16_t SPO2_GSEN_POW_THRE; +} spo2_usuallyadjust_t; + +typedef struct { + uint16_t MEAN_NUM; + int32_t SOP2_DEGLITCH_THRE; + int32_t SPO2_REMOVE_JUMP_THRE; + uint16_t SPO2_LOW_CLIP_END_TIME; + uint16_t SPO2_LOW_CLIP_DN; + uint16_t SPO2_NORMAL_CLIP_DN; + uint16_t IR_AC_TOUCH_THRE; + uint16_t IR_FFT_POW_THRE; + uint8_t SPO2_CALI; + uint8_t SLOPE_PARA_MAX; + uint8_t SLOPE_PARA_MIN; +} spo2_barelychange_t; + +void tyhx_spo2_set_switch(uint8_t XCORR_MODE,uint8_t QUICK_RESULT); +void tyhx_spo2_para_usuallyadjust(uint8_t SPO2_LOW_XCORR_THRE,uint8_t SPO2_LOW_SNR_THRE,uint8_t COUNT_BLOCK_NUM,uint32_t SPO2_BASE_LINE_INIT,uint32_t SPO2_SLOPE,uint16_t SPO2_GSEN_POW_THRE); +void tyhx_spo2_para_barelychange(uint16_t MEAN_NUM,int32_t SOP2_DEGLITCH_THRE,int32_t SPO2_REMOVE_JUMP_THRE, \ + uint16_t SPO2_LOW_CLIP_END_TIME,uint16_t SPO2_LOW_CLIP_DN,uint16_t SPO2_NORMAL_CLIP_DN, \ + uint16_t IR_AC_TOUCH_THRE,uint16_t IR_FFT_POW_THRE,uint8_t SPO2_CALI,uint8_t SLOPE_PARA_MAX,uint8_t SLOPE_PARA_MIN); + +void tyhx_spo2_set_living(uint8_t living_mode, uint8_t qu_thre, uint8_t st_thre); +void tyhx_spo2_set_mode(spo2_mode_t mode); +bool tyhx_spo2_alg_send_data(int32_t *red_new_raw_data,int32_t *ir_new_raw_data,int32_t *green_new_raw_data,uint8_t R_LEDDAC,uint8_t IR_LEDDAC,uint8_t G_LEDDAC, int16_t *gsen_data_x, int16_t *gsen_data_y, int16_t *gsen_data_z, uint8_t dat_len); +void tyhx_spo2_alg(int32_t red_new_raw_data , int32_t ir_new_raw_data, int32_t green_new_raw_data,uint8_t R_LEDDAC,uint8_t IR_LEDDAC,uint8_t G_LEDDAC); +void tyhx_spo2_alg_close(void); +bool tyhx_spo2_alg_open(void); +bool tyhx_spo2_alg_open_deep(void); +spo2_results_t tyhx_spo2_alg_get_results(void); +spo2_debug_t tyhx_spo2_alg_debug_results(void); + +#endif + diff --git a/2.sdk/Helios_SDK/services/microPython/lib/lvgl/lv_conf.h b/2.sdk/Helios_SDK/services/microPython/lib/lvgl/lv_conf.h index 54bb9724..1f690280 100644 --- a/2.sdk/Helios_SDK/services/microPython/lib/lvgl/lv_conf.h +++ b/2.sdk/Helios_SDK/services/microPython/lib/lvgl/lv_conf.h @@ -193,7 +193,7 @@ /*Default Dot Per Inch. Used to initialize default sizes such as widgets sized, style paddings. *(Not so important, you can adjust it to modify default sizes and spaces)*/ -#define LV_DPI_DEF 130 /*[px/inch]*/ +#define LV_DPI_DEF 89 /*[px/inch]*/ /*======================= * FEATURE CONFIGURATION diff --git a/2.sdk/Helios_SDK/services/microPython/lib/lvgl/src/hal/lv_hal_indev.h b/2.sdk/Helios_SDK/services/microPython/lib/lvgl/src/hal/lv_hal_indev.h index 5bbcf530..450ad9ca 100644 --- a/2.sdk/Helios_SDK/services/microPython/lib/lvgl/src/hal/lv_hal_indev.h +++ b/2.sdk/Helios_SDK/services/microPython/lib/lvgl/src/hal/lv_hal_indev.h @@ -42,10 +42,10 @@ extern "C" { /*Gesture threshold in pixels*/ -#define LV_INDEV_DEF_GESTURE_LIMIT 50 +#define LV_INDEV_DEF_GESTURE_LIMIT 20 /*Gesture min velocity at release before swipe (pixels)*/ -#define LV_INDEV_DEF_GESTURE_MIN_VELOCITY 3 +#define LV_INDEV_DEF_GESTURE_MIN_VELOCITY 2 /********************** diff --git a/2.sdk/Helios_SDK/services/microPython/microPython.mk b/2.sdk/Helios_SDK/services/microPython/microPython.mk index 72a23da5..72b84586 100644 --- a/2.sdk/Helios_SDK/services/microPython/microPython.mk +++ b/2.sdk/Helios_SDK/services/microPython/microPython.mk @@ -261,6 +261,7 @@ QPY_SRCS = \ ports/quectel/core/source/modGsensor_SC7A20.c \ ports/quectel/core/source/modHsensor.c \ ports/quectel/core/source/modHsensor_GH3018.c \ + ports/quectel/core/source/modHsensor_HX3918.c \ ports/quectel/core/source/modrsa.c \ ports/quectel/core/source/utils_crc32.c \ ports/quectel/core/source/modwebserver.c \ @@ -680,6 +681,9 @@ ifeq ($(CONFIG_QRCODE), y) $(NAME)_COMPONENTS += components/qrcode endif +ifeq ($(CONFIG_HX3918), y) +$(NAME)_COMPONENTS += components/HX3918 +endif ifeq ($(CONFIG_GH301x), y) $(NAME)_COMPONENTS += components/GH301X endif diff --git a/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor.c b/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor.c index 21ec318a..41238909 100644 --- a/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor.c +++ b/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor.c @@ -35,19 +35,62 @@ #include "pyexec.h" #include "mphalport.h" - -#if 1 //MICROPY_QPY_Hsensor_GH3018 - -extern const mp_obj_type_t Hsensor_GH3018_type; - +#include "autoconf.h" +#if 1 // +#if CONFIG_GH301x +extern const mp_obj_type_t Hsensor_GH3018_type; +extern void GH3018_thread_do(void); +#endif +#if CONFIG_HX3918 +extern const mp_obj_type_t Hsensor_HX3918_type; +extern void HX3918_thread_do(void); +#endif +void sensor_thread_entry(void * argv) +{ + //GH3018_LOG("sensor_thread_entry: 11111111!!!!!!!!\r\n"); + + #if CONFIG_GH301x || CONFIG_HX3918 + while(1) + { + #if CONFIG_GH301x + GH3018_thread_do(); + #endif + #if CONFIG_HX3918 + HX3918_thread_do(); + #endif + } + #else + while(1) + { + #if CONFIG_SC7A20 + SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(); + #endif + Helios_msleep(1000); + + } + #endif + +} +Helios_Thread_t sensor_thread_id = 0; +void sensor_thread_entry(void * argv); +Helios_ThreadAttr ThreadAttr = { + .name = "HealthSensor", + .stack_size = 1024*20, + .priority = 100, + .entry = sensor_thread_entry, + .argv = NULL + }; STATIC const mp_rom_map_elem_t Hsensor_module_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_Hsensor) }, #if CONFIG_GH301x { MP_ROM_QSTR(MP_QSTR_GH3018), MP_ROM_PTR(&Hsensor_GH3018_type) }, +#endif +#if CONFIG_HX3918 + { MP_ROM_QSTR(MP_QSTR_HX3918), MP_ROM_PTR(&Hsensor_HX3918_type) }, #endif //TODO add other deriver }; diff --git a/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor_GH3018.c b/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor_GH3018.c index 08e19035..19595dea 100644 --- a/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor_GH3018.c +++ b/2.sdk/Helios_SDK/services/microPython/ports/quectel/core/source/modHsensor_GH3018.c @@ -19,15 +19,7 @@ #include "binary.h" #include -Helios_Thread_t sensor_thread_id = 0; -void sensor_thread_entry(void * argv); -Helios_ThreadAttr ThreadAttr = { - .name = "HealthSensor", - .stack_size = 1024*20, - .priority = 100, - .entry = sensor_thread_entry, - .argv = NULL - }; +#include "autoconf.h" #if CONFIG_GH301x #include "helios_gpio.h" @@ -41,8 +33,11 @@ Helios_ThreadAttr ThreadAttr = { #include "helios_debug.h" #include "gh3011_example.h" -#include "autoconf.h" + #define GH3018_LOG(msg, ...) custom_log("GH3018", msg, ##__VA_ARGS__) +extern void sensor_thread_entry(void * argv); +extern Helios_ThreadAttr ThreadAttr; +extern Helios_Thread_t sensor_thread_id ; ////////////////////////////////////////////////////////////////////////////// typedef struct _GH3018_obj_t { @@ -56,8 +51,8 @@ typedef struct _GH3018_obj_t } GH3018_obj_t; STATIC GH3018_obj_t *g_GH3018 = NULL; -static unsigned char is_gh3018 = 0;//是否存在IC -static unsigned char is_open_gh3018 = 0; //是否打开测试 +unsigned char is_gh3018 = 0;//是否存在IC +unsigned char is_open_gh3018 = 0; //是否打开测试 static unsigned char s_gh3018_heart_rate = 0x0;//心律 static unsigned char s_gh3018_high_blood = 0x0;//血压/高压 static unsigned char s_gh3018_low_blood = 0x0;//血压/低压 @@ -68,7 +63,7 @@ static unsigned char s_gh3018_wear_status = 0;//佩戴状态 unsigned char s_gh3018_heart_rate_buff[HEART_RATE_BUFF_LEN]={0}; unsigned short s_gh3018_heart_rate_buff_count = 0; -Helios_ThreadAttr ThreadAttr; + char GH3018_sleep_flag = 0; #include "helios_extint.h" @@ -85,12 +80,67 @@ extern signed char SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(void); extern unsigned char Gsensor_init_flag ; #endif -extern void hal_gh30x_int_handler(void); +extern void hal_gh30x_int_handler(void); +void GH3018_test(uint32_t mode); +void gh3018_close(void); char GH3018_irq_lock = 0; // int test_count1 = 0; // int test_count2 = 0; +void GH3018_thread_do(void) +{ + if(gh3018_run_mode == RUN_MODE_CLOSE) + { + gh3018_close(); + //GH3018_LOG("GH3018_irq_cb: 1111111111111!!!!!!!!\r\n"); + gh3018_run_mode = RUN_MODE_INVALID; + GH3018_irq_flag = 0; + return; + } + if(gh3018_run_mode != RUN_MODE_INVALID ) + { + GH3018_test(gh3018_run_mode); + + gh3018_run_mode = RUN_MODE_INVALID; + } + if(is_gh3018 == 1 && is_open_gh3018 == 1)//处理Hsensor中断数据 + { + if(GH3018_irq_flag) + { + GH3018_irq_lock = 1; + hal_gh30x_int_handler(); + + GH3018_irq_lock = 0; + //GH3018_LOG("GH3018_irq_cb: 1111111111111!!!!!!!!\r\n"); + //GH3018_LOG("hal_gh30x_int_handler:test_count1:%d test_count2:%d\r\n",test_count1,test_count2); + GH3018_irq_flag = 0; + } + if(timer_Gsensor_count>(1000/TIMER_TIME_MS))//1秒定时,轮询更新Gsensor数据 + { + timer_Gsensor_count = 0; + //Helios_msleep(5); + #if CONFIG_SC7A20 + SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(); + #endif + + } + } + else + { + #if CONFIG_SC7A20 + SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(); + #endif + Helios_msleep(1000); + if(GH3018_sleep_flag == 1) + { + GH3018_sleep_flag = 0; + Helios_msleep(3000); + } + } + Helios_msleep(5); + +} void sensor_timerout_cb(void); void GH3018_result_set_heart_rate(unsigned char heart_rate) @@ -168,8 +218,7 @@ STATIC mp_obj_t GH3018_make_new(const mp_obj_type_t *type, STATIC mp_obj_t mp_GH3018_init(mp_obj_t self_in); STATIC mp_obj_t mp_GH3018_deinit(mp_obj_t self_in); -void GH3018_test(uint32_t mode); -void gh3018_close(void); + void sensor_timerout_cb(void) @@ -460,73 +509,4 @@ const mp_obj_type_t Hsensor_GH3018_type = { #endif -void sensor_thread_entry(void * argv) -{ - //GH3018_LOG("sensor_thread_entry: 11111111!!!!!!!!\r\n"); - - #if CONFIG_GH301x - while(1) - { - - if(gh3018_run_mode == RUN_MODE_CLOSE) - { - gh3018_close(); - //GH3018_LOG("GH3018_irq_cb: 1111111111111!!!!!!!!\r\n"); - gh3018_run_mode = RUN_MODE_INVALID; - GH3018_irq_flag = 0; - continue; - } - if(gh3018_run_mode != RUN_MODE_INVALID ) - { - GH3018_test(gh3018_run_mode); - - gh3018_run_mode = RUN_MODE_INVALID; - } - if(is_gh3018 == 1 && is_open_gh3018 == 1)//处理Hsensor中断数据 - { - if(GH3018_irq_flag) - { - GH3018_irq_lock = 1; - hal_gh30x_int_handler(); - - GH3018_irq_lock = 0; - //GH3018_LOG("GH3018_irq_cb: 1111111111111!!!!!!!!\r\n"); - //GH3018_LOG("hal_gh30x_int_handler:test_count1:%d test_count2:%d\r\n",test_count1,test_count2); - GH3018_irq_flag = 0; - } - if(timer_Gsensor_count>(1000/TIMER_TIME_MS))//1秒定时,轮询更新Gsensor数据 - { - timer_Gsensor_count = 0; - //Helios_msleep(5); - #if CONFIG_SC7A20 - SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(); - #endif - - } - } - else - { - #if CONFIG_SC7A20 - SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(); - #endif - Helios_msleep(1000); - if(GH3018_sleep_flag == 1) - { - GH3018_sleep_flag = 0; - Helios_msleep(3000); - } - } - Helios_msleep(5); - } - #else - while(1) - { - #if CONFIG_SC7A20 - SL_SC7A20_PEDO_KCAL_WRIST_SLEEP_SWAY_L_ALGO(); - #endif - Helios_msleep(1000); - - } - #endif - -} +