From 4df74475d2fcc8c79f8176ed78e163a163317ca0 Mon Sep 17 00:00:00 2001 From: sunbeam Date: Fri, 27 Dec 2024 14:26:13 +0800 Subject: [PATCH] =?UTF-8?q?=E7=A7=BB=E6=A4=8DHOD=E5=88=9D=E7=89=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cva_asw_m0128/src/ad_button1.c | 144 ++++ cva_asw_m0128/src/ad_button1.h | 16 + cva_asw_m0128/src/appTask.c | 96 ++- cva_asw_m0128/src/canuser.c | 8 +- cva_asw_m0128/src/heat_NTC.c | 78 +++ cva_asw_m0128/src/heat_NTC.h | 6 + cva_asw_m0128/src/hod/hod.h | 34 + cva_asw_m0128/src/hod/hod_touchonly_20ms.c | 212 ++++++ cva_asw_m0128/src/hod/libtouch/libtouch.a | Bin 0 -> 34428 bytes cva_asw_m0128/src/hod/libtouch/touch_button.h | 216 ++++++ cva_asw_m0128/src/hod/libtouch/touch_drv.h | 625 ++++++++++++++++++ cva_asw_m0128/src/hod/libtouch/touch_slider.h | 239 +++++++ cva_asw_m0128/src/hod/libtouch/touch_trx.h | 196 ++++++ cva_asw_m0128/src/hod/touch_config.c | 108 +++ cva_asw_m0128/src/hod/touch_config.h | 64 ++ cva_asw_m0128/src/hod/touch_widget_config.c | 81 +++ cva_asw_m0128/src/hod/touch_widget_config.h | 66 ++ cva_asw_m0128/src/hwctrl.c | 21 +- cva_asw_m0128/src/key.c | 220 ++++++ cva_asw_m0128/src/key.h | 24 + cva_asw_m0128/src/user_can_config.c | 174 +++++ cva_asw_m0128/src/user_can_config.h | 8 + 22 files changed, 2625 insertions(+), 11 deletions(-) create mode 100644 cva_asw_m0128/src/ad_button1.c create mode 100644 cva_asw_m0128/src/ad_button1.h create mode 100644 cva_asw_m0128/src/heat_NTC.c create mode 100644 cva_asw_m0128/src/heat_NTC.h create mode 100644 cva_asw_m0128/src/hod/hod.h create mode 100644 cva_asw_m0128/src/hod/hod_touchonly_20ms.c create mode 100644 cva_asw_m0128/src/hod/libtouch/libtouch.a create mode 100644 cva_asw_m0128/src/hod/libtouch/touch_button.h create mode 100644 cva_asw_m0128/src/hod/libtouch/touch_drv.h create mode 100644 cva_asw_m0128/src/hod/libtouch/touch_slider.h create mode 100644 cva_asw_m0128/src/hod/libtouch/touch_trx.h create mode 100644 cva_asw_m0128/src/hod/touch_config.c create mode 100644 cva_asw_m0128/src/hod/touch_config.h create mode 100644 cva_asw_m0128/src/hod/touch_widget_config.c create mode 100644 cva_asw_m0128/src/hod/touch_widget_config.h create mode 100644 cva_asw_m0128/src/key.c create mode 100644 cva_asw_m0128/src/key.h create mode 100644 cva_asw_m0128/src/user_can_config.c create mode 100644 cva_asw_m0128/src/user_can_config.h diff --git a/cva_asw_m0128/src/ad_button1.c b/cva_asw_m0128/src/ad_button1.c new file mode 100644 index 0000000..a4ee899 --- /dev/null +++ b/cva_asw_m0128/src/ad_button1.c @@ -0,0 +1,144 @@ +/******************************************************************************* + * the includes + ******************************************************************************/ +#include "ad_button1.h" + + +/******************************************************************************* + * the defines + ******************************************************************************/ + +#define DMA_CHANNEL (0) +#define ADC_DEMO_LAST_CHANNLE (2u) +#define ADC_DEMO_CHANNLE_NUMBER (4u) + +/*ad_value = v * 1024 / 3.3 + v = ad_value * 3.3 / 1024 +*/ + +#define AD1_1 467 +#define AD1_2 653 +#define AD2_1 467 +#define AD2_2 653 + +#define AD3_1 467 +#define AD3_2 653 +#define AD3_3 0 + +#define AD_tolerance 50 +#define Key_Delay 10 + +/******************************************************************************* + * the typedefs + ******************************************************************************/ + +/******************************************************************************* + * the globals + ******************************************************************************/ + +volatile int32_t adcRawValue[ADC_DEMO_CHANNLE_NUMBER] = {0,0,0,0}; +uint16_t switch_count[7]; +unsigned char ad_button_state=0; + +/* Instance of MCU */ +extern McuType mcu; + + + +/******************************************************************************* + * the functions + ******************************************************************************/ + + +void adc_init(void) +{ + PinsDrv_SetMuxModeSel(&mcu.ptc, 2, PINSDRV_PIN_DISABLED); /*ntc_ad*/ + PinsDrv_SetMuxModeSel(&mcu.ptc, 3, PINSDRV_PIN_DISABLED); /*ad3*/ + PinsDrv_SetMuxModeSel(&mcu.ptc, 4, PINSDRV_PIN_DISABLED); /*ad2*/ + PinsDrv_SetMuxModeSel(&mcu.ptc, 5, PINSDRV_PIN_DISABLED); /*ad1*/ + + /* Configure ADC module */ + AdcDrv_ConfigType adcCfg; + AdcDrv_GetDefaultConfig(&adcCfg); + + adcCfg.trgSrcCfg.hwTrgSrc = ADCDRV_HW_TRGSRC_PDB; /* Use PDB output for trigger source */ + adcCfg.trgSrcCfg.pretrgSrc = ADCDRV_PRETRG_PDB_PRETRIGGER; /* Use PDB Pre-Trigger for ADC Pre-Trigger sources */ + adcCfg.avgEnable = true; /* Enable hardware average function */ + adcCfg.avgSamplesSel = ADCDRV_AVERAGE_32; /* Select 32 samples average */ + adcCfg.continuousMode = ADCDRV_ONESHOT; /* Select one-shot mode */ + + adcCfg.chnCfg[0].pCh = ADCDRV_PCH_TK_ADC18; + adcCfg.chnCfg[0].intEnable = true; + + adcCfg.chnCfg[1].pCh = ADCDRV_PCH_TK_ADC19; + adcCfg.chnCfg[1].intEnable = true; + adcCfg.chnCfg[2].pCh = ADCDRV_PCH_TK_ADC20; + adcCfg.chnCfg[2].intEnable = true; + adcCfg.chnCfg[3].pCh = ADCDRV_PCH_TK_ADC21; + adcCfg.chnCfg[3].intEnable = true; + + /* Enable ADC interrupts */ + IrqDrv_EnableIrq(ADC_IRQn); + + AdcDrv_Configure(&mcu.adcDrv, &adcCfg); + + /* Configure PDB module */ + uint32_t pdbFreq; + ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_PDB, &pdbFreq); + + PdbDrv_ConfigType pdbCfg; + PdbDrv_GetDefaultConfig(&pdbCfg); + + pdbCfg.trgInSel = PDBDRV_TRGSEL_TRGGER_SOFTWARE; /* Use software trigger source */ + pdbCfg.cMode = PDBDRV_CONT_CONTINUOUS; /* PDB operation in One-Shot mode */ + pdbCfg.prescalerFactor = PDBDRV_PRESCALER_128MULT; /* Counting uses the peripheral clock divided by MULT (the multiplication factor) */ + pdbCfg.mult = PDBDRV_MULT_FACTOR_40; /* Multiplication factor is 40 */ + pdbCfg.preTrgCfg.mode[0][0] = PDBDRV_PRETRG_DELAY_MODE; /* The first Pre-Trigger channel start with bypassed mode */ + pdbCfg.preTrgCfg.mode[0][1] = PDBDRV_PRETRG_BB_MODE; + pdbCfg.preTrgCfg.mode[0][2] = PDBDRV_PRETRG_BB_MODE; /* The others use Back-to-Back operation */ + pdbCfg.preTrgCfg.mode[0][3] = PDBDRV_PRETRG_BB_MODE; + pdbCfg.dlyCfg.modCnt = pdbFreq / 128 / 4000; /* Periodic triggering PDB in 1s*/ + pdbCfg.dlyCfg.dlyCnt[0][0] = 0; /* first channel don't need delay time*/ + PdbDrv_Configure(&mcu.pdbDrv, &pdbCfg); + + /* Enable PDB */ + PdbDrv_EnablePdb(&mcu.pdbDrv); + + /* Trigger PDB*/ + PdbDrv_SwtrigCmd(&mcu.pdbDrv); +} + + +void ad_key_scan(void) +{ + AD_switch_detect(adcRawValue[1],AD3_1,1,&switch_count[0]);//s11 + AD_switch_detect(adcRawValue[1],AD3_2,2,&switch_count[1]);//s12 + AD_switch_detect(adcRawValue[1],AD3_3,3,&switch_count[2]);//s13 + + AD_switch_detect(adcRawValue[2],AD2_1,4,&switch_count[3]);//s9 + AD_switch_detect(adcRawValue[2],AD2_2,5,&switch_count[4]);//s10 + + AD_switch_detect(adcRawValue[3],AD1_1,6,&switch_count[5]);//s7 + AD_switch_detect(adcRawValue[3],AD1_2,7,&switch_count[6]);//s8 + + +} + +void AD_switch_detect(int32_t adcRawValue,int32_t AD_mid1,uint8_t index,uint16_t *switch_count) +{ + if(adcRawValue<=AD_mid1+AD_tolerance && adcRawValue>=AD_mid1-AD_tolerance) + { + (*switch_count)++; + if((*switch_count)>=Key_Delay)//短按10改为20，5ms*20=100ms; + { + ad_button_state = 0x01 << (index-1); + } + } + else + { + *switch_count=0; + ad_button_state &= ~(1<< (index-1) ); + } +} + + diff --git a/cva_asw_m0128/src/ad_button1.h b/cva_asw_m0128/src/ad_button1.h new file mode 100644 index 0000000..68fadd6 --- /dev/null +++ b/cva_asw_m0128/src/ad_button1.h @@ -0,0 +1,16 @@ +#ifndef _AD_BUTTON1_H +#define _AD_BUTTON1_H +#include +#include "mcu.h" + +extern unsigned char ad_button_state; +extern volatile int32_t adcRawValue[4]; + + + + +void adc_init(void); +void ad_key_scan(void); +void AD_switch_detect(int32_t adcRawValue,int32_t AD_mid1,uint8_t index,uint16_t *switch_count); + +#endif \ No newline at end of file diff --git a/cva_asw_m0128/src/appTask.c b/cva_asw_m0128/src/appTask.c index 657867a..cd02f86 100644 --- a/cva_asw_m0128/src/appTask.c +++ b/cva_asw_m0128/src/appTask.c @@ -19,6 +19,10 @@ #define UDS_RECV_BUF (1026) #define UDS_SEND_BUF (128) +#define heat_level_low 80 +#define heat_level_mid 85 +#define heat_level_high 90 + /******************************************************************************* * the globals ******************************************************************************/ @@ -52,6 +56,34 @@ Uds_ParamsType udsParam = { }; +//DMK-RP-77C +volatile uint16_t adc_conv_val = 0; +volatile uint32_t adc_conv_cnt = 0; + + +volatile int16_t rawdata = 0; +volatile int16_t basedata = 0; +volatile int16_t diffdata = 0; +volatile uint16_t tempdata = 0; /* adc raw val, not temp. */ + +const hod_gpio_t hod_high_side1_pin = {&mcu.ptc, 10}; //pwm p1 +const hod_gpio_t hod_high_side2_pin = {&mcu.ptc, 11}; //pwm p2 +const hod_gpio_t hod_low_side_pin = {&mcu.ptc, 9}; //pwm n2 +const hod_gpio_t hod_heat_shd_pin = {&mcu.pta, 0}; //shd-en-pmos +const hod_gpio_t hod_sensor_pin = {&mcu.ptc, 13}; //hod pc13 +const hod_gpio_t hod_shd_pin = {&mcu.ptc, 12}; //shd + +uint8_t heat_min=heat_level_low; + +uint16_t tempdata1 = 0; /* adc raw val, not temp. */ +uint32_t temp_adc=0; +uint8_t heating = 0; +uint8_t heat_level = 0; +volatile uint8_t handing = 0; + +uint32_t hod_heating_duty = 0; /* control heating duty, 10 ~ 99. */ + + /******************************************************************************* * the functions ******************************************************************************/ @@ -77,7 +109,7 @@ void appTaskInit(void) { /* UDS init */ Uds_UserInit(&udsObj, &udsParam); - + while(!hod_init(timer_1ms)) {}; } void appTask(void) @@ -116,6 +148,68 @@ void appTask(void) gSystick1msCnt = 0; } + hod_task(timer_1ms); + heat_deal(); } } +void hod_upload_info_cb(int16_t raw, int16_t base, int16_t diff) +{ + rawdata = raw; + basedata = base; + diffdata = diff; +} + +void hod_touch_on_cb() +{ + handing = 1; +} + +void hod_touch_off_cb() +{ + handing = 0; +} + +void heat_deal(void) +{ + switch (heat_level) + { + case 1: + heat_min=heat_level_low; + break; + case 2: + heat_min=heat_level_mid; + break; + case 4: + heat_min=heat_level_high; + break; + default: + heat_min=heat_level_low; + break; + } + + tempdata < heat_min ? (hod_heating_duty = 80) : (hod_heating_duty = 20); +} + + +/* adc control, get adc raw data. */ + +void ADC_Handler() +{ + adc_conv_val += AdcDrv_GetRn(&mcu.adcDrv, 0); + adc_conv_cnt++; + + if (adc_conv_cnt == 64) + { + tempdata1 = (adc_conv_val >> 8) & 0xFF; + temp_adc = ((uint32_t)adc_conv_val)*4700; + temp_adc /= (65536-adc_conv_val); + tempdata = GetTempture(temp_adc); + adc_conv_val = 0; + adc_conv_cnt = 0; + } + + for(uint8_t i=1;i<4;i++){ + adcRawValue[i] = AdcDrv_GetRn(&mcu.adcDrv, i); + } +} diff --git a/cva_asw_m0128/src/canuser.c b/cva_asw_m0128/src/canuser.c index 22f4310..d9583e8 100644 --- a/cva_asw_m0128/src/canuser.c +++ b/cva_asw_m0128/src/canuser.c @@ -19,10 +19,13 @@ typedef enum { UDS_MSG_IDX_STD_RX_PHYS, UDS_MSG_IDX_STD_RX_FUNC, + UDS_MSG_IDX_STD_TX, + + UDS_MSG_IDX_STD_RX_TEST1, UDS_MSG_IDX_STD_RX_TEST2, UDS_MSG_IDX_STD_TX_TEST1, - UDS_MSG_IDX_STD_TX, + UDS_MSG_IDX_STD_TEST1, UDS_MSG_IDX_STD_TEST2, @@ -55,9 +58,10 @@ uint8_t txMsgBuf[8] = {0}; const FlexCanDrv_MsgCfgType msgCfgObj[UDS_MSG_IDX_NUM] = { {UDS_MSG_IDX_STD_RX_PHYS, 1, UDS_PHYS_RECV_MSG_ID, false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_PHYS */ {UDS_MSG_IDX_STD_RX_FUNC, 1, UDS_FUNC_RECV_MSG_ID, false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_FUNC */ + {UDS_MSG_IDX_STD_TX, 1, UDS_PHYS_RESP_MSG_ID, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */ {UDS_MSG_IDX_STD_RX_TEST1, 1, APP_RX_TEST1_MSG_ID, false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_FUNC */ {UDS_MSG_IDX_STD_RX_TEST2, 1, APP_RX_TEST2_MSG_ID, false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_RX_FUNC */ - {UDS_MSG_IDX_STD_TX, 1, UDS_PHYS_RESP_MSG_ID, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */ + {UDS_MSG_IDX_STD_TEST1, 1, APP_TX_TEST1_MSG_ID, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */ {UDS_MSG_IDX_STD_TEST2, 1, APP_TX_TEST2_MSG_ID, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, false, 0xFFFFFFFF}, /* CAN_MSGOBJ_STD_TX */ }; diff --git a/cva_asw_m0128/src/heat_NTC.c b/cva_asw_m0128/src/heat_NTC.c new file mode 100644 index 0000000..8e94d75 --- /dev/null +++ b/cva_asw_m0128/src/heat_NTC.c @@ -0,0 +1,78 @@ +#include "heat_NTC.h" + +const uint32_t g_heat_ntc_temp[166] = +{ + 202269, 191064, 180555, 170694, 161439, + 152747, 144581, 136905, 129688, 122899, + 116509, 110493, 104827, 99488, 94456, + 89710, 85233, 81008, 77019, 73252, + 69693, 66329, 63149, 60140, 57294, + 54600, 52049, 49633, 47344, 45174, + 43117, 41166, 39315, 37559, 35891, + 34307, 32803, 31373, 30015, 28723, + 27494, 26325, 25212, 24153, 23144, + 22184, 21268, 20396, 19564, 18771, + 18015, 17294, 16605, 15948, 15320, + 14720, 14148, 13600, 13077, 12577, + 12099, 11641, 11204, 10785, 10384, + 10000, 9632, 9280, 8943, 8620, + 8310, 8012, 7728, 7454, 7192, + 6940, 6699, 6467, 6244, 6030, + 5825, 5628, 5438, 5256, 5080, + 4912, 4750, 4594, 4444, 4300, + 4161, 4027, 3898, 3774, 3654, + 3539, 3428, 3322, 3219, 3119, + 3023, 2931, 2842, 2756, 2673, + 2593, 2516, 2441, 2369, 2299, + 2232, 2167, 2105, 2044, 1985, + 1929, 1874, 1821, 1770, 1720, + 1673, 1626, 1581, 1538, 1496, + 1455, 1416, 1378, 1341, 1305, + 1270, 1237, 1204, 1173, 1142, + 1113, 1084, 1056, 1029, 1003, + 977, 953, 929, 906, 883, + 861, 840, 819, 799, 780, + 761, 743, 725, 707, 691, + 674, 658, 643, 628, 613, + 599, 585, 572, 559, 546, + 534 +}; + +uint16_t GetTempture(uint32_t key) +{ + uint8_t low=0; //Êý×é×îСË÷ÒýÖµ + uint8_t high=165; //Êý×é×î´óË÷ÒýÖµ + uint8_t fac = 0; + uint32_t ht = 0; + uint32_t lt = 0; + uint32_t mid = 0; + if(key > g_heat_ntc_temp[1]) + { + return 0; + } + if(key < g_heat_ntc_temp[164]) + { + //return 1650; + return 165; + } + while(low<=high) + { + mid=(low+high)/2; + ht = (g_heat_ntc_temp[mid+1] + g_heat_ntc_temp[mid])/2;// + lt = (g_heat_ntc_temp[mid-1] + g_heat_ntc_temp[mid])/2; + if(key>=ht && key<=lt){ + //fac = (key - ht) * 10 / (lt - ht); + //return mid*10 + fac; + return mid; + } + else if(keyhighµÄÇé¿ö£¬ÕâÖÖÇé¿öÏÂkeyµÄÖµ´óÓÚarrÖÐ×î´óµÄÔªËØÖµ»òÕßkeyµÄֵСÓÚarrÖÐ×îСµÄÔªËØÖµ + +} \ No newline at end of file diff --git a/cva_asw_m0128/src/heat_NTC.h b/cva_asw_m0128/src/heat_NTC.h new file mode 100644 index 0000000..f0b2a91 --- /dev/null +++ b/cva_asw_m0128/src/heat_NTC.h @@ -0,0 +1,6 @@ +#ifndef _HEAT_NTC_H_ +#define _HEAT_NTC_H_ + +#include "mcu.h" +uint16_t GetTempture(uint32_t key); +#endif //_HEAT_NTC_H_ \ No newline at end of file diff --git a/cva_asw_m0128/src/hod/hod.h b/cva_asw_m0128/src/hod/hod.h new file mode 100644 index 0000000..30d3497 --- /dev/null +++ b/cva_asw_m0128/src/hod/hod.h @@ -0,0 +1,34 @@ +#ifndef __HOD_H__ +#define __HOD_H__ + +#include +#include "mcu.h" +#include "touch/touch_config.h" +#include "touch/touch_widget_config.h" + +typedef struct hod_gpio +{ + PinsDrvType *port; + uint32_t pin; +} hod_gpio_t; + +extern McuType mcu; + +extern uint32_t hod_heating_duty; +extern uint8_t heating; + +extern const hod_gpio_t hod_high_side1_pin; +extern const hod_gpio_t hod_high_side2_pin; +extern const hod_gpio_t hod_low_side_pin; +extern const hod_gpio_t hod_heat_shd_pin; +extern const hod_gpio_t hod_sensor_pin; +extern const hod_gpio_t hod_shd_pin; + +bool hod_init(uint32_t ticks); +void hod_task(uint32_t ticks); + +void hod_upload_info_cb(int16_t raw, int16_t base, int16_t diff); +void hod_touch_on_cb(); +void hod_touch_off_cb(); + +#endif /* __HOD_H__ */ \ No newline at end of file diff --git a/cva_asw_m0128/src/hod/hod_touchonly_20ms.c b/cva_asw_m0128/src/hod/hod_touchonly_20ms.c new file mode 100644 index 0000000..c7375eb --- /dev/null +++ b/cva_asw_m0128/src/hod/hod_touchonly_20ms.c @@ -0,0 +1,212 @@ +#include "hod.h" + +volatile uint8_t g_touchIrqFlag = 0; +volatile uint32_t g_touch_state = 0; +static TouchDrvType touchDrv; + +#define HEAT_HIGH_SIDE_INIT() PinsDrv_SetMuxModeSel(hod_high_side1_pin.port, hod_high_side1_pin.pin, PINSDRV_MUX_AS_GPIO);PinsDrv_SetPinDirection(hod_high_side1_pin.port, hod_high_side1_pin.pin, 1) +#define HEAT_HIGH_SIDE_ON() PinsDrv_SetPin(hod_high_side1_pin.port, hod_high_side1_pin.pin) +#define HEAT_HIGH_SIDE_OFF() PinsDrv_ClearPin(hod_high_side1_pin.port, hod_high_side1_pin.pin) + +#define HEAT_HIGH_SIDE2_INIT() PinsDrv_SetMuxModeSel(hod_high_side2_pin.port, hod_high_side2_pin.pin, PINSDRV_MUX_AS_GPIO);PinsDrv_SetPinDirection(hod_high_side2_pin.port, hod_high_side2_pin.pin, 1) +#define HEAT_HIGH_SIDE2_ON() PinsDrv_SetPin(hod_high_side2_pin.port, hod_high_side2_pin.pin) +#define HEAT_HIGH_SIDE2_OFF() PinsDrv_ClearPin(hod_high_side2_pin.port, hod_high_side2_pin.pin) + +#define HEAT_LOW_SIDE_INIT() PinsDrv_SetMuxModeSel(hod_low_side_pin.port, hod_low_side_pin.pin, PINSDRV_MUX_AS_GPIO);PinsDrv_SetPinDirection(hod_low_side_pin.port, hod_low_side_pin.pin, 1) +#define HEAT_LOW_SIDE_ON() PinsDrv_SetPin(hod_low_side_pin.port, hod_low_side_pin.pin) +#define HEAT_LOW_SIDE_OFF() PinsDrv_ClearPin(hod_low_side_pin.port, hod_low_side_pin.pin) + +#define HEAT_SHD_INIT() PinsDrv_SetMuxModeSel(hod_heat_shd_pin.port, hod_heat_shd_pin.pin, PINSDRV_MUX_AS_GPIO);PinsDrv_SetPinDirection(hod_heat_shd_pin.port, hod_heat_shd_pin.pin, 1) +#define HEAT_SHD_ON() PinsDrv_ClearPin(hod_heat_shd_pin.port, hod_heat_shd_pin.pin) +#define HEAT_SHD_OFF() PinsDrv_SetPin(hod_heat_shd_pin.port, hod_heat_shd_pin.pin) + +static uint32_t hod_init_ticks = 0; +static uint32_t hod_init_idx = 0; +bool hod_init(uint32_t ticks) +{ + bool ret = false; + + if (hod_init_ticks != ticks) + { + hod_init_ticks = ticks; + + switch (hod_init_idx) + { + case 0: + HEAT_HIGH_SIDE_INIT(); + HEAT_HIGH_SIDE2_INIT(); + HEAT_LOW_SIDE_INIT(); + HEAT_SHD_INIT(); + + HEAT_HIGH_SIDE_OFF(); + HEAT_HIGH_SIDE2_OFF(); + HEAT_LOW_SIDE_OFF(); + HEAT_SHD_ON(); + break; + case 5: + /* Initialize touch */ + PinsDrv_SetMuxModeSel(hod_sensor_pin.port, hod_sensor_pin.pin, PINSDRV_PIN_DISABLED); + PinsDrv_SetMuxModeSel(hod_shd_pin.port, hod_shd_pin.pin, PINSDRV_PIN_DISABLED); + ButtonDrv_Init(NULL, &g_button_cfg); + TouchDrv_Init(&touchDrv); + TouchDrv_Configure(&touchDrv, &g_touchCfg); + TouchDrv_Calibration(&touchDrv, 8192); + TouchDrv_CleanIrqState(&touchDrv); + g_touchIrqFlag = 0; + NVIC_EnableIRQ(TOUCH_IRQn); + break; + case 1000: + ret = true; + break; + default: + break; + } + hod_init_idx++; + } + + if (ret == true) + { + hod_init_ticks = 0; + hod_init_idx = 0; + } + + return ret; +} + +void TOUCH_Handler(void) +{ + TouchDrv_CleanIrqState(&touchDrv); + g_touchIrqFlag = 1; +} + +volatile static uint32_t hod_task_main_idx = 0; +volatile static uint32_t hod_task_sub_idx = 0; +volatile static uint32_t hod_task_last_ticks = 0; +volatile static uint32_t hod_task_heating_idx = 0; +void hod_task(uint32_t ticks) +{ + TouchDrv_InfoType info = {0}; + int16_t raw [TOUCH_SCAN_PHASE_NUM] = {0}; + int16_t base[TOUCH_SCAN_PHASE_NUM] = {0}; + int16_t diff[TOUCH_SCAN_PHASE_NUM] = {0}; + + if (hod_task_last_ticks != ticks) + { + hod_task_last_ticks = ticks; + + if (hod_task_main_idx == 0) + { + hod_task_heating_idx++; + switch (hod_task_sub_idx) + { + case 0: + TouchDrv_Start(&touchDrv, TOUCHDRV_AUTO_MODE); + hod_task_sub_idx++; + break; + case 1: + if (g_touchIrqFlag) hod_task_sub_idx++; + break; + case 2: + TouchDrv_Stop(&touchDrv); + info.irqState = TouchDrv_GetIrqState(&touchDrv); + info.proxState = TouchDrv_GetProxState(&touchDrv); + TouchDrv_GetRawdata(&touchDrv, 0, APP_TOUCH_SCAN_PHASE_NUM, raw); + info.raw = raw; + info.base = base; + info.diff = diff; + ButtonDrv_Process(NULL, &info); + + if (ButtonDrv_GetButtonEvent(NULL, 0) == BUTTON_STATE_ON) + { + if (g_touch_state == 0) + { + hod_touch_on_cb(); + } + g_touch_state = 1; + } + else if (ButtonDrv_GetButtonEvent(NULL, 0) == BUTTON_STATE_OFF) + { + if (g_touch_state == 1) + { + hod_touch_off_cb(); + } + g_touch_state = 0; + } + + raw[0] = ButtonDrv_GetButtonElemRawData(NULL, 0, 0); + base[0] = ButtonDrv_GetButtonElemBaseData(NULL, 0, 0); + diff[0] = ButtonDrv_GetButtonElemDiffData(NULL, 0, 0); + + hod_upload_info_cb(raw[0], base[0], diff[0]); + break; + default: + break; + } + if (hod_task_heating_idx >= 10 && hod_task_sub_idx == 2)//hod speed 20ms,50hz;10ms==100hz(>=10) + { + hod_task_heating_idx = 0; + hod_task_sub_idx = 0; + hod_task_main_idx = heating > 0 ? 1 : 0; + } + } + else + { + switch (hod_task_sub_idx) + { + case 3: + HEAT_SHD_OFF(); + break; + case 6: + HEAT_LOW_SIDE_ON(); + break; + case 9: + if (heating > 0) + { + HEAT_HIGH_SIDE2_ON(); + } + break; + case 12: + if (heating > 0) + { + HEAT_HIGH_SIDE_ON(); + } + break; + case 100: + HEAT_HIGH_SIDE_OFF(); + break; + case 103: + HEAT_HIGH_SIDE2_OFF(); + break; + case 106: + HEAT_LOW_SIDE_OFF(); + break; + case 109: + HEAT_SHD_ON(); + break; + case 112: + hod_task_sub_idx = 0; + hod_task_main_idx = 0; + hod_task_heating_idx = 0; + break; + default: + if (hod_task_sub_idx > 15 + && hod_task_sub_idx > hod_heating_duty + && hod_task_sub_idx < 100) + { + hod_task_heating_idx++; + if (hod_task_heating_idx == 3) + { + HEAT_HIGH_SIDE_OFF(); + } + else if (hod_task_heating_idx == 6) + { + HEAT_HIGH_SIDE2_OFF(); + } + } + break; + } + + if (hod_task_main_idx == 1) hod_task_sub_idx++; + } + } +} \ No newline at end of file diff --git a/cva_asw_m0128/src/hod/libtouch/libtouch.a b/cva_asw_m0128/src/hod/libtouch/libtouch.a new file mode 100644 index 0000000000000000000000000000000000000000..615217d698c93d6ce8655109ab97d33c31770e9a GIT binary patch literal 34428 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�qBb6zz(?0sd3bs4z4YpXFls#Xak?mIZroO5^ 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 NB2Ds)ah2qy{XexG=dJ(% literal 0 HcmV?d00001 diff --git a/cva_asw_m0128/src/hod/libtouch/touch_button.h b/cva_asw_m0128/src/hod/libtouch/touch_button.h new file mode 100644 index 0000000..96bec00 --- /dev/null +++ b/cva_asw_m0128/src/hod/libtouch/touch_button.h @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. + */ + +#ifndef _TOUCH_BUTTON_H_ +#define _TOUCH_BUTTON_H_ + +/*! \brief Contains public interface to various functions related + * to the driver of BUTTON module + */ + +/****************************************************************************** + * the includes + *****************************************************************************/ +#include +#include +#include +#include "touch_drv.h" + +/*! \addtogroup touch_button + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * the defines + *****************************************************************************/ + +/****************************************************************************** + * the typedefs + *****************************************************************************/ + +/*! \brief Touch button event type + */ +typedef enum +{ + BUTTON_STATE_OFF = 0x00, + BUTTON_STATE_ON, + BUTTON_STATE_NEED_RECALI, +} ButtonDrv_StateType; + +typedef struct +{ + uint8_t phase; + uint32_t thr; + uint32_t hyst; + uint8_t onDebNum; + uint8_t offDebNum; + uint16_t onMaxNum; + uint16_t rawFltCoef; + uint16_t baseFltPosCoef; + uint16_t baseFltNegCoef; +} ButtonDrv_ElemCfgType; + +typedef struct +{ + ButtonDrv_StateType state; + int32_t raw; + int32_t base; + int32_t diff; + uint16_t onCnt; + uint16_t offCnt; + uint8_t initFlag; +} ButtonDrv_ElemVarType; + +typedef struct +{ + uint8_t elementNum; + uint8_t autoDetectionEn; + ButtonDrv_ElemCfgType *elemsCfg; +} ButtonDrv_WidgetCfgType; + +typedef struct +{ + ButtonDrv_StateType event; + ButtonDrv_ElemVarType *elemsVar; +} ButtonDrv_WidgetVarType; + +/*! \brief Definition of Touch button driver configuration + */ +typedef struct +{ + uint8_t buttonNum; + + ButtonDrv_WidgetCfgType *buttonsCfg; + + ButtonDrv_WidgetVarType *buttonsVar; + + TouchDrv_CfgType *touchDrvCfg; +} ButtonDrv_CfgType; + +/*! \brief Definition of Touch button driver class + */ +typedef struct +{ + TouchDrvType *touchDrv; +} ButtonDrvType; + +/****************************************************************************** + * the globals + ******************************************************************************/ + +/****************************************************************************** + * the function prototypes + ******************************************************************************/ + +/*! \brief Initializes the Touch button module + * + * This function initializes Touch button driver by user configuration + * + * \param[in] obj : pointer to button driver instance + * \param[in] cfg : pointer to configuration structure + */ +void ButtonDrv_Init(ButtonDrvType *obj, ButtonDrv_CfgType *cfg); + +/*! \brief Touch button detection process + * + * This function poll Touch button event state + * + * \param[in] obj : pointer to Touch button driver instance + * \param[in] info : pointer to button element information + * + */ +uint8_t ButtonDrv_Process(ButtonDrvType *obj, TouchDrv_InfoType *info); + +/*! \brief Getting Touch button event state + * + * This function get Touch button event state + * + * \param[in] obj : pointer to Touch button driver instance + * \param[in] buttonIndex : touch button index + * \return touch button event state + * + */ +uint8_t ButtonDrv_GetButtonEvent(ButtonDrvType *obj, uint8_t buttonIndex); + +/*! \brief Get touch button element raw data + * + * This function for getting touch button element raw data + * + * \param[in] obj : pointer to Touch Button driver instance + * \param[in] buttonIndex : touch button index + * \param[in] elemIndex : touch button element index + * \return touch button raw data + * + */ +int32_t ButtonDrv_GetButtonElemRawData(ButtonDrvType *obj, uint8_t buttonIndex, uint8_t elemIndex); + +/*! \brief Get touch button element base data + * + * This function for getting touch button element base data + * + * \param[in] obj : pointer to Touch Button driver instance + * \param[in] buttonIndex : touch button index + * \param[in] elemIndex : touch button element index + * \return touch button base data + * + */ +int32_t ButtonDrv_GetButtonElemBaseData(ButtonDrvType *obj, uint8_t buttonIndex, uint8_t elemIndex); + +/*! \brief Get touch button element diff data + * + * This function for getting touch button element diff data + * + * \param[in] obj : pointer to Touch Button driver instance + * \param[in] buttonIndex : touch button index + * \param[in] elemIndex : touch button element index + * \return touch button diff data + * + */ +int32_t ButtonDrv_GetButtonElemDiffData(ButtonDrvType *obj, uint8_t buttonIndex, uint8_t elemIndex); + +/*! \brief Setting Touch button driver configuration + * + * This function set Touch button driver configuration + * + * \param[in] obj : pointer to Touch button driver instance + * \param[in] cfg : pointer to configuration data + * \param[in] len : configuration data length + * + */ +void ButtonDrv_SetCfg(void *obj, uint8_t *cfg, uint32_t len); + +/*! \brief Getting Touch button driver configuration + * + * This function get Touch button driver configuration + * + * \param[in] obj : pointer to Touch button driver instance + * \param[in] cfg : pointer to configuration data + * \param[in] len : configuration data length + * + */ +void ButtonDrv_GetCfg(void *obj, uint8_t *cfg, uint32_t len); + +#ifdef __cplusplus +} +#endif /* extern "C" */ + +/*! @}*/ + +#endif diff --git a/cva_asw_m0128/src/hod/libtouch/touch_drv.h b/cva_asw_m0128/src/hod/libtouch/touch_drv.h new file mode 100644 index 0000000..3f601a5 --- /dev/null +++ b/cva_asw_m0128/src/hod/libtouch/touch_drv.h @@ -0,0 +1,625 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. + */ + +#ifndef _TOUCH_DRV_H_ +#define _TOUCH_DRV_H_ + +/*! \brief Contains public interface to various functions related + * to the driver of UART module + */ + +/****************************************************************************** + * the includes + *****************************************************************************/ +#include +#include +#include + +/*! \addtogroup proc_drv + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * the defines + *****************************************************************************/ +#define TOUCH_SCAN_PHASE_NUM 30 +#define TOUCH_ND_PHASE_NUM 30 + +#define TOUCHDRV_UNUSED(p) ((void)(p)) + +#define BIT_MASK32(n) ((uint32_t)1 << (n)) + +#define TOUCH_DRV_COM_BYTES_TO_WORD(a, b) (((a) & 0x00FF) | (((b) << 8) & 0xFF00)) +#define TOUCH_DRV_COM_BYTES_TO_DWORD(a, b, c, d) (((a) & 0x000000FF) | (((b) << 8) & 0x0000FF00) | (((c) << 16) & 0x00FF0000) | (((d) << 24) & 0xFF000000)) + +#define TOUCH_DRV_GET_BYTE0_FROM_WORD(a) ((a) & 0xFF) +#define TOUCH_DRV_GET_BYTE1_FROM_WORD(a) (((a) >> 8) & 0xFF) + +#define TOUCH_DRV_GET_BYTE0_FROM_DWORD(a) ((a) & 0xFF) +#define TOUCH_DRV_GET_BYTE1_FROM_DWORD(a) (((a) >> 8) & 0xFF) +#define TOUCH_DRV_GET_BYTE2_FROM_DWORD(a) (((a) >> 16) & 0xFF) +#define TOUCH_DRV_GET_BYTE3_FROM_DWORD(a) (((a) >> 24) & 0xFF) + +/****************************************************************************** + * the typedefs + *****************************************************************************/ + +/*! \brief Touch Phase index + */ +typedef enum +{ + TOUCHDRV_Phase0 = 0, + TOUCHDRV_Phase1 = 1, + TOUCHDRV_Phase2 = 2, + TOUCHDRV_Phase3 = 3, + TOUCHDRV_Phase4 = 4, + TOUCHDRV_Phase5 = 5, + TOUCHDRV_Phase6 = 6, + TOUCHDRV_Phase7 = 7, + TOUCHDRV_Phase8 = 8, + TOUCHDRV_Phase9 = 9, + TOUCHDRV_Phase10 = 10, + TOUCHDRV_Phase11 = 11, + TOUCHDRV_Phase12 = 12, + TOUCHDRV_Phase13 = 13, + TOUCHDRV_Phase14 = 14, + TOUCHDRV_Phase15 = 15, + TOUCHDRV_Phase16 = 16, + TOUCHDRV_Phase17 = 17, + TOUCHDRV_Phase18 = 18, + TOUCHDRV_Phase19 = 19, + TOUCHDRV_Phase20 = 20, + TOUCHDRV_Phase21 = 21, + TOUCHDRV_Phase22 = 22, + TOUCHDRV_Phase23 = 23, + TOUCHDRV_Phase24 = 24, + TOUCHDRV_Phase25 = 25, + TOUCHDRV_Phase26 = 26, + TOUCHDRV_Phase27 = 27, + TOUCHDRV_Phase28 = 28, + TOUCHDRV_Phase29 = 29, + TOUCHDRV_Phase30 = 30, + TOUCHDRV_Phase31 = 31, + TOUCHDRV_Phase32 = 32, + TOUCHDRV_Phase33 = 33, + TOUCHDRV_Phase34 = 34, + TOUCHDRV_Phase35 = 35, + TOUCHDRV_Phase36 = 36, + TOUCHDRV_Phase37 = 37, + TOUCHDRV_Phase38 = 38, + TOUCHDRV_Phase39 = 39, + TOUCHDRV_Phase40 = 40, + TOUCHDRV_Phase41 = 41, + TOUCHDRV_Phase42 = 42, + TOUCHDRV_Phase43 = 43, + TOUCHDRV_Phase44 = 44, + TOUCHDRV_Phase45 = 45, + TOUCHDRV_Phase46 = 46, + TOUCHDRV_Phase47 = 47, + TOUCHDRV_Phase48 = 48, + TOUCHDRV_Phase49 = 49, + TOUCHDRV_Phase50 = 50, + TOUCHDRV_Phase51 = 51, + TOUCHDRV_Phase52 = 52, + TOUCHDRV_Phase53 = 53, + TOUCHDRV_Phase54 = 54, + TOUCHDRV_Phase55 = 55, + TOUCHDRV_Phase56 = 56, + TOUCHDRV_Phase57 = 57, + TOUCHDRV_Phase58 = 58, + TOUCHDRV_Phase59 = 59, +} TouchDrv_Phase; + +/*! \brief Touch Phase mask + */ +typedef enum +{ + TOUCHDRV_PhaseNone_MASK = 0x00000000, + TOUCHDRV_Phase0_MASK = BIT_MASK32(0), + TOUCHDRV_Phase1_MASK = BIT_MASK32(1), + TOUCHDRV_Phase2_MASK = BIT_MASK32(2), + TOUCHDRV_Phase3_MASK = BIT_MASK32(3), + TOUCHDRV_Phase4_MASK = BIT_MASK32(4), + TOUCHDRV_Phase5_MASK = BIT_MASK32(5), + TOUCHDRV_Phase6_MASK = BIT_MASK32(6), + TOUCHDRV_Phase7_MASK = BIT_MASK32(7), + TOUCHDRV_Phase8_MASK = BIT_MASK32(8), + TOUCHDRV_Phase9_MASK = BIT_MASK32(9), + TOUCHDRV_Phase10_MASK = BIT_MASK32(10), + TOUCHDRV_Phase11_MASK = BIT_MASK32(11), + TOUCHDRV_Phase12_MASK = BIT_MASK32(12), + TOUCHDRV_Phase13_MASK = BIT_MASK32(13), + TOUCHDRV_Phase14_MASK = BIT_MASK32(14), + TOUCHDRV_Phase15_MASK = BIT_MASK32(15), + TOUCHDRV_Phase16_MASK = BIT_MASK32(16), + TOUCHDRV_Phase17_MASK = BIT_MASK32(17), + TOUCHDRV_Phase18_MASK = BIT_MASK32(18), + TOUCHDRV_Phase19_MASK = BIT_MASK32(19), + TOUCHDRV_Phase20_MASK = BIT_MASK32(20), + TOUCHDRV_Phase21_MASK = BIT_MASK32(21), + TOUCHDRV_Phase22_MASK = BIT_MASK32(22), + TOUCHDRV_Phase23_MASK = BIT_MASK32(23), + TOUCHDRV_Phase24_MASK = BIT_MASK32(24), + TOUCHDRV_Phase25_MASK = BIT_MASK32(25), + TOUCHDRV_Phase26_MASK = BIT_MASK32(26), + TOUCHDRV_Phase27_MASK = BIT_MASK32(27), + TOUCHDRV_Phase28_MASK = BIT_MASK32(28), + TOUCHDRV_Phase29_MASK = BIT_MASK32(29), + TOUCHDRV_PhaseAll_MASK = 0x3FFFFFFF, +} TouchDrv_Phase_Mask; + +/*! \brief Noise Detection Phase mask + */ +typedef enum +{ + TOUCHDRV_Nd_PhaseNone_MASK = 0x00000000, + TOUCHDRV_Phase30_MASK = BIT_MASK32(0), + TOUCHDRV_Phase31_MASK = BIT_MASK32(1), + TOUCHDRV_Phase32_MASK = BIT_MASK32(2), + TOUCHDRV_Phase33_MASK = BIT_MASK32(3), + TOUCHDRV_Phase34_MASK = BIT_MASK32(4), + TOUCHDRV_Phase35_MASK = BIT_MASK32(5), + TOUCHDRV_Phase36_MASK = BIT_MASK32(6), + TOUCHDRV_Phase37_MASK = BIT_MASK32(7), + TOUCHDRV_Phase38_MASK = BIT_MASK32(8), + TOUCHDRV_Phase39_MASK = BIT_MASK32(9), + TOUCHDRV_Phase40_MASK = BIT_MASK32(10), + TOUCHDRV_Phase41_MASK = BIT_MASK32(11), + TOUCHDRV_Phase42_MASK = BIT_MASK32(12), + TOUCHDRV_Phase43_MASK = BIT_MASK32(13), + TOUCHDRV_Phase44_MASK = BIT_MASK32(14), + TOUCHDRV_Phase45_MASK = BIT_MASK32(15), + TOUCHDRV_Phase46_MASK = BIT_MASK32(16), + TOUCHDRV_Phase47_MASK = BIT_MASK32(17), + TOUCHDRV_Phase48_MASK = BIT_MASK32(18), + TOUCHDRV_Phase49_MASK = BIT_MASK32(19), + TOUCHDRV_Phase50_MASK = BIT_MASK32(20), + TOUCHDRV_Phase51_MASK = BIT_MASK32(21), + TOUCHDRV_Phase52_MASK = BIT_MASK32(22), + TOUCHDRV_Phase53_MASK = BIT_MASK32(23), + TOUCHDRV_Phase54_MASK = BIT_MASK32(24), + TOUCHDRV_Phase55_MASK = BIT_MASK32(25), + TOUCHDRV_Phase56_MASK = BIT_MASK32(26), + TOUCHDRV_Phase57_MASK = BIT_MASK32(27), + TOUCHDRV_Phase58_MASK = BIT_MASK32(28), + TOUCHDRV_Phase59_MASK = BIT_MASK32(29), + TOUCHDRV_Nd_PhaseAll_MASK = 0x3FFFFFFF, +} TouchDrv_Nd_Phase_Mask; + +/*! \brief Touch driver status. + */ +typedef enum +{ + /* Generic error codes */ + TOUCHDRV_STATUS_SUCCESS = 0x000U, /*!< Generic operation success status */ + TOUCHDRV_STATUS_ERROR = 0x001U, /*!< Generic operation failure status */ + TOUCHDRV_STATUS_BUSY = 0x002U, /*!< Generic operation busy status */ + TOUCHDRV_STATUS_TIMEOUT = 0x003U, /*!< Generic operation timeout status */ + TOUCHDRV_STATUS_UNSUPPORTED = 0x004U, /*!< Generic operation unsupported status */ +} TouchDrv_Status; + +/*! \brief Touch sensing mode. + */ +typedef enum +{ + TOUCHDRV_SELF_LIGHT = 0x00u, /*!< Sensing method for self-light. */ + TOUCHDRV_SELF_HEAVY, /*!< Sensing method for self-heavy. */ + TOUCHDRV_ND, /*!< Sensing method for noise detection. */ + TOUCHDRV_MUTUAL, /*!< Sensing method for mutual. */ +} TouchDrv_Sense_Method; + +/*! \brief Touch CSIO pad function + */ +typedef enum +{ + TOUCHDRV_CSIO_FUNC_NONE = 0x00u, /*!< CSIO function for none.*/ + TOUCHDRV_CSIO_FUNC_INPUT = 0x01u, /*!< CSIO function for Input.*/ + TOUCHDRV_CSIO_FUNC_SHD = 0x02u, /*!< CSIO function for Shielding.*/ + TOUCHDRV_CSIO_FUNC_TX = 0x03u, /*!< CSIO function for mutual tx.*/ + TOUCHDRV_CSIO_FUNC_GND = 0x04u, /*!< CSIO function for GND.*/ + TOUCHDRV_CSIO_FUNC_VCM = 0x05u, /*!< CSIO function for VCM.*/ +} TouchDrv_CsioFuncType; + +/*! \brief Touch Sampling number + */ +typedef enum +{ + TOUCHDRV_NSMP_64 = 0x02u, /*!< Sampling number for 64.*/ + TOUCHDRV_NSMP_128 = 0x03u, /*!< Sampling number for 128.*/ + TOUCHDRV_NSMP_256 = 0x04u, /*!< Sampling number for 256.*/ + TOUCHDRV_NSMP_512 = 0x05u, /*!< Sampling number for 512.*/ + TOUCHDRV_NSMP_1024 = 0x06u, /*!< Sampling number for 1024.*/ + TOUCHDRV_NSMP_2048 = 0x07u, /*!< Sampling number for 2048.*/ +} TouchDrv_Sense_Nsmp; + +/*! \brief Touch Auto-Detection filter coefficient + */ +typedef enum +{ + TOUCHDRV_FLT_COEF_BYPASS = 0x00u, /*!< Auto-Detection filter bypass.*/ + TOUCHDRV_FLT_COEF_1, /*!< Auto-Detection filter intensity 1.*/ + TOUCHDRV_FLT_COEF_2, /*!< Auto-Detection filter intensity 2.*/ + TOUCHDRV_FLT_COEF_3, /*!< Auto-Detection filter intensity 3.*/ + TOUCHDRV_FLT_COEF_4, /*!< Auto-Detection filter intensity 4.*/ + TOUCHDRV_FLT_COEF_5, /*!< Auto-Detection filter intensity 5.*/ + TOUCHDRV_FLT_COEF_6, /*!< Auto-Detection filter intensity 6.*/ + TOUCHDRV_FLT_COEF_7, /*!< Auto-Detection filter intensity 7.*/ + TOUCHDRV_FLT_COEF_8, /*!< Auto-Detection filter intensity 8.*/ + TOUCHDRV_FLT_COEF_9, /*!< Auto-Detection filter intensity 9.*/ + TOUCHDRV_FLT_COEF_10, /*!< Auto-Detection filter intensity 10.*/ + TOUCHDRV_FLT_COEF_11, /*!< Auto-Detection filter intensity 11.*/ +} TouchDrv_FltCoefType; + +/*! \brief Touch Auto-Detection debounce number + */ +typedef enum +{ + TOUCHDRV_DEB_NUM_1 = 0x00u, /*!< Auto-Detection debounce bypass.*/ + TOUCHDRV_DEB_NUM_2, /*!< Auto-Detection debounce number: 2.*/ + TOUCHDRV_DEB_NUM_4, /*!< Auto-Detection debounce number: 4.*/ + TOUCHDRV_DEB_NUM_8, /*!< Auto-Detection debounce number: 8.*/ +} TouchDrv_DebNumType; + +/*! \brief Touch Auto-Detection hysteresis intensity + */ +typedef enum +{ + TOUCHDRV_HYST_BYPASS = 0x00u, /*!< Auto-Detection hysteresis bypass.*/ + TOUCHDRV_HYST_WEAK, /*!< Auto-Detection hysteresis intensity: weak.*/ + TOUCHDRV_HYST_MEDIUM, /*!< Auto-Detection hysteresis intensity: medium.*/ + TOUCHDRV_HYST_STRONG, /*!< Auto-Detection hysteresis intensity: strong.*/ +} TouchDrv_HystCoefType; + +/*! \brief Touch Auto-Detection doze mode scan period multiple + */ +typedef enum +{ + TOUCHDRV_DOZE_MUL_BYPASS = 0x00u, /*!< Auto-Detection doze mode bypass.*/ + TOUCHDRV_DOZE_MUL_2, /*!< Auto-Detection doze mode scan period multiple equal 2.*/ + TOUCHDRV_DOZE_MUL_4, /*!< Auto-Detection doze mode scan period multiple equal 4.*/ + TOUCHDRV_DOZE_MUL_8, /*!< Auto-Detection doze mode scan period multiple equal 8.*/ + TOUCHDRV_DOZE_MUL_16, /*!< Auto-Detection doze mode scan period multiple equal 16.*/ + TOUCHDRV_DOZE_MUL_32, /*!< Auto-Detection doze mode scan period multiple equal 32.*/ + TOUCHDRV_DOZE_MUL_64, /*!< Auto-Detection doze mode scan period multiple equal 64.*/ +} TouchDrv_DozeMulType; + +/*! \brief Touch sampling mode. + */ +typedef enum +{ + TOUCHDRV_MANUAL_MODE = 0x00u, /*!< Manual mode Scan */ + TOUCHDRV_AUTO_MODE, /*!< Auto mode Scan */ + TOUCHDRV_INIT_MODE +} TouchDrv_Mode; + +/*! \brief Touch command. + */ +typedef enum +{ + FSMDRV_HOST_SCAN = 0x0Au, /*!< Start Scan */ + FSMDRV_HOST_IDLE = 0x0Bu, /*!< go idle */ + FSMDRV_HOST_COMP = 0x0Eu, /*!< go compensation */ +} FsmDrvHostCmd; + +/*! \brief Touch state. + */ +typedef enum +{ + TOUCHDRV_FSM_STATE_INIT = 0x00u, /*!< Touch FSM state: inited. */ + TOUCHDRV_FSM_STATE_IDLE, /*!< Touch FSM state: idle. */ + TOUCHDRV_FSM_STATE_BRANCH, /*!< Touch FSM state: branch. */ + TOUCHDRV_FSM_STATE_COMPENSATION, /*!< Touch FSM state: auto-calibrating. */ + TOUCHDRV_FSM_STATE_SENSING, /*!< Touch FSM state: sensing. */ + TOUCHDRV_FSM_STATE_SUSPEND, /*!< Touch FSM state: suspending. */ + TOUCHDRV_FSM_STATE_WAIT, /*!< Touch FSM state: waitting. */ +} TouchDrv_Fsm_State; + +/*! \brief Touch IRQ enable. + */ +typedef enum +{ + TOUCHDRV_IRQ_DISABLE = 0x0000, /*!< Touch interrupt request: none. */ + TOUCHDRV_IRQ_TOUCH_EN = 0x0002, /*!< Touch interrupt request: any phase change to touch state from no-touch state. */ + TOUCHDRV_IRQ_NOTOUCH_EN = 0x0004, /*!< Touch interrupt request: any phase change to no-touch state from touch state. */ + TOUCHDRV_IRQ_CALIDONE_EN = 0x0008, /*!< Touch interrupt request: calibration done. */ + TOUCHDRV_IRQ_CONVDONE_EN = 0x0010, /*!< Touch interrupt request: sampling done. */ + TOUCHDRV_IRQ_ND_EN = 0x0040, /*!< Touch interrupt request: noise detection. */ + TOUCHDRV_IRQ_AUTOCALI_EN = 0x0080, /*!< Touch interrupt request: auto-calibration. */ + TOUCHDRV_IRQ_TOUCHAND_EN = 0x0100, /*!< Touch interrupt request: all phase change to touch state from no-touch state. */ + TOUCHDRV_IRQ_NOTOUCHAND_EN = 0x0200, /*!< Touch interrupt request: all phase change to no-touch state from touch state. */ +} TouchDrv_IrqEnType; + +/*! \brief touch instance pointer */ +typedef struct _TouchDrvType_ +{ + void *afecReg; + void *procReg; + void *fsmReg; +} TouchDrvType; + +/*! \brief Definition of touch phase configuration + */ +typedef struct +{ + uint8_t phaseIndex; /*!< phase index.*/ + + uint32_t tk00Func: 3; /*!< CSIO0 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk01Func: 3; /*!< CSIO1 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk02Func: 3; /*!< CSIO2 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk03Func: 3; /*!< CSIO3 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk04Func: 3; /*!< CSIO4 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk05Func: 3; /*!< CSIO5 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk06Func: 3; /*!< CSIO6 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk07Func: 3; /*!< CSIO7 function, refer TouchDrv_CsioFuncType.*/ + uint32_t : 0; + + uint32_t tk08Func: 3; /*!< CSIO0 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk09Func: 3; /*!< CSIO1 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk10Func: 3; /*!< CSIO2 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk11Func: 3; /*!< CSIO3 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk12Func: 3; /*!< CSIO4 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk13Func: 3; /*!< CSIO5 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk14Func: 3; /*!< CSIO6 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk15Func: 3; /*!< CSIO7 function, refer TouchDrv_CsioFuncType.*/ + uint32_t : 0; + + uint32_t tk16Func: 3; /*!< CSIO0 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk17Func: 3; /*!< CSIO1 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk18Func: 3; /*!< CSIO2 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk19Func: 3; /*!< CSIO3 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk20Func: 3; /*!< CSIO4 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk21Func: 3; /*!< CSIO5 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk22Func: 3; /*!< CSIO6 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk23Func: 3; /*!< CSIO7 function, refer TouchDrv_CsioFuncType.*/ + uint32_t : 0; + + uint32_t tk24Func: 3; /*!< CSIO0 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk25Func: 3; /*!< CSIO1 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk26Func: 3; /*!< CSIO2 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk27Func: 3; /*!< CSIO3 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk28Func: 3; /*!< CSIO4 function, refer TouchDrv_CsioFuncType.*/ + uint32_t tk29Func: 3; /*!< CSIO5 function, refer TouchDrv_CsioFuncType.*/ + uint32_t trst: 3; + uint32_t td: 4; + uint32_t : 0; + + uint32_t afeMode: 2; /*!< Sampling number, refer TouchDrv_SampleNumType.*/ + uint32_t bitSel: 5; /*!< Sampling frequency, refer TouchDrv_FreqType.*/ + uint32_t cf: 4; /*!< Sampling number, refer TouchDrv_SampleNumType.*/ + uint32_t rf: 4; /*!< Sampling number, refer TouchDrv_SampleNumType.*/ + uint32_t rfEn: 1; /*!< Sampling number, refer TouchDrv_SampleNumType.*/ + uint32_t freq: 7; /*!< Sampling number, refer TouchDrv_SampleNumType.*/ + uint32_t num: 3; /*!< Sampling number, refer TouchDrv_SampleNumType.*/ + uint32_t : 0; + + uint16_t adcFltEn: 1; /*!< adc filter enable.*/ + uint16_t adcFltWin: 2; /*!< adc filter window.*/ + uint16_t adcFltInCoef: 2; /*!< adc filter in-coef.*/ + uint16_t adcFltUnderCoef: 2;/*!< adc filter under-coef*/ + uint16_t adcFltOverCoef: 2; /*!< adc filter over-coef*/ + uint16_t : 0; + + uint16_t rawFltCoef: 3; /*!< Raw data filter coefficient, refer TouchDrv_FltCoefType, range in [TOUCHDRV_FLT_COEF_BYPASS, TOUCHDRV_FLT_COEF_7].*/ + uint16_t avgFltPosCoef: 4; /*!< Avg filter positive coefficient, refer TouchDrv_FltCoefType, range in [TOUCHDRV_FLT_COEF_BYPASS, TOUCHDRV_FLT_COEF_11].*/ + uint16_t avgFltNegCoef: 3; /*!< Avg filter negative coefficient, refer TouchDrv_FltCoefType, range in [TOUCHDRV_FLT_COEF_BYPASS, TOUCHDRV_FLT_COEF_7].*/ + uint16_t autoCaliDebNum: 2; /*!< Auto-calibration debounce coefficient, refer TouchDrv_DebNumType.*/ + uint16_t : 0; + + uint32_t autoCaliPosThr: 16;/*!< auto-calibration positive threshold, range in [0, 65535].*/ + uint32_t autoCaliNegThr: 16;/*!< auto-calibration negative threshold, range in [0, 65535].*/ + + uint32_t thr: 16; /*!< Touch threshold, range in [0, 65535].*/ + uint32_t thrHyst: 3; /*!< Touch threshold hysteresis coefficient, refer TouchDrv_HystCoefType.*/ + + uint16_t touchDebNum: 8; /*!< touch debouncer, range in [0, 255].*/ + uint16_t noTouchDebNum: 8; /*!< no-touch debouncer, range in [0, 255].*/ +} TouchDrv_PhaseCfgType; + +/*! \brief Definition of touch driver configuration + */ +typedef struct +{ + const TouchDrv_PhaseCfgType *phaseCfg; /*!< Phase configuration, refer TouchDrv_PhaseCfgType.*/ + uint8_t phaseCfgNum; /*!< Total phase number.*/ + + uint16_t irqEn; /*!< Interrupt requst enable, refer TouchDrv_IrqEnType.*/ + uint16_t scanPeriod; /*!< Scan period, range in [1ms, 4000ms] by 1ms step.*/ + TouchDrv_DozeMulType dozeMul; /*!< Doze mode scan period multiple, refer TouchDrv_DozeMulType.*/ + uint32_t sensingPhaseSel; /*!< Sensing phase selection.*/ + uint32_t autoDetectionPhaseSel; /*!< Auto detection phase selection.*/ + uint32_t ndPhaseSel; /*!< Noise detection phase selection.*/ + uint32_t touchAndSel; /*!< Touch phase selection when touch-and function enabled.*/ + uint32_t noTouchAndSel; /*!< No-Touch phase selection when no-touch-and function enabled.*/ + uint8_t senScen; +} TouchDrv_CfgType; + +/*! \brief Definition of touch driver information + */ +typedef struct _TouchDrv_Info_ +{ + uint32_t irqState; /*!< Touch interrupt state.*/ + uint32_t proxState; /*!< Phase state by Auot-Detecion.*/ + int16_t *raw; /*!< Raw data.*/ + int16_t *base; /*!< Basedata.*/ + int16_t *diff; /*!< Diff data.*/ +} TouchDrv_InfoType; + +/****************************************************************************** + * the globals + ******************************************************************************/ + +/****************************************************************************** + * the function prototypes + ******************************************************************************/ + +/*! \brief Initializes the Touch driver module + * + * This function initializes Touch driver by setting the register + * instance to it. + * + * \param[in] obj : pointer to Touch driver instance + */ +extern void TouchDrv_Init(TouchDrvType *obj); + +/*! \brief Configures the Touch module from a user configuration structure + * + * This function configures the Touch module from a user configuration structure + * + * \param[in] obj : pointer to Touch driver instance + * \param[in] cfg : pointer to configuration structure + */ +extern TouchDrv_Status TouchDrv_Configure(TouchDrvType *obj, TouchDrv_CfgType *cfg); + +/*! \brief Calibration the Touch sensor + * + * This function calibarte the touch sensor + * + * \param[in] obj : pointer to Touch driver instance + */ +extern TouchDrv_Status TouchDrv_Calibration(TouchDrvType *obj, int32_t target); + +/*! \brief Start touch sampling and detection + * + * This function start touch module to sample capacitance and detect proxmity state + * + * \param[in] obj : pointer to Touch driver instance + */ +extern TouchDrv_Status TouchDrv_Start(TouchDrvType *obj, TouchDrv_Mode mode); + +/*! \brief Stop touch sampling and detection + * + * This function stop touch module to sample capacitance and detect proxmity state + * + * \param[in] obj : pointer to Touch driver instance + */ +extern TouchDrv_Status TouchDrv_Stop(TouchDrvType *obj); + +/*! \brief Get touch raw data + * + * This function for getting touch raw data + * + * \param[in] obj : pointer to Touch driver instance + * \param[in] phStart : the start phase to be read + * \param[in] len : the len to be read + * \param[out] data : pointer to raw data buffer + * + */ +extern TouchDrv_Status TouchDrv_GetRawdata(TouchDrvType *obj, uint8_t ph_start, uint8_t len, int16_t data[]); + +/*! \brief Get touch base data + * + * This function for getting touch base data + * + * \param[in] obj : pointer to Touch driver instance + * \param[in] phStart : the start phase to be read + * \param[in] len : the len to be read + * \param[out] data : pointer to base data buffer + * + */ +extern TouchDrv_Status TouchDrv_GetBasedata(TouchDrvType *obj, uint8_t ph_start, uint8_t len, int16_t data[]); + +/*! \brief Get touch diff data + * + * This function for getting touch diff data + * + * \param[in] obj : pointer to Touch driver instance + * \param[in] phStart : the start phase to be read + * \param[in] len : the len to be read + * \param[out] data : pointer to diff data buffer + * + */ +extern TouchDrv_Status TouchDrv_GetDiffdata(TouchDrvType *obj, uint8_t ph_start, uint8_t len, int16_t data[]); + +// extern TouchDrv_Status TouchDrv_GetNddata(TouchDrvType *obj, uint8_t ph_start, uint8_t len, int16_t data[]); +// extern TouchDrv_Status TouchDrv_GetSmoothdata(TouchDrvType *obj, uint8_t ph_start, uint8_t len, int16_t data[]); +// extern TouchDrv_Status TouchDrv_GetAvgdata(TouchDrvType *obj, uint8_t ph_start, uint8_t len, int16_t data[]); +// extern TouchDrv_Status TouchDrv_GetUsefuldata(TouchDrvType *obj, uint8_t ph_start, uint8_t len, int16_t data[]); + +/*! \brief Get touch capacitance load + * + * This function for getting touch capacitance load + * + * \param[in] obj : pointer to Touch driver instance + * \param[in] phStart : the start phase to be read + * \param[in] len : the len to be read + * \param[out] data : pointer to cc data buffer + * + */ +extern TouchDrv_Status TouchDrv_GetCc(TouchDrvType *obj, uint8_t ph_start, uint8_t len, uint16_t data[]); + +/*! \brief Get touch lib version + * + * This function for getting touch lib version + * + * \param[in] obj : pointer to Touch driver instance + * + */ +extern char* TouchDrv_GetLibVersion(TouchDrvType *obj); + +/*! \brief Get touch irq state + * + * This function for getting irq state + * + * \param[in] obj : pointer to Touch driver instance + * \return touch irq state + * + */ +extern uint32_t TouchDrv_GetIrqState(TouchDrvType *obj); + +/*! \brief Get touch proxmity state + * + * This function for getting proxmity state + * + * \param[in] obj : pointer to Touch driver instance + * \return touch proxmity state + * + */ +extern uint32_t TouchDrv_GetProxState(TouchDrvType *obj); + +// extern uint32_t TouchDrv_GetNdState(TouchDrvType *obj); +// extern uint32_t TouchDrv_GetCompState(TouchDrvType *obj); +// extern uint32_t TouchDrv_GetAutoCompState(TouchDrvType *obj); + +/*! \brief Get touch fsm state + * + * This function for getting fsm state + * + * \param[in] obj : pointer to Touch driver instance + * \return touch fsm state + * + */ +extern uint8_t TouchDrv_GetDebugState(TouchDrvType *obj); + +/*! \brief Clear touch irq state + * + * This function for clearing touch irq state + * + * \param[in] obj : pointer to Touch driver instance + * + */ +extern void TouchDrv_CleanIrqState(TouchDrvType *obj); + +#ifdef __cplusplus +} +#endif /* extern "C" */ + +/*! @}*/ + +#endif diff --git a/cva_asw_m0128/src/hod/libtouch/touch_slider.h b/cva_asw_m0128/src/hod/libtouch/touch_slider.h new file mode 100644 index 0000000..0b57b38 --- /dev/null +++ b/cva_asw_m0128/src/hod/libtouch/touch_slider.h @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. + */ + +#ifndef _TOUCH_SLIDER_H_ +#define _TOUCH_SLIDER_H_ + +/*! \brief Contains public interface to various functions related + * to the driver of SLIDER module + */ + +/****************************************************************************** + * the includes + *****************************************************************************/ +#include +#include +#include +#include "touch_drv.h" + +/*! \addtogroup touch_slider + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * the defines + *****************************************************************************/ +#define TOUCH_SLIDER_INVALIDE_COOR (0x7FFF) +#define TOUCH_SLIDER_NEED_RECALI (0x7FFE) +#define TOUCH_SLIDER_COOR_PITCH (100) + +/****************************************************************************** + * the typedefs + *****************************************************************************/ + +/*! \brief Touch slider event type + */ +typedef enum +{ + SLIDER_STATE_OFF = 0x00, + SLIDER_STATE_ON, + SLIDER_STATE_NEED_RECALI, +} SliderDrv_StateType; + +typedef struct +{ + uint8_t phase; + uint32_t thr; + uint32_t hyst; + uint8_t onDebNum; + uint8_t offDebNum; + uint16_t onMaxNum; + uint16_t rawFltCoef; + uint16_t baseFltPosCoef; + uint16_t baseFltNegCoef; +} SliderDrv_ElemCfgType; + +typedef struct +{ + SliderDrv_StateType state; + int32_t raw; + int32_t base; + int32_t diff; + uint16_t onCnt; + uint16_t offCnt; + uint8_t initFlag; +} SliderDrv_ElemVarType; + +typedef struct +{ + uint8_t elementNum; + uint8_t autoDetectionEn; + SliderDrv_ElemCfgType *elemsCfg; +} SliderDrv_WidgetCfg; + +typedef struct +{ + uint16_t coor; + uint8_t event; + SliderDrv_ElemVarType *elemsVar; +} SliderDrv_WidgetVarType; + +/*! \brief Definition of Touch slider driver configuration + */ +typedef struct +{ + uint8_t slidersNum; + + SliderDrv_WidgetCfg *slidersCfg; + + SliderDrv_WidgetVarType *slidersVar; + + TouchDrv_CfgType *touchDrvCfg; +} SliderDrv_CfgType; + +/*! \brief Definition of Touch slider driver class + */ +typedef struct +{ + TouchDrvType *touchDrv; +} SliderDrvTypeType; + +/****************************************************************************** + * the globals + ******************************************************************************/ + +/****************************************************************************** + * the function prototypes + ******************************************************************************/ + +/*! \brief Initializes the Touch slider module + * + * This function initializes Touch slider driver by user configuration + * + * \param[in] obj : pointer to slider driver instance + * \param[in] cfg : pointer to configuration structure + */ +void SliderDrv_Init(SliderDrvTypeType *obj, SliderDrv_CfgType *cfg); + +/*! \brief Polling Touch slider event state + * + * This function poll Touch slider event state + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] cfg : pointer to configuration structure + * \param[out] state : state[0] for slider sensor0 state, 1 means sensor0 is in proximity state; + * state[1] for slider sensor1 state, 1 means sensor1 is in proximity state; + * state[2] for slider event state, refer to SliderDrv_Event; + * + */ +uint8_t SliderDrv_Process(SliderDrvTypeType *obj, TouchDrv_InfoType *info); + +uint16_t SliderDrv_GetSliderCoor(SliderDrvTypeType *obj, uint8_t sliderIndex); + +/*! \brief Getting Touch slider event state + * + * This function get Touch slider event state + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] sliderIndex : touch slider index + * \param[in] elemIndex : touch slider elem index + * \return touch slider event state + * + */ +uint16_t SliderDrv_GetSliderState(SliderDrvTypeType *obj, uint8_t sliderIndex, uint8_t elemIndex); + +/*! \brief Getting Touch slider event state + * + * This function get Touch slider event state + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] buttonIndex : touch slider index + * \return touch slider event state + * + */ +uint16_t SliderDrv_GetSliderEvent(SliderDrvTypeType *obj, uint8_t sliderIndex); + +/*! \brief Get touch slider element raw data + * + * This function for getting touch slider element raw data + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] sliderIndex : touch slider index + * \param[in] elemIndex : touch slider element index + * \return touch slider raw data + * + */ +int32_t SliderDrv_GetSliderElemRawData(SliderDrvTypeType *obj, uint8_t sliderIndex, uint8_t elemIndex); + +/*! \brief Get touch slider element base data + * + * This function for getting touch slider element base data + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] sliderIndex : touch slider index + * \param[in] elemIndex : touch slider element index + * \return touch slider base data + * + */ +int32_t SliderDrv_GetSliderElemBaseData(SliderDrvTypeType *obj, uint8_t sliderIndex, uint8_t elemIndex); + +/*! \brief Get touch slider element diff data + * + * This function for getting touch slider element diff data + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] sliderIndex : touch slider index + * \param[in] elemIndex : touch slider element index + * \return touch slider diff data + * + */ +int32_t SliderDrv_GetSliderElemDiffData(SliderDrvTypeType *obj, uint8_t sliderIndex, uint8_t elemIndex); + +/*! \brief Setting Touch slider driver configuration + * + * This function set Touch slider driver configuration + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] cfg : pointer to configuration data + * \param[in] len : configuration data length + * + */ +void SliderDrv_SetCfg(void *obj, uint8_t *cfg, uint32_t len); + +/*! \brief Getting Touch slider driver configuration + * + * This function get Touch slider driver configuration + * + * \param[in] obj : pointer to Touch slider driver instance + * \param[in] cfg : pointer to configuration data + * \param[in] len : configuration data length + * + */ +void SliderDrv_GetCfg(void *obj, uint8_t *cfg, uint32_t len); + + + +#ifdef __cplusplus +} +#endif /* extern "C" */ + +/*! @}*/ + +#endif diff --git a/cva_asw_m0128/src/hod/libtouch/touch_trx.h b/cva_asw_m0128/src/hod/libtouch/touch_trx.h new file mode 100644 index 0000000..b4ad9c1 --- /dev/null +++ b/cva_asw_m0128/src/hod/libtouch/touch_trx.h @@ -0,0 +1,196 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. + */ + +#ifndef _TOUCH_TRX_H_ +#define _TOUCH_TRX_H_ + +/*! \brief Contains public interface to various functions related + * to the driver of TOUCH TRX module + */ + +/****************************************************************************** + * the includes + *****************************************************************************/ +#include +#include +#include +#include "touch_drv.h" + +/*! \addtogroup touch_trx + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * the defines + *****************************************************************************/ + +/****************************************************************************** + * the typedefs + *****************************************************************************/ +typedef void (*widget_set_cfg)(void *obj, uint8_t *cfg, uint32_t var); + +typedef void (*widget_get_cfg)(void *obj, uint8_t *cfg, uint32_t var); + +/*! \brief Touch communication interface function pointer prototype + */ +typedef int8_t(*touchIfTx)(uint8_t *packet, uint16_t len); + +typedef struct +{ + widget_set_cfg widget_set_cfg_func; + + widget_get_cfg widget_get_cfg_func; +} Trx_Widget_FuncType; + +/*! \brief Touch communication command + */ +typedef enum +{ + TOUCH_TRX_CMD_MODE = 0X00, + TOUCH_TRX_CMD_MODE_ACK = 0X01, + + TOUCH_TRX_CMD_REG_RD = 0X50, + TOUCH_TRX_CMD_I2C_RD_ACK = 0X51, + + TOUCH_TRX_CMD_REG_WR = 0X52, + TOUCH_TRX_CMD_I2C_WR_ACK = 0X53, + + TOUCH_TRX_CMD_GET_VER = 0X56, + TOUCH_TRX_CMD_GET_VER_ACK = 0X57, + + TOUCH_TRX_CMD_HOST_CMD = 0X58, + TOUCH_TRX_CMD_HOST_CMD_ACK = 0X59, + + TOUCH_TRX_CMD_GET_EVENT = 0X5C, + TOUCH_TRX_CMD_GET_EVENT_ACK = 0X5D, + + TOUCH_TRX_CMD_SET_FLASH = 0X7a, + TOUCH_TRX_CMD_SET_FLASH_ACK = 0X7b, + + TOUCH_TRX_CMD_GET_FLASH = 0X80, + TOUCH_TRX_CMD_GET_FLASH_ACK = 0X81, + + TOUCH_TRX_CMD_GET_KEY_VAR = 0X82, + TOUCH_TRX_CMD_GET_KEY_VAR_ACK = 0X83, + + TOUCH_TRX_CMD_GET_INFO = 0X84, + TOUCH_TRX_CMD_GET_INFO_ACK = 0X85, + + TOUCH_TRX_CMD_SET_CFG = 0X86, + TOUCH_TRX_CMD_SET_CFG_ACK = 0X87, + + TOUCH_TRX_CMD_GET_CFG = 0X88, + TOUCH_TRX_CMD_GET_CFG_ACK = 0X89, + + TOUCH_TRX_CMD_GET_MISC = 0X90, + TOUCH_TRX_CMD_GET_MISC_ACK = 0X91, +} TouchTrx_CmdType; + +/*! \brief Touch communication error code + */ +typedef enum +{ + TOUCH_TRX_PACK_ERR_HEAD = 0x01, + TOUCH_TRX_PACK_ERR_SIZE = 0x02, + TOUCH_TRX_PACK_ERR_CRC = 0x03, + TOUCH_TRX_PACK_ERR_BSY = 0x04, + TOUCH_TRX_PACK_PASS = 0x55, +} TouchTrx_PackStatusType; + +/*! \brief Touch communication mode + */ +typedef enum +{ + TOUCH_TRX_SHOW_EN = 2, + TOUCH_TRX_SHOW_DIS = 3, +} TouchTrx_ModeType; + +/*! \brief Touch communication information type + */ +typedef enum +{ + TouchTrx_InfoNone = 0x00, + TouchTrx_InfoDiff = 0x01, + TouchTrx_InfoRaw = 0x02, + TouchTrx_InfoBase = 0x04, + TouchTrx_InfoProx = 0x08, + TouchTrx_InfoGesture = 0x40, +} TouchTrx_InfoType; + + +/****************************************************************************** + * the globals + ******************************************************************************/ + +/****************************************************************************** + * the function prototypes + ******************************************************************************/ + +/*! \brief Parse touch communication stream + * + * This function parse communication stream + * + * \param[in] data : communication stream data + */ +void TouchTrx_Parse(uint8_t data); + +/*! \brief Handle touch communication package + * + * This function handle touch communication package + * + */ +void TouchTrx_Handler(void); + +/*! \brief Send touch event + * + * This function for sending touch event + * + * \param[in] event : touch event + */ +void TouchTrx_SendEvent(uint8_t event); + +/*! \brief Send touch information + * + * This function for sending touch information, like raw-data/base-data/diff-data etc. + * + * \param[in] event : touch event buffer + * \param[in] len : touch event buffer length in byte + */ +void TouchTrx_SendInfo(TouchDrv_InfoType *info, uint8_t extInfo[], uint16_t extLen); + +/*! \brief regist widget func to touch trx + * + * This function for registing widget func to touch trx. + * + * \param[in] widget_func : point to func struct for registing + */ +void TouchTrx_RegistFuncCallback(Trx_Widget_FuncType *widget_func); + +void TouchTrx_RegisterTxFun(touchIfTx prt); + +void TouchTrx_SetVersion(char *version, uint8_t len); + +#ifdef __cplusplus +} +#endif /* extern "C" */ + +/*! @}*/ + +#endif diff --git a/cva_asw_m0128/src/hod/touch_config.c b/cva_asw_m0128/src/hod/touch_config.c new file mode 100644 index 0000000..2207af2 --- /dev/null +++ b/cva_asw_m0128/src/hod/touch_config.c @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. +*/ + +/****************************************************************************** + * the includes + *****************************************************************************/ + +#include "touch_config.h" + +/******************************************************************************* + * the defines + ******************************************************************************/ + +/******************************************************************************* + * the typedefs + ******************************************************************************/ + +/******************************************************************************* + * the globals + ******************************************************************************/ +const TouchDrv_PhaseCfgType g_touchPhaseCfg[APP_TOUCH_SCAN_PHASE_NUM] = +{ + /* phase0 config */ + { + .phaseIndex = TOUCHDRV_Phase0, + + .tk00Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk01Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk02Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk03Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk04Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk05Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk06Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk07Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk08Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk09Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk10Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk11Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk12Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk13Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk14Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk15Func = TOUCHDRV_CSIO_FUNC_NONE, + + .tk16Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk17Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk18Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk19Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk20Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk21Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk22Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk23Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk24Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk25Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk26Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk27Func = TOUCHDRV_CSIO_FUNC_NONE, + .tk28Func = TOUCHDRV_CSIO_FUNC_SHD, + .tk29Func = TOUCHDRV_CSIO_FUNC_INPUT, + + .afeMode = TOUCHDRV_SELF_LIGHT, + .bitSel = 10, + .cf = 14, + .rf = 0, + .rfEn = 0, + .freq = 18, + .num = TOUCHDRV_NSMP_2048, + .trst = 2, + .td = 0, + + .adcFltEn = 0, + .adcFltWin = 0, + .adcFltInCoef = 0, + .adcFltUnderCoef = 0, + .adcFltOverCoef = 0, + }, +}; + +TouchDrv_CfgType g_touchCfg = +{ + .phaseCfg = g_touchPhaseCfg, + .phaseCfgNum = APP_TOUCH_SCAN_PHASE_NUM, + + .irqEn = TOUCHDRV_IRQ_CONVDONE_EN, + .scanPeriod = 5, + .dozeMul = TOUCHDRV_DOZE_MUL_BYPASS, + .sensingPhaseSel = TOUCHDRV_Phase0_MASK, + .autoDetectionPhaseSel = TOUCHDRV_PhaseNone_MASK, + .ndPhaseSel = TOUCHDRV_PhaseNone_MASK, + .touchAndSel = TOUCHDRV_PhaseNone_MASK, + .noTouchAndSel = TOUCHDRV_PhaseNone_MASK, + .senScen = 0, +}; + +/******************************************************************************* + * the functions + ******************************************************************************/ diff --git a/cva_asw_m0128/src/hod/touch_config.h b/cva_asw_m0128/src/hod/touch_config.h new file mode 100644 index 0000000..5942cad --- /dev/null +++ b/cva_asw_m0128/src/hod/touch_config.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. + */ + +#ifndef _TOUCH_CONFIG_H_ +#define _TOUCH_CONFIG_H_ + +/*! \brief Contains public interface to various functions related + * to the driver of TOUCH module + */ + +/****************************************************************************** + * the includes + *****************************************************************************/ +#include +#include +#include "touch_drv.h" + +/*! \addtogroup touch + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * the defines + *****************************************************************************/ +#define APP_TOUCH_SCAN_PHASE_NUM 1 + +/****************************************************************************** + * the typedefs + *****************************************************************************/ + +/****************************************************************************** + * the globals + ******************************************************************************/ +extern TouchDrv_CfgType g_touchCfg; + +/****************************************************************************** + * the function prototypes + ******************************************************************************/ + +#ifdef __cplusplus +} +#endif /* extern "C" */ + +/*! @}*/ + +#endif + diff --git a/cva_asw_m0128/src/hod/touch_widget_config.c b/cva_asw_m0128/src/hod/touch_widget_config.c new file mode 100644 index 0000000..6aeb36a --- /dev/null +++ b/cva_asw_m0128/src/hod/touch_widget_config.c @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. +*/ + +/****************************************************************************** + * the includes + *****************************************************************************/ + +#include "touch_widget_config.h" + +/******************************************************************************* + * the defines + ******************************************************************************/ + +/******************************************************************************* + * the typedefs + ******************************************************************************/ + +/******************************************************************************* + * the globals + ******************************************************************************/ + +/* button config */ +ButtonDrv_ElemCfgType g_button0ElementsCfg[TOUCH_BUTTON0_ELEMENT_NUM] = +{ + { + .phase = TOUCHDRV_Phase0, + .thr = 500, + .hyst = 100, + .onDebNum = 2, + .offDebNum = 2, + .onMaxNum = 0, + .rawFltCoef = 256,//256 + .baseFltPosCoef = 2, //16/1024 = 1/64 + .baseFltNegCoef = 256, //256/1024 = 1/4 + }, +}; + +ButtonDrv_ElemVarType g_button0ElementsVar[TOUCH_BUTTON0_ELEMENT_NUM]; + +ButtonDrv_WidgetCfgType g_buttonsCfg[TOUCH_BUTTON_NUM] = +{ + { + .elementNum = TOUCH_BUTTON0_ELEMENT_NUM, + .autoDetectionEn = false, + .elemsCfg = g_button0ElementsCfg, + }, +}; + +ButtonDrv_WidgetVarType g_buttonsVar[TOUCH_BUTTON_NUM] = +{ + { + .event = BUTTON_STATE_OFF, + .elemsVar = g_button0ElementsVar, + }, +}; + +ButtonDrv_CfgType g_button_cfg = +{ + .buttonNum = TOUCH_BUTTON_NUM, + .buttonsCfg = g_buttonsCfg, + .buttonsVar = g_buttonsVar, + .touchDrvCfg = &g_touchCfg, +}; + + +/******************************************************************************* + * the functions + ******************************************************************************/ diff --git a/cva_asw_m0128/src/hod/touch_widget_config.h b/cva_asw_m0128/src/hod/touch_widget_config.h new file mode 100644 index 0000000..d688903 --- /dev/null +++ b/cva_asw_m0128/src/hod/touch_widget_config.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD + * All rights reserved. + * + * Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use + * exclusively with CVA's microcontroller products. This file can be freely + * distributed within development tools that are supporting such microcontroller + * products. + * + * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED + * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. + * CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, + * OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. + */ + +#ifndef _TOUCH_WIDGET_CONFIG_H_ +#define _TOUCH_WIDGET_CONFIG_H_ + +/*! \brief Contains public interface to various functions related + * to the driver of TOUCH module + */ + +/****************************************************************************** + * the includes + *****************************************************************************/ +#include +#include "touch_drv.h" +#include "touch_config.h" +#include "touch_button.h" + +/*! \addtogroup touch + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * the defines + *****************************************************************************/ +#define TOUCH_BUTTON_NUM (1) +#define TOUCH_BUTTON0_ELEMENT_NUM (1) + +/****************************************************************************** + * the typedefs + *****************************************************************************/ + +/****************************************************************************** + * the globals + ******************************************************************************/ +extern ButtonDrv_CfgType g_button_cfg; + +/****************************************************************************** + * the function prototypes + ******************************************************************************/ + +#ifdef __cplusplus +} +#endif /* extern "C" */ + +/*! @}*/ + +#endif + diff --git a/cva_asw_m0128/src/hwctrl.c b/cva_asw_m0128/src/hwctrl.c index 0319511..3a42d9b 100644 --- a/cva_asw_m0128/src/hwctrl.c +++ b/cva_asw_m0128/src/hwctrl.c @@ -4,6 +4,8 @@ #include "hwctrl.h" #include "canuser.h" #include "TLE94x1.h" +#include "key.h" +#include "ad_button1.h" /******************************************************************************* * the defines ******************************************************************************/ @@ -43,8 +45,9 @@ void hw_init(void) SBC_SPI_INIT(); - - + encoder_init(); + key_init(); + adc_init(); /* get CAN controller default configuration */ FlexCanBoot_Init(); @@ -70,16 +73,11 @@ static void hw_clock_init(void) ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTB, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTC, &clockConfig); - /* Setup the Pll div2 clock */ - clockConfig.gating = true; - clockConfig.source = CLOCKDRV_PLL; - clockConfig.div = 1; - ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PLL_DIV, &clockConfig); clockConfig.gating = true; clockConfig.source = CLOCKDRV_PLL; clockConfig.div = 2; - ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PLL_DIV, &clockConfig); + ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PLL_DIV, &clockConfig);//40M /* Setup the SPI clock */ clockConfig.gating = true; @@ -93,6 +91,13 @@ static void hw_clock_init(void) ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_CORE, &gCpuClockFrequency); SysTick_Config(gCpuClockFrequency / 1000u); + + clockConfig.source = CLOCKDRV_SIRC; + ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_ADC, &clockConfig); + ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PDB, &clockConfig); + ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_TOUCH, &clockConfig); + + IrqDrv_EnableIrq(SysTick_IRQn); } \ No newline at end of file diff --git a/cva_asw_m0128/src/key.c b/cva_asw_m0128/src/key.c new file mode 100644 index 0000000..97e75f1 --- /dev/null +++ b/cva_asw_m0128/src/key.c @@ -0,0 +1,220 @@ +//key.c +#include "key.h" +#include "mcu.h" +#include "RTT/SEGGER_RTT.h" + +//KEY1:PB11 +#define KEY1 11 +//KEY2:PB08 +#define KEY2 8 +//KEY3:PB07 +#define KEY3 7 +//KEY4:PB10 +#define KEY4 10 +//KEY5:PB06 +#define KEY5 9 +//KEY6:PB06 +#define KEY6 6 + +unsigned int key1_delay_count,key2_delay_count,key3_delay_count,key4_delay_count,key5_delay_count,key6_delay_count; + +unsigned char r_switch_state=0;//one bit corresponding a key's state,two bit reserved + +extern McuType mcu; +extern FlexCanDrv_MsgObjType txMsgObj; +uint8_t roll_count = 0; + + +Encoder_t encoder1; +unsigned char encoder_state=0; +signed char up_down=0;//encoder up_down count +unsigned char send_state=0;//encoder can message send flag + + +unsigned char button_stick=0; +unsigned char initflag[6]={1,1,1,1,1,1};//vioce,phone,back,left,ok,right + + + +unsigned char key_buf[16]; + +void key_init(void) +{ + PinsDrv_SetMuxModeSel(&mcu.ptb, KEY1, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.ptb, KEY1, 0);//input + + PinsDrv_SetMuxModeSel(&mcu.ptb, KEY2, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.ptb, KEY2, 0);//input + + PinsDrv_SetMuxModeSel(&mcu.ptb, KEY3, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.ptb, KEY3, 0);//input + + PinsDrv_SetMuxModeSel(&mcu.ptb, KEY4, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.ptb, KEY4, 0);//input + + PinsDrv_SetMuxModeSel(&mcu.ptb, KEY5, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.ptb, KEY5, 0);//input + + PinsDrv_SetMuxModeSel(&mcu.ptb, KEY6, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.ptb, KEY6, 0);//input +} + + +/* GPIO init */ +void encoder_init(void) +{ + /*pta1:KIT3033S enable pin*/ + /*GPIO mode*/ + PinsDrv_SetMuxModeSel(&mcu.pta, 1, PINSDRV_MUX_AS_GPIO); + /*GPIO direction out*/ + PinsDrv_SetPinDirection(&mcu.pta, 1, 1);/*output*/ + /*out high*/ + PinsDrv_WritePin(&mcu.pta, 1, 1); + + /*pta2:KIT3033S OUT 0*/ + PinsDrv_SetMuxModeSel(&mcu.pta, 2, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.pta, 2, 0);/*input*/ + + /*pta3:KIT3033S OUT 1*/ + PinsDrv_SetMuxModeSel(&mcu.pta, 3, PINSDRV_MUX_AS_GPIO); + PinsDrv_SetPinDirection(&mcu.pta, 3, 0); +} + + +/*pin1,pin2:light high,blocked low*/ +/*ret:0:none,1:roll-up,2:roll-down*/ +static unsigned char encoder_deal(Encoder_t *e,unsigned char pin1,unsigned char pin2) +{ + unsigned char ret=0; + + switch (e->state) + { + case 0: + if(pin1 == 1 && pin2 == 1)//default + {return 0;} + if(pin1 == 0 && pin2 == 1)//rolling step1(roll-up):pin1 blocked,pin2 not blocked yet + { + e->state=1;//step1 detected + e->rise_state=1;//roll-up rise + } + else if (pin1 == 1 && pin2 == 0)//rolling step1(roll-down):pin2 blocked first + { + e->state=1;//step1 detected + e->rise_state=2;//roll-down + } + break; + + case 1: + if(pin1 == 1 && pin2 == 1)//give up rolling + { + e->state=0; + e->rise_state=0; + } + else if(pin1 == 0 && pin2 == 0){e->state = 2;}//rolling to step2:both blocked + break; + + case 2: + if(pin1 == 1 && pin2 == 0){e->fall_state = 1;}//rolling to step3(roll-up):pin1 light first + else if(pin1 == 0 && pin2 == 1){e->fall_state = 2;}//rolling to step3(roll-down):pin2 light first + else if(pin1 == 1 && pin2 == 1)//finish + { + if(e->rise_state == 1 && e->fall_state == 1) + { + ret =1; + }//slide-up + else if (e->rise_state == 2 && e->fall_state == 2) + { + ret = 2; + }//slide-down + else {ret =0;} + + e->state=0; + e->rise_state=0; + e->fall_state=0; + } + } + return ret; +} + +void Encoder_process() +{ + unsigned char ret_val,button_up,button_down; + + button_up = PinsDrv_ReadPin(&mcu.pta,2); + button_down = PinsDrv_ReadPin(&mcu.pta,3); + + ret_val=encoder_deal(&encoder1,button_up,button_down); + if(ret_val == 1) + { + up_down++; + } + if(ret_val == 2) + { + up_down--; + } + + if(up_down !=0) + { + if(up_down>0) + { + encoder_state = 1; + up_down--; + roll_count++; + roll_count = (roll_count << 4) & 0xf0; + } + if(up_down<0) + { + encoder_state = 2; + up_down++; + roll_count++; + roll_count = (roll_count & 0x0f); + } + } + else{ + if(send_state == 1) + { + send_state=0; + encoder_state = 0; + } + } + +} + +void button_detect(unsigned char button_state,unsigned char *init_code,unsigned char button_bit,unsigned int *delay_count) +{ + if(button_state == 0) + { + + if(*init_code != 0) + {return;} + (*delay_count)++; + if(*delay_count >=3 && *delay_count <12000) + { + r_switch_state |= 1<<(button_bit -1); + } + else if(*delay_count >=12000) + { + *delay_count=12000; + button_stick=1; + } + } + else + { + *delay_count=0; + r_switch_state &= ~(1<<(button_bit -1)); + *init_code=0; + } + +} + +void button_scan(void) +{ + button_stick=0; + button_detect(PinsDrv_ReadPin(&mcu.ptb,KEY1),&initflag[1],1,&key1_delay_count); + button_detect(PinsDrv_ReadPin(&mcu.ptb,KEY2),&initflag[2],2,&key2_delay_count); + button_detect(PinsDrv_ReadPin(&mcu.ptb,KEY3),&initflag[3],3,&key3_delay_count); + button_detect(PinsDrv_ReadPin(&mcu.ptb,KEY4),&initflag[4],4,&key4_delay_count); + button_detect(PinsDrv_ReadPin(&mcu.ptb,KEY5),&initflag[5],5,&key5_delay_count); + button_detect(PinsDrv_ReadPin(&mcu.ptb,KEY6),&initflag[6],6,&key6_delay_count); + button_stick=0; +} diff --git a/cva_asw_m0128/src/key.h b/cva_asw_m0128/src/key.h new file mode 100644 index 0000000..a78ed2d --- /dev/null +++ b/cva_asw_m0128/src/key.h @@ -0,0 +1,24 @@ +//key.h +#ifndef _KEY_H +#define _KEY_H +#include "mcu.h" +typedef struct{ + unsigned char state; + unsigned char rise_state;//the state that means pin change from light to blocked + unsigned char fall_state;// !above +}Encoder_t; + + +extern unsigned char r_switch_state;/*right keys state*/ +extern unsigned char encoder_state;/*encoder state*/ +extern signed char up_down;/*encoder roll count*/ +extern unsigned char send_state; +extern uint8_t roll_count; + + + +void encoder_init(void); +void key_init(void); +void Encoder_process(void); +void button_scan(void); +#endif \ No newline at end of file diff --git a/cva_asw_m0128/src/user_can_config.c b/cva_asw_m0128/src/user_can_config.c new file mode 100644 index 0000000..62ca2fd --- /dev/null +++ b/cva_asw_m0128/src/user_can_config.c @@ -0,0 +1,174 @@ +//user_can_config.c +#include "user_can_config.h" +#include "mcu.h" +#include "key.h" +#include "ad_button1.h" + +#include "RTT/SEGGER_RTT.h" + +#include "touch/touch_widget_config.h" + + +extern McuType mcu; +extern uint8_t heating; +extern uint8_t heat_level; +extern ButtonDrv_ElemCfgType g_button0ElementsCfg[TOUCH_BUTTON0_ELEMENT_NUM]; + + +extern volatile int16_t rawdata; +extern volatile int16_t basedata; +extern volatile int16_t diffdata; +extern volatile uint16_t tempdata; +extern volatile uint8_t handing; + +volatile static bool can_txrx_idle[4] = {false, true, true,true}; +FlexCanDrv_MsgObjType txMsgObj = {0}; + +const FlexCanDrv_MsgCfgType msgCfgObj[] = { + {0, 1, 0x3F0, false, FLEXCANDRV_MSGTYPE_RX, DLC_BYTE_8, false, true, 0}, + {1, 1, 0x3F1, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, true, 0}, + {2, 1, 0x3F2, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, true, 0}, + {3, 1, 0x400, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, true, 0} //buttons + //{3, 1, 0x3F3, false, FLEXCANDRV_MSGTYPE_TX, DLC_BYTE_8, false, true, 0}, +}; + + +/* can init. */ +void app_can_init(void) +{ + PinsDrv_SetMuxModeSel(&mcu.ptb, 15, PINSDRV_MUX_ALT6);/*can rx*/ + PinsDrv_SetMuxModeSel(&mcu.ptb, 14, PINSDRV_MUX_ALT6);/*can tx*/ + + FlexCanDrv_ControllerCfgType flexCanCfg; + FlexCanDrv_GetDefaultCfg(&flexCanCfg); + FlexCanDrv_BitTimingCalc(&flexCanCfg.bitTiming,80000000, 500000, 7500, 2500, 0); + flexCanCfg.clkSrc = FLEXCANDRV_CLKSRC_CHICLK; + flexCanCfg.busoffIntEnable = 1; + flexCanCfg.errorIntEnable = 1; + flexCanCfg.msgNum = sizeof(msgCfgObj) / sizeof(FlexCanDrv_MsgCfgType); + flexCanCfg.msgCfg = msgCfgObj; + FlexCanDrv_Configure(&(mcu.flexCanDrv), &flexCanCfg); + IrqDrv_EnableIrq(CAN_ORed_0_31_MB_IRQn); + IrqDrv_EnableIrq(CAN_ORed_IRQn); +} + +/* can err, busoff interrupt. */ +void CAN_ORed_Handler() +{ + if(FlexCanReg_GetBusoffIntFlag(mcu.flexCanDrv.flexCanReg)) + { + FlexCanReg_ClearBusoffIntFlag(mcu.flexCanDrv.flexCanReg); + } + if(FlexCanReg_GetErrIntFlag(mcu.flexCanDrv.flexCanReg)) + { + FlexCanReg_ClearErrIntFlag(mcu.flexCanDrv.flexCanReg); + } +} + + + +/* can tx, rx interrupt. */ +void CAN_ORed_0_31_MB_Handler() +{ + FlexCanDrv_MsgObjType msgObj; + + /* rx data. */ + msgObj.msgBufId = 0; + if(FlexCanDrv_GetMsgObjFlag(&mcu.flexCanDrv, &msgObj)) + { + FlexCanDrv_ClearMsgObjFlag(&mcu.flexCanDrv, &msgObj); + FlexCanDrv_GetRxMsg(&mcu.flexCanDrv, &msgObj); + if (msgObj.dlc > 0) + { + heating = msgObj.data[0]; + heat_level = msgObj.data[1]; + } + if (heating > 0) + { + g_button0ElementsCfg[0].baseFltPosCoef = 8; + } + else + { + g_button0ElementsCfg[0].baseFltPosCoef = 2; + } + } + + /* tx data. */ + for(uint32_t i = 1; i < sizeof(msgCfgObj) / sizeof(FlexCanDrv_MsgCfgType); i++) + { + msgObj.msgBufId = i; + + if(FlexCanDrv_GetMsgObjFlag(&(mcu.flexCanDrv), &msgObj)) + { + FlexCanDrv_ClearMsgObjFlag(&(mcu.flexCanDrv), &msgObj); + can_txrx_idle[i] = true; + } + } +} + +/*keys can message data*/ +void can_keys_task(void) +{ + if (can_txrx_idle[3])//KEYS + { + can_txrx_idle[3] = false; + + txMsgObj.data[0] = (uint8_t)0xFF; + txMsgObj.data[1] = (uint8_t)ad_button_state; //left keys + txMsgObj.data[2] = (uint8_t)0xFF; + txMsgObj.data[3] = (uint8_t)0xFF; + txMsgObj.data[4] = (uint8_t)0xFF; + txMsgObj.data[5] = (uint8_t)r_switch_state; //right keys + txMsgObj.data[6] = (uint8_t)encoder_state; //encoder_state,0x01 roll-up,0x02 roll-down + txMsgObj.data[7] = (uint8_t)roll_count;//encoder roll count + + txMsgObj.msgBufId = 3; + txMsgObj.dlc = DLC_BYTE_8; + FlexCanDrv_SetTxMsg(&(mcu.flexCanDrv), &txMsgObj); + FlexCanDrv_TransmitMsg(&(mcu.flexCanDrv), &txMsgObj); + } + +} + + +/* can task, send raw, base, diff, temp, hand msg per 100ms. */ +void can_task() +{ + if (can_txrx_idle[1])//hod + { + can_txrx_idle[1] = false; + txMsgObj.data[0] = (uint8_t)((rawdata >> 8) & 0xFF); + txMsgObj.data[1] = (uint8_t)((rawdata >> 0) & 0xFF); + txMsgObj.data[2] = (uint8_t)((basedata >> 8) & 0xFF); + txMsgObj.data[3] = (uint8_t)((basedata >> 0) & 0xFF); + txMsgObj.data[4] = (uint8_t)((diffdata >> 8) & 0xFF); + txMsgObj.data[5] = (uint8_t)((diffdata >> 0) & 0xFF); + txMsgObj.data[6] = tempdata; //aa + + txMsgObj.data[7] = heating << 1 | handing; + txMsgObj.msgBufId = 1; + txMsgObj.dlc = DLC_BYTE_8; + FlexCanDrv_SetTxMsg(&(mcu.flexCanDrv), &txMsgObj); + FlexCanDrv_TransmitMsg(&(mcu.flexCanDrv), &txMsgObj); + } + + if (can_txrx_idle[2])// + { + can_txrx_idle[2] = false; + txMsgObj.data[0] = handing; + txMsgObj.data[1] = 0; + txMsgObj.data[2] = 0; + txMsgObj.data[3] = 0; + txMsgObj.data[4] = 0; + txMsgObj.data[5] = 0; + txMsgObj.data[6] = 0; + txMsgObj.data[7] = 0; + txMsgObj.msgBufId = 2; + txMsgObj.dlc = DLC_BYTE_8; + FlexCanDrv_SetTxMsg(&(mcu.flexCanDrv), &txMsgObj); + FlexCanDrv_TransmitMsg(&(mcu.flexCanDrv), &txMsgObj); + } + + + SEGGER_RTT_printf(0,"can task"); +}/*can_task()*/ diff --git a/cva_asw_m0128/src/user_can_config.h b/cva_asw_m0128/src/user_can_config.h new file mode 100644 index 0000000..fcfb75e --- /dev/null +++ b/cva_asw_m0128/src/user_can_config.h @@ -0,0 +1,8 @@ +//user_can_config.h +#ifndef _USER_CAN_CONFIG_H +#define _USER_CAN_CONFIG_H + +void app_can_init(void); +void can_keys_task(void); +void can_task(void); +#endif \ No newline at end of file