rtthread的sensor框架存在两个版本，其中V2版的框架号称是为了解决V1对多传感器共用一颗IC的场景支持问题而设计的。由于两个sensor框架都有在使用，因此两版传感器框架都需要了解。
传感器接口
此部分源码所处位置为：\components\drivers\sensor\v1\sensor.c
从之前对rtt设备驱动套路上的结论的角度上看，要想分析对应的驱动框架，只需要在对应的框架代码中找结构体 struct rt_device_ops 便可以找到对应的对驱动层的注册接口。按照此思路找下去，sensor框架对应的注册接口为：
传感器注册接口
static char *const sensor_name_str[] =
{
"none",
"acce_", /* Accelerometer */
"gyro_", /* Gyroscope */
"mag_", /* Magnetometer */
"temp_", /* Temperature */
"humi_", /* Relative Humidity */
"baro_", /* Barometer */
"li_", /* Ambient light */
"pr_", /* Proximity */
"hr_", /* Heart Rate */
"tvoc_", /* TVOC Level */
"noi_", /* Noise Loudness */
"step_", /* Step sensor */
"forc_", /* Force sensor */
"dust_", /* Dust sensor */
"eco2_", /* eCO2 sensor */
"gnss_", /* GPS/GNSS sensor */
"tof_", /* TOF sensor */
"spo2_", /* SpO2 sensor */
"iaq_", /* IAQ sensor */
"etoh_", /* EtOH sensor */
"bp_" /* Blood Pressure */
};
static rt_ssize_t local_fetch_data(struct rt_sensor_device *sensor, void *buf, rt_size_t len)
{
LOG_D("Undefined fetch_data");
return 0;
}
static rt_err_t local_control(struct rt_sensor_device *sensor, int cmd, void *arg)
{
LOG_D("Undefined control");
return -RT_ERROR;
}
static struct rt_sensor_ops local_ops =
{
.fetch_data = local_fetch_data,
.control = local_control
};
#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops rt_sensor_ops =
{
RT_NULL,
rt_sensor_open,
rt_sensor_close,
rt_sensor_read,
RT_NULL,
rt_sensor_control
};
#endif
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;
// 如果注册时未提供对应的ops，则使用默认ops，
// 默认ops只是提供打印，告诉编程者对应的接口未实现
if (sensor->ops == RT_NULL)
{
sensor->ops = &local_ops;
}
/* 获取注册的设备驱动名字，传感器类型+传入名称 */
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 = rt_sensor_open;
device->close = rt_sensor_close;
device->read = rt_sensor_read;
device->write = RT_NULL;
device->control = rt_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("rt_sensor[%s] register err code: %d", device_name, result);
rt_free(device_name);
return result;
}
LOG_I("rt_sensor[%s] init success", device_name);
rt_free(device_name);
return RT_EOK;
}在注册函数中，我们可以知道，V1的传感器框架已经支持了常见的那些传感器种类了，而且在架构设计时，已经考虑到了一颗芯片存在支持多种数据的问题。
传感器打开接口
void rt_sensor_cb(rt_sensor_t sen)
{
if (sen->parent.rx_indicate == RT_NULL)
{
return;
}
// 预先处理传感器数据
// 在支持中断嵌套的平台下，不少传感器驱动把数据读取和转化放在该接口中实现
if (sen->irq_handle != RT_NULL)
{
sen->irq_handle(sen);
}
/* 通过rx_indicate回调函数通知上层应用有数据，以及数据有多少，以便上层完整读取 */
if (sen->data_len > 0)
{
sen->parent.rx_indicate(&sen->parent, sen->data_len / sizeof(struct rt_sensor_data));
}
else if (sen->config.mode == RT_SENSOR_MODE_INT)
{
sen->parent.rx_indicate(&sen->parent, 1);
}
else if (sen->config.mode == RT_SENSOR_MODE_FIFO)
{
sen->parent.rx_indicate(&sen->parent, sen->info.fifo_max);
}
}
static void irq_callback(void *args)
{
rt_sensor_t sensor = (rt_sensor_t)args;
rt_uint8_t i;
if (sensor->module)
{
/* 如果是模组，由于模组只有一个中断脚，收到中断时无法区分是什么数据，
因此所有模块都通知一遍。在模块读取数据时判断是什么数据到了 */
for (i = 0; i < sensor->module->sen_num; i++)
{
rt_sensor_cb(sensor->module->sen[i]);
}
}
else
{
rt_sensor_cb(sensor);
}
}
static rt_err_t rt_sensor_irq_init(rt_sensor_t sensor)
{
// 如果没设置中断脚，则不注册回调函数
if (sensor->config.irq_pin.pin == RT_PIN_NONE)
{
return -RT_EINVAL;
}
//不同的输入配置，设置成不同的工作模式
//设置成输入带下拉时，则使用上升沿中断处理回调
// 输入上拉时，默认使用下降沿触发
// 输入悬空，默认使用下降沿触发（缘由：大部分硬件在io口不能配上下拉时会选择外部接上拉）
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);
}
// 使能io口中断
rt_pin_irq_enable(sensor->config.irq_pin.pin, RT_TRUE);
LOG_I("interrupt init success");
return 0;
}
static rt_err_t rt_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)(struct rt_sensor_device * sensor, int cmd, void *arg) = local_control;
if (sensor->module)
{
/* 如果是模组的话，因为总线只有一个，
多线程错开访问可能会导致异常，因此需要模组锁做限制 */
rt_mutex_take(sensor->module->lock, RT_WAITING_FOREVER);
}
// 如果是模组并支持fifo模式的数据存储，而fifo对应的buffer未申请，则申请该buffer
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;
}
// 默认设置未轮询模式
sensor->config.mode = RT_SENSOR_MODE_POLLING;
if (oflag & RT_DEVICE_FLAG_RDONLY && dev->flag & RT_DEVICE_FLAG_RDONLY)
{
/* 如果支持轮询模式，则初始化成轮询模式 */
local_ctrl(sensor, RT_SENSOR_CTRL_SET_MODE, (void *)RT_SENSOR_MODE_POLLING);
}
else if (oflag & RT_DEVICE_FLAG_INT_RX && dev->flag & RT_DEVICE_FLAG_INT_RX)
{
/* 如果支持中断模式，则初始化成中断模式并注册中断回调函数 */
if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_MODE, (void *)RT_SENSOR_MODE_INT) == RT_EOK)
{
rt_sensor_irq_init(sensor);
sensor->config.mode = RT_SENSOR_MODE_INT;
}
}
else if (oflag & RT_DEVICE_FLAG_FIFO_RX && dev->flag & RT_DEVICE_FLAG_FIFO_RX)
{
/* 如果支持fifo模式，则注册成fifo模式并注册回调函数 */
if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_MODE, (void *)RT_SENSOR_MODE_FIFO) == RT_EOK)
{
rt_sensor_irq_init(sensor);
sensor->config.mode = RT_SENSOR_MODE_FIFO;
}
}
else
{
res = -RT_EINVAL;
goto __exit;
}
/* 把传感器工作模式切换为正常工作模式 */
if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER, (void *)RT_SENSOR_POWER_NORMAL) == RT_EOK)
{
sensor->config.power = RT_SENSOR_POWER_NORMAL;
}
__exit:
if (sensor->module)
{
/* 操作完毕，释放模组锁 */
rt_mutex_release(sensor->module->lock);
}
return res;
}通过对读接口的分析，我们可以知道，上层应用使用传感器时，必须注册rx_indicate回调函数（除非使用轮询，不需要底层通知应用有新数据到达）。另外，结合注册函数，会发现v1的框架做了一些容错性设计（传感器没有定义ops时，运行时出各种打印），虽然在最终的应用中不会出问题，但能在一定程度上对适配传感器框架带来帮助。
驱动读接口
static rt_ssize_t rt_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);
}
/* 如果有缓存数据，则直接把缓存数据复制到缓冲区并清空缓存 */
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));
sensor->data_len = 0;
result = len;
}
else
{
/* 如果缓存数据为空，则读取数据，并放置与读取的缓冲区中 */
if (sensor->ops->fetch_data != RT_NULL)
{
result = sensor->ops->fetch_data(sensor, buf, len);
}
}
if (sensor->module)
{
rt_mutex_release(sensor->module->lock);
}
return result;
}读接口，其实并没有什么特定的操作，直接对应的传感器去读取传感器的数据，由于涉及到模组的情况，因此每次读的时候都用锁做了队列，防止读冲突。
传感器控制接口
static rt_err_t rt_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)(struct rt_sensor_device * sensor, int cmd, void *arg) = local_control;
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_GET_INFO: // 获取传感器信息
if (args)
{
rt_memcpy(args, &sensor->info, sizeof(struct rt_sensor_info));
}
break;
case RT_SENSOR_CTRL_SET_RANGE: // 设置传感器的测量精度或量程
result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_RANGE, args);
if (result == RT_EOK)
{
sensor->config.range = (rt_int32_t)args;
LOG_D("set range %d", sensor->config.range);
}
break;
case RT_SENSOR_CTRL_SET_ODR: // 设置传感器的检测频率
result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_ODR, args);
if (result == RT_EOK)
{
sensor->config.odr = (rt_uint32_t)args & 0xFFFF;
LOG_D("set odr %d", sensor->config.odr);
}
break;
case RT_SENSOR_CTRL_SET_POWER: // 设置传感器的工作模式
result = local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER, args);
if (result == RT_EOK)
{
sensor->config.power = (rt_uint32_t)args & 0xFF;
LOG_D("set power mode code:", sensor->config.power);
}
break;
case RT_SENSOR_CTRL_SELF_TEST: // 传感器自检，若支持的话
result = local_ctrl(sensor, RT_SENSOR_CTRL_SELF_TEST, args);
break;
default:
//若传感器有用户自定义功能，则在此下发
if (cmd > RT_SENSOR_CTRL_USER_CMD_START)
{
result = local_ctrl(sensor, cmd, args);
}
else
{
result = -RT_ERROR;
}
break;
}
if (sensor->module)
{
rt_mutex_release(sensor->module->lock);
}
return result;
}传感器关闭接口
static rt_err_t rt_sensor_close(rt_device_t dev)
{
rt_sensor_t sensor = (rt_sensor_t)dev;
int i;
rt_err_t (*local_ctrl)(struct rt_sensor_device * sensor, int cmd, void *arg) = local_control;
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;
}
/* 传感器设置到关机状态 */
if (local_ctrl(sensor, RT_SENSOR_CTRL_SET_POWER, (void *)RT_SENSOR_POWER_DOWN) == RT_EOK)
{
sensor->config.power = RT_SENSOR_POWER_DOWN;
}
// 如果是模组，且支持fifo，此时若所有模块都关闭了，则销毁fifo缓存
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;
}
for (i = 0; i < sensor->module->sen_num; i ++)
{
if (sensor->module->sen[i]->data_buf != RT_NULL)
{
rt_free(sensor->module->sen[i]->data_buf);
sensor->module->sen[i]->data_buf = RT_NULL;
}
}
}
// 如果非轮询模式，则对应的注销中断回调处理
if (sensor->config.mode != RT_SENSOR_MODE_POLLING)
{
if (sensor->config.irq_pin.pin != RT_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;
}传感器关闭接口的实现，看起来挺简单，仅仅是通知驱动切换到power down模式，并销毁对应的资源。这也是和打开接口逻辑一一对应的地方。
总结
至此，传感器驱动对接应用的部分就分析完毕了，通过对此部分的分析，我们会发现，应用层要用传感器，实际上仅仅需要打开对应功能的传感器，设置好量程，频率，若需要非轮询的功能，则注册回调函数获取底层以采集的数据量。便可实现传感器的使用。
而从上面的分析，我们也大致能看出V1的传感器框架对驱动适配的要求，这个在后面的传感器驱动分析再细讲，即：
#include <drivers/sensor.h>
struct sensor_device {
// driver Param
};
static rt_size_t _polling_get_data(rt_sensor_t sensor, struct rt_sensor_data *data)
{
struct sensor_device *dev = sensor->parent.user_data;
if (sensor->info.type == RT_SENSOR_CLASS_NONE)
{
// TODO: Read and fill data to struct rt_sensor_data *data
return 1;
}
return 0;
}
static rt_size_t _get_data(rt_sensor_t sensor, struct rt_sensor_data *data)
{
struct sensor_device *dev = sensor->parent.user_data;
if (sensor->info.type == RT_SENSOR_CLASS_NONE)
{
// TODO: Read and fill data to struct rt_sensor_data *data
return 1;
}
return 0;
}
static rt_size_t fetch_data(struct rt_sensor_device *sensor, void *buf, rt_size_t len)
{
RT_ASSERT(buf);
if (sensor->config.mode == RT_SENSOR_MODE_POLLING)
return _polling_get_data(sensor, buf);
else
return _get_data(sensor, buf);
}
static rt_err_t control(struct rt_sensor_device *sensor, int cmd, void *args)
{
rt_err_t result = RT_EOK;
switch (cmd)
{
case RT_SENSOR_CTRL_GET_ID:
// TODO: get device id
// result = xxxx(sensor, args);
break;
case RT_SENSOR_CTRL_SET_RANGE:
// TODO: set test range
// result = xxxx(sensor, args);
break;
case RT_SENSOR_CTRL_SET_ODR:
// TODO: set frequency
// result = xxxx(sensor, args);
break;
case RT_SENSOR_CTRL_SET_MODE:
// TODO: set work mode
// result = xxxx(sensor, args);
break;
case RT_SENSOR_CTRL_SET_POWER:
// TODO: set power mode
// result = xxxx(sensor, args);
break;
case RT_SENSOR_CTRL_SELF_TEST:
// TODO: process self test
// result = xxxx(sensor);
break;
default:
return -RT_ERROR;
}
return result;
}
static struct rt_sensor_ops sensor_ops =
{
fetch_data,
control
};
int rt_hw_init(const char *name, struct rt_sensor_config *cfg)
{
rt_int8_t result;
rt_sensor_t sensor = RT_NULL;
struct sensor_device *dev;
// TODO: dev init
/* sensor register */
sensor = rt_calloc(1, sizeof(struct rt_sensor_device));
if (sensor == RT_NULL)
goto __exit;
sensor->info.type = RT_SENSOR_CLASS_NONE; // Set real type
sensor->info.vendor = RT_SENSOR_VENDOR_UNKNOWN; // Set real vendor
sensor->info.model = "xxxx"; // set real model name
sensor->info.unit = RT_SENSOR_UNIT_NONE; // set to real unit flag
sensor->info.intf_type = RT_SENSOR_INTF_SPI; // Set interface type
sensor->info.range_max = SENSOR_RANGE_MAX; // Set to range max
sensor->info.range_min = SENSOR_RANGE_MIN; // Set to range min
sensor->info.period_min = 50; // Set frequency
rt_memcpy(&sensor->config, cfg, sizeof(struct rt_sensor_config));
sensor->ops = &sensor_ops;
result = rt_hw_sensor_register(sensor, name, RT_DEVICE_FLAG_RDONLY, dev);
if (result != RT_EOK)
{
goto __exit;
}
return RT_EOK;
__exit:
if (sensor)
rt_free(sensor);
// TODO: dev deinit
return -RT_ERROR;
}
STM32
MCU
通讯及无线技术
物联网技术
电子DIY
板卡试用
基础知识
软件与操作系统
我爱生活
小e食堂