增加[血压]虚拟传感器，更新传感器的数据个数读取

README.md

@@ -21,7 +21,8 @@ rt-thread虚拟传感器，基于RT-Thread Sensor框架，模拟传感器设备
 | 11   | Noise         | 噪声传感器   |
 | 12   | StepCounter   | 计步传感器   |
 | 13   | Force         | 力传感器     |
-
+| 14   | SPO2          | 血氧         |
+| 15   | BloodPressure | 血压         |
 
 
 

SConscript

@@ -49,6 +49,9 @@ if GetDepend(['PKG_USING_VIRTUAL_SENSOR_TVOC']):
 if GetDepend(['PKG_USING_VIRTUAL_SENSOR_SPO2']):
     src += Glob('v_spo2.c')
 
+if GetDepend(['PKG_USING_VIRTUAL_SENSOR_BP']):
+    src += Glob('v_bloodpressure.c')
+
 group = DefineGroup('vsensor', src, depend = ['PKG_USING_VIRTUAL_SENSOR'], CPPPATH = CPPPATH)
 
 Return('group')

v_accelerometer.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* acce_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,38 +81,57 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t acce_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t acce_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t acce_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t acce_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t acce_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = acce_info_tbl[SENS_ACCE_01].range_max - acce_info_tbl[SENS_ACCE_01].range_min;
-    data->type = RT_SENSOR_CLASS_TVOC;
-    data->data.acce.x = rand() % max_range + acce_info_tbl[SENS_ACCE_01].range_min;
-    data->data.acce.y = rand() % max_range + acce_info_tbl[SENS_ACCE_01].range_min;
-    data->data.acce.z = rand() % max_range + acce_info_tbl[SENS_ACCE_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d,%d,%d", __func__, data->data.acce.x,
-        data->data.acce.y, data->data.acce.z);
-    return RT_EOK;
+
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_ACCE;
+        data->data.acce.x = rand() % max_range + acce_info_tbl[SENS_ACCE_01].range_min;
+        data->data.acce.y = rand() % max_range + acce_info_tbl[SENS_ACCE_01].range_min;
+        data->data.acce.z = rand() % max_range + acce_info_tbl[SENS_ACCE_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d,%d,%d", __func__, data->data.acce.x,
+            data->data.acce.y, data->data.acce.z);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t acce_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -125,13 +144,13 @@ static rt_err_t acce_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_acce_tbl[SENS_ACCE_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = acce_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = acce_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = acce_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -161,11 +180,11 @@ int rt_vd_sens_acce_init(void)
 
     for (index = 0; index < SENS_ACCE_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        acce_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -184,7 +203,7 @@ int rt_vd_sens_acce_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_acce_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_barometer.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* baro_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t baro_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t baro_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t baro_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t baro_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t baro_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = baro_info_tbl[SENS_BARO_01].range_max - baro_info_tbl[SENS_BARO_01].range_min;
-    data->type = RT_SENSOR_CLASS_BARO;
-    data->data.baro = rand() % max_range + baro_info_tbl[SENS_BARO_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.baro);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_BARO;
+        data->data.baro = rand() % max_range + baro_info_tbl[SENS_BARO_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.baro);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t baro_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t baro_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_baro_tbl[SENS_BARO_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = baro_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = baro_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = baro_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_baro_init(void)
 
     for (index = 0; index < SENS_BARO_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        baro_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_baro_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_baro_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_bloodpressure.c

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2006-2020, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-11-23     zhangsz      add virtual sensor device
+ */
+
+#include <rtthread.h>
+
+#ifdef PKG_USING_VIRTUAL_SENSOR_BP
+
+#include "sensor.h"
+#include <stdlib.h>
+
+#define DBG_TAG    "v_bp"
+#ifdef PKG_USING_VIRTUAL_SENSOR_DBG
+    #define DBG_LVL    DBG_LOG
+#else
+    #define DBG_LVL    DBG_INFO
+#endif
+#include <rtdbg.h>
+
+enum SENS_BP_ID
+{
+    SENS_BP_01 = 0, //BP
+    SENS_BP_MAX,
+};
+
+#define SENS_BUS_NAME                       "sens_bus"
+#define SENS_BP_01_SENSOR_ID                 (RT_SENSOR_CLASS_BP + 0x10)
+
+struct _sens_bp
+{
+    char* dev_name;
+    rt_uint8_t sens_id;
+};
+
+static struct _sens_bp _sens_tbl[SENS_BP_MAX] =
+{
+    {V_SENS_BP_DEV_NAME,                0x00 }, /* BloodPressure */
+};
+
+static struct rt_sensor_info _sens_info_tbl[SENS_BP_MAX] =
+{
+    {RT_SENSOR_CLASS_BP,  RT_SENSOR_VENDOR_STM,   RT_NULL,    RT_SENSOR_UNIT_MMHG,      RT_SENSOR_INTF_SPI,     200,   0,   1 },
+};
+
+static rt_uint8_t sensor_get_id(rt_uint8_t sens_index)
+{
+    rt_uint8_t chip_id = 0x00;
+
+    switch (sens_index)
+    {
+    case SENS_BP_01:
+        chip_id = SENS_BP_01_SENSOR_ID;
+        break;
+    default:
+        break;
+    }
+
+    return chip_id;
+}
+
+static int sensor_init(rt_uint8_t index)
+{
+    _sens_tbl[index].sens_id = sensor_get_id(index);
+
+    return RT_EOK;
+}
+
+static void* bp_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+{
+    if (sensor_init(index) != RT_EOK)
+    {
+        LOG_E("%s:error!", __func__);
+    }
+
+    return 0;
+}
+
+static rt_err_t bp_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+{
+    LOG_D("%s:odr=%d", __func__, odr);
+    return RT_EOK;
+}
+
+static rt_err_t bp_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+{
+    LOG_D("%s:range=%d", __func__, range);
+    return RT_EOK;
+}
+
+static rt_err_t bp_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+{
+    rt_int8_t rslt = 0;
+    LOG_D("%s:power=%d", __func__, power);
+    return rslt;
+}
+
+static rt_size_t bp_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
+{
+    struct rt_sensor_data* data = buf;
+    rt_int16_t max_range = 0;
+
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
+    max_range = _sens_info_tbl[SENS_BP_01].range_max - _sens_info_tbl[SENS_BP_01].range_min;
+
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_BP;
+        data->data.bp.sbp = rand() % max_range + _sens_info_tbl[SENS_BP_01].range_min;
+        data->data.bp.dbp = rand() % max_range + _sens_info_tbl[SENS_BP_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:[%d,%d]", __func__, data->data.bp.sbp, data->data.bp.dbp);
+        data++;
+    }
+
+    return size;
+}
+
+static rt_err_t bp_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
+{
+    rt_err_t result = RT_EOK;
+
+    switch (cmd)
+    {
+    case RT_SENSOR_CTRL_GET_ID:
+        *(rt_uint8_t*)args = _sens_tbl[SENS_BP_01].sens_id;
+        break;
+    case RT_SENSOR_CTRL_SET_ODR:
+        result = bp_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        break;
+    case RT_SENSOR_CTRL_SET_RANGE:
+        result = bp_sensor_set_range(sensor, (rt_uint32_t)args);
+        break;
+    case RT_SENSOR_CTRL_SET_POWER:
+        result = bp_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        break;
+    case RT_SENSOR_CTRL_SELF_TEST:
+        /* TODO */
+        result = -RT_EINVAL;
+        break;
+    default:
+        return -RT_EINVAL;
+    }
+    return result;
+}
+
+static struct rt_sensor_ops sensor_ops[] =
+{
+    {bp_sensor_fetch_data, bp_sensor_control},
+};
+
+int rt_vd_sens_bp_init(void)
+{
+    rt_int8_t result;
+    rt_uint8_t index = 0;
+    rt_sensor_t sensor_dat = RT_NULL;
+    struct rt_sensor_config cfg;
+
+    cfg.intf.dev_name = SENS_BUS_NAME;
+    cfg.intf.user_data = RT_NULL;
+    cfg.irq_pin.pin = RT_PIN_NONE;
+
+    for (index = 0; index < SENS_BP_MAX; index++)
+    {
+        bp_sensor_create(&cfg.intf, index);
+        sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
+        if (sensor_dat == RT_NULL)
+        {
+            LOG_E("%s:rt_calloc err!", __func__);
+            return -RT_ERROR;
+        }
+
+        sensor_dat->info.type = _sens_info_tbl[index].type;
+        sensor_dat->info.vendor = _sens_info_tbl[index].vendor;
+        sensor_dat->info.model = _sens_info_tbl[index].model;
+        sensor_dat->info.unit = _sens_info_tbl[index].unit;
+        sensor_dat->info.intf_type = _sens_info_tbl[index].intf_type;
+        sensor_dat->info.range_max = _sens_info_tbl[index].range_max;
+        sensor_dat->info.range_min = _sens_info_tbl[index].range_min;
+        sensor_dat->info.period_min = _sens_info_tbl[index].period_min;
+
+        rt_memcpy(&sensor_dat->config, &cfg, sizeof(struct rt_sensor_config));
+        sensor_dat->ops = &sensor_ops[index];
+
+        result = rt_hw_sensor_register(sensor_dat, _sens_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
+        if (result != RT_EOK)
+        {
+            LOG_E("%s:device register err! code=%d", __func__, result);
+            rt_free(sensor_dat);
+            return -RT_ERROR;
+        }
+    }
+
+    return RT_EOK;
+}
+
+INIT_DEVICE_EXPORT(rt_vd_sens_bp_init);
+
+#endif
+

v_force.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* force_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t force_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t force_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t force_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t force_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t force_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = force_info_tbl[SENS_FORCE_01].range_max - force_info_tbl[SENS_FORCE_01].range_min;
-    data->type = RT_SENSOR_CLASS_FORCE;
-    data->data.force = rand() % max_range + force_info_tbl[SENS_FORCE_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.force);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_FORCE;
+        data->data.force = rand() % max_range + force_info_tbl[SENS_FORCE_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.force);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t force_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t force_sensor_control(struct rt_sensor_device* sensor, int cmd, v
         *(rt_uint8_t*)args = sens_force_tbl[SENS_FORCE_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = force_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = force_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = force_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_force_init(void)
 
     for (index = 0; index < SENS_FORCE_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        force_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_force_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_force_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_gyroscope.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* gyro_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,40 +81,57 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t gyro_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t gyro_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t gyro_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t gyro_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t gyro_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = gyro_info_tbl[SENS_GYRO_01].range_max - gyro_info_tbl[SENS_GYRO_01].range_min;
-    data->type = RT_SENSOR_CLASS_GYRO;
 
-    data->data.gyro.x = rand() % max_range + gyro_info_tbl[SENS_GYRO_01].range_min;
-    data->data.gyro.y = rand() % max_range + gyro_info_tbl[SENS_GYRO_01].range_min;
-    data->data.gyro.z = rand() % max_range + gyro_info_tbl[SENS_GYRO_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d,%d,%d", __func__, data->data.gyro.x,
-        data->data.gyro.y, data->data.gyro.z);
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_GYRO;
+        data->data.gyro.x = rand() % max_range + gyro_info_tbl[SENS_GYRO_01].range_min;
+        data->data.gyro.y = rand() % max_range + gyro_info_tbl[SENS_GYRO_01].range_min;
+        data->data.gyro.z = rand() % max_range + gyro_info_tbl[SENS_GYRO_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d,%d,%d", __func__, data->data.gyro.x,
+            data->data.gyro.y, data->data.gyro.z);
+        data++;
+    }
 
-    return RT_EOK;
+    return size;
 }
 
 static rt_err_t gyro_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -127,13 +144,13 @@ static rt_err_t gyro_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_gyro_tbl[SENS_GYRO_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = gyro_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = gyro_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = gyro_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -163,11 +180,11 @@ int rt_vd_sens_gyro_init(void)
 
     for (index = 0; index < SENS_GYRO_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        gyro_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -186,7 +203,7 @@ int rt_vd_sens_gyro_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_gyro_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_heartRate.c

@@ -45,7 +45,7 @@ static struct sens_hr sens_hr_tbl[SENS_HR_MAX] =
 
 static struct rt_sensor_info hr_info_tbl[SENS_HR_MAX] =
 {
-    {RT_SENSOR_CLASS_HR,  RT_SENSOR_VENDOR_STM,   RT_NULL,    RT_SENSOR_UNIT_BPM,      RT_SENSOR_INTF_UART,     200,   0,   1 },
+    {RT_SENSOR_CLASS_HR,  RT_SENSOR_VENDOR_STM,   RT_NULL,    RT_SENSOR_UNIT_BPM,      RT_SENSOR_INTF_UART,     150,   50,   1 },
 };
 
 static rt_uint8_t sensor_get_id(rt_uint8_t sens_index)
@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* hr_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t hr_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t hr_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t hr_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t hr_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t hr_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = hr_info_tbl[SENS_HR_01].range_max - hr_info_tbl[SENS_HR_01].range_min;
-    data->type = RT_SENSOR_CLASS_HR;
-    data->data.hr = rand() % max_range + hr_info_tbl[SENS_HR_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.hr);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_HR;
+        data->data.hr = rand() % max_range + hr_info_tbl[SENS_HR_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.hr);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t hr_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t hr_sensor_control(struct rt_sensor_device* sensor, int cmd, void
         *(rt_uint8_t*)args = sens_hr_tbl[SENS_HR_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = hr_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = hr_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = hr_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_hr_init(void)
 
     for (index = 0; index < SENS_HR_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        hr_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_hr_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_hr_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_humidity.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* humi_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t humi_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t humi_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t humi_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t humi_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t humi_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = humi_info_tbl[SENS_HUMI_01].range_max - humi_info_tbl[SENS_HUMI_01].range_min;
-    data->type = RT_SENSOR_CLASS_HUMI;
-    data->data.humi = rand() % max_range + humi_info_tbl[SENS_HUMI_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.humi);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_HUMI;
+        data->data.humi = rand() % max_range + humi_info_tbl[SENS_HUMI_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.humi);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t humi_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t humi_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_humi_tbl[SENS_HUMI_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = humi_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = humi_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = humi_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_humi_init(void)
 
     for (index = 0; index < SENS_HUMI_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        humi_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_humi_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_humi_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_light.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* li_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,37 +81,55 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t li_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t li_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t li_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t light_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t light_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = light_info_tbl[SENS_LIGHT_01].range_max - light_info_tbl[SENS_LIGHT_01].range_min;
-    data->type = RT_SENSOR_CLASS_LIGHT;
-    data->data.light = rand() % max_range + light_info_tbl[SENS_LIGHT_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
 
-    LOG_D("%s:%d", __func__, data->data.light);
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_LIGHT;
+        data->data.light = rand() % max_range + light_info_tbl[SENS_LIGHT_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
 
-    return RT_EOK;
+        LOG_D("%s:%d", __func__, data->data.light);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t light_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -124,13 +142,13 @@ static rt_err_t light_sensor_control(struct rt_sensor_device* sensor, int cmd, v
         *(rt_uint8_t*)args = sens_light_tbl[SENS_LIGHT_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = li_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = li_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = li_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -160,11 +178,11 @@ int rt_vd_sens_light_init(void)
 
     for (index = 0; index < SENS_LIGHT_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        li_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -183,7 +201,7 @@ int rt_vd_sens_light_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_light_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_magnetometer.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* mag_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,40 +81,58 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t mag_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t mag_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t mag_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t mag_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t mag_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = mag_info_tbl[SENS_MAG_01].range_max - mag_info_tbl[SENS_MAG_01].range_min;
-    data->type = RT_SENSOR_CLASS_MAG;
-    data->data.mag.x = rand() % max_range + mag_info_tbl[SENS_MAG_01].range_min;
-    data->data.mag.y = rand() % max_range + mag_info_tbl[SENS_MAG_01].range_min;
-    data->data.mag.z = rand() % max_range + mag_info_tbl[SENS_MAG_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
 
-    LOG_D("%s:%d,%d,%d", __func__, data->data.mag.x,
-        data->data.mag.y, data->data.mag.z);
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_MAG;
+        data->data.mag.x = rand() % max_range + mag_info_tbl[SENS_MAG_01].range_min;
+        data->data.mag.y = rand() % max_range + mag_info_tbl[SENS_MAG_01].range_min;
+        data->data.mag.z = rand() % max_range + mag_info_tbl[SENS_MAG_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+
+        LOG_D("%s:%d,%d,%d", __func__, data->data.mag.x,
+            data->data.mag.y, data->data.mag.z);
+        data++;
+    }
 
-    return RT_EOK;
+    return size;
 }
 
 static rt_err_t mag_sensor_control(struct rt_sensor_device *sensor, int cmd, void *args)
@@ -127,13 +145,13 @@ static rt_err_t mag_sensor_control(struct rt_sensor_device *sensor, int cmd, voi
         *(rt_uint8_t*)args = sens_mag_tbl[SENS_MAG_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = mag_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = mag_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = mag_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -163,11 +181,11 @@ int rt_vd_sens_mag_init(void)
 
     for (index = 0; index < SENS_MAG_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        mag_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -186,7 +204,7 @@ int rt_vd_sens_mag_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_mag_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_noise.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* noise_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t noise_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t noise_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t noise_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t noise_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t noise_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = noise_info_tbl[SENS_NOISE_01].range_max - noise_info_tbl[SENS_NOISE_01].range_min;
-    data->type = RT_SENSOR_CLASS_NOISE;
-    data->data.noise = rand() % max_range + noise_info_tbl[SENS_NOISE_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.noise);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_NOISE;
+        data->data.noise = rand() % max_range + noise_info_tbl[SENS_NOISE_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.noise);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t noise_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t noise_sensor_control(struct rt_sensor_device* sensor, int cmd, v
         *(rt_uint8_t*)args = sens_noise_tbl[SENS_NOISE_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = noise_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = noise_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = noise_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_noise_init(void)
 
     for (index = 0; index < SENS_NOISE_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        noise_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_noise_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_noise_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_proximity.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* prox_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t prox_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t prox_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t prox_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t prox_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t prox_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = prox_info_tbl[SENS_PROX_01].range_max - prox_info_tbl[SENS_PROX_01].range_min;
-    data->type = RT_SENSOR_CLASS_HUMI;
-    data->data.proximity = rand() % max_range + prox_info_tbl[SENS_PROX_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.proximity);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_HUMI;
+        data->data.proximity = rand() % max_range + prox_info_tbl[SENS_PROX_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.proximity);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t prox_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t prox_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_prox_tbl[SENS_PROX_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = prox_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = prox_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = prox_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_prox_init(void)
 
     for (index = 0; index < SENS_PROX_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        prox_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_prox_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_prox_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_spo2.c

@@ -45,7 +45,7 @@ static struct sens_spo2 sens_spo2_tbl[SENS_SPO2_MAX] =
 
 static struct rt_sensor_info spo2_info_tbl[SENS_SPO2_MAX] =
 {
-    {RT_SENSOR_CLASS_SPO2,  RT_SENSOR_VENDOR_UNKNOWN,   RT_NULL,    RT_SENSOR_UNIT_PERCENT,      RT_SENSOR_INTF_UART,     200,   0,   1 },
+    {RT_SENSOR_CLASS_SPO2,  RT_SENSOR_VENDOR_UNKNOWN,   RT_NULL,    RT_SENSOR_UNIT_PERMILLAGE,      RT_SENSOR_INTF_UART,     100,   0,   1 },
 };
 
 static rt_uint8_t sensor_get_id(rt_uint8_t sens_index)
@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* spo2_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,32 +81,51 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t spo2_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t spo2_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t spo2_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t spo2_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t spo2_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
 
-    data->type = RT_SENSOR_CLASS_SPO2;
-    data->data.spo2 = 90 + rand() % 10;
-    data->timestamp = rt_sensor_get_ts();
-    return RT_EOK;
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_SPO2;
+        data->data.spo2 = 90 + rand() % 10;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:[%d]", __func__, data->data.spo2);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t spo2_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -119,13 +138,13 @@ static rt_err_t spo2_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_spo2_tbl[SENS_SPO2_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = spo2_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = spo2_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = spo2_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -155,11 +174,11 @@ int rt_vd_sens_spo2_init(void)
 
     for (index = 0; index < SENS_SPO2_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        spo2_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -178,7 +197,7 @@ int rt_vd_sens_spo2_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_spo2_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_stepcounter.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* step_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,53 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t step_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+static rt_err_t step_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t step_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t step_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t step_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = step_info_tbl[SENS_STEP_01].range_max - step_info_tbl[SENS_STEP_01].range_min;
-    data->type = RT_SENSOR_CLASS_STEP;
-    data->data.step = rand() % max_range + step_info_tbl[SENS_STEP_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.step);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_STEP;
+        data->data.step = rand() % max_range + step_info_tbl[SENS_STEP_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.step);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t step_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +140,13 @@ static rt_err_t step_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_step_tbl[SENS_STEP_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = step_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = step_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = step_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +176,11 @@ int rt_vd_sens_step_init(void)
 
     for (index = 0; index < SENS_STEP_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        step_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +199,7 @@ int rt_vd_sens_step_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_step_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_temperature.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* temp_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t temp_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t temp_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t temp_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t temp_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t temp_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = temp_info_tbl[SENS_TEMP_01].range_max - temp_info_tbl[SENS_TEMP_01].range_min;
-    data->type = RT_SENSOR_CLASS_TEMP;
-    data->data.temp = rand() % max_range + temp_info_tbl[SENS_TEMP_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.temp);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_TEMP;
+        data->data.temp = rand() % max_range + temp_info_tbl[SENS_TEMP_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.temp);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t temp_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t temp_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_temp_tbl[SENS_TEMP_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = temp_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = temp_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = temp_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_temp_init(void)
 
     for (index = 0; index < SENS_TEMP_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        temp_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_temp_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_temp_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }

v_tvoc.c

@@ -71,7 +71,7 @@ static int sensor_init(rt_uint8_t index)
     return RT_EOK;
 }
 
-static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
+static void* tvoc_sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
 {
     if (sensor_init(index) != RT_EOK)
     {
@@ -81,36 +81,54 @@ static void* _sensor_create(struct rt_sensor_intf* intf, rt_uint8_t index)
     return 0;
 }
 
-static rt_err_t _sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
+static rt_err_t tvoc_sensor_set_odr(rt_sensor_t sensor, rt_uint16_t odr)
 {
     LOG_D("%s:odr=%d", __func__, odr);
     return RT_EOK;
 }
-static rt_err_t _sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
+
+static rt_err_t tvoc_sensor_set_range(rt_sensor_t sensor, rt_uint16_t range)
 {
     LOG_D("%s:range=%d", __func__, range);
     return RT_EOK;
 }
 
-static rt_err_t _sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
+static rt_err_t tvoc_sensor_set_power(rt_sensor_t sensor, rt_uint8_t power)
 {
     rt_int8_t rslt = 0;
     LOG_D("%s:power=%d", __func__, power);
     return rslt;
 }
 
-static rt_size_t tvoc_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t len)
+static rt_size_t tvoc_sensor_fetch_data(struct rt_sensor_device* sensor, void* buf, rt_size_t size)
 {
     struct rt_sensor_data* data = buf;
     rt_int16_t max_range = 0;
 
+    if (size < 1)
+    {
+        LOG_E("%s:read size err! size=%d", __func__, size);
+        return 0;
+    }
+
+    if (buf == RT_NULL)
+    {
+        LOG_E("%s:read buf is NULL!", __func__);
+        return 0;
+    }
+
     max_range = tvoc_info_tbl[SENS_TVOC_01].range_max - tvoc_info_tbl[SENS_TVOC_01].range_min;
-    data->type = RT_SENSOR_CLASS_TVOC;
-    data->data.tvoc = rand() % max_range + tvoc_info_tbl[SENS_TVOC_01].range_min;
-    data->timestamp = rt_sensor_get_ts();
-    LOG_D("%s:%d", __func__, data->data.tvoc);
 
-    return RT_EOK;
+    for (int i = 0; i < size; i++)
+    {
+        data->type = RT_SENSOR_CLASS_TVOC;
+        data->data.tvoc = rand() % max_range + tvoc_info_tbl[SENS_TVOC_01].range_min;
+        data->timestamp = rt_sensor_get_ts();
+        LOG_D("%s:%d", __func__, data->data.tvoc);
+        data++;
+    }
+
+    return size;
 }
 
 static rt_err_t tvoc_sensor_control(struct rt_sensor_device* sensor, int cmd, void* args)
@@ -123,13 +141,13 @@ static rt_err_t tvoc_sensor_control(struct rt_sensor_device* sensor, int cmd, vo
         *(rt_uint8_t*)args = sens_tvoc_tbl[SENS_TVOC_01].sens_id;
         break;
     case RT_SENSOR_CTRL_SET_ODR:
-        result = _sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
+        result = tvoc_sensor_set_odr(sensor, (rt_uint32_t)args & 0xffff);
         break;
     case RT_SENSOR_CTRL_SET_RANGE:
-        result = _sensor_set_range(sensor, (rt_uint32_t)args);
+        result = tvoc_sensor_set_range(sensor, (rt_uint32_t)args);
         break;
     case RT_SENSOR_CTRL_SET_POWER:
-        result = _sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
+        result = tvoc_sensor_set_power(sensor, (rt_uint32_t)args & 0xff);
         break;
     case RT_SENSOR_CTRL_SELF_TEST:
         /* TODO */
@@ -159,11 +177,11 @@ int rt_vd_sens_tvoc_init(void)
 
     for (index = 0; index < SENS_TVOC_MAX; index++)
     {
-        _sensor_create(&cfg.intf, index);
+        tvoc_sensor_create(&cfg.intf, index);
         sensor_dat = rt_calloc(1, sizeof(struct rt_sensor_device));
         if (sensor_dat == RT_NULL)
         {
-            LOG_E("rt_hw_sens_init:rt_calloc err!");
+            LOG_E("%s:rt_calloc err!", __func__);
             return -RT_ERROR;
         }
 
@@ -182,7 +200,7 @@ int rt_vd_sens_tvoc_init(void)
         result = rt_hw_sensor_register(sensor_dat, sens_tvoc_tbl[index].dev_name, RT_DEVICE_FLAG_RDWR, RT_NULL);
         if (result != RT_EOK)
         {
-            LOG_E("device register err code: %d", result);
+            LOG_E("%s:device register err code: %d", __func__, result);
             rt_free(sensor_dat);
             return -RT_ERROR;
         }