wen/luban-lite-t3e-pro
1
0
Fork 0
mirror of https://gitee.com/Vancouver2017/luban-lite-t3e-pro.git synced 2025-12-16 19:38:56 +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

15
bsp/examples/test-ctp/SConscript
View File

@@ -6,18 +6,9 @@ cwd = GetCurrentDir()
CPPPATH = []
src = []
if GetDepend('AIC_TP_DRV_TEST'):
src = []
if GetDepend('AIC_TOUCH_PANEL_GT911'):
src += Glob('test_gt911.c')
if GetDepend('AIC_TOUCH_PANEL_FT7411'):
src += Glob('test_ft7411.c')
if GetDepend('AIC_TOUCH_PANEL_GSL1680'):
src += Glob('test_gsl1680.c')
if GetDepend('AIC_TOUCH_PANEL_ST16XX'):
src += Glob('test_st16xx.c')
if GetDepend('AIC_TOUCH_PANEL_AXS15260'):
src += Glob('test_axs15260.c')
src = Glob('*.c')
group = DefineGroup('test-ctp', src, depend = [''], CPPPATH = CPPPATH)
group = DefineGroup('test-touch', src, depend = [''], CPPPATH = CPPPATH)
Return('group')

105
bsp/examples/test-ctp/test_axs15260.c
View File

@@ -1,105 +0,0 @@
/*
* Copyright (c) 2024, ArtInChip Technology Co., Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Notes
* 2024-05-27 the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#include "axs15260.h"
#define THREAD_PRIORITY 25
#define THREAD_STACK_SIZE 4096
#define THREAD_TIMESLICE 5
static rt_sem_t g_axs15260_sem = RT_NULL;
static rt_device_t g_dev = RT_NULL;
static struct rt_touch_data *g_read_data;
static struct rt_touch_info g_info;
static void axs15260_entry(void *parameter)
{
g_read_data = (struct rt_touch_data *)rt_malloc(sizeof(struct rt_touch_data) * 2);
while (1) {
rt_sem_take(g_axs15260_sem, RT_WAITING_FOREVER);
rt_memset(g_read_data, 0, sizeof(g_read_data));
rt_device_read(g_dev, 0, g_read_data, 1);
switch(g_read_data->event)
{
case RT_TOUCH_EVENT_DOWN:
rt_kprintf("down x: %03d y: %03d\n",
g_read_data->x_coordinate, g_read_data->y_coordinate);
break;
case RT_TOUCH_EVENT_UP:
rt_kprintf("up x: %03d y: %03d\n",
g_read_data->x_coordinate, g_read_data->y_coordinate);
break;
case RT_TOUCH_EVENT_MOVE:
rt_kprintf("move x: %03d y: %03d\n",
g_read_data->x_coordinate, g_read_data->y_coordinate);
break;
default:
break;
}
rt_device_control(g_dev, RT_TOUCH_CTRL_ENABLE_INT, RT_NULL);
}
}
static rt_err_t rx_callback(rt_device_t dev, rt_size_t size)
{
rt_sem_release(g_axs15260_sem);
rt_device_control(dev, RT_TOUCH_CTRL_DISABLE_INT, RT_NULL);
return 0;
}
/* Test function */
static void test_axs15260(void *parameter)
{
rt_thread_t axs15260_thread = RT_NULL;
g_dev = rt_device_find("axs15260");
if (g_dev == RT_NULL) {
rt_kprintf("can't find device: axs15260\n");
return;
}
if (rt_device_open(g_dev, RT_DEVICE_FLAG_INT_RX) != RT_EOK) {
rt_kprintf("open device failed!");
return;
} else {
rt_device_control(g_dev, RT_TOUCH_CTRL_GET_INFO, &g_info);
rt_kprintf("type :%d\n", g_info.type);
rt_kprintf("point_num :%d\n", g_info.point_num);
rt_kprintf("range_x :%d\n", g_info.range_x);
rt_kprintf("range_y :%d\n", g_info.range_y);
}
rt_device_set_rx_indicate(g_dev, rx_callback);
g_axs15260_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_FIFO);
if (g_axs15260_sem == RT_NULL) {
rt_kprintf("create dynamic semaphore failed.\n");
return;
}
axs15260_thread = rt_thread_create("axs15260",
axs15260_entry,
RT_NULL,
THREAD_STACK_SIZE,
THREAD_PRIORITY,
THREAD_TIMESLICE);
if (axs15260_thread != RT_NULL)
rt_thread_startup(axs15260_thread);
return;
}
MSH_CMD_EXPORT(test_axs15260, test axs15260 sample);

85
bsp/examples/test-ctp/test_ft7411.c
View File

@@ -1,85 +0,0 @@
/*
* Copyright (c) 2023-2024, ArtInChip Technology Co., Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Notes
* 2024-01-06 the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#include "ft7411.h"
#include "touch.h"
#include "aic_hal_gpio.h"
#include <rtdbg.h>
#define DBG_TAG "ft7411_example"
#define DBG_LVL DBG_LOG
static rt_thread_t ft7411_thread;
static rt_device_t ft7411;
static void ft7411_thread_entry(void *parameter)
{
struct rt_touch_data *read_data;
read_data = (struct rt_touch_data *)rt_calloc(1, sizeof(struct rt_touch_data));
while(1)
{
rt_memset(read_data, 0, sizeof(struct rt_touch_data));
rt_device_read(ft7411, 0, read_data, 1);
switch(read_data->event)
{
case RT_TOUCH_EVENT_DOWN:
rt_kprintf("down x: %03d y: %03d", read_data->x_coordinate, read_data->y_coordinate);
rt_kprintf(" t: %d\n", read_data->timestamp);
break;
case RT_TOUCH_EVENT_UP:
rt_kprintf("up x: %03d y: %03d", read_data->x_coordinate, read_data->y_coordinate);
rt_kprintf(" t: %d\n", read_data->timestamp);
break;
case RT_TOUCH_EVENT_MOVE:
rt_kprintf("move x: %03d y: %03d", read_data->x_coordinate, read_data->y_coordinate);
rt_kprintf(" t: %d\n", read_data->timestamp);
break;
default:
break;
}
rt_thread_delay(10);
}
}
static int test_ft7411(void)
{
ft7411 = rt_device_find("ft7411");
rt_device_open(ft7411, RT_DEVICE_FLAG_RDONLY);
struct rt_touch_info info;
rt_device_control(ft7411, RT_TOUCH_CTRL_GET_INFO, &info);
LOG_I("type :%d", info.type);
LOG_I("vendor :%d", info.vendor);
LOG_I("point_num :%d", info.point_num);
LOG_I("range_x :%d", info.range_x);
LOG_I("range_y :%d", info.range_y);
ft7411_thread = rt_thread_create("ft7411", ft7411_thread_entry, RT_NULL, 1600, 25, 20);
if (ft7411_thread == RT_NULL)
{
LOG_D("create ft7411 thread err");
return -RT_ENOMEM;
}
rt_thread_startup(ft7411_thread);
return RT_EOK;
}
MSH_CMD_EXPORT(test_ft7411, test ft7411 sample);

84
bsp/examples/test-ctp/test_gsl1680.c
View File

@@ -1,84 +0,0 @@
/*
* Copyright (c) 2023-2024, ArtInChip Technology Co., Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Notes
* 2024-01-10 the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#include "gsl1680.h"
#include "touch.h"
#include <rtdbg.h>
#define DBG_TAG "gsl1680_example"
#define DBG_LVL DBG_LOG
rt_thread_t gsl1680_thread;
rt_device_t gsl1680;
void gsl1680_thread_entry(void *parameter)
{
struct rt_touch_data *read_data;
read_data = (struct rt_touch_data *)rt_calloc(1, sizeof(struct rt_touch_data));
while(1)
{
rt_memset(read_data, 0, sizeof(struct rt_touch_data));
rt_device_read(gsl1680, 0, read_data, 1);
switch (read_data->event)
{
case RT_TOUCH_EVENT_DOWN:
rt_kprintf("down x: %03d y: %03d", read_data->x_coordinate, read_data->y_coordinate);
rt_kprintf(" t: %d\n", read_data->timestamp);
break;
case RT_TOUCH_EVENT_MOVE:
rt_kprintf("move x: %03d y: %03d", read_data->x_coordinate, read_data->y_coordinate);
rt_kprintf(" t: %d\n", read_data->timestamp);
break;
case RT_TOUCH_EVENT_UP:
rt_kprintf("up x: %03d y: %03d", read_data->x_coordinate, read_data->y_coordinate);
rt_kprintf(" t: %d\n", read_data->timestamp);
break;
default:
break;
}
rt_thread_delay(10);
}
}
int test_gsl1680(void)
{
gsl1680 = rt_device_find("gsl1680");
rt_device_open(gsl1680, RT_DEVICE_FLAG_RDONLY);
struct rt_touch_info info;
rt_device_control(gsl1680, RT_TOUCH_CTRL_GET_INFO, &info);
LOG_I("type :%d", info.type);
LOG_I("vendor :%d", info.vendor);
LOG_I("point_num :%d", info.point_num);
LOG_I("range_x :%d", info.range_x);
LOG_I("range_y :%d", info.range_y);
gsl1680_thread = rt_thread_create("gsl1680", gsl1680_thread_entry, RT_NULL, 1600, 25, 20);
if (gsl1680_thread == RT_NULL)
{
LOG_D("create gsl1680 thread err");
return -RT_ENOMEM;
}
rt_thread_startup(gsl1680_thread);
return RT_EOK;
}
MSH_CMD_EXPORT(test_gsl1680, test gsl1680 sample);

111
bsp/examples/test-ctp/test_gt911.c
View File

@@ -1,111 +0,0 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2021-01-13 RiceChen the first version
* 2023-05-04 GeoDong modified for ArtInChip
*/
#include <rtthread.h>
#include <rtdevice.h>
#include "gt911.h"
#define THREAD_PRIORITY 25
#define THREAD_STACK_SIZE 1024
#define THREAD_TIMESLICE 5
static rt_thread_t gt911_thread = RT_NULL;
static rt_sem_t gt911_sem = RT_NULL;
static rt_device_t dev = RT_NULL;
static struct rt_touch_data *read_data;
static struct rt_touch_info info;
static void gt911_entry(void *parameter)
{
rt_device_control(dev, RT_TOUCH_CTRL_GET_INFO, &info);
read_data = (struct rt_touch_data *)rt_malloc(sizeof(struct rt_touch_data) * info.point_num);
while (1)
{
rt_sem_take(gt911_sem, RT_WAITING_FOREVER);
if (rt_device_read(dev, 0, read_data, info.point_num) == info.point_num)
{
for (rt_uint8_t i = 0; i < info.point_num; i++)
{
if (read_data[i].event == RT_TOUCH_EVENT_DOWN || read_data[i].event == RT_TOUCH_EVENT_MOVE)
{
rt_kprintf("%d %d %d %d %d\n", read_data[i].track_id,
read_data[i].x_coordinate,
read_data[i].y_coordinate,
read_data[i].timestamp,
read_data[i].width);
}
}
}
rt_device_control(dev, RT_TOUCH_CTRL_ENABLE_INT, RT_NULL);
}
}
static rt_err_t rx_callback(rt_device_t dev, rt_size_t size)
{
rt_sem_release(gt911_sem);
rt_device_control(dev, RT_TOUCH_CTRL_DISABLE_INT, RT_NULL);
return 0;
}
/* Test function */
static void test_gt911(void *parameter)
{
void *id;
dev = rt_device_find("gt911");
if (dev == RT_NULL)
{
rt_kprintf("can't find device:%s\n", "gt911");
return;
}
if (rt_device_open(dev, RT_DEVICE_FLAG_INT_RX) != RT_EOK)
{
rt_kprintf("open device failed!");
return;
}
id = rt_malloc(sizeof(rt_uint8_t) * 8);
rt_device_control(dev, RT_TOUCH_CTRL_GET_ID, id);
rt_uint8_t * read_id = (rt_uint8_t *)id;
rt_kprintf("id = GT%d%d%d \n", read_id[0] - '0', read_id[1] - '0', read_id[2] - '0');
// rt_device_control(dev, RT_TOUCH_CTRL_SET_X_RANGE, &x); /* if possible you can set your x y coordinate*/
// rt_device_control(dev, RT_TOUCH_CTRL_SET_Y_RANGE, &y);
rt_device_control(dev, RT_TOUCH_CTRL_GET_INFO, id);
rt_kprintf("range_x = %d \n", (*(struct rt_touch_info*)id).range_x);
rt_kprintf("range_y = %d \n", (*(struct rt_touch_info*)id).range_y);
rt_kprintf("point_num = %d \n", (*(struct rt_touch_info*)id).point_num);
rt_free(id);
rt_device_set_rx_indicate(dev, rx_callback);
gt911_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_FIFO);
if (gt911_sem == RT_NULL)
{
rt_kprintf("create dynamic semaphore failed.\n");
return;
}
gt911_thread = rt_thread_create("gt911",
gt911_entry,
RT_NULL,
THREAD_STACK_SIZE,
THREAD_PRIORITY,
THREAD_TIMESLICE);
if (gt911_thread != RT_NULL)
rt_thread_startup(gt911_thread);
return;
}
MSH_CMD_EXPORT(test_gt911, test gt911 sample);

76
bsp/examples/test-ctp/test_st16xx.c → bsp/examples/test-ctp/test_touch.c
View File

@@ -1,36 +1,45 @@
/*
* Copyright (c) 2024-2025, ArtInChip Technology Co., Ltd
* Copyright (c) 2024, ArtInChip Technology Co., Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Notes
* 2024-04-22 the first version
* 2024-08-14 the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#include "st16xx.h"
#define THREAD_PRIORITY 25
#define THREAD_STACK_SIZE 4096
#define THREAD_TIMESLICE 5
#define THREAD_PRIORITY 25
#define THREAD_STACK_SIZE 4096
#define THREAD_TIMESLICE 5
#define TOUCH_DEFAULT_NAME "gt911"
static rt_sem_t g_st16xx_sem = RT_NULL;
static rt_sem_t g_touch_sem = RT_NULL;
static rt_device_t g_dev = RT_NULL;
static struct rt_touch_data *g_read_data;
static struct rt_touch_info g_info;
static struct rt_touch_data *g_read_data = RT_NULL;
static struct rt_touch_info g_info = {0};
static void st16xx_entry(void *parameter)
static void cmd_touch_test_help(void)
{
rt_kprintf("Usage:\n");
rt_kprintf("\ttest_touch <sensor_name>\n");
rt_kprintf("\tFor example:\n");
rt_kprintf("\t\ttest_touch\n");
rt_kprintf("\t\ttest_touch gt911\n");
}
static void touch_entry(void *parameter)
{
rt_device_control(g_dev, RT_TOUCH_CTRL_GET_INFO, &g_info);
g_read_data = (struct rt_touch_data *)rt_malloc(sizeof(struct rt_touch_data) * g_info.point_num);
while (1) {
rt_sem_take(g_st16xx_sem, RT_WAITING_FOREVER);
rt_sem_take(g_touch_sem, RT_WAITING_FOREVER);
if (rt_device_read(g_dev, 0, g_read_data, g_info.point_num) == g_info.point_num) {
if (rt_device_read(g_dev, 0, g_read_data, g_info.point_num) > 0) {
for (rt_uint8_t i = 0; i < g_info.point_num; i++) {
if (g_read_data[i].event == RT_TOUCH_EVENT_DOWN ||
g_read_data[i].event == RT_TOUCH_EVENT_MOVE ||
@@ -43,24 +52,40 @@ static void st16xx_entry(void *parameter)
}
}
rt_device_control(g_dev, RT_TOUCH_CTRL_ENABLE_INT, RT_NULL);
/*
* If using polling mode,
* the following conmments must be opened,
* and the masking related to semaphores must be removed.
*/
//rt_thread_mdelay(10);
}
}
static rt_err_t rx_callback(rt_device_t dev, rt_size_t size)
{
rt_sem_release(g_st16xx_sem);
rt_sem_release(g_touch_sem);
rt_device_control(dev, RT_TOUCH_CTRL_DISABLE_INT, RT_NULL);
return 0;
}
/* Test function */
static void test_st16xx(void *parameter)
static void test_touch(int argc, char *argv[])
{
rt_thread_t st16xx_thread = RT_NULL;
rt_thread_t touch_thread = RT_NULL;
char touch_name[RT_NAME_MAX];
g_dev = rt_device_find("st16xx");
if (argc == 2) {
rt_strncpy(touch_name, argv[1], RT_NAME_MAX);
} else if (argc > 2) {
cmd_touch_test_help();
return;
} else {
rt_strncpy(touch_name, TOUCH_DEFAULT_NAME, RT_NAME_MAX);
}
g_dev = rt_device_find(touch_name);
if (g_dev == RT_NULL) {
rt_kprintf("can't find device: st16xx\n");
rt_kprintf("can't find device: touch\n");
return;
}
@@ -76,22 +101,23 @@ static void test_st16xx(void *parameter)
}
rt_device_set_rx_indicate(g_dev, rx_callback);
g_st16xx_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_FIFO);
if (g_st16xx_sem == RT_NULL) {
g_touch_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_FIFO);
if (g_touch_sem == RT_NULL) {
rt_kprintf("create dynamic semaphore failed.\n");
return;
}
st16xx_thread = rt_thread_create("st16xx",
st16xx_entry,
touch_thread = rt_thread_create("touch",
touch_entry,
RT_NULL,
THREAD_STACK_SIZE,
THREAD_PRIORITY,
THREAD_TIMESLICE);
if (st16xx_thread != RT_NULL)
rt_thread_startup(st16xx_thread);
if (touch_thread != RT_NULL)
rt_thread_startup(touch_thread);
return;
}
MSH_CMD_EXPORT(test_st16xx, test st16xx sample);
MSH_CMD_EXPORT(test_touch, test touch sample);