本帖最后由 oxlm 于 2023-7-12 23:57 编辑


  • 前言
在某个电子工程师的群里面，发现了面包板的赠书活动，一看书名，刚好是自己感兴趣的RTT芯片驱动开发方向的指南，因此直接申请参加了这次赠书活动，也非常荣幸的拿到了《RT-Thread设备驱动开发指南》这本书籍。

  • 知识背景

  由于自己之前又配过一系列简单驱动，对基础篇中的驱动配置都十分熟悉，因此直接跳过基础篇的驱动配置内容，查看最近使用的sensor部分。
     在阅读sensor部分，首先得了解rtt上很通用的posix标准，sensor框架对接应用层驱动是基于该标准实现，即驱动层需要实现rt_device_ops ：
  1. #ifdef RT_USING_DEVICE_OPS
  2. const static struct rt_device_ops rt_sensor_ops =
  3. {
  4.     RT_NULL,
  5.     rt_sensor_open,
  6.     rt_sensor_close,
  7.     rt_sensor_read,
  8.     RT_NULL,
  9.     rt_sensor_control
  10. };
  11. #endif
同时，需通过 rt_device_register注册设备，
  1. rt_err_t rt_device_register(rt_device_t dev, const char *name, rt_uint16_t flags)
，驱动层完成以上步骤后，应用层就可以通过 rt_device_open , rt_device_close, rt_device_control, rt_device_read 和 rt_device_set_rx_indicate等接口实现逻辑控制。

  • sensor框架各接口的使用
  • 初始化接口
前一章提到设备是通过 rt_device_register接口注册成传感器设备的，因此只需要找到传感器框架中调用该接口的位置便可找到具体实现逻辑。
  2. /*
  3. * sensor register
  4. */
  5. int rt_hw_sensor_register(rt_sensor_t sensor,
  6.                                          const char              *name,
  7.                                          rt_uint32_t              flag,
  8.                                          void                    *data)
  9. {
  10.      rt_int8_t result;
  11.     rt_device_t device;
  12.     RT_ASSERT(sensor != RT_NULL);
  14.     char *sensor_name = RT_NULL, *device_name = RT_NULL;
  16.     if (sensor->ops == RT_NULL)
  17.     {
  18.         sensor->ops = &local_ops;
  19.     }
  21.     /* Add a type name for the sensor device */
  22.     sensor_name = sensor_name_str[sensor->info.type];
  23.     device_name = (char *)rt_calloc(1, rt_strlen(sensor_name) + 1 + rt_strlen(name));
  24.     if (device_name == RT_NULL)
  25.     {
  26.         LOG_E("device_name calloc failed!");
  27.         return -RT_ERROR;
  28.     }
  30.     rt_memcpy(device_name, sensor_name, rt_strlen(sensor_name) + 1);
  31.     strcat(device_name, name);
  33.     if (sensor->module != RT_NULL && sensor->module->lock == RT_NULL)
  34.     {
  35.         /* Create a mutex lock for the module */
  36.         sensor->module->lock = rt_mutex_create(name, RT_IPC_FLAG_PRIO);
  37.         if (sensor->module->lock == RT_NULL)
  38.         {
  39.             rt_free(device_name);
  40.             return -RT_ERROR;
  41.         }
  42.     }
  44.     device = &sensor->parent;
  46.     #ifdef RT_USING_DEVICE_OPS
  47.     device->ops         = &rt_sensor_ops;
  48.     #else
  49.     device->init        = RT_NULL;
  50.     device->open        = rt_sensor_open;
  51.     device->close       = rt_sensor_close;
  52.     device->read        = rt_sensor_read;
  53.     device->write       = RT_NULL;
  54.     device->control     = rt_sensor_control;
  55. #endif
  56.     device->type        = RT_Device_Class_Sensor;
  57.     device->rx_indicate = RT_NULL;
  58.     device->tx_complete = RT_NULL;
  59.     device->user_data   = data;
  61.    <font color="#ff00ff"> result = rt_device_register(device, device_name, flag | RT_DEVICE_FLAG_STANDALONE);</font>
  62.     if (result != RT_EOK)
  63.     {
  64.         LOG_E("rt_sensor[%s] register err code: %d", device_name, result);
  65.         rt_free(device_name);
  66.         return result;
  67.     }
  69.     LOG_I("rt_sensor[%s] init success", device_name);
  70.     rt_free(device_name);
  71.     return RT_EOK;
  72. }
   而该接口的调用位置，即在驱动初始化的位置，以BMX160驱动中的地磁传感器为例，注册实现为：
  1. #ifdef BMX160_USING_MAG
  2. static void * _mag_init(const char *name, <font color="#ff8c00">struct rt_sensor_config *cfg, </font>void *hdev)
  3. {
  4.     rt_int8_t result;
  5.     rt_sensor_t sensor_mag = RT_NULL;
  7.     sensor_mag = rt_calloc(1, sizeof(struct rt_sensor_device));
  8.     if (sensor_mag == RT_NULL)
  9.         return RT_NULL;
  11.     sensor_mag->info.type       = RT_SENSOR_CLASS_MAG;
  12.     sensor_mag->info.vendor     = RT_SENSOR_VENDOR_BOSCH;
  13.     sensor_mag->info.model      = "bmi160_mag";
  14.     sensor_mag->info.unit       = RT_SENSOR_UNIT_MGAUSS;
  15.     sensor_mag->info.intf_type  = RT_SENSOR_INTF_I2C;
  16.     sensor_mag->info.range_max  = 2000;
  17.     sensor_mag->info.range_min  = 125;
  18.     sensor_mag->info.period_min = 100;
  19.     sensor_mag->info.fifo_max   = FIFO_DATA_LEN;
  21. <font color="#ff8c00">    rt_memcpy(&sensor_mag->config, cfg, sizeof(struct rt_sensor_config));</font>
  22. <font color="#2e8b57">    sensor_mag->ops = &sensor_ops;</font>
  24. <font color="#ff00ff">    result = rt_hw_sensor_register(sensor_mag, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_FIFO_RX, hdev);</font>
  25.     if (result != RT_EOK)
  26.     {
  27.         LOG_E("device register err code: %d", result);
  28.         rt_free(sensor_mag);
  29.         rt_device_unregister(&sensor_mag->parent);
  30.         return RT_NULL;
  31.     }
  33.     return sensor_mag;
  34. }
  35. #endif

  • 应用打开设备接口
    由上一章节已知，应用打开传感器设备，使用的接口为rt_device_open，具体对应的驱动层接口为对应设备驱动结构体 rt_device_ops  中的init和open接口，由于init接口为空，因此直接调用接口为 rt_sensor_open，此函数实现如下：
  2. /* RT-Thread Device Interface */
  3. static rt_err_t rt_sensor_open(rt_device_t dev, rt_uint16_t oflag)
  4. {
  5.     rt_sensor_t sensor = (rt_sensor_t)dev;
  6.     RT_ASSERT(dev != RT_NULL);
  7.     rt_err_t res = RT_EOK;
  8.     rt_err_t (*local_ctrl)(struct rt_sensor_device * sensor, int cmd, void *arg) =  local_control;
  10.     if (sensor->module)
  11.     {
  12.         /* take the module mutex */
  13.         rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
  14.     }
  16.     if (sensor->module != RT_NULL && sensor->info.fifo_max > 0 && sensor->data_buf == RT_NULL)
  17.     {
  18.         /* Allocate memory for the sensor buffer */
  19.         sensor->data_buf = rt_malloc(sizeof(struct rt_sensor_data) * sensor->info.fifo_max);
  20.         if (sensor->data_buf == RT_NULL)
  21.         {
  22.             res = -RT_ENOMEM;
  23.             goto __exit;
  24.         }
  25.     }
  26.     if (sensor->ops->control != RT_NULL)
  27.     {
  28.         local_ctrl = sensor->ops->control;
  29.     }
  31.     sensor->config.mode = RT_SENSOR_MODE_POLLING;
  32.     if (oflag & RT_DEVICE_FLAG_RDONLY && dev->flag & RT_DEVICE_FLAG_RDONLY)
  33.     {
  34.         /* If polling mode is supported, configure it to polling mode */
  35. <font color="#ff00ff">        local_ctrl(sensor, RT_SENSOR_CTRL_SET_MODE, (void *)RT_SENSOR_MODE_POLLING);</font>
  36.     }
  37.     else if (oflag & RT_DEVICE_FLAG_INT_RX && dev->flag & RT_DEVICE_FLAG_INT_RX)
  38.     {
  39.         /* If interrupt mode is supported, configure it to interrupt mode */
  40. <font color="#ff00ff">        if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_MODE, (void *)RT_SENSOR_MODE_INT) == RT_EOK)</font>
  41.         {
  42.             /* Initialization sensor interrupt */
  43. <font color="#ff8c00">            rt_sensor_irq_init(sensor);</font>
  44.             sensor->config.mode = RT_SENSOR_MODE_INT;
  45.         }
  46.     }
  47.     else if (oflag & RT_DEVICE_FLAG_FIFO_RX && dev->flag & RT_DEVICE_FLAG_FIFO_RX)
  48.     {
  49.         /* If fifo mode is supported, configure it to fifo mode */
  50. <font color="#ff00ff">        if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_MODE, (void *)RT_SENSOR_MODE_FIFO) == RT_EOK)</font>
  51.         {
  52.             /* Initialization sensor interrupt */
  53. <font color="#ff00ff">            rt_sensor_irq_init(sensor);</font>
  54.             sensor->config.mode = RT_SENSOR_MODE_FIFO;
  55.         }
  56.     }
  57.     else
  58.     {
  59.         res = -RT_EINVAL;
  60.         goto __exit;
  61.     }
  63.     /* Configure power mode to normal mode */
  64.     if (<font color="#ff00ff">local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER, (void *)RT_SENSOR_POWER_NORMAL) == RT_EOK</font>)
  65.     {
  66.         sensor->config.power = RT_SENSOR_POWER_NORMAL;
  67.     }
  69. __exit:
  70.     if (sensor->module)
  71.     {
  72.         /* release the module mutex */
  73.         rt_mutex_release(sensor->module->lock);
  74.     }
  76.     return res;
  77. }
  从代码中可以看出，整个open的过程实际上时sensor对应的ops中control实现的过程，而此ops也是在驱动注册时指定的，具体指定位置见 _mag_init中标绿部分，而ops的定义为：
  2. static rt_err_t _control(struct rt_sensor_device *sensor, int cmd, void *args)
  3. {
  4.     struct bmi160_dev *hdev = sensor->parent.user_data;
  5.     rt_err_t result = RT_EOK;
  7.     switch (cmd)
  8.     {
  9.     case RT_SENSOR_CTRL_GET_ID:
  10.         *(rt_uint8_t *)args = hdev->chip_id;
  11.         break;
  12.     case RT_SENSOR_CTRL_SET_ODR:
  13.         result = _set_odr(sensor, (rt_uint32_t)args & 0xffff);
  14.         break;
  15.     case RT_SENSOR_CTRL_SET_RANGE:
  16.         result = _set_range(sensor, (rt_uint32_t)args);
  17.         break;
  18.     case RT_SENSOR_CTRL_SET_POWER:
  19.         result = _set_power(sensor, (rt_uint32_t)args & 0xff);
  20.         break;
  21.     case RT_SENSOR_CTRL_SET_MODE:
  22.         result = _select_mode(sensor, (rt_uint32_t)args);
  23.         break;
  24.     case RT_SENSOR_CTRL_SELF_TEST:
  25.         /* TODO */
  26.         result = -RT_EINVAL;
  27.         break;
  28.     default:
  29.         return -RT_EINVAL;
  30.     }
  31.     return result;
  32. }
  34. <font color="#9932cc">static struct rt_sensor_ops sensor_ops =
  35. {
  36.     _fetch_data,
  37.     _control
  38. };</font>

也就是说，control至少需要实现 RT_SENSOR_CTRL_SET_MODE 和 RT_SENSOR_CTRL_SET_POWER两个接口，另外，如果是中断设备，需要在设备注册时指定中断引脚信息，即驱动注册和打开驱动部分中标黄的部分，具体实现可见：
  1. /* Sensor interrupt initialization function */
  2. static rt_err_t rt_sensor_irq_init(rt_sensor_t sensor)
  3. {
  4.     if (sensor->config.irq_pin.pin == RT_PIN_NONE)
  5.     {
  6.         return -RT_EINVAL;
  7.     }
  9.     rt_pin_mode(sensor->config.irq_pin.pin, sensor->config.irq_pin.mode);
  11.     if (sensor->config.irq_pin.mode == PIN_MODE_INPUT_PULLDOWN)
  12.     {
  13. <font color="#2e8b57">        rt_pin_attach_irq(sensor->config.irq_pin.pin, PIN_IRQ_MODE_RISING, irq_callback, (void *)sensor);</font>
  14.     }
  15.     else if (sensor->config.irq_pin.mode == PIN_MODE_INPUT_PULLUP)
  16.     {
  17. <font color="#008080">        rt_pin_attach_irq(sensor->config.irq_pin.pin, PIN_IRQ_MODE_FALLING, irq_callback, (void *)sensor);</font>
  18.     }
  19.     else if (sensor->config.irq_pin.mode == PIN_MODE_INPUT)
  20.     {
  21. <font color="#008080">        rt_pin_attach_irq(sensor->config.irq_pin.pin, PIN_IRQ_MODE_RISING_FALLING, irq_callback, (void *)sensor);</font>
  22.     }
  24.     rt_pin_irq_enable(sensor->config.irq_pin.pin, RT_TRUE);
  26.     LOG_I("interrupt init success");
  28.     return 0;
  29. }


  • 应用设置参数接口
    设置参数接口，应用层调用的是rt_device_control接口，对应sensor框架中的实现为rt_sensor_control，此实现为：
  1. static rt_err_t rt_sensor_control(rt_device_t dev, int cmd, void *args)
  2. {
  3.     rt_sensor_t sensor = (rt_sensor_t)dev;
  4.     rt_err_t result = RT_EOK;
  5.     RT_ASSERT(dev != RT_NULL);
  6.     rt_err_t (*local_ctrl)(struct rt_sensor_device * sensor, int cmd, void *arg) = local_control;
  8.     if (sensor->module)
  9.     {
  10.         rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
  11.     }
  12.     if (sensor->ops->control != RT_NULL)
  13.     {
  14.         local_ctrl = sensor->ops->control;
  15.     }
  17.     switch (cmd)
  18.     {
  19.     case RT_SENSOR_CTRL_GET_ID:
  20.         if (args)
  21.         {
  22. <font color="#ff00ff">            result = local_ctrl(sensor, RT_SENSOR_CTRL_GET_ID, args);</font>
  23.         }
  24.         break;
  25.     case RT_SENSOR_CTRL_GET_INFO:
  26.         if (args)
  27.         {
  28.             rt_memcpy(args, &sensor->info, sizeof(struct rt_sensor_info));
  29.         }
  30.         break;
  31.     case RT_SENSOR_CTRL_SET_RANGE:
  32.         /* Configuration measurement range */
  33. <font color="#ff00ff">        result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_RANGE, args);</font>
  34.         if (result == RT_EOK)
  35.         {
  36.             sensor->config.range = (rt_int32_t)args;
  37.             LOG_D("set range %d", sensor->config.range);
  38.         }
  39.         break;
  40.     case RT_SENSOR_CTRL_SET_ODR:
  41.         /* Configuration data output rate */
  42. <font color="#ff00ff">        result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_ODR, args);</font>
  43.         if (result == RT_EOK)
  44.         {
  45.             sensor->config.odr = (rt_uint32_t)args & 0xFFFF;
  46.             LOG_D("set odr %d", sensor->config.odr);
  47.         }
  48.         break;
  49.     case RT_SENSOR_CTRL_SET_POWER:
  50.         /* Configuration sensor power mode */
  51. <font color="#ff00ff">        result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER, args);</font>
  52.         if (result == RT_EOK)
  53.         {
  54.             sensor->config.power = (rt_uint32_t)args & 0xFF;
  55.             LOG_D("set power mode code:", sensor->config.power);
  56.         }
  57.         break;
  58.     case RT_SENSOR_CTRL_SELF_TEST:
  59.         /* Device self-test */
  60. <font color="#ff00ff">        result = local_ctrl(sensor, RT_SENSOR_CTRL_SELF_TEST, args);</font>
  61.         break;
  62.     default:
  64.         if (cmd > RT_SENSOR_CTRL_USER_CMD_START)
  65.         {
  66.             /* Custom commands */
  67. <font color="#ff00ff">            result = local_ctrl(sensor, cmd, args);</font>
  68.         }
  69.         else
  70.         {
  71.             result = -RT_ERROR;
  72.         }
  73.         break;
  74.     }
  76.     if (sensor->module)
  77.     {
  78.         rt_mutex_release(sensor->module->lock);
  79.     }
  81.     return result;
  82. }
从代码上看，rt_sensor_control接口仅仅是将驱动中control中所实现的所有接口再一次暴露给应用，用于某些参数的更新。

  • 通知应用新数据接收到接口
    应用需调用 rt_device_set_rx_indicate接口注册回调事件，而sensor框架层实现回调接口注册见上文中 rt_sensor_irq_init 函数中标绿部分，其中sensor层统一处理回调的函数实现如下：
  1. /* Sensor interrupt correlation function */
  2. /*
  3. * Sensor interrupt handler function
  4. */
  5. void rt_sensor_cb(rt_sensor_t sen)
  6. {
  7.     if (sen->parent.rx_indicate == RT_NULL)
  8.     {
  9.         return;
  10.     }
  12.     if (sen->irq_handle != RT_NULL)
  13.     {
  14.         sen->irq_handle(sen);
  15.     }
  17.     /* The buffer is not empty. Read the data in the buffer first */
  18.     if (sen->data_len > 0)
  19.     {
  20. <font color="#4169e1">        sen->parent.rx_indicate(&sen->parent, sen->data_len / sizeof(struct rt_sensor_data));</font>
  21.     }
  22.     else if (sen->config.mode == RT_SENSOR_MODE_INT)
  23.     {
  24.         /* The interrupt mode only produces one data at a time */
  25. <font color="#4169e1">        sen->parent.rx_indicate(&sen->parent, 1);</font>
  26.     }
  27.     else if (sen->config.mode == RT_SENSOR_MODE_FIFO)
  28.     {
  29. <font color="#4169e1">        sen->parent.rx_indicate(&sen->parent, sen->info.fifo_max);</font>
  30.     }
  31. }
  33. /* ISR for sensor interrupt */
  34. static void irq_callback(void *args)
  35. {
  36.     rt_sensor_t sensor = (rt_sensor_t)args;
  37.     rt_uint8_t i;
  39.     if (sensor->module)
  40.     {
  41.         /* Invoke a callback for all sensors in the module */
  42.         for (i = 0; i < sensor->module->sen_num; i++)
  43.         {
  44.             rt_sensor_cb(sensor->module->sen[i]);
  45.         }
  46.     }
  47.     else
  48.     {
  49.         rt_sensor_cb(sensor);
  50.     }
  51. }
其中标蓝部分即为通知应用数据准备好实现


  • 应用读取数据接口
    应用读取数据接口为rt_device_read，此接口对应sensor框架接口为rt_sensor_read，此函数具体实现为：
  1. static rt_ssize_t rt_sensor_read(rt_device_t dev, rt_off_t pos, void *buf, rt_size_t len)
  2. {
  3.     rt_sensor_t sensor = (rt_sensor_t)dev;
  4.     rt_size_t result = 0;
  5.     RT_ASSERT(dev != RT_NULL);
  7.     if (buf == NULL || len == 0)
  8.     {
  9.         return 0;
  10.     }
  12.     if (sensor->module)
  13.     {
  14.         rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
  15.     }
  17.     /* The buffer is not empty. Read the data in the buffer first */
  18.     if (sensor->data_len > 0)
  19.     {
  20.         if (len > sensor->data_len / sizeof(struct rt_sensor_data))
  21.         {
  22.             len = sensor->data_len / sizeof(struct rt_sensor_data);
  23.         }
  25.         rt_memcpy(buf, sensor->data_buf, len * sizeof(struct rt_sensor_data));
  27.         /* Clear the buffer */
  28.         sensor->data_len = 0;
  29.         result = len;
  30.     }
  31.     else
  32.     {
  33.         /* If the buffer is empty read the data */
  34.         if (sensor->ops->fetch_data !=  RT_NULL)
  35.         {
  36. <font color="#ff00ff">            result = sensor->ops->fetch_data(sensor, buf, len);</font>
  37.         }
  38.     }
  40.     if (sensor->module)
  41.     {
  42.         rt_mutex_release(sensor->module->lock);
  43.     }
  45.     return result;
  46. }
由此可见，驱动层需实现fetch_data接口即可，在前面有提到（打开传感器中，control接口描述中标紫部分），对应的_fetch_data实现为：
  1. static void _copy_data(struct rt_sensor_data *dst, struct bmi160_sensor_data *src)
  2. {
  3.     dst->data.acce.x = src->x;
  4.     dst->data.acce.y = src->y;
  5.     dst->data.acce.z = src->z;
  6.     dst->timestamp = rt_sensor_get_ts();
  7. }
  9. static int _get_data(struct rt_sensor_device *sensor, void *buf)
  10. {
  11.     struct bmi160_dev *hdev = sensor->parent.user_data;
  12.     struct rt_sensor_data *data = buf;
  13.     struct bmi160_sensor_data acce_data, gyro_data;
  15.     if (sensor->info.type == RT_SENSOR_CLASS_MAG)
  16.     {
  17.         if (hdev->chip_id == BMX160_CHIP_ID) /* BMX160 */
  18.         {
  19.             _get_mag_data(hdev, data);
  20.             return 1;
  21.         }
  22.         return 0;
  23.     }
  24.     bmi160_get_sensor_data(BMI160_ACCEL_SEL | BMI160_GYRO_SEL, &acce_data, &gyro_data, hdev);
  25.     if (sensor->info.type == RT_SENSOR_CLASS_ACCE)
  26.     {
  27.         data->type = RT_SENSOR_CLASS_ACCE;
  28.         _copy_data(data, &acce_data);
  29.     }
  30.     else if (sensor->info.type == RT_SENSOR_CLASS_GYRO)
  31.     {
  32.         data->type = RT_SENSOR_CLASS_GYRO;
  33.         _copy_data(data, &gyro_data);
  34.     }
  35.     return 1;
  36. }
  38. static int _get_fifo_data(struct rt_sensor_device *sensor, void *buf, rt_size_t len)
  39. {
  40.         int i;
  41.     uint8_t frame_len = FIFO_DATA_LEN;
  42.     struct rt_sensor_data *data = buf;
  43.     struct bmi160_sensor_data buffer[FIFO_DATA_LEN]; // 32 data frames
  44.     struct bmi160_dev *hdev = sensor->parent.user_data;
  45.     rt_uint8_t data_type;
  47.     if (bmi160_get_fifo_data(hdev) != BMI160_OK)
  48.         return 0;
  50.     if (sensor->info.type == RT_SENSOR_CLASS_ACCE)
  51.     {
  52.         data_type = RT_SENSOR_CLASS_ACCE;
  53.         bmi160_extract_accel(buffer, &frame_len, hdev);
  54.     }
  55.     else if(sensor->info.type == RT_SENSOR_CLASS_GYRO)
  56.     {
  57.         data_type = RT_SENSOR_CLASS_GYRO;
  58.         bmi160_extract_gyro(buffer, &frame_len, hdev);
  59.     }
  60.     else if (sensor->info.type == RT_SENSOR_CLASS_MAG)
  61.     {
  62.         struct bmi160_aux_data aux_data[FIFO_DATA_LEN];
  63.         data_type = RT_SENSOR_CLASS_MAG;
  64.         bmi160_extract_aux(aux_data, &frame_len, hdev);
  65.         _extract_mag(hdev, aux_data, buffer, frame_len);
  66.     }
  67.     len = len < frame_len ? len : frame_len;
  68.     for (i = 0; i < len; i++)
  69.     {
  70.         data[i].type = data_type;
  71.         _copy_data(data + i, buffer + i);
  72.     }
  73.     return len;
  74. }
  76. static rt_size_t _fetch_data(struct rt_sensor_device *sensor, void *buf, rt_size_t len)
  77. {
  78.     if (sensor->config.mode == RT_SENSOR_MODE_FIFO)
  79.         return _get_fifo_data(sensor, buf, len);
  80.     return _get_data(sensor, buf);
  81. }

由实现可以知道，该接口需要实现读取数据，并将数据转换成 rt_sensor_data 格式数据上报，唯一的区别仅仅是不同工作模式需上报数据的数据量多少差异。

  • 应用关闭设备接口
    应用层关闭sensor接口为 rt_device_close，对应sensor框架中接口为 rt_sensor_close，此函数实现为：
  2. static rt_err_t rt_sensor_close(rt_device_t dev)
  3. {
  4.     rt_sensor_t sensor = (rt_sensor_t)dev;
  5.     int i;
  6.     rt_err_t (*local_ctrl)(struct rt_sensor_device * sensor, int cmd, void *arg) = local_control;
  8.     RT_ASSERT(dev != RT_NULL);
  10.     if (sensor->module)
  11.     {
  12.         rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
  13.     }
  14.     if (sensor->ops->control != RT_NULL)
  15.     {
  16.         local_ctrl = sensor->ops->control;
  17.     }
  19.     /* Configure power mode to power down mode */
  20.     if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER, (void *)RT_SENSOR_POWER_DOWN) == RT_EOK)
  21.     {
  22.         sensor->config.power = RT_SENSOR_POWER_DOWN;
  23.     }
  25.     if (sensor->module != RT_NULL && sensor->info.fifo_max > 0 && sensor->data_buf != RT_NULL)
  26.     {
  27.         for (i = 0; i < sensor->module->sen_num; i ++)
  28.         {
  29.             if (sensor->module->sen[i]->parent.ref_count > 0)
  30.                 goto __exit;
  31.         }
  33.         /* Free memory for the sensor buffer */
  34.         for (i = 0; i < sensor->module->sen_num; i ++)
  35.         {
  36.             if (sensor->module->sen[i]->data_buf != RT_NULL)
  37.             {
  38.                 rt_free(sensor->module->sen[i]->data_buf);
  39.                 sensor->module->sen[i]->data_buf = RT_NULL;
  40.             }
  41.         }
  42.     }
  43.     if (sensor->config.mode != RT_SENSOR_MODE_POLLING)
  44.     {
  45.         /* Sensor disable interrupt */
  46.         if (sensor->config.irq_pin.pin != RT_PIN_NONE)
  47.         {
  48.             rt_pin_irq_enable(sensor->config.irq_pin.pin, RT_FALSE);
  49.         }
  50.     }
  52. __exit:
  53.     if (sensor->module)
  54.     {
  55.         rt_mutex_release(sensor->module->lock);
  56.     }
  58.     return RT_EOK;
  59. }
通过该接口可知，关闭sensor实现较为简单，即关闭sensor，释放资源，同时关闭io口中断。

  • 参考资料

  • rtt源码中：/components/driver/sensor/v1/sensor.c
  • rtt软件包中的 BMI160/BMX60驱动
  • 《RT-Thread设备驱动开发指南》 传感器设备驱动开发章节


  • 注意事项
    目前sensor框架在做V2版本的重构，后续版本的sensor框架实现可能部分与该文描述不符。