[sensor-v2]将当前sensor框架revert回v1版本并独立为v2 (#7698)

1 files changed, 0 insertions, 521 deletions

diff --git a/components/drivers/sensor/sensor.c b/components/drivers/sensor/sensor.c
deleted file mode 100644
index e100cc27c3..0000000000
--- a/components/drivers/sensor/sensor.c
+++ /dev/null
@@ -1,521 +0,0 @@
-/*
- * Copyright (c) 2006-2023, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author       Notes
- * 2019-01-31     flybreak     first version
- * 2020-02-22     luhuadong    support custom commands
- * 2022-12-17     Meco Man     re-implement sensor framework
- */
-
-#include <drivers/sensor.h>
-
-#define DBG_TAG  "sensor"
-#define DBG_LVL DBG_INFO
-#include <rtdbg.h>
-
-#include <string.h>
-
-static char *const sensor_name_str[] =
-{
-    "None",
-    "ac-",       /* Accelerometer     */
-    "gy-",       /* Gyroscope         */
-    "ma-",       /* Magnetometer      */
-    "tm-",       /* Temperature       */
-    "hm-",       /* Relative Humidity */
-    "br-",       /* Barometer         */
-    "li-",       /* Ambient light     */
-    "pr-",       /* Proximity         */
-    "hr-",       /* Heart Rate        */
-    "tv-",       /* TVOC Level        */
-    "ni-",       /* Noise Loudness    */
-    "st-",       /* Step sensor       */
-    "fr-",       /* Force sensor      */
-    "du-",       /* Dust sensor       */
-    "ec-",       /* eCO2 sensor       */
-    "gn-",       /* GPS/GNSS sensor   */
-    "tf-",       /* TOF sensor        */
-    "sp-",       /* SpO2 sensor       */
-    "ia-",       /* IAQ sensor        */
-    "et-",       /* EtOH sensor       */
-    "bp-"        /* Blood Pressure    */
-};
-
-/* sensor interrupt handler function */
-static void _sensor_cb(rt_sensor_t sen)
-{
-    if (sen->parent.rx_indicate == RT_NULL)
-    {
-        return;
-    }
-
-    if (sen->irq_handle != RT_NULL)
-    {
-        sen->irq_handle(sen);
-    }
-
-    /* The buffer is not empty. Read the data in the buffer first */
-    if (sen->data_len > 0)
-    {
-        sen->parent.rx_indicate(&sen->parent, sen->data_len / sizeof(struct rt_sensor_data));
-    }
-    else if (RT_SENSOR_MODE_GET_FETCH(sen->info.mode) == RT_SENSOR_MODE_FETCH_INT)
-    {
-        /* The interrupt mode only produces one data at a time */
-        sen->parent.rx_indicate(&sen->parent, 1);
-    }
-    else if (RT_SENSOR_MODE_GET_FETCH(sen->info.mode) == RT_SENSOR_MODE_FETCH_FIFO)
-    {
-        sen->parent.rx_indicate(&sen->parent, sen->info.fifo_max);
-    }
-}
-
-/* ISR for sensor interrupt */
-static void _irq_callback(void *args)
-{
-    rt_sensor_t sensor = (rt_sensor_t)args;
-    rt_uint8_t i;
-
-    if (sensor->module)
-    {
-        /* Invoke a callback for all sensors in the module */
-        for (i = 0; i < sensor->module->sen_num; i++)
-        {
-            _sensor_cb(sensor->module->sen[i]);
-        }
-    }
-    else
-    {
-        _sensor_cb(sensor);
-    }
-}
-
-/* Sensor interrupt initialization function */
-static rt_err_t _sensor_irq_init(rt_sensor_t sensor)
-{
-    if (sensor->config.irq_pin.pin == PIN_IRQ_PIN_NONE)
-    {
-        return -RT_EINVAL;
-    }
-
-    rt_pin_mode(sensor->config.irq_pin.pin, sensor->config.irq_pin.mode);
-
-    if (sensor->config.irq_pin.mode == PIN_MODE_INPUT_PULLDOWN)
-    {
-        rt_pin_attach_irq(sensor->config.irq_pin.pin, PIN_IRQ_MODE_RISING, _irq_callback, (void *)sensor);
-    }
-    else if (sensor->config.irq_pin.mode == PIN_MODE_INPUT_PULLUP)
-    {
-        rt_pin_attach_irq(sensor->config.irq_pin.pin, PIN_IRQ_MODE_FALLING, _irq_callback, (void *)sensor);
-    }
-    else if (sensor->config.irq_pin.mode == PIN_MODE_INPUT)
-    {
-        rt_pin_attach_irq(sensor->config.irq_pin.pin, PIN_IRQ_MODE_RISING_FALLING, _irq_callback, (void *)sensor);
-    }
-
-    rt_pin_irq_enable(sensor->config.irq_pin.pin, RT_TRUE);
-
-    LOG_I("interrupt init success");
-
-    return 0;
-}
-
-/* sensor local ops */
-static rt_ssize_t _local_fetch_data(rt_sensor_t sensor, rt_sensor_data_t buf, rt_size_t len)
-{
-    LOG_D("Undefined fetch_data");
-    return -RT_EINVAL;
-}
-static rt_err_t _local_control(rt_sensor_t sensor, int cmd, void *arg)
-{
-    LOG_D("Undefined control");
-    return -RT_EINVAL;
-}
-static struct rt_sensor_ops local_ops =
-{
-    .fetch_data = _local_fetch_data,
-    .control = _local_control
-};
-
-/* RT-Thread Device Interface */
-static rt_err_t _sensor_open(rt_device_t dev, rt_uint16_t oflag)
-{
-    rt_sensor_t sensor = (rt_sensor_t)dev;
-    RT_ASSERT(dev != RT_NULL);
-    rt_err_t res = RT_EOK;
-    rt_err_t (*local_ctrl)(rt_sensor_t sensor, int cmd, void *arg) =  _local_control;
-
-    if (sensor->module)
-    {
-        /* take the module mutex */
-        rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
-    }
-
-    if (sensor->module != RT_NULL && sensor->info.fifo_max > 0 && sensor->data_buf == RT_NULL)
-    {
-        /* Allocate memory for the sensor buffer */
-        sensor->data_buf = rt_malloc(sizeof(struct rt_sensor_data) * sensor->info.fifo_max);
-        if (sensor->data_buf == RT_NULL)
-        {
-            res = -RT_ENOMEM;
-            goto __exit;
-        }
-    }
-    if (sensor->ops->control != RT_NULL)
-    {
-        local_ctrl = sensor->ops->control;
-    }
-
-    if (oflag & RT_DEVICE_FLAG_RDONLY && dev->flag & RT_DEVICE_FLAG_RDONLY)
-    {
-        /* If polling mode is supported, configure it to polling mode */
-        if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_FETCH_MODE, (void *)RT_SENSOR_MODE_FETCH_POLLING) == RT_EOK)
-        {
-            RT_SENSOR_MODE_SET_FETCH(sensor->info.mode, RT_SENSOR_MODE_FETCH_POLLING);
-        }
-    }
-    else if (oflag & RT_DEVICE_FLAG_INT_RX && dev->flag & RT_DEVICE_FLAG_INT_RX)
-    {
-        /* If interrupt mode is supported, configure it to interrupt mode */
-        if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_FETCH_MODE, (void *)RT_SENSOR_MODE_FETCH_INT) == RT_EOK)
-        {
-            /* Initialization sensor interrupt */
-            _sensor_irq_init(sensor);
-            RT_SENSOR_MODE_SET_FETCH(sensor->info.mode, RT_SENSOR_MODE_FETCH_INT);
-        }
-    }
-    else if (oflag & RT_DEVICE_FLAG_FIFO_RX && dev->flag & RT_DEVICE_FLAG_FIFO_RX)
-    {
-        /* If fifo mode is supported, configure it to fifo mode */
-        if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_FETCH_MODE, (void *)RT_SENSOR_MODE_FETCH_FIFO) == RT_EOK)
-        {
-            /* Initialization sensor interrupt */
-            _sensor_irq_init(sensor);
-            RT_SENSOR_MODE_SET_FETCH(sensor->info.mode, RT_SENSOR_MODE_FETCH_FIFO);
-        }
-    }
-    else
-    {
-        res = -RT_EINVAL;
-        goto __exit;
-    }
-
-    /* Configure power mode to highest mode */
-    if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER_MODE, (void *)RT_SENSOR_MODE_POWER_HIGHEST) == RT_EOK)
-    {
-        RT_SENSOR_MODE_SET_POWER(sensor->info.mode, RT_SENSOR_MODE_POWER_HIGHEST);
-    }
-
-    /* Configure accuracy mode to highest mode */
-    if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_ACCURACY_MODE, (void *)RT_SENSOR_MODE_ACCURACY_HIGHEST) == RT_EOK)
-    {
-        RT_SENSOR_MODE_SET_ACCURACY(sensor->info.mode, RT_SENSOR_MODE_ACCURACY_HIGHEST);
-    }
-
-__exit:
-    if (sensor->module)
-    {
-        /* release the module mutex */
-        rt_mutex_release(sensor->module->lock);
-    }
-
-    return res;
-}
-
-static rt_err_t _sensor_close(rt_device_t dev)
-{
-    rt_sensor_t sensor = (rt_sensor_t)dev;
-    rt_err_t (*local_ctrl)(rt_sensor_t sensor, int cmd, void *arg) = _local_control;
-    int i;
-
-    RT_ASSERT(dev != RT_NULL);
-
-    if (sensor->module)
-    {
-        rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
-    }
-    if (sensor->ops->control != RT_NULL)
-    {
-        local_ctrl = sensor->ops->control;
-    }
-
-    /* Configure power mode to power down mode */
-    if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER_MODE, (void *)RT_SENSOR_MODE_POWER_DOWN) == RT_EOK)
-    {
-        RT_SENSOR_MODE_SET_POWER(sensor->info.mode, RT_SENSOR_MODE_POWER_DOWN);
-    }
-
-    if (sensor->module != RT_NULL && sensor->info.fifo_max > 0 && sensor->data_buf != RT_NULL)
-    {
-        for (i = 0; i < sensor->module->sen_num; i ++)
-        {
-            if (sensor->module->sen[i]->parent.ref_count > 0)
-                goto __exit;
-        }
-
-        /* Free memory for the sensor buffer */
-        for (i = 0; i < sensor->module->sen_num; i ++)
-        {
-            if (sensor->module->sen[i]->data_buf)
-            {
-                rt_free(sensor->module->sen[i]->data_buf);
-                sensor->module->sen[i]->data_buf = RT_NULL;
-            }
-        }
-    }
-    if (RT_SENSOR_MODE_GET_FETCH(sensor->info.mode) != RT_SENSOR_MODE_FETCH_POLLING)
-    {
-        /* Sensor disable interrupt */
-        if (sensor->config.irq_pin.pin != PIN_IRQ_PIN_NONE)
-        {
-            rt_pin_irq_enable(sensor->config.irq_pin.pin, RT_FALSE);
-        }
-    }
-
-__exit:
-    if (sensor->module)
-    {
-        rt_mutex_release(sensor->module->lock);
-    }
-
-    return RT_EOK;
-}
-
-static rt_ssize_t _sensor_read(rt_device_t dev, rt_off_t pos, void *buf, rt_size_t len)
-{
-    rt_sensor_t sensor = (rt_sensor_t)dev;
-    rt_size_t result = 0;
-    RT_ASSERT(dev != RT_NULL);
-
-    if (buf == NULL || len == 0)
-    {
-        return 0;
-    }
-
-    if (sensor->module)
-    {
-        rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
-    }
-
-    /* The buffer is not empty. Read the data in the buffer first */
-    if (sensor->data_len > 0)
-    {
-        if (len > sensor->data_len / sizeof(struct rt_sensor_data))
-        {
-            len = sensor->data_len / sizeof(struct rt_sensor_data);
-        }
-
-        rt_memcpy(buf, sensor->data_buf, len * sizeof(struct rt_sensor_data));
-
-        /* Clear the buffer */
-        sensor->data_len = 0;
-        result = len;
-    }
-    else
-    {
-        /* If the buffer is empty, read the data */
-        if (sensor->ops->fetch_data)
-        {
-            result = sensor->ops->fetch_data(sensor, buf, len);
-        }
-    }
-
-    if (sensor->module)
-    {
-        rt_mutex_release(sensor->module->lock);
-    }
-
-    return result;
-}
-
-static rt_err_t _sensor_control(rt_device_t dev, int cmd, void *args)
-{
-    rt_sensor_t sensor = (rt_sensor_t)dev;
-    rt_err_t result = RT_EOK;
-    RT_ASSERT(dev != RT_NULL);
-    rt_err_t (*local_ctrl)(rt_sensor_t sensor, int cmd, void *arg) = _local_control;
-    rt_uint8_t mode;
-
-    if (sensor->module)
-    {
-        rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
-    }
-    if (sensor->ops->control != RT_NULL)
-    {
-        local_ctrl = sensor->ops->control;
-    }
-
-    switch (cmd)
-    {
-        case RT_SENSOR_CTRL_GET_ID:
-            if (args)
-            {
-                result = local_ctrl(sensor, RT_SENSOR_CTRL_GET_ID, args);
-            }
-            break;
-        case RT_SENSOR_CTRL_SET_ACCURACY_MODE:
-            /* Configuration sensor power mode */
-            mode = (rt_uint32_t)args & 0x000F;
-            if (!(mode == RT_SENSOR_MODE_ACCURACY_HIGHEST || mode == RT_SENSOR_MODE_ACCURACY_HIGH ||\
-                  mode == RT_SENSOR_MODE_ACCURACY_MEDIUM  || mode == RT_SENSOR_MODE_ACCURACY_LOW  ||\
-                  mode == RT_SENSOR_MODE_ACCURACY_LOWEST  || mode == RT_SENSOR_MODE_ACCURACY_NOTRUST))
-            {
-                LOG_E("sensor accuracy mode illegal: %d", mode);
-                return -RT_EINVAL;
-            }
-            result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_ACCURACY_MODE, args);
-            if (result == RT_EOK)
-            {
-                RT_SENSOR_MODE_SET_ACCURACY(sensor->info.mode, mode);
-                LOG_D("set accuracy mode code: %d", RT_SENSOR_MODE_GET_ACCURACY(sensor->info.mode));
-            }
-            break;
-        case RT_SENSOR_CTRL_SET_POWER_MODE:
-            /* Configuration sensor power mode */
-            mode = (rt_uint32_t)args & 0x000F;
-            if (!(mode == RT_SENSOR_MODE_POWER_HIGHEST || mode == RT_SENSOR_MODE_POWER_HIGH ||\
-                  mode == RT_SENSOR_MODE_POWER_MEDIUM  || mode == RT_SENSOR_MODE_POWER_LOW  ||\
-                  mode == RT_SENSOR_MODE_POWER_LOWEST  || mode == RT_SENSOR_MODE_POWER_DOWN))
-            {
-                LOG_E("sensor power mode illegal: %d", mode);
-                return -RT_EINVAL;
-            }
-            result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER_MODE, args);
-            if (result == RT_EOK)
-            {
-                RT_SENSOR_MODE_SET_POWER(sensor->info.mode, mode);
-                LOG_D("set power mode code: %d", RT_SENSOR_MODE_GET_POWER(sensor->info.mode));
-            }
-            break;
-        case RT_SENSOR_CTRL_SET_FETCH_MODE:
-            /* Configuration sensor power mode */
-            mode = (rt_uint32_t)args & 0x000F;
-            if (!(mode == RT_SENSOR_MODE_FETCH_POLLING || mode == RT_SENSOR_MODE_FETCH_INT ||\
-                  mode == RT_SENSOR_MODE_FETCH_FIFO))
-            {
-                LOG_E("sensor fetch data mode illegal: %d", mode);
-                return -RT_EINVAL;
-            }
-            result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_FETCH_MODE, args);
-            if (result == RT_EOK)
-            {
-                RT_SENSOR_MODE_SET_FETCH(sensor->info.mode, mode);
-                LOG_D("set fetch mode code: %d", RT_SENSOR_MODE_GET_FETCH(sensor->info.mode));
-            }
-            break;
-        case RT_SENSOR_CTRL_SELF_TEST:
-            /* device self test */
-            result = local_ctrl(sensor, RT_SENSOR_CTRL_SELF_TEST, args);
-            break;
-        case RT_SENSOR_CTRL_SOFT_RESET:
-            /* device soft reset */
-            result = local_ctrl(sensor, RT_SENSOR_CTRL_SOFT_RESET, args);
-            break;
-        default:
-            if (cmd > RT_SENSOR_CTRL_USER_CMD_START)
-            {
-                /* Custom commands */
-                result = local_ctrl(sensor, cmd, args);
-            }
-            else
-            {
-                result = -RT_EINVAL;
-            }
-            break;
-    }
-
-    if (sensor->module)
-    {
-        rt_mutex_release(sensor->module->lock);
-    }
-
-    return result;
-}
-
-#ifdef RT_USING_DEVICE_OPS
-const static struct rt_device_ops rt_sensor_ops =
-{
-    RT_NULL,
-    _sensor_open,
-    _sensor_close,
-    _sensor_read,
-    RT_NULL,
-    _sensor_control
-};
-#endif
-
-/*
- * sensor register
- */
-int rt_hw_sensor_register(rt_sensor_t    sensor,
-                          const char    *name,
-                          rt_uint32_t    flag,
-                          void          *data)
-{
-    rt_int8_t result;
-    rt_device_t device;
-    RT_ASSERT(sensor != RT_NULL);
-
-    char *sensor_name = RT_NULL, *device_name = RT_NULL;
-
-    if (sensor->ops == RT_NULL)
-    {
-        sensor->ops = &local_ops;
-    }
-
-    /* Add a type name for the sensor device */
-    sensor_name = sensor_name_str[sensor->info.type];
-    device_name = (char *)rt_calloc(1, rt_strlen(sensor_name) + 1 + rt_strlen(name));
-    if (device_name == RT_NULL)
-    {
-        LOG_E("device_name calloc failed!");
-        return -RT_ERROR;
-    }
-
-    rt_memcpy(device_name, sensor_name, rt_strlen(sensor_name) + 1);
-    strcat(device_name, name);
-
-    if (sensor->module != RT_NULL && sensor->module->lock == RT_NULL)
-    {
-        /* Create a mutex lock for the module */
-        sensor->module->lock = rt_mutex_create(name, RT_IPC_FLAG_PRIO);
-        if (sensor->module->lock == RT_NULL)
-        {
-            rt_free(device_name);
-            return -RT_ERROR;
-        }
-    }
-
-    device = &sensor->parent;
-
-#ifdef RT_USING_DEVICE_OPS
-    device->ops         = &rt_sensor_ops;
-#else
-    device->init        = RT_NULL;
-    device->open        = _sensor_open;
-    device->close       = _sensor_close;
-    device->read        = _sensor_read;
-    device->write       = RT_NULL;
-    device->control     = _sensor_control;
-#endif
-    device->type        = RT_Device_Class_Sensor;
-    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("sensor[%s] register err code: %d", device_name, result);
-        rt_free(device_name);
-        return result;
-    }
-
-    LOG_I("sensor[%s] init success", device_name);
-    rt_free(device_name);
-
-    return RT_EOK;
-}