wen/luban-lite-t3e-pro
1
0
Fork 0
mirror of https://gitee.com/Vancouver2017/luban-lite-t3e-pro.git synced 2025-12-16 03:18:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

V1.0.6

Browse Source
This commit is contained in:
刘可亮
2024-09-03 11:16:08 +08:00
parent cf270df8d6
commit 803cac77d5
2931 changed files with 614364 additions and 31222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

274
bsp/examples/test-tsen/test_tsen.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023, ArtInChip Technology Co., Ltd
* Copyright (c) 2022-2024, ArtInChip Technology Co., Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
@@ -10,6 +10,7 @@
#include <string.h>
#include <getopt.h>
#include <sys/time.h>
#include <fcntl.h>
#define DBG_TAG "tsen.cmd"
@@ -17,24 +18,54 @@
#include "aic_log.h"
#include "sensor.h"
#include "hal_tsen.h"
#include <unistd.h>
#include <time.h>
/* Global macro and variables */
#define THREAD_PRIORITY 25
#define THREAD_STACK_SIZE 2048
#define THREAD_STACK_SIZE 4096
#define THREAD_TIMESLICE 50
#define AIC_CONFIG_FOLDER_PERMISSION 0755
#define AIC_CONFIG_PATH "/data/config"
#define AIC_TSEN_TEMP_PATH "/data/config/tsen_temp_records"
static rt_sensor_t g_sensor;
static int g_samples_num = 10;
static int g_sensor_id = 0;
static int g_polling_time = 10000;
static rt_device_t g_tsen_dev = RT_NULL;
static rt_thread_t g_tsen_thread = RT_NULL;
static rt_thread_t g_tsen_thread_polling = RT_NULL;
static rt_thread_t g_tsen_thread_recording = RT_NULL;
static const char sopts[] = "s:n:t:h";
/* Common configuration for various modes */
struct test_tsen_mod_cfg {
int sensor_id;
int mode_id;
int samp_cnt;
int polling_time;
};
/* Special configuration for recording modes */
struct test_tsen_record_cfg {
int record_time;
int record_data_size;
int temp_diff_th;
};
enum test_tsen_mod {
TEST_TSEN_MODE_READ = 0,
TEST_TSEN_MODE_RECORD,
TEST_TSEN_MODE_GET_RECORD
};
static struct test_tsen_mod_cfg g_modcfg = {0, -1, 10, 10};
static struct test_tsen_record_cfg g_recfg = {100, 0, 20};
static const char sopts[] = "m:s:n:t:r:d:h";
static const struct option lopts[] = {
{"mode", required_argument, NULL, 'm'},
{"sensor_id", required_argument, NULL, 's'},
{"samples_num", required_argument, NULL, 'n'},
{"polling_interval", required_argument, NULL, 't'},
{"record_time", required_argument, NULL, 'r'},
{"temp_diff_threshold", required_argument, NULL, 'd'},
{"help", no_argument, NULL, 'h'},
{0, 0, 0, 0}
};
@@ -42,25 +73,36 @@ static const struct option lopts[] = {
static void cmd_tsen_usage(char *program)
{
printf("Usage: %s [options]\n", program);
printf("\t -m, --mode_id\t\t\tSelect and start the reading/recording mode\n");
printf("\t -s, --sensor_id\t\tSelect the sensor, default is 0\n");
printf("\t -n, --samples_number\t\tSet the samples number, default is 10\n");
printf("\t -t, --polling_interval\t\tSet the polling interval (ms), default is 10000ms\n");
printf("\t -t, --polling_interval\t\tSet the polling interval (ms), default is 10ms\n");
printf("\t -r, --recording_time\t\tSet the recording time (ms), default is 100ms\n");
printf("\t -d, --temp_diff_threshold\tSet the temperature diff threshold (0.1℃ ), default is 20(2℃ )\n");
printf("\t -h, --help \n");
printf("\n");
printf("Example: %s -s 1 -n 10\n", program);
printf("Example: \n");
printf("\t %s -n 5 -t 10 -d 2 -r 20\n", program);
printf("\t %s -s 0 -m 1\n", program);
printf("\t %s -m 2\n", program);
printf("Mode ID:\n");
printf("\t[0] read temperature\n");
printf("\t[1] record temperature\n");
printf("\t[2] get recording temperature\n");
printf("Sensor ID:\n");
printf("\t[0] sensor_cpu\n");
printf("\t[1] sensor_gpai\n");
}
static void tsen_single_mode(void) {
static void test_tsen_single_mode(void) {
int num = 0;
struct rt_sensor_data data;
for (num = 0; num < g_samples_num; num++) {
for (num = 0; num < g_modcfg.samp_cnt; num++) {
if (rt_device_read(g_tsen_dev, 0, &data, 1) == 1)
rt_kprintf("num:%3d, temp:%3d.%d C, timestamp:%5d\n",
rt_kprintf("[%d] temp:%3d.%d C, timestamp:%5d\n",
num, data.data.temp / 10,(rt_uint32_t)data.data.temp % 10,
data.timestamp);
else
@@ -70,37 +112,146 @@ static void tsen_single_mode(void) {
}
static void tsen_polling_mode(void *parameter)
static void test_tsen_polling_mode(void *parameter)
{
int num = 0;
struct rt_sensor_data data;
int sampling_cnt = 0;
while (1) {
for (num = 0; num < g_samples_num; num++) {
if (rt_device_read(g_tsen_dev, 0, &data, 1) == 1)
rt_kprintf("num:%3d, temp:%3d.%d C, timestamp:%5d\n", num,
for (num = 0; num < g_modcfg.samp_cnt; num++) {
if (rt_device_read(g_tsen_dev, 0, &data, 1) == 1) {
rt_kprintf("[%d] temp:%3d.%d C, timestamp:%5d\n", num,
data.data.temp / 10,
(rt_uint32_t)data.data.temp % 10, data.timestamp);
sampling_cnt++;
}
else
rt_kprintf("read data failed!");
}
rt_thread_mdelay(g_polling_time);
rt_thread_mdelay(g_modcfg.polling_time);
}
}
static void tsen_start_polling(void)
static void test_tsen_start_polling(void)
{
g_tsen_thread = rt_thread_create("tsen_polling", tsen_polling_mode,
RT_NULL, THREAD_STACK_SIZE,
THREAD_PRIORITY, THREAD_TIMESLICE);
if (g_tsen_thread != RT_NULL)
rt_thread_startup(g_tsen_thread);
g_tsen_thread_polling = rt_thread_create("tsen_polling",
test_tsen_polling_mode, RT_NULL,
THREAD_STACK_SIZE, THREAD_PRIORITY,
THREAD_TIMESLICE);
if (g_tsen_thread_polling != RT_NULL)
rt_thread_startup(g_tsen_thread_polling);
return;
}
static char* tsen_sensor_selected(int sensor_id)
static int test_tsen_get_record_temp(void)
{
int fd;
int line_cnt =0;
int y_play;
int temp_buf[g_recfg.record_data_size];
memset(temp_buf, 0, sizeof(int) * g_recfg.record_data_size);
fd = open(AIC_TSEN_TEMP_PATH, O_RDONLY);
if (fd < 0)
return -1;
read(fd, temp_buf, sizeof(int) * g_recfg.record_data_size);
while(line_cnt < g_recfg.record_data_size) {
y_play = temp_buf[line_cnt];
rt_kprintf("[%d] temp:%3d.%d C\n", line_cnt, y_play / 10,
(rt_uint32_t)y_play % 10);
line_cnt++;
}
close(fd);
return 0;
}
static void test_tsen_record_mode(void *parameter)
{
int fd;
int num = 0;
struct rt_sensor_data data;
int sampling_cnt = 0;
int temp = 0;
int cur_temp = 0;
int last_temp = 0;
int abs_temp = 0;
int temp_buf_size = 0;
int samp_cnt = g_modcfg.samp_cnt;
int record_cnt = 0;
int polling_cnt = g_recfg.record_time / g_modcfg.polling_time;
if (samp_cnt <= 0)
return;
if (open(AIC_CONFIG_PATH, O_RDONLY) < 0)
mkdir(AIC_CONFIG_PATH, AIC_CONFIG_FOLDER_PERMISSION);
fd = open(AIC_TSEN_TEMP_PATH, O_CREAT | O_WRONLY);
if (fd > 0) {
temp_buf_size = samp_cnt * polling_cnt;
int temp_buf[temp_buf_size];
memset(temp_buf, 0, sizeof(int) * temp_buf_size);
while (polling_cnt) {
polling_cnt--;
for (num = 0; num < samp_cnt; num++) {
if(num == 0)
rt_kprintf("=========[%d]=========\n",
g_recfg.record_time / g_modcfg.polling_time -
polling_cnt);
if (rt_device_read(g_tsen_dev, 0, &data, 1) == 1) {
rt_kprintf("[%d] temp:%3d.%d C, timestamp:%5d\n",
sampling_cnt, data.data.temp / 10,
(rt_uint32_t)data.data.temp % 10,
data.timestamp);
temp += data.data.temp;
sampling_cnt++;
} else {
rt_kprintf("read data failed!");
}
}
cur_temp = temp / samp_cnt;
abs_temp = abs(cur_temp - last_temp);
if (abs_temp > g_recfg.temp_diff_th) {
memcpy(temp_buf + record_cnt, &cur_temp, sizeof(int));
record_cnt++;
}
last_temp = cur_temp;
rt_thread_mdelay(g_modcfg.polling_time);
temp = 0;
}
write(fd, temp_buf, sizeof(int) * record_cnt);
g_recfg.record_data_size = record_cnt;
rt_kprintf("total record count:%d\n", g_recfg.record_data_size);
close(fd);
rt_device_close(g_tsen_dev);
rt_thread_delete(g_tsen_thread_recording);
} else {
rt_kprintf("open file failed!\n");
}
}
static void test_tsen_start_recording(void)
{
g_tsen_thread_recording = rt_thread_create("tsen_recording",
test_tsen_record_mode, RT_NULL,
THREAD_STACK_SIZE,
THREAD_PRIORITY,
THREAD_TIMESLICE);
if (g_tsen_thread_recording != RT_NULL)
rt_thread_startup(g_tsen_thread_recording);
return;
}
static char* test_tsen_sensor_selected(int sensor_id)
{
switch (sensor_id) {
case AIC_TSEN_SENSOR_CPU:
@@ -113,73 +264,106 @@ static char* tsen_sensor_selected(int sensor_id)
}
static void cmd_test_tsen(int argc, char **argv)
static int cmd_test_tsen(int argc, char **argv)
{
int c, ret;
int c, ret = -1;
struct aic_tsen_ch tsen_info;
char *aic_tsen_name = NULL;
if (argc < 2) {
cmd_tsen_usage(argv[0]);
return;
goto __exit;
}
optind = 0;
while ((c = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
switch (c) {
case 's':
g_sensor_id = atoi(optarg);
g_modcfg.sensor_id = atoi(optarg);
continue;
case 'n':
g_samples_num = atoi(optarg);
g_modcfg.samp_cnt = atoi(optarg);
continue;
case 't':
g_polling_time = atoi(optarg);
g_modcfg.polling_time = atoi(optarg);
continue;
case 'r':
g_recfg.record_time = atoi(optarg);
continue;
case 'd':
g_recfg.temp_diff_th = atoi(optarg);
continue;
case 'm':
g_modcfg.mode_id = atoi(optarg);
continue;
case 'h':
cmd_tsen_usage(argv[0]);
return;
goto __exit;
default:
break;
}
}
if (g_modcfg.mode_id < 0)
goto __exit;
g_sensor = (rt_sensor_t)g_tsen_dev;
aic_tsen_name = tsen_sensor_selected(g_sensor_id);
aic_tsen_name = test_tsen_sensor_selected(g_modcfg.sensor_id);
if (aic_tsen_name == NULL) {
rt_kprintf("The sensor_id is error\n");
return;
goto __exit;
}
g_tsen_dev = rt_device_find(aic_tsen_name);
if (g_tsen_dev == RT_NULL) {
rt_kprintf("Failed to find %s device\n", aic_tsen_name);
return;
goto __exit;
}
ret = rt_device_open(g_tsen_dev, RT_DEVICE_FLAG_RDONLY);
if (ret != RT_EOK) {
rt_kprintf("Failed to open %s device\n", aic_tsen_name);
return;
goto __exit;
}
rt_device_control(g_tsen_dev, RT_SENSOR_CTRL_GET_CH_INFO, &tsen_info);
switch (tsen_info.soft_mode) {
case AIC_TSEN_SOFT_MODE_SINGLE:
rt_kprintf("[%s] Starting single mode\n", aic_tsen_name);
tsen_single_mode();
switch (g_modcfg.mode_id) {
case TEST_TSEN_MODE_READ:
if (tsen_info.soft_mode == AIC_TSEN_SOFT_MODE_SINGLE) {
rt_kprintf("[%s] Starting single mode\n", aic_tsen_name);
test_tsen_single_mode();
} else if (tsen_info.soft_mode == AIC_TSEN_SOFT_MODE_POLLING) {
rt_kprintf("[%s] Starting polling mode\n", aic_tsen_name);
test_tsen_start_polling();
} else {
rt_kprintf("Unknown read mode %d\n", tsen_info.mode);
goto __exit;
}
break;
case AIC_TSEN_SOFT_MODE_POLLING:
rt_kprintf("[%s] Starting polling mode\n", aic_tsen_name);
tsen_start_polling();
case TEST_TSEN_MODE_RECORD:
if (tsen_info.soft_mode != AIC_TSEN_SOFT_MODE_POLLING) {
rt_kprintf("Recording way needs select polling mode\n");
goto __exit;
}
test_tsen_start_recording();
break;
case TEST_TSEN_MODE_GET_RECORD:
test_tsen_get_record_temp();
rt_device_close(g_tsen_dev);
break;
default:
rt_kprintf("Unknown mode %d\n", tsen_info.mode);
}
rt_device_close(g_tsen_dev);
rt_kprintf("Unknown mode %d\n", g_modcfg.mode_id);
goto __exit;
}
g_modcfg.mode_id = -1;
ret = 0;
__exit:
return ret;
return;
}
MSH_CMD_EXPORT_ALIAS(cmd_test_tsen, test_tsen, tsen device sample);