helloyifa/lock_lfvx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
lock_lfvx/bk_idk/components/bk_cli/cli_adc.c
helloyifa 40580710f2 first commit
2025-10-10 16:07:00 +08:00

406 lines
12 KiB
C
Raw Blame History

#include "cli.h"
#include "bk_saradc.h"
#include <driver/adc.h>
#include "adc_statis.h"
#include <os/os.h>
#include <os/os.h>
#include "sys_driver.h"
static UINT8 flag = 0;
static void cli_adc_help(void)
{
CLI_LOGI("adc_driver init/deinit\n");
CLI_LOGI("adc_test [channel] [init/deinit/start/stop/dump_statis/get_value/single_step_mode_read\n");
CLI_LOGI("adc_test [channel] [config] [mode] [src_clk] [adc_clk] [sature_mode] [sampl_rate]\n");
CLI_LOGI("adc_test [channel] [read/rag_cb] [size] [time_out]\n");
CLI_LOGI("adc_api_test [set_mode/get_mode/set_clk/set_sample_rate/set_channel/set_filter/\
set_steady_time/set_sample_cnt/set_saturate\n");
}
static void cli_adc_register_cb(uint32_t param)
{
CLI_LOGI("param:%d , adc isr cb \r\n", param);
}
static void cli_adc_driver_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
if (argc < 2) {
cli_adc_help();
return;
}
if (os_strcmp(argv[1], "init") == 0) {
BK_LOG_ON_ERR(bk_adc_driver_init());
CLI_LOGI("adc driver init\n");
} else if (os_strcmp(argv[1], "deinit") == 0) {
BK_LOG_ON_ERR(bk_adc_driver_deinit());
CLI_LOGI("adc driver deinit\n");
} else {
cli_adc_help();
return;
}
}
static float cli_adc_read_multi_chan(void)
{
uint16_t value = 0;
float cali_value = 0;
UINT8 adc_chan_buff[12] = {0,1,2,3,4,5,6,10,12,13,14,15};
UINT32 loop_num = 10;
adc_config_t config = {0};
if(flag == 1)
{
CLI_LOGI("adc_read is running\r\n");
return 0;
}
config.chan = 0;
config.adc_mode = 3;
config.src_clk = 1;
config.clk = 0x30e035;
config.saturate_mode = 4;
config.steady_ctrl= 7;
config.adc_filter = 0;
if(config.adc_mode == ADC_CONTINUOUS_MODE) {
config.sample_rate = 0;
}
flag = 1;
BK_LOG_ON_ERR(bk_adc_acquire());
sys_drv_set_ana_pwd_gadc_buf(1);
for(UINT8 i = 0; i < (sizeof(adc_chan_buff)/sizeof(UINT8)); i++)
{
config.chan = adc_chan_buff[i];
BK_LOG_ON_ERR(bk_adc_init(config.chan));
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(UINT8 j = 0; j < loop_num; j++)
{
BK_LOG_ON_ERR(bk_adc_read(&value, ADC_READ_SEMAPHORE_WAIT_TIME));
cali_value = bk_adc_data_calculate(value, config.chan);
CLI_LOGI("volt:%d mv,chan=%d\n",(uint32_t)(cali_value*1000),config.chan);
}
bk_adc_stop();
bk_adc_deinit(config.chan);
}
sys_drv_set_ana_pwd_gadc_buf(0);
bk_adc_release();
flag = 0;
return cali_value;
}
static float cli_adc_read_single_chan(UINT8 adc_chan)
{
uint16_t value = 0;
float cali_value = 0;
if(flag == 1)
{
CLI_LOGI("adc_read is running\r\n");
return 0;
}
flag = 1;
BK_LOG_ON_ERR(bk_adc_acquire());
sys_drv_set_ana_pwd_gadc_buf(1);
BK_LOG_ON_ERR(bk_adc_init(adc_chan));
adc_config_t config = {0};
config.chan = adc_chan;
config.adc_mode = 3;
config.src_clk = 1;
config.clk = 0x30e035;
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());
BK_LOG_ON_ERR(bk_adc_read(&value, ADC_READ_SEMAPHORE_WAIT_TIME));
cali_value = bk_adc_data_calculate(value, adc_chan);
bk_adc_stop();
sys_drv_set_ana_pwd_gadc_buf(0);
bk_adc_deinit(adc_chan);
bk_adc_release();
CLI_LOGI("volt value:%d mv\n",(uint32_t)(cali_value*1000));
flag = 0;
return cali_value;
}
static void cli_adc_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t adc_chan;
if (argc < 2) {
cli_adc_help();
return;
}
adc_chan = os_strtoul(argv[1], NULL, 10);
if (os_strcmp(argv[2], "config") == 0) {
adc_config_t config = {0};
os_memset(&config, 0, sizeof(adc_config_t));
config.chan = adc_chan;
config.adc_mode = os_strtoul(argv[3], NULL, 10);
config.src_clk = os_strtoul(argv[4], NULL, 10);
config.clk = os_strtoul(argv[5], NULL, 10);
config.saturate_mode = os_strtoul(argv[6], NULL, 10);
config.steady_ctrl= 7;
config.adc_filter = 0;
if(config.adc_mode == ADC_CONTINUOUS_MODE) {
config.sample_rate = os_strtoul(argv[7], NULL, 10);
}
BK_LOG_ON_ERR(bk_adc_init(adc_chan));
BK_LOG_ON_ERR(bk_adc_set_config(&config));
CLI_LOGI("adc init test:adc_channel:%x, adc_mode:%x,src_clk:%x,adc_clk:%x, saturate_mode:%x, sample_rate:%x",
adc_chan, config.adc_mode, config.src_clk, config.clk, config.saturate_mode, config.sample_rate);
} else if (os_strcmp(argv[2], "deinit") == 0) {
BK_LOG_ON_ERR(bk_adc_deinit(adc_chan));
CLI_LOGI("adc deinit test");
} else if (os_strcmp(argv[2], "start") == 0) {
BK_LOG_ON_ERR(bk_adc_set_channel(adc_chan));
BK_LOG_ON_ERR(bk_adc_enable_bypass_clalibration());
BK_LOG_ON_ERR(bk_adc_start());
CLI_LOGI("start adc test\n");
} else if (os_strcmp(argv[2], "stop") == 0) {
BK_LOG_ON_ERR(bk_adc_stop());
bk_adc_release();
CLI_LOGI("adc_stop test: %d\n", adc_chan);
} else if (os_strcmp(argv[2], "get_value") == 0) {
uint16_t value = 0;
float cali_value = 0;
if(bk_adc_set_channel(adc_chan)) {
bk_adc_release();
return;
}
BK_LOG_ON_ERR(bk_adc_read(&value, ADC_READ_SEMAPHORE_WAIT_TIME));
cali_value = saradc_calculate(value);
CLI_LOGI("adc value:%d mv\n", (uint32_t)(cali_value * 1000));
} else if (os_strcmp(argv[2], "read") == 0) {
uint32_t sum = 0;
uint32_t size = os_strtoul(argv[3], NULL, 10);
uint16_t *recv_data = (uint16_t *)os_malloc(size*sizeof(uint16_t));
if (recv_data == NULL) {
CLI_LOGE("recv buffer malloc failed\r\n");
return;
}
int time_out = os_strtoul(argv[4], NULL, 10);
if (time_out < 0) {
time_out = BEKEN_WAIT_FOREVER;
}
bk_adc_acquire();
if(bk_adc_set_channel(adc_chan)) {
bk_adc_release();
return;
}
BK_LOG_ON_ERR(bk_adc_read_raw(recv_data, size, time_out));
#if 0
if((length > ADC_TEST_CNT_MAX) || (length == 0))
return;
#endif
bk_adc_release();
if (!recv_data) {
CLI_LOGE("adc read failed, recv_data is null \r\n");
}
CLI_LOGI("adc: read length :time_out:%d read_size:%d\n",time_out, size);
for (int i = 0; i < size; i++) {
sum = sum + recv_data[i];
CLI_LOGI("recv_buffer[%d]=%02x, sum =%d\n", i, recv_data[i], sum);
}
sum = sum / size;
CLI_LOGI("adc read size:%d, adc_result_from _data_reg:%d\n", size, sum);
os_free(recv_data);
} else if (os_strcmp(argv[2], "dump_statis") == 0) {
adc_statis_dump();
CLI_LOGI("adc dump statis ok\r\n");
} else if (os_strcmp(argv[2], "single_step_mode_read") == 0) {
bk_adc_acquire();
bk_adc_set_channel(adc_chan);
uint32_t ret = bk_adc_set_mode(ADC_SINGLE_STEP_MODE);
if(ret) {
bk_adc_release();
return ;
}
uint16_t data = 0;
bk_adc_single_read(&data);
bk_adc_release();
CLI_LOGI("adc single step mode: adc value is 0x%x\n", data);
} else if (os_strcmp(argv[2], "reg_cb") == 0) {
uint32_t size = os_strtoul(argv[3], NULL, 10);
BK_LOG_ON_ERR(bk_adc_register_isr(cli_adc_register_cb, size));
CLI_LOGI("adc isr cb register\r\n");
}
else if (0 == os_strcmp(argv[2], "saradc_val_read"))
{
uint32_t status;
status=0;
//status = manual_cal_load_adc_cali_flash();
if (status != 0)
{
os_printf("Can't read cali value, use default!\r\n");
os_printf("calibrate low value:[%x]\r\n", saradc_val.low);
os_printf("calibrate high value:[%x]\r\n", saradc_val.high);
}
}
else if(0 == os_strcmp(argv[2], "use_sample_set_saradc_val"))
{
uint16_t sample_value= 0;
uint8_t ret;
SARADC_MODE saradc_cal_mode;
adc_config_t config = {0};
os_memset(&config, 0, sizeof(adc_config_t));
config.chan = adc_chan;
config.adc_mode = os_strtoul(argv[3], NULL, 10);
config.src_clk = os_strtoul(argv[4], NULL, 10);
config.clk = os_strtoul(argv[5], NULL, 10);
config.saturate_mode = os_strtoul(argv[6], NULL, 10);
config.steady_ctrl= 7;
config.adc_filter = 0;
if(config.adc_mode == ADC_CONTINUOUS_MODE)
{
config.sample_rate = os_strtoul(argv[7], NULL, 10);
}
BK_LOG_ON_ERR(bk_adc_init(adc_chan));
BK_LOG_ON_ERR(bk_adc_set_config(&config));
CLI_LOGI("adc init test:adc_channel:%x, adc_mode:%x,src_clk:%x,adc_clk:%x, saturate_mode:%x, sample_rate:%x",
adc_chan, config.adc_mode, config.src_clk, config.clk, config.saturate_mode, config.sample_rate);
BK_LOG_ON_ERR(bk_adc_set_channel(adc_chan));
if (0 == os_strcmp(argv[8], "low"))
{
saradc_cal_mode = SARADC_CALIBRATE_LOW;
}
else if (0 == os_strcmp(argv[3], "high"))
{
saradc_cal_mode = SARADC_CALIBRATE_HIGH;
}
else
{
os_printf("invalid parameter\r\n");
return;
}
BK_LOG_ON_ERR(bk_adc_start());
BK_LOG_ON_ERR(bk_adc_enable_bypass_clalibration());
CLI_LOGI("start adc test\n");
bk_adc_acquire();
BK_LOG_ON_ERR(bk_adc_read(&sample_value, ADC_READ_SEMAPHORE_WAIT_TIME));
ret = saradc_set_calibrate_val(&sample_value, saradc_cal_mode);
if(ret == SARADC_FAILURE)
{
os_printf("saradc_set_calibrate_val fail\r\n");
}
os_printf("saradc_set_calibrate_val success\r\n");
os_printf("mode:[%s] value:[%d]\r\n", (saradc_cal_mode ? "high" : "low"), sample_value);
//BK_LOG_ON_ERR(bk_adc_stop());
}
else if(os_strcmp(argv[2], "single_adc_example") == 0)
{
cli_adc_read_single_chan(adc_chan);
}
else if(os_strcmp(argv[2], "multi_adc_example") == 0)
{
cli_adc_read_multi_chan();
}
else
{
cli_adc_help();
return;
}
}
static void cli_adc_api_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
if (argc < 2) {
cli_adc_help();
return;
}
if (os_strcmp(argv[1], "set_clk") == 0) {
uint32_t clk = os_strtoul(argv[2], NULL, 10);
uint32_t src_clk = os_strtoul(argv[3], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_clk(src_clk, clk));
CLI_LOGI("adc set clk: clk_src:%d, clk:%d", src_clk, clk);
} else if (os_strcmp(argv[1], "set_mode") == 0) {
uint32_t mode = os_strtoul(argv[2], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_mode(mode));
CLI_LOGI("adc set_mode: %x", mode);
} else if (os_strcmp(argv[1], "set_channel") == 0) {
uint32_t adc_chan = os_strtoul(argv[2], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_channel(adc_chan));
CLI_LOGI("adc %d test", adc_chan);
}else if (os_strcmp(argv[1], "set_sample_rate") == 0) {
uint32_t sample_rate = os_strtoul(argv[2], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_sample_rate(sample_rate));
CLI_LOGI("adc sample rate: %x", sample_rate);
} else if (os_strcmp(argv[1], "set_filter") == 0) {
uint32_t filter = os_strtoul(argv[2], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_filter(filter));
CLI_LOGI("adc set_filter : %x", filter);
} else if (os_strcmp(argv[1], "set_steady_time") == 0) {
uint32_t time = os_strtoul(argv[2], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_steady_time(time));
CLI_LOGI("adc set_steady time : %x", time);
}else if (os_strcmp(argv[1], "set_sample_cnt") == 0) {
uint32_t sample_cnt = os_strtoul(argv[2], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_sample_cnt(sample_cnt));
CLI_LOGI("adc set_sample_cnt: %x", sample_cnt);
} else if (os_strcmp(argv[1], "set_saturate") == 0) {
uint32_t saturate = os_strtoul(argv[2], NULL, 10);
BK_LOG_ON_ERR(bk_adc_set_saturate_mode(saturate));
CLI_LOGI("adc set_set_saturate: %x", saturate);
} else if (os_strcmp(argv[1], "get_mode") == 0) {
uint32_t mode = 0;
mode = bk_adc_get_mode();
CLI_LOGI("adc get_mode: %x", mode);
} else {
cli_adc_help();
return;
}
}
#define ADC_CMD_CNT (sizeof(s_adc_commands) / sizeof(struct cli_command))
static const struct cli_command s_adc_commands[] = {
{"adc_driver", "adc_driver [init/deinit]", cli_adc_driver_cmd},
{"adc_test", "adc_test [channel] [start/stop/dump_statis]", cli_adc_cmd},
{"adc_api_test", "adc_api_test []", cli_adc_api_cmd},
};
int cli_adc_init(void)
{
return cli_register_commands(s_adc_commands, ADC_CMD_CNT);
}
Reference in New Issue View Git Blame Copy Permalink