diff --git a/components/drivers/Kconfig b/components/drivers/Kconfig index ff2639b8fabf2c33b0e572de5dd1b7a2fb66e019..cc3919ccecf754e24fa07a04fddebc62add5a258 100755 --- a/components/drivers/Kconfig +++ b/components/drivers/Kconfig @@ -438,6 +438,16 @@ config RT_USING_ENCODER bool "Using ENCODER device drivers" default n +config RT_USING_CAPTURE + bool "Using CAPTURE device drivers" + default n + +if RT_USING_CAPTURE + config RT_CAPTURE_RB_SIZE + int "Set capture rinbuffer size" + default 100 +endif + menuconfig RT_USING_WIFI bool "Using Wi-Fi framework" default n diff --git a/components/drivers/include/drivers/rt_capture.h b/components/drivers/include/drivers/rt_capture.h new file mode 100644 index 0000000000000000000000000000000000000000..efc2ae4db12b172fdb704bba6df9407f13c57d01 --- /dev/null +++ b/components/drivers/include/drivers/rt_capture.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2006-2018, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2019-08-13 balanceTWK first version. + */ + +#ifndef __RT_CAPTURE_H__ +#define __RT_CAPTURE_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* capture control command */ +#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 +{ + rt_bool_t is_high; + rt_uint32_t pulsewidth_us; +}; + +struct rt_capture_device +{ + struct rt_device parent; + + const struct rt_capture_ops *ops; + struct rt_ringbuffer *ringbuff; + rt_size_t watermark; +}; + +/** + * capture operators + */ +struct rt_capture_ops +{ + rt_err_t (*init)(struct rt_capture_device *capture); + rt_err_t (*open)(struct rt_capture_device *capture); + rt_err_t (*close)(struct rt_capture_device *capture); + rt_err_t (*get_pulsewidth)(struct rt_capture_device *capture, rt_uint32_t *pulsewidth_us); +}; + +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); +#ifdef __cplusplus +} +#endif + +#endif /* __RT_CAPTURE_H__ */ diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h index 0c009e95807763a776224f32011948f66a2772c4..3ba7f723571ccc3d5d2d399e1d06b92152853408 100644 --- a/components/drivers/include/rtdevice.h +++ b/components/drivers/include/rtdevice.h @@ -130,6 +130,10 @@ extern "C" { #include "drivers/encoder.h" #endif +#ifdef RT_USING_CAPTURE +#include "drivers/rt_capture.h" +#endif + #ifdef __cplusplus } #endif diff --git a/components/drivers/misc/SConscript b/components/drivers/misc/SConscript index 3bfb73fea0787c5b8b673e27ec7e3e222b102bb8..7bc638f42751db2214e87879cb0b18b443f6d3f6 100644 --- a/components/drivers/misc/SConscript +++ b/components/drivers/misc/SConscript @@ -17,6 +17,9 @@ if GetDepend(['RT_USING_PWM']): if GetDepend(['RT_USING_ENCODER']): src = src + ['encoder.c'] +if GetDepend(['RT_USING_CAPTURE']): + src = src + ['rt_capture.c'] + if len(src): group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH) diff --git a/components/drivers/misc/rt_capture.c b/components/drivers/misc/rt_capture.c new file mode 100644 index 0000000000000000000000000000000000000000..69337fc319825f884ae8e452abad90daf7591223 --- /dev/null +++ b/components/drivers/misc/rt_capture.c @@ -0,0 +1,184 @@ +/* + * Copyright (c) 2006-2018, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2019-08-13 balanceTWK the first version + */ + +#include +#include + +static rt_err_t rt_capture_init(struct rt_device *dev) +{ + struct rt_capture_device *capture; + + RT_ASSERT(dev != RT_NULL); + + capture = (struct rt_capture_device *)dev; + capture->watermark = RT_CAPTURE_RB_SIZE/2; + if(capture->ops->init) + { + return capture->ops->init(capture); + } + else + { + return -RT_ENOSYS; + } +} + +static rt_err_t rt_capture_open(struct rt_device *dev, rt_uint16_t oflag) +{ + struct rt_capture_device *capture; + + RT_ASSERT(dev != RT_NULL); + + capture = (struct rt_capture_device *)dev; + if(capture->ringbuff == RT_NULL) + { + capture->ringbuff = rt_ringbuffer_create(sizeof(struct capture_data_struct)*RT_CAPTURE_RB_SIZE); + } + if(capture->ops->open) + { + return capture->ops->open(capture); + } + else + { + return -RT_ENOSYS; + } +} + +static rt_err_t rt_capture_close(struct rt_device *dev) +{ + rt_err_t ret; + struct rt_capture_device *capture; + + RT_ASSERT(dev != RT_NULL); + + ret = -RT_ERROR; + + capture = (struct rt_capture_device *)dev; + + if (capture->ops->close) + { + ret = capture->ops->close(capture); + } + else + { + return -RT_ENOSYS; + } + if(ret == RT_EOK) + { + if(capture->ringbuff) + { + 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_size_t receive_size; + struct rt_capture_device *capture; + + 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); + + return receive_size/sizeof(struct capture_data_struct); +} + +static rt_err_t rt_capture_control(struct rt_device *dev, int cmd, void *args) +{ + rt_err_t result; + struct rt_capture_device *capture; + + RT_ASSERT(dev != RT_NULL); + + result = RT_EOK; + capture = (struct rt_capture_device *)dev; + switch (cmd) + { + case CAPTURE_CMD_CLEAR_BUF: + rt_ringbuffer_reset(capture->ringbuff); + break; + case CAPTURE_CMD_SET_WATERMARK: + capture->watermark = *(rt_size_t *)args; + break; + default: + result = -RT_ENOSYS; + break; + } + + return result; +} + +#ifdef RT_USING_DEVICE_OPS +const static struct rt_device_ops capture_ops = +{ + rt_capture_init, + rt_capture_open, + rt_capture_close, + rt_capture_read, + RT_NULL, + rt_capture_control +}; +#endif + +rt_err_t rt_device_capture_register(struct rt_capture_device *capture, const char *name, void *user_data) +{ + struct rt_device *device; + + RT_ASSERT(capture != RT_NULL); + RT_ASSERT(capture->ops != RT_NULL); + + device = &(capture->parent); + + device->type = RT_Device_Class_Miscellaneous; + device->rx_indicate = RT_NULL; + device->tx_complete = RT_NULL; + +#ifdef RT_USING_DEVICE_OPS + device->ops = &capture_ops; +#else + device->init = rt_capture_init; + device->open = rt_capture_open; + device->close = rt_capture_close; + device->read = rt_capture_read; + device->write = RT_NULL; + device->control = rt_capture_control; +#endif + device->user_data = user_data; + + return rt_device_register(device, name, RT_DEVICE_FLAG_RDONLY | RT_DEVICE_FLAG_STANDALONE); +} + +/* ISR for capture interrupt */ +void rt_hw_capture_isr(struct rt_capture_device *capture, rt_bool_t level) +{ + struct capture_data_struct data; + rt_size_t receive_size; + 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)); + + receive_size = rt_ringbuffer_data_len(capture->ringbuff); + if(receive_size >= capture->watermark) + { + /* indicate to upper layer application */ + if (capture->parent.rx_indicate != RT_NULL) + capture->parent.rx_indicate(&capture->parent, receive_size); + } +}