add touch framework

components/drivers/include/drivers/i2c.h

@@ -60,6 +60,13 @@ struct rt_i2c_bus_device
     void *priv;
 };
 
+struct rt_i2c_client
+{
+    struct rt_device               parent;
+    struct rt_i2c_bus_device       *bus;
+    rt_uint16_t                    client_addr;
+};
+
 #ifdef RT_I2C_DEBUG
 #define i2c_dbg(fmt, ...)   rt_kprintf(fmt, ##__VA_ARGS__)
 #else

components/drivers/touch/SConscript

+# SConscript for touch framework 
+
+from building import *
+
+cwd = GetCurrentDir()
+src = ['touch.c']
+CPPPATH = [cwd, cwd + '/../include']
+
+group = DefineGroup('Touch', src, depend = ['RT_USING_TOUCH', 'RT_USING_DEVICE'], CPPPATH = CPPPATH)
+
+Return('group')

components/drivers/touch/touch.c

+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-05-20     tyustli      the first version
+ */
+
+#include "touch.h"
+#include <string.h>
+
+#define DBG_TAG  "touch"
+#define DBG_LVL DBG_INFO
+#include <rtdbg.h>
+
+/* touch interrupt handler function */
+void rt_touch_cb(rt_touch_t touch)
+{
+    if (touch->parent.rx_indicate == RT_NULL)
+    {
+        return;
+    }
+
+    if (touch->irq_handle != RT_NULL)
+    {
+        touch->irq_handle(touch);
+    }
+
+    touch->parent.rx_indicate(&touch->parent, 1);
+}
+
+/* ISR for touch interrupt */
+static void irq_callback(void *args)
+{
+    rt_touch_t touch;
+
+    touch = (rt_touch_t)args;
+
+    rt_touch_cb(touch);
+}
+
+/* touch interrupt initialization function */
+static rt_err_t rt_touch_irq_init(rt_touch_t touch)
+{
+    if (touch->config.irq_pin.pin == RT_PIN_NONE)
+    {
+        return -RT_EINVAL;
+    }
+
+    rt_pin_mode(touch->config.irq_pin.pin, touch->config.irq_pin.mode);
+
+    if (touch->config.irq_pin.mode == PIN_MODE_INPUT_PULLDOWN)
+    {
+        rt_pin_attach_irq(touch->config.irq_pin.pin, PIN_IRQ_MODE_RISING, irq_callback, (void *)touch);
+    }
+    else if (touch->config.irq_pin.mode == PIN_MODE_INPUT_PULLUP)
+    {
+        rt_pin_attach_irq(touch->config.irq_pin.pin, PIN_IRQ_MODE_FALLING, irq_callback, (void *)touch);
+    }
+    else if (touch->config.irq_pin.mode == PIN_MODE_INPUT)
+    {
+        rt_pin_attach_irq(touch->config.irq_pin.pin, PIN_IRQ_MODE_RISING_FALLING, irq_callback, (void *)touch);
+    }
+
+    rt_pin_irq_enable(touch->config.irq_pin.pin, PIN_IRQ_ENABLE);
+
+    LOG_I("interrupt init success");
+
+    return 0;
+}
+
+/* touch interrupt enable */
+static void rt_touch_irq_enable(rt_touch_t touch)
+{
+    if (touch->config.irq_pin.pin != RT_PIN_NONE)
+    {
+        rt_pin_irq_enable(touch->config.irq_pin.pin, RT_TRUE);
+    }
+}
+
+/* touch interrupt disable */
+static void rt_touch_irq_disable(rt_touch_t touch)
+{
+    if (touch->config.irq_pin.pin != RT_PIN_NONE)
+    {
+        rt_pin_irq_enable(touch->config.irq_pin.pin, RT_FALSE);
+    }
+}
+
+static rt_err_t rt_touch_open(rt_device_t dev, rt_uint16_t oflag)
+{
+    rt_touch_t touch;
+    RT_ASSERT(dev != RT_NULL);
+    touch = (rt_touch_t)dev;
+
+    if (oflag & RT_DEVICE_FLAG_INT_RX && dev->flag & RT_DEVICE_FLAG_INT_RX)
+    {
+        /* Initialization touch interrupt */
+        rt_touch_irq_init(touch);
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t  rt_touch_close(rt_device_t dev)
+{
+    rt_touch_t touch;
+    RT_ASSERT(dev != RT_NULL);
+    touch = (rt_touch_t)dev;
+
+    /* touch disable interrupt */
+    rt_touch_irq_disable(touch);
+
+    return RT_EOK;
+}
+
+static rt_size_t rt_touch_read(rt_device_t dev, rt_off_t pos, void *buf, rt_size_t len)
+{
+    rt_touch_t touch;
+    rt_size_t result = 0;
+    RT_ASSERT(dev != RT_NULL);
+    touch = (rt_touch_t)dev;
+
+    if (buf == NULL || len == 0)
+    {
+        return 0;
+    }
+
+    result = touch->ops->touch_readpoint(touch, buf, len);
+
+    return result;
+}
+
+static rt_err_t rt_touch_control(rt_device_t dev, int cmd, void *args)
+{
+    rt_touch_t touch;
+    rt_err_t result = RT_EOK;
+    RT_ASSERT(dev != RT_NULL);
+    touch = (rt_touch_t)dev;
+
+    switch (cmd)
+    {
+    case RT_TOUCH_CTRL_GET_ID:
+        if (args)
+        {
+            result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_GET_ID, args);
+        }
+        else
+        {
+            result = RT_ERROR;
+        }
+
+        break;
+    case RT_TOUCH_CTRL_GET_INFO:
+        if (args)
+        {
+            result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_GET_INFO, args);
+        }
+        else
+        {
+            result = RT_ERROR;
+        }
+
+        break;
+    case RT_TOUCH_CTRL_SET_MODE:
+        result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_SET_MODE, args);
+
+        if (result == RT_EOK)
+        {
+            rt_uint16_t mode;
+            mode  = *(rt_uint16_t*)args;
+            if (mode == RT_DEVICE_FLAG_INT_RX)
+            {
+                rt_touch_irq_enable(touch);  /* enable interrupt */
+            }
+        }
+
+        break;
+    case RT_TOUCH_CTRL_SET_X_RANGE:
+        result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_SET_X_RANGE, args);
+
+        if (result == RT_EOK)
+        {
+            touch->info.range_x = *(rt_int32_t *)args;
+            LOG_D("set x coordinate range :%d\n", touch->info.range_x);
+        }
+
+        break;
+    case RT_TOUCH_CTRL_SET_Y_RANGE:
+        result = touch->ops->touch_control(touch, RT_TOUCH_CTRL_SET_Y_RANGE, args);
+
+        if (result == RT_EOK)
+        {
+            touch->info.range_y = *(rt_uint32_t *)args;
+            LOG_D("set y coordinate range :%d \n", touch->info.range_x);
+        }
+
+        break;
+    default:
+        return -RT_ERROR;
+    }
+
+    return result;
+}
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops rt_touch_ops =
+{
+    RT_NULL,
+    rt_touch_open,
+    rt_touch_close,
+    rt_touch_read,
+    RT_NULL,
+    rt_touch_control
+};
+#endif
+
+/*
+ * touch register
+ */
+int rt_hw_touch_register(rt_touch_t touch,
+                         const char              *name,
+                         rt_uint32_t              flag,
+                         void                    *data)
+{
+    rt_int8_t result;
+    rt_device_t device;
+    RT_ASSERT(touch != RT_NULL);
+
+    char *touch_name = RT_NULL;
+    char *device_name = RT_NULL;
+
+    touch_name = "touch_";
+    device_name = rt_calloc(1, rt_strlen(touch_name) + 1 + rt_strlen(name));
+
+    if (device_name == RT_NULL)
+    {
+        LOG_E("device_name calloc failed!");
+        return -RT_ERROR;
+    }
+
+    rt_memcpy(device_name, touch_name, rt_strlen(touch_name) + 1);
+    strcat(device_name, name);
+
+    device = &touch->parent;
+
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &rt_touch_ops;
+#else
+    device->init        = RT_NULL;
+    device->open        = rt_touch_open;
+    device->close       = rt_touch_close;
+    device->read        = rt_touch_read;
+    device->write       = RT_NULL;
+    device->control     = rt_touch_control;
+#endif
+    device->type        = RT_Device_Class_Touch;
+    device->rx_indicate = RT_NULL;
+    device->tx_complete = RT_NULL;
+    device->user_data   = data;
+
+    result = rt_device_register(device, device_name, flag | RT_DEVICE_FLAG_STANDALONE);
+
+    if (result != RT_EOK)
+    {
+        LOG_E("rt_touch register err code: %d", result);
+        return result;
+    }
+
+    LOG_I("rt_touch init success");
+
+    return RT_EOK;
+}

components/drivers/touch/touch.h

+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-05-20     tyustli      the first version
+ */
+
+#ifndef __TOUCH_H__
+#define __TOUCH_H__
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef RT_USING_RTC
+#define  rt_touch_get_ts()  time(RT_NULL)          /* API for the touch to get the timestamp */
+#else
+#define  rt_touch_get_ts()  rt_tick_get()          /* API for the touch to get the timestamp */
+#endif
+
+#define  RT_PIN_NONE                     0xFFFF      /* RT PIN NONE */
+
+/* Touch vendor types */
+#define RT_TOUCH_VENDOR_UNKNOWN          (0)  /* unknown */
+#define RT_TOUCH_VENDOR_GT               (1)  /* GTxx series */
+#define RT_TOUCH_VENDOR_FT               (2)  /* FTxx series */
+
+/* Touch ic type*/
+#define  RT_TOUCH_TYPE_NONE              (0)  /* touch ic none */
+#define  RT_TOUCH_TYPE_CAPACITANCE       (1)  /* capacitance ic */
+#define  RT_TOUCH_TYPE_RESISTANCE        (2)  /* resistance ic */
+
+/* Touch control cmd types */
+#define  RT_TOUCH_CTRL_GET_ID            (0)   /* Get device id */
+#define  RT_TOUCH_CTRL_GET_INFO          (1)   /* Get touch info */
+#define  RT_TOUCH_CTRL_SET_MODE          (2)   /* Set touch's work mode. ex. RT_TOUCH_MODE_POLLING,RT_TOUCH_MODE_INT */
+#define  RT_TOUCH_CTRL_SET_X_RANGE       (3)   /* Set x coordinate range */
+#define  RT_TOUCH_CTRL_SET_Y_RANGE       (4)   /* Set y coordinate range */
+#define  RT_TOUCH_CTRL_SET_X_TO_Y        (5)   /* Set X Y coordinate exchange */
+
+/* Touch event */
+#define RT_TOUCH_EVENT_NONE              (0)   /* Touch none */
+#define RT_TOUCH_EVENT_UP                (1)   /* Touch up event */
+#define RT_TOUCH_EVENT_DOWN              (2)   /* Touch down event */
+#define RT_TOUCH_EVENT_MOVE              (3)   /* Touch move event */
+
+struct rt_touch_info
+{
+    rt_uint8_t     type;                       /* The touch type */
+    rt_uint8_t     vendor;                     /* Vendor of touchs */
+    rt_uint8_t     point_num;                  /* Support point num */
+    rt_int32_t     range_x;                    /* X coordinate range */
+    rt_int32_t     range_y;                    /* Y coordinate range */
+};
+
+struct rt_touch_config
+{
+    struct rt_device_pin_mode   irq_pin;       /* Interrupt pin, The purpose of this pin is to notification read data */
+    char                        *dev_name;     /* The name of the communication device */
+    void                        *user_data;
+};
+
+typedef struct rt_touch_device *rt_touch_t;
+struct rt_touch_device
+{
+    struct rt_device            parent;        /* The standard device */
+    struct rt_touch_info        info;          /* The touch info data */
+    struct rt_touch_config      config;        /* The touch config data */
+
+    const struct rt_touch_ops  *ops;           /* The touch ops */
+    rt_err_t (*irq_handle)(rt_touch_t touch);  /* Called when an interrupt is generated, registered by the driver */
+};
+
+struct rt_touch_data
+{
+    rt_uint8_t          event;                 /* The touch event of the data */
+    rt_uint8_t          track_id;              /* Track id of point */
+    rt_uint8_t          width;                 /* Point of width */
+    rt_uint16_t         x_coordinate;          /* Point of x coordinate */
+    rt_uint16_t         y_coordinate;          /* Point of y coordinate */
+    rt_tick_t           timestamp;             /* The timestamp when the data was received */
+};
+
+struct rt_touch_ops
+{
+    rt_size_t (*touch_readpoint)(struct rt_touch_device *touch, void *buf, rt_size_t touch_num);
+    rt_err_t (*touch_control)(struct rt_touch_device *touch, int cmd, void *arg);
+};
+
+int rt_hw_touch_register(rt_touch_t    touch,
+                         const char    *name,
+                         rt_uint32_t   flag,
+                         void          *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TOUCH_H__ */

components/finsh/cmd.c

@@ -801,6 +801,7 @@ static char *const device_type_str[] =
     "Timer Device",
     "Miscellaneous Device",
     "Sensor Device",
+    "Touch Device",
     "Unknown"
 };
 

include/rtdef.h

@@ -854,6 +854,7 @@ enum rt_device_class_type
     RT_Device_Class_Timer,                              /**< Timer device */
     RT_Device_Class_Miscellaneous,                      /**< Miscellaneous device */
     RT_Device_Class_Sensor,                             /**< Sensor device */
+    RT_Device_Class_Touch,                              /**< Touch device */
     RT_Device_Class_Unknown                             /**< unknown device */
 };