移植HOD初版

This commit is contained in:
sunbeam 2024-12-27 14:26:13 +08:00
parent 2b08fb7402
commit 4df74475d2
22 changed files with 2625 additions and 11 deletions

View File

@ -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改为205ms*20=100ms;
{
ad_button_state = 0x01 << (index-1);
}
}
else
{
*switch_count=0;
ad_button_state &= ~(1<< (index-1) );
}
}

View File

@ -0,0 +1,16 @@
#ifndef _AD_BUTTON1_H
#define _AD_BUTTON1_H
#include <stdint.h>
#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

View File

@ -19,6 +19,10 @@
#define UDS_RECV_BUF (1026) #define UDS_RECV_BUF (1026)
#define UDS_SEND_BUF (128) #define UDS_SEND_BUF (128)
#define heat_level_low 80
#define heat_level_mid 85
#define heat_level_high 90
/******************************************************************************* /*******************************************************************************
* the globals * 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 * the functions
******************************************************************************/ ******************************************************************************/
@ -77,7 +109,7 @@ void appTaskInit(void)
{ {
/* UDS init */ /* UDS init */
Uds_UserInit(&udsObj, &udsParam); Uds_UserInit(&udsObj, &udsParam);
while(!hod_init(timer_1ms)) {};
} }
void appTask(void) void appTask(void)
@ -116,6 +148,68 @@ void appTask(void)
gSystick1msCnt = 0; 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);
}
}

View File

@ -19,10 +19,13 @@ typedef enum
{ {
UDS_MSG_IDX_STD_RX_PHYS, UDS_MSG_IDX_STD_RX_PHYS,
UDS_MSG_IDX_STD_RX_FUNC, UDS_MSG_IDX_STD_RX_FUNC,
UDS_MSG_IDX_STD_TX,
UDS_MSG_IDX_STD_RX_TEST1, UDS_MSG_IDX_STD_RX_TEST1,
UDS_MSG_IDX_STD_RX_TEST2, UDS_MSG_IDX_STD_RX_TEST2,
UDS_MSG_IDX_STD_TX_TEST1, UDS_MSG_IDX_STD_TX_TEST1,
UDS_MSG_IDX_STD_TX,
UDS_MSG_IDX_STD_TEST1, UDS_MSG_IDX_STD_TEST1,
UDS_MSG_IDX_STD_TEST2, UDS_MSG_IDX_STD_TEST2,
@ -55,9 +58,10 @@ uint8_t txMsgBuf[8] = {0};
const FlexCanDrv_MsgCfgType msgCfgObj[UDS_MSG_IDX_NUM] = { 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_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_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_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_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_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 */ {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 */
}; };

View File

@ -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(key<ht)
{
low=mid+1;
}
else{
high=mid-1;
}
}
return -1; //low>high的情况这种情况下key的值大于arr中最大的元素值或者key的值小于arr中最小的元素值
}

View File

@ -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_

View File

@ -0,0 +1,34 @@
#ifndef __HOD_H__
#define __HOD_H__
#include <stdint.h>
#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__ */

View File

@ -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++;
}
}
}

Binary file not shown.

View File

@ -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 <stdint.h>
#include <stdbool.h>
#include <string.h>
#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

View File

@ -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 <stdint.h>
#include <stdbool.h>
#include <string.h>
/*! \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

View File

@ -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 <stdint.h>
#include <stdbool.h>
#include <string.h>
#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

View File

@ -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 <stdint.h>
#include <stdbool.h>
#include <string.h>
#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

View File

@ -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
******************************************************************************/

View File

@ -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 <stdint.h>
#include <stdbool.h>
#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

View File

@ -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
******************************************************************************/

View File

@ -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 <stdint.h>
#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

View File

@ -4,6 +4,8 @@
#include "hwctrl.h" #include "hwctrl.h"
#include "canuser.h" #include "canuser.h"
#include "TLE94x1.h" #include "TLE94x1.h"
#include "key.h"
#include "ad_button1.h"
/******************************************************************************* /*******************************************************************************
* the defines * the defines
******************************************************************************/ ******************************************************************************/
@ -43,8 +45,9 @@ void hw_init(void)
SBC_SPI_INIT(); SBC_SPI_INIT();
encoder_init();
key_init();
adc_init();
/* get CAN controller default configuration */ /* get CAN controller default configuration */
FlexCanBoot_Init(); FlexCanBoot_Init();
@ -70,16 +73,11 @@ static void hw_clock_init(void)
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTB, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTB, &clockConfig);
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PORTC, &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.gating = true;
clockConfig.source = CLOCKDRV_PLL; clockConfig.source = CLOCKDRV_PLL;
clockConfig.div = 2; clockConfig.div = 2;
ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PLL_DIV, &clockConfig); ClockDrv_ConfigureClock(&mcu.clockDrv, CLOCKDRV_PLL_DIV, &clockConfig);//40M
/* Setup the SPI clock */ /* Setup the SPI clock */
clockConfig.gating = true; clockConfig.gating = true;
@ -93,6 +91,13 @@ static void hw_clock_init(void)
ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_CORE, &gCpuClockFrequency); ClockDrv_GetFreq(&mcu.clockDrv, CLOCKDRV_CORE, &gCpuClockFrequency);
SysTick_Config(gCpuClockFrequency / 1000u); 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); IrqDrv_EnableIrq(SysTick_IRQn);
} }

220
cva_asw_m0128/src/key.c Normal file
View File

@ -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;
}

24
cva_asw_m0128/src/key.h Normal file
View File

@ -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

View File

@ -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()*/

View File

@ -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