[components][drivers] update capture driven framework

components/drivers/Kconfig

@@ -444,7 +444,7 @@ config RT_USING_CAPTURE
 
 if RT_USING_CAPTURE
     config RT_CAPTURE_RB_SIZE
-        int "Set capture rinbuffer size"
+        int "Set capture ringbuffer size"
         default 100
 endif
 

components/drivers/include/drivers/rt_capture.h

@@ -22,19 +22,19 @@ extern "C" {
 #define CAPTURE_CMD_CLEAR_BUF        (128 + 0)    /* clear capture buf */
 #define CAPTURE_CMD_SET_WATERMARK    (128 + 1)    /* Set the callback threshold */
 
-struct capture_data_struct
+struct capture_data
 {
-    rt_bool_t   is_high;
     rt_uint32_t pulsewidth_us;
+    rt_bool_t   is_high;
 };
 
 struct rt_capture_device
 {
-    struct rt_device          parent;
+    struct rt_device               parent;
 
-    const struct rt_capture_ops *ops;
-    struct rt_ringbuffer *ringbuff;
-    rt_size_t watermark;
+    const struct rt_capture_ops    *ops;
+    struct rt_ringbuffer           *ringbuff;
+    rt_size_t                      watermark;
 };
 
 /**
@@ -50,10 +50,9 @@ struct rt_capture_ops
 
 void rt_hw_capture_isr(struct rt_capture_device *capture, rt_bool_t level);
 
-rt_err_t rt_hw_capture_register(struct rt_capture_device *capture,
-                               const char              *name,
-                               rt_uint32_t              flag,
-                               void                    *data);
+rt_err_t rt_device_capture_register(struct rt_capture_device *capture,
+                                    const char               *name,
+                                    void                     *data);
 #ifdef __cplusplus
 }
 #endif

components/drivers/misc/rt_capture.c

@@ -10,44 +10,45 @@
 
 #include <rtthread.h>
 #include <rtdevice.h>
+#include <rtdbg.h>
 
 static rt_err_t rt_capture_init(struct rt_device *dev)
 {
+    rt_err_t ret;
     struct rt_capture_device *capture;
 
     RT_ASSERT(dev != RT_NULL);
 
+    ret = RT_EOK;
     capture = (struct rt_capture_device *)dev;
-    capture->watermark = RT_CAPTURE_RB_SIZE/2;
-    if(capture->ops->init)
-    {
-        return capture->ops->init(capture);
-    }
-    else
+    capture->watermark = RT_CAPTURE_RB_SIZE / 2;
+    if (capture->ops->init)
     {
-        return -RT_ENOSYS;
+        ret = capture->ops->init(capture);
     }
+
+    return ret;
 }
 
 static rt_err_t rt_capture_open(struct rt_device *dev, rt_uint16_t oflag)
 {
+    rt_err_t ret;
     struct rt_capture_device *capture;
 
     RT_ASSERT(dev != RT_NULL);
 
+    ret = RT_EOK;
     capture = (struct rt_capture_device *)dev;
-    if(capture->ringbuff == RT_NULL)
+    if (capture->ringbuff == RT_NULL)
     {
-        capture->ringbuff = rt_ringbuffer_create(sizeof(struct capture_data_struct)*RT_CAPTURE_RB_SIZE);
+        capture->ringbuff = rt_ringbuffer_create(sizeof(struct capture_data) * RT_CAPTURE_RB_SIZE);
     }
-    if(capture->ops->open)
+    if (capture->ops->open)
     {
-        return capture->ops->open(capture);
-    }
-    else
-    {
-        return -RT_ENOSYS;
+        ret = capture->ops->open(capture);
     }
+
+    return ret;
 }
 
 static rt_err_t rt_capture_close(struct rt_device *dev)
@@ -58,32 +59,30 @@ static rt_err_t rt_capture_close(struct rt_device *dev)
     RT_ASSERT(dev != RT_NULL);
 
     ret = -RT_ERROR;
-
     capture = (struct rt_capture_device *)dev;
 
     if (capture->ops->close)
     {
         ret = capture->ops->close(capture);
     }
-    else
+
+    if (ret != RT_EOK)
     {
-        return -RT_ENOSYS;
+        return ret;
     }
-    if(ret == RT_EOK)
+
+    if (capture->ringbuff)
     {
-        if(capture->ringbuff)
-        {
-            rt_ringbuffer_destroy(capture->ringbuff);
-            capture->ringbuff = RT_NULL;
-        }
+        rt_ringbuffer_destroy(capture->ringbuff);
+        capture->ringbuff = RT_NULL;
     }
     return ret;
 }
 
 static rt_size_t rt_capture_read(struct rt_device *dev,
-                                rt_off_t          pos,
-                                void             *buffer,
-                                rt_size_t         size)
+                                 rt_off_t          pos,
+                                 void             *buffer,
+                                 rt_size_t         size)
 {
     rt_size_t receive_size;
     struct rt_capture_device *capture;
@@ -91,9 +90,9 @@ static rt_size_t rt_capture_read(struct rt_device *dev,
     RT_ASSERT(dev != RT_NULL);
 
     capture = (struct rt_capture_device *)dev;
-    receive_size = rt_ringbuffer_get(capture->ringbuff, (rt_uint8_t*)buffer, sizeof(struct capture_data_struct)*size);
+    receive_size = rt_ringbuffer_get(capture->ringbuff, (rt_uint8_t *)buffer, sizeof(struct capture_data) * size);
 
-    return receive_size/sizeof(struct capture_data_struct);
+    return receive_size / sizeof(struct capture_data);
 }
 
 static rt_err_t rt_capture_control(struct rt_device *dev, int cmd, void *args)
@@ -108,7 +107,10 @@ static rt_err_t rt_capture_control(struct rt_device *dev, int cmd, void *args)
     switch (cmd)
     {
     case CAPTURE_CMD_CLEAR_BUF:
-        rt_ringbuffer_reset(capture->ringbuff);
+        if (capture->ringbuff)
+        {
+            rt_ringbuffer_reset(capture->ringbuff);
+        }
         break;
     case CAPTURE_CMD_SET_WATERMARK:
         capture->watermark = *(rt_size_t *)args;
@@ -139,12 +141,14 @@ rt_err_t rt_device_capture_register(struct rt_capture_device *capture, const cha
 
     RT_ASSERT(capture != RT_NULL);
     RT_ASSERT(capture->ops != RT_NULL);
+    RT_ASSERT(capture->ops->get_pulsewidth != RT_NULL);
 
     device = &(capture->parent);
 
     device->type        = RT_Device_Class_Miscellaneous;
     device->rx_indicate = RT_NULL;
     device->tx_complete = RT_NULL;
+    capture->ringbuff = RT_NULL;
 
 #ifdef RT_USING_DEVICE_OPS
     device->ops         = &capture_ops;
@@ -161,21 +165,28 @@ rt_err_t rt_device_capture_register(struct rt_capture_device *capture, const cha
     return rt_device_register(device, name, RT_DEVICE_FLAG_RDONLY | RT_DEVICE_FLAG_STANDALONE);
 }
 
-/* ISR for capture interrupt */
+/**
+ * This function is ISR for capture interrupt.
+ * level: RT_TRUE denotes high level pulse, and RT_FALSE denotes low level pulse.
+ */
 void rt_hw_capture_isr(struct rt_capture_device *capture, rt_bool_t level)
 {
-    struct capture_data_struct data;
+    struct capture_data data;
     rt_size_t receive_size;
-    if(capture->ops->get_pulsewidth(capture, &data.pulsewidth_us) != RT_EOK)
+    if (capture->ops->get_pulsewidth(capture, &data.pulsewidth_us) != RT_EOK)
     {
         return;
     }
 
     data.is_high = level;
-    rt_ringbuffer_put(capture->ringbuff, (rt_uint8_t*)&data.pulsewidth_us, sizeof(rt_uint32_t));
+    if (rt_ringbuffer_put(capture->ringbuff, (rt_uint8_t *)&data, sizeof(struct capture_data)) == 0)
+    {
+        LOG_W("capture ringbuffer doesn't have enough space.");
+    }
+
+    receive_size =  rt_ringbuffer_data_len(capture->ringbuff) / sizeof(struct capture_data);
 
-    receive_size = rt_ringbuffer_data_len(capture->ringbuff);
-    if(receive_size >= capture->watermark)
+    if (receive_size >= capture->watermark)
     {
         /* indicate to upper layer application */
         if (capture->parent.rx_indicate != RT_NULL)