helloyifa/lock_lfvx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
lock_lfvx/bk_idk/components/demos/peripheral/touch/touch_demo.c

736 lines
22 KiB
C
Raw Normal View History

first commit
2025-10-10 16:07:00 +08:00
// Copyright 2020-2021 Beken
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <os/mem.h>
#include <os/str.h>
#include <os/os.h>
#include <driver/touch.h>
#include <driver/touch_types.h>
#include "sys_driver.h"
#include "touch_driver.h"
#include "aon_pmu_driver.h"
#include <driver/timer.h>
#include "bk_saradc.h"
#include <driver/adc.h>
float iir_x[11][3] = {0};
float iir_y[11][2] = {0};
float iir_y_x[11][3] = {0};
float iir_y_y[11][2] = {0};
uint32_t g_gain_s = 0;
UINT8 g_num = 0;
UINT8 g_touch_capa_cali_flag = 0;
beken_timer_t touch_capa_cali_tmr = {0};
beken_timer_t touch_tmr = {0};
static beken_thread_t touch_digital_tube_disp_thread_hdl = NULL;
extern void delay(int num);
extern uint32_t s_touch_channel;
static void cli_touch_help(void)
{
TOUCH_LOGI("touch_single_channel_calib_mode_test {0|1|2|...|15} {0|1|2|3}\r\n");
TOUCH_LOGI("touch_single_channel_manul_mode_test {0|1|...|15} {calibration_value}\r\n");
TOUCH_LOGI("touch_multi_channel_scan_mode_test {start|stop} {0|1|2|3}\r\n");
TOUCH_LOGI("touch_single_channel_multi_calib_test {0|1|...|15} {0|1|2|3}");
}
static void cli_touch_isr(void *param)
{
// uint32_t int_status = 0;
// int_status = bk_touch_get_int_status();
// TOUCH_LOGI("interrupt status = %x\r\n", int_status);
}
static void touch_cyclic_calib_timer_isr(timer_id_t chan)
{
uint32_t cap_out = 0;
uint32_t touch_id = 0;
uint32_t touch_crg[16] = {0};
uint32_t touch_crg_max = 0;
uint32_t multi_chann_value = 0xffff;
touch_config_t touch_config;
TOUCH_LOGI("multi_channel_cyclic_calib_test start!\r\n");
bk_touch_clear_int(multi_chann_value);
bk_touch_int_enable(multi_chann_value, 0);
bk_touch_scan_mode_enable(0);
bk_touch_scan_mode_multi_channl_set(0);
bk_touch_enable(0);
for(touch_id = 0; touch_id < 16; touch_id++)
{
bk_touch_enable(1 << touch_id);
touch_config.sensitivity_level = g_gain_s;
touch_config.detect_threshold = TOUCH_DETECT_THRESHOLD_6;
touch_config.detect_range = TOUCH_DETECT_RANGE_8PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_12PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_19PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_27PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
TOUCH_LOGE("Calibration value is out of the detect range, the channel cannot be used, please select the other channel!\r\n");
return;
}
}
}
}
touch_crg[touch_id] = touch_config.detect_range;
TOUCH_LOGI("touch[%d] crg = %d, calibration value = %x !\r\n", touch_id, touch_crg[touch_id], cap_out);
delay(1000);
}
for (touch_id = 0; touch_id < 16; touch_id++)
{
if (touch_crg_max < touch_crg[touch_id]) {
touch_crg_max = touch_crg[touch_id];
}
}
TOUCH_LOGI("touch_crg_max = %d\r\n", touch_crg_max);
for (touch_id = 0; touch_id < 16; touch_id++)
{
if (touch_crg_max != touch_crg[touch_id]) {
bk_touch_enable(1 << touch_id);
touch_config.detect_range = touch_crg_max;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
}
}
bk_touch_scan_mode_multi_channl_set(multi_chann_value);
bk_touch_scan_mode_enable(1);
bk_touch_int_enable(multi_chann_value, 1);
}
static void touch_digital_tube_disp_main(void)
{
bk_touch_digital_tube_init();
while(1) {
bk_touch_digital_tube_display(s_touch_channel);
}
}
bk_err_t bk_touch_digital_tube_display_init(void)
{
bk_err_t ret = BK_OK;
ret = rtos_create_thread(&touch_digital_tube_disp_thread_hdl,
BEKEN_DEFAULT_WORKER_PRIORITY,
"touch_digital_tube_disp",
(beken_thread_function_t)touch_digital_tube_disp_main,
4096,
NULL);
if (ret != kNoErr) {
os_printf("create touch digital tube disp task failed!\r\n");
touch_digital_tube_disp_thread_hdl = NULL;
}
return ret;
}
void cli_touch_single_channel_calib_mode_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t touch_id = 0;
uint32_t cap_out = 0;
uint32_t gain_s = 0;
touch_config_t touch_config;
if (argc != 3) {
cli_touch_help();
return;
}
touch_id = os_strtoul(argv[1], NULL, 10) & 0xFF;
gain_s = os_strtoul(argv[2], NULL, 10) & 0xFF;
if(touch_id >= 0 && touch_id < 16) {
TOUCH_LOGI("touch single channel calib mode test %d start!\r\n", touch_id);
bk_touch_gpio_init(1 << touch_id);
bk_touch_enable(1 << touch_id);
bk_touch_register_touch_isr(1 << touch_id, cli_touch_isr, NULL);
touch_config.sensitivity_level = gain_s;
touch_config.detect_threshold = TOUCH_DETECT_THRESHOLD_6;
touch_config.detect_range = TOUCH_DETECT_RANGE_8PF;
bk_touch_config(&touch_config);
#if (CONFIG_SOC_BK7236XX || CONFIG_SOC_BK7239XX || CONFIG_SOC_BK7286XX)
bk_touch_set_test_mode(0, 0);
bk_touch_set_calib_mode(0x3F, 9);
#endif
bk_touch_scan_mode_enable(0);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out0 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_12PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out1 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_19PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out2 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_27PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out3 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
TOUCH_LOGE("Calibration value is out of the detect range, the channel cannot be used, please select the other channel!\r\n");
return;
}
}
}
}
bk_touch_int_enable(1 << touch_id, 1);
} else {
TOUCH_LOGE("unsupported touch channel selection command!\r\n");
}
}
void cli_touch_single_channel_manul_mode_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t calib_value = 0;
uint32_t cap_out = 0;
uint32_t touch_id = 0;
touch_config_t touch_config;
if (argc != 3) {
cli_touch_help();
return;
}
touch_id = os_strtoul(argv[1], NULL, 16) & 0xFF;
if(touch_id >= 0 && touch_id < 16) {
TOUCH_LOGI("touch single channel manul mode test %d start!\r\n", touch_id);
bk_touch_gpio_init(1 << touch_id);
bk_touch_enable(1 <<touch_id);
bk_touch_register_touch_isr(1 << touch_id, cli_touch_isr, NULL);
touch_config.sensitivity_level = TOUCH_SENSITIVITY_LEVLE_3;
touch_config.detect_threshold = TOUCH_DETECT_THRESHOLD_6;
touch_config.detect_range = TOUCH_DETECT_RANGE_27PF;
bk_touch_config(&touch_config);
bk_touch_scan_mode_enable(0);
calib_value = os_strtoul(argv[2], NULL, 16) & 0xFFF;
TOUCH_LOGI("calib_value = %x\r\n", calib_value);
bk_touch_manul_mode_enable(calib_value);
bk_touch_int_enable(1 << touch_id, 1);
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out = %x\r\n", cap_out);
if(calib_value == cap_out) {
TOUCH_LOGI("single channel manul mode test is successful!\r\n");
} else {
TOUCH_LOGE("single channel manul mode test is failed!\r\n");
TOUCH_LOGE("please input larger calibration value!\r\n");
bk_touch_manul_mode_disable();
bk_touch_disable();
}
} else {
TOUCH_LOGE("unsupported touch channel selection command!\r\n");
}
}
void cli_touch_multi_channel_scan_mode_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
bk_err_t ret = BK_OK;
uint32_t multi_chann_value = 0xCF3F;
uint32_t touch_crg[16] = {0};
uint32_t touch_crg_max = 0;
uint32_t touch_id = 0;
uint32_t cap_out = 0;
uint32_t gain_s = 0;
touch_config_t touch_config;
if (argc != 3) {
cli_touch_help();
return;
}
ret = bk_touch_digital_tube_display_init();
if (ret != BK_OK) {
os_printf("init touch digital tube display task failed!\r\n");
return;
}
if (os_strcmp(argv[1], "start") == 0) {
TOUCH_LOGI("multi_channel_scan_mode_test start!\r\n");
gain_s = os_strtoul(argv[2], NULL, 10) & 0xFF;
for(touch_id = 0; touch_id < 16; touch_id++)
{
if (touch_id == 6 || touch_id == 7 || touch_id == 13 || touch_id == 12) {
continue;
}
bk_touch_gpio_init(1 << touch_id);
bk_touch_enable(1 << touch_id);
bk_touch_register_touch_isr(1 << touch_id, cli_touch_isr, NULL);
touch_config.sensitivity_level = gain_s;
touch_config.detect_threshold = TOUCH_DETECT_THRESHOLD_6;
touch_config.detect_range = TOUCH_DETECT_RANGE_8PF;
bk_touch_config(&touch_config);
bk_touch_scan_mode_enable(0);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_12PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_19PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_27PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
TOUCH_LOGE("Calibration value is out of the detect range, the channel cannot be used, please select the other channel!\r\n");
return;
}
}
}
}
touch_crg[touch_id] = touch_config.detect_range;
TOUCH_LOGI("touch[%d] crg = %d, calibration value = %x !\r\n", touch_id, touch_crg[touch_id], cap_out);
delay(1000);
}
for (touch_id = 0; touch_id < 16; touch_id++)
{
if (touch_id == 6 || touch_id == 7 || touch_id == 13 || touch_id == 12) {
continue;
}
if (touch_crg_max < touch_crg[touch_id]) {
touch_crg_max = touch_crg[touch_id];
}
}
TOUCH_LOGI("touch_crg_max = %d\r\n", touch_crg_max);
for (touch_id = 0; touch_id < 16; touch_id++)
{
if (touch_id == 6 || touch_id == 7 || touch_id == 13 || touch_id == 12) {
continue;
}
if (touch_crg_max != touch_crg[touch_id]) {
bk_touch_enable(1 << touch_id);
touch_config.detect_range = touch_crg_max;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
}
}
bk_touch_scan_mode_multi_channl_set(multi_chann_value);
bk_touch_scan_mode_enable(1);
bk_touch_int_enable(multi_chann_value, 1);
} else if (os_strcmp(argv[1], "stop") == 0) {
TOUCH_LOGI("multi_channel_scan_mode_test stop!\r\n");
bk_touch_scan_mode_enable(0);
bk_touch_disable();
}
}
void cli_touch_single_channel_multi_calib_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t touch_id = 0;
uint32_t cap_out = 0;
uint32_t gain_s = 0;
uint32_t count = 0;
touch_config_t touch_config;
if (argc != 3) {
cli_touch_help();
return;
}
touch_id = os_strtoul(argv[1], NULL, 10) & 0xFF;
gain_s = os_strtoul(argv[2], NULL, 10) & 0xFF;
if(touch_id >= 0 && touch_id < 16) {
TOUCH_LOGI("touch single channel calib mode test %d start!\r\n", touch_id);
bk_touch_gpio_init(1 << touch_id);
bk_touch_enable(1 << touch_id);
bk_touch_register_touch_isr(1 << touch_id, cli_touch_isr, NULL);
touch_config.sensitivity_level = gain_s;
touch_config.detect_threshold = TOUCH_DETECT_THRESHOLD_6;
touch_config.detect_range = TOUCH_DETECT_RANGE_8PF;
bk_touch_config(&touch_config);
bk_touch_scan_mode_enable(0);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out0 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_12PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out1 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_19PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out2 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_27PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out3 = %x\r\n", cap_out);
if (cap_out >= 0x1F0) {
TOUCH_LOGE("Calibration value is out of the detect range, the channel cannot be used, please select the other channel!\r\n");
return;
}
}
}
}
for (count = 0; count < 5000; count++)
{
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
TOUCH_LOGI("cap_out = %x\r\n", cap_out);
delay(10000);
}
bk_touch_int_enable(1 << touch_id, 1);
} else {
TOUCH_LOGE("unsupported touch channel selection command!\r\n");
}
}
void cli_touch_multi_channel_cyclic_calib_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int ret = 0;
uint32_t multi_chann_value = 0xffff;
uint32_t touch_crg[16] = {0};
uint32_t touch_crg_max = 0;
uint32_t touch_id = 0;
uint32_t cap_out = 0;
touch_config_t touch_config;
if (argc != 3) {
cli_touch_help();
return;
}
if (os_strcmp(argv[1], "start") == 0) {
g_gain_s = os_strtoul(argv[2], NULL, 10) & 0xFF;
for(touch_id = 0; touch_id < 16; touch_id++)
{
bk_touch_gpio_init(1 << touch_id);
bk_touch_enable(1 << touch_id);
bk_touch_register_touch_isr(1 << touch_id, cli_touch_isr, NULL);
touch_config.sensitivity_level = g_gain_s;
touch_config.detect_threshold = TOUCH_DETECT_THRESHOLD_6;
touch_config.detect_range = TOUCH_DETECT_RANGE_8PF;
bk_touch_config(&touch_config);
bk_touch_scan_mode_enable(0);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_12PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_19PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
touch_config.detect_range = TOUCH_DETECT_RANGE_27PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
if (cap_out >= 0x1F0) {
TOUCH_LOGE("Calibration value is out of the detect range, the channel cannot be used, please select the other channel!\r\n");
return;
}
}
}
}
touch_crg[touch_id] = touch_config.detect_range;
TOUCH_LOGI("touch[%d] crg = %d, calibration value = %x !\r\n", touch_id, touch_crg[touch_id], cap_out);
delay(1000);
}
for (touch_id = 0; touch_id < 16; touch_id++)
{
if (touch_crg_max < touch_crg[touch_id]) {
touch_crg_max = touch_crg[touch_id];
}
}
TOUCH_LOGI("touch_crg_max = %d\r\n", touch_crg_max);
for (touch_id = 0; touch_id < 16; touch_id++)
{
if (touch_crg_max != touch_crg[touch_id]) {
bk_touch_enable(1 << touch_id);
touch_config.detect_range = touch_crg_max;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
}
}
bk_touch_scan_mode_multi_channl_set(multi_chann_value);
bk_touch_scan_mode_enable(1);
bk_touch_int_enable(multi_chann_value, 1);
ret = bk_timer_start(TIMER_ID1, 10000, touch_cyclic_calib_timer_isr);
if (ret != BK_OK) {
os_printf("Timer start failed\r\n");
}
}
}
#if CONFIG_SOC_BK7256XX
void touch_push(float *data_buff, float data, UINT8 num)
{
UINT8 i;
for(i=0;i<num;i++)
{
data_buff[i] = data_buff[i+1];
}
data_buff[num] = data;
}
void touch_saradc_iir_iir_fillter(UINT8 chan_idx)
{
UINT16 value = 0;
UINT32 sum = 0;
float touch_delt[11] = {-300,-300,-300,-300,-300,-300,-300,-300,-300,-300,-300};
uint32_t chan[11] = {2,3,4,5,8,9,10,11,12,14,15};
float x=0.0,y1=0.0,y2=0.0,b1=1.0,b2=0.0,b3=-1.0,a1=1.0,a2=-1.8945,a3=0.9037,a4=-1.5515,a5=0.6755,s1=0.1588,s2=0.1588;
aon_pmu_drv_touch_select(chan[chan_idx]);
for(UINT8 i = 0; i<= 1; i++)
{
BK_LOG_ON_ERR(bk_adc_read(&value, ADC_READ_SEMAPHORE_WAIT_TIME));
value = value << 1;
sum += value;
}
x = ((float)sum)/2;
//IIR1
touch_push(iir_x[chan_idx], x, 2);
y1 = (((b1*iir_x[chan_idx][2] + b2*iir_x[chan_idx][1] + b3*iir_x[chan_idx][0]) - a2 * iir_y[chan_idx][1] - a3 * iir_y[chan_idx][0])/a1);
touch_push(iir_y[chan_idx], y1, 1);
//IIR2
y1 = y1*s1;
touch_push(iir_y_x[chan_idx], y1, 2);
y2 = (((b1*iir_y_x[chan_idx][2] + b2*iir_y_x[chan_idx][1] + b3*iir_y_x[chan_idx][0]) - a4 * iir_y_y[chan_idx][1] - a5 * iir_y_y[chan_idx][0])/a1);
touch_push(iir_y_y[chan_idx], y2, 1);
y2 = y2*s2;
//TOUCH_LOGI("y2=%f,touch_chan=%d,num=%d\r\n",y2,chan_idx,num);
//initial oscilation
if(g_num >= 100)
{
//The y2 is negative
if ((y2 < touch_delt[chan_idx]))
{
s_touch_channel = chan[chan_idx];
}
}
rtos_delay_milliseconds(2);
}
void touch_capa_cali(void *param)
{
uint32_t touch_chan = 2;
UINT32 cap_out = 0;
int ret = 0;
uint32_t chan[11] = {2,3,4,5,8,9,10,11,12,14,15};
UINT8 j = 0;
touch_config_t touch_config;
if(g_touch_capa_cali_flag == 0)
{
g_touch_capa_cali_flag = 1;
for(j = 0; j < 11; j++)
{
touch_chan = chan[j];
bk_touch_gpio_init(1 << touch_chan);
bk_touch_enable(1 << touch_chan);
bk_touch_scan_mode_enable(0);
touch_config.sensitivity_level = TOUCH_SENSITIVITY_LEVLE_0;
touch_config.detect_threshold = TOUCH_DETECT_THRESHOLD_6;
touch_config.detect_range = TOUCH_DETECT_RANGE_8PF;
bk_touch_config(&touch_config);
bk_touch_calibration_start();
cap_out = bk_touch_get_calib_value();
//TOUCH_LOGI("cap_out=%d,touch_chan=%d\r\n",cap_out,chan[j]);
bk_touch_manul_mode_enable(cap_out);
bk_touch_manul_mode_disable();
}
if (touch_capa_cali_tmr.handle != NULL)
{
ret = rtos_reload_timer(&touch_capa_cali_tmr);
BK_ASSERT(kNoErr == ret);
}
g_touch_capa_cali_flag = 0;
}
else
{
TOUCH_LOGI("touch saradc task executing!\r\n");
}
}
void touch_adc_get(void *param)
{
UINT8 j;
int err;
g_num += 1;
if(g_touch_capa_cali_flag == 0)
{
g_touch_capa_cali_flag = 2;
BK_LOG_ON_ERR(bk_adc_acquire());
sys_drv_set_ana_pwd_gadc_buf(0);
BK_LOG_ON_ERR(bk_adc_init(ADC_9));
adc_config_t config = {0};
config.chan = ADC_9;
config.adc_mode = 3;
config.src_clk = 1;
config.clk = 0x31975;
config.saturate_mode = 4;
config.steady_ctrl= 7;
config.adc_filter = 0;
if(config.adc_mode == ADC_CONTINUOUS_MODE)
{
config.sample_rate = 0;
}
BK_LOG_ON_ERR(bk_adc_set_config(&config));
BK_LOG_ON_ERR(bk_adc_enable_bypass_clalibration());
BK_LOG_ON_ERR(bk_adc_start());
for(j = 0; j < 11; j++)
{
touch_saradc_iir_iir_fillter(j);
}
if(g_num >= 100)
g_num -= 1;
bk_adc_stop();
bk_adc_deinit(ADC_9);
bk_adc_release();
if (touch_tmr.handle != NULL)
{
err = rtos_reload_timer(&touch_tmr);
BK_ASSERT(kNoErr == err);
}
g_touch_capa_cali_flag = 0;
}
}
void cli_touch_adc_mode_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
if (os_strcmp(argv[1], "cali") == 0)
{
UINT32 t_ms = 5000;
int err;
if (touch_capa_cali_tmr.handle != NULL)
{
err = rtos_deinit_timer(&touch_capa_cali_tmr);
BK_ASSERT(kNoErr == err);
touch_capa_cali_tmr.handle = NULL;
}
err = rtos_init_timer(&touch_capa_cali_tmr,
t_ms,
touch_capa_cali,
(void *)0);
BK_ASSERT(kNoErr == err);
err = rtos_start_timer(&touch_capa_cali_tmr);
BK_ASSERT(kNoErr == err);
//enable LED
err = bk_touch_digital_tube_display_init();
if (err != BK_OK)
{
TOUCH_LOGI("init touch digital tube display task failed!\r\n");
return;
}
}
else if(os_strcmp(argv[1], "test") == 0)
{
UINT32 t_ms = 100;
int err;
if (touch_tmr.handle != NULL)
{
err = rtos_deinit_timer(&touch_tmr);
BK_ASSERT(kNoErr == err);
touch_tmr.handle = NULL;
}
err = rtos_init_timer(&touch_tmr,
t_ms,
touch_adc_get,
(void *)0);
BK_ASSERT(kNoErr == err);
err = rtos_start_timer(&touch_tmr);
BK_ASSERT(kNoErr == err);
}
}
#endif
Reference in New Issue Copy Permalink