Merge pull request #2937 from balanceTWK/master_encoder

[components][drivers] add encoder driven framework

components/drivers/Kconfig

@@ -434,6 +434,10 @@ menuconfig RT_USING_HWCRYPTO
         endif
     endif
 
+config RT_USING_ENCODER
+    bool "Using ENCODER device drivers"
+    default n
+
 menuconfig RT_USING_WIFI
     bool "Using Wi-Fi framework"
     default n

components/drivers/include/drivers/encoder.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-08-08     balanceTWK   the first version
+ */
+
+#ifndef __ENCODER_H__
+#define __ENCODER_H__
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* encoder control command */
+#define ENCODER_CMD_GET_TYPE       (128 + 0)    /* get a encoder type information */
+#define ENCODER_CMD_ENABLE         (128 + 1)    /* enable encoder */
+#define ENCODER_CMD_DISABLE        (128 + 2)    /* disable encoder */
+#define ENCODER_CMD_CLEAR_COUNT    (128 + 3)    /* clear encoder count */
+
+/* encoder type */
+enum rt_encoder_type
+{
+    UNKNOWN_ENCODER_TYPE = 0x00,    /* Unknown encoder type */
+    SINGLE_PHASE_ENCODER,           /* single phase encoder */
+    AB_PHASE_ENCODER                /* two phase encoder */
+};
+
+struct rt_encoder_device;
+
+struct rt_encoder_ops
+{
+    rt_err_t (*init)(struct rt_encoder_device *encoder);
+    rt_int32_t (*get_count)(struct rt_encoder_device *encoder);
+    rt_err_t (*clear_count)(struct rt_encoder_device *encoder);
+    rt_err_t (*control)(struct rt_encoder_device *encoder, rt_uint32_t cmd, void *args);
+};
+
+struct rt_encoder_device
+{
+    struct rt_device parent;
+    const struct rt_encoder_ops *ops;
+    enum rt_encoder_type type;
+};
+
+rt_err_t rt_device_encoder_register(struct rt_encoder_device *encoder, const char *name, void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ENCODER_H__ */

components/drivers/include/rtdevice.h

@@ -126,6 +126,10 @@ extern "C" {
 #include "drivers/crypto.h"
 #endif
 
+#ifdef RT_USING_ENCODER
+#include "drivers/encoder.h"
+#endif
+
 #ifdef __cplusplus
 }
 #endif

components/drivers/misc/SConscript

@@ -13,6 +13,9 @@ if GetDepend(['RT_USING_ADC']):
     
 if GetDepend(['RT_USING_PWM']):
     src = src + ['rt_drv_pwm.c']
+    
+if GetDepend(['RT_USING_ENCODER']):
+    src = src + ['encoder.c']
 
 if len(src):
     group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH)

components/drivers/misc/encoder.c

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-08-08     balanceTWK   the first version
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+static rt_err_t rt_encoder_init(struct rt_device *dev)
+{
+    struct rt_encoder_device *encoder;
+
+    encoder = (struct rt_encoder_device *)dev;
+    if (encoder->ops->init)
+    {
+        return encoder->ops->init(encoder);
+    }
+    else
+    {
+        return -RT_ENOSYS;
+    }
+}
+
+static rt_err_t rt_encoder_open(struct rt_device *dev, rt_uint16_t oflag)
+{
+    struct rt_encoder_device *encoder;
+
+    encoder = (struct rt_encoder_device *)dev;
+    if (encoder->ops->control)
+    {
+        return encoder->ops->control(encoder, ENCODER_CMD_ENABLE, RT_NULL);
+    }
+    else
+    {
+        return -RT_ENOSYS;
+    }
+}
+
+static rt_err_t rt_encoder_close(struct rt_device *dev)
+{
+    struct rt_encoder_device *encoder;
+
+    encoder = (struct rt_encoder_device *)dev;
+    if (encoder->ops->control)
+    {
+        return encoder->ops->control(encoder, ENCODER_CMD_DISABLE, RT_NULL);
+    }
+    else
+    {
+        return -RT_ENOSYS;
+    }
+}
+
+static rt_size_t rt_encoder_read(struct rt_device *dev, rt_off_t pos, void *buffer, rt_size_t size)
+{
+    struct rt_encoder_device *encoder;
+
+    encoder = (struct rt_encoder_device *)dev;
+    if (encoder->ops->get_count)
+    {
+        *(rt_int32_t *)buffer = encoder->ops->get_count(encoder);
+    }
+    return 1;
+}
+
+static rt_err_t rt_encoder_control(struct rt_device *dev, int cmd, void *args)
+{
+    rt_err_t result;
+    struct rt_encoder_device *encoder;
+
+    result = RT_EOK;
+    encoder = (struct rt_encoder_device *)dev;
+    switch (cmd)
+    {
+    case ENCODER_CMD_CLEAR_COUNT:
+        result = encoder->ops->clear_count(encoder);
+        break;
+    case ENCODER_CMD_GET_TYPE:
+        *(enum rt_encoder_type *)args = encoder->type;
+        break;
+    case ENCODER_CMD_ENABLE:
+    case ENCODER_CMD_DISABLE:
+        result = encoder->ops->control(encoder, cmd, args);
+        break;
+    default:
+        result = -RT_ENOSYS;
+        break;
+    }
+
+    return result;
+}
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops encoder_ops =
+{
+    rt_encoder_init,
+    rt_encoder_open,
+    rt_encoder_close,
+    rt_encoder_read,
+    RT_NULL,
+    rt_encoder_control
+};
+#endif
+
+rt_err_t rt_device_encoder_register(struct rt_encoder_device *encoder, const char *name, void *user_data)
+{
+    struct rt_device *device;
+
+    RT_ASSERT(encoder != RT_NULL);
+    RT_ASSERT(encoder->ops != RT_NULL);
+
+    device = &(encoder->parent);
+
+    device->type        = RT_Device_Class_Miscellaneous;
+    device->rx_indicate = RT_NULL;
+    device->tx_complete = RT_NULL;
+
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &encoder_ops;
+#else
+    device->init        = rt_encoder_init;
+    device->open        = rt_encoder_open;
+    device->close       = rt_encoder_close;
+    device->read        = rt_encoder_read;
+    device->write       = RT_NULL;
+    device->control     = rt_encoder_control;
+#endif
+    device->user_data   = user_data;
+
+    return rt_device_register(device, name, RT_DEVICE_FLAG_RDONLY | RT_DEVICE_FLAG_STANDALONE);
+}