1# Sensor 2 3 4## 概述 5 6### 功能简介 7 8Sensor驱动模型屏蔽硬件器件差异，为上层Sensor服务系统提供稳定的Sensor基础能力接口，包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅，Sensor参数配置等功能。Sensor设备驱动的开发是基于HDF驱动框架基础上，结合操作系统适配层（OSAL）和平台驱动接口（比如I2C/SPI/UART总线等平台资源）能力，屏蔽不同操作系统和平台总线资源差异，实现Sensor驱动“一次开发，多系统部署”的目标。Sensor驱动模型如图1所示。 9 10**图 1** Sensor驱动模型图 11 12 13 14### 基本概念 15 16目前根据sensorId将Sensor分为医学类Sensor、传统类Sensor两种。 17 18- 医学类Sensor：已订阅的sensorId枚举值在128-160范围的为医学类Sensor。 19 20- 传统类Sensor：已订阅的sensorId枚举值不在128-160范围的为传统类Sensor。 21 22### 运作机制 23 24通过介绍Sensor驱动模型的加载以及运行流程，对模型内部关键组件以及关联组件之间的关系进行了划分，整体加载流程如图2所示： 25 26**图 2** Sensor驱动运行图 27 28 29 30Sensor驱动模型以标准系统Hi3516DV300产品中的加速度传感器驱动为例，介绍整个驱动加载及运行流程： 31 321. 从device_info.hcs配置文件中的Sensor Host读取到Sensor设备管理配置信息。 332. HDF配置框架从HCB数据库中解析Sensor设备管理配置信息，并关联对应设备驱动。 343. 加载并初始化Sensor设备管理驱动。 354. Sensor设备管理驱动向HDI发布Sensor基础能力接口。 365. 从device_info.hcs配置文件中的Sensor Host读取到加速度传感器驱动配置信息。 376. 加载加速度传感器抽象驱动，调用初始化接口，完成Sensor器件的驱动资源分配和数据处理队列的创建。 387. 从accel_xxx_config.hcs配置文件中读取到加速度传感器差异化驱动配置和私有化配置信息。 398. 加速度传感器芯片差异化驱动，调用通用配置解析接口，完成器件属性信息解析，器件寄存器解析。 409. 加速度传感器芯片差异化驱动完成器件的探测，并分配加速度传感器配置资源和加速度传感器差异化接口注册。 4110. 加速度传感器成功探测到器件之后，加速度传感器芯片差异化驱动通知加速度传感器抽象驱动，注册加速度传感器设备到Sensor设备管理中。 42 43## 开发指导 44 45### 场景介绍 46 47- 通过重力和陀螺仪传感器数据，能感知设备倾斜和旋转量，提高用户在游戏场景中的体验。 48- 通过接近光传感器数据，感知距离遮挡物的距离，使设备能够自动亮灭屏，达到防误触目的。例如，手机通话时，如屏幕距离人脸过近，则自动关闭屏幕，防止误触的同时降低功耗。 49- 通过气压计传感器数据，可以准确的判断设备当前所处的海拔。 50- 通过环境光传感器数据，设备能够实现背光自动调节。 51- 通过霍尔传感器数据，设备可以实现皮套功能，皮套合上，手机上开一个小窗口，可降低功耗。 52 53### 接口说明 54 55Sensor驱动模型对外开放的API接口能力如下： 56 57- 提供Sensor HDI（Hardware Device Interface）能力接口，简化服务开发。 58- 提供Sensor驱动模型能力接口： 59 - 依赖HDF驱动框架实现Sensor器件驱动的加载、器件探测、注册和去注册等能力。 60 - 提供同一类型Sensor器件驱动归一接口、寄存器配置解析操作接口、总线访问抽象接口和平台抽象接口。 61- 提供开发者实现的能力接口：依赖HDF驱动框架的HCS（HDF Configuration Source）配置管理，根据同类型Sensor差异化配置，实现Sensor器件参数序列化配置和器件部分操作接口，简化Sensor器件驱动开发。 62 63Sensor驱动模型对外开放的API接口能力的具体实现请参考： 64 65**表 1** Sensor驱动模型对外API接口功能介绍 66 67| 接口名 | 功能描述 | 68| ----- | -------- | 69| int32_t GetAllSensors(struct SensorInformation **sensorInfo, int32_t *count) | 获取系统中注册的所有传感器信息，一组完整传感器信息包括传感器名字、设备厂商、固件版本号、硬件版本号、传感器类型编号、传感器标识、最大量程、精度、功耗。 | 70| int32_t Enable(int32_t sensorId) | 使能指定传感器设备，只有数据订阅者使能传感器后，才能获取订阅的传感器数据。 | 71| int32_t Disable(int32_t sensorId) | 去使能指定传感器设备。 | 72| int32_t SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval) | 设置指定传感器的数据采样间隔和数据上报间隔。 | 73| int32_t SetMode(int32_t sensorId, int32_t mode) | 设置指定传感器的工作模式，不同的工作模式，上报数据方式不同。 | 74| int32_t SetOption(int32_t sensorId, uint32_t option) | 设置指定传感器量程，精度等可选配置。 | 75| int32_t Register(int32_t groupId, RecordDataCallback cb) | 订阅者根据不同groupId注册传感器数据回调函数，系统会将获取到的传感器数据上报给订阅者。 | 76| int32_t Unregister(int32_t groupId, RecordDataCallback cb) | 订阅者根据groupId和回调函数注销对应订阅者的传感器数据回调函数。 | 77 78 79 80Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无需实现，直接使用，请参考： 81 82 **表2** Sensor驱动模型对驱动开发者开放的功能接口列表 83 84| 接口名 | 功能描述 | 85| ----- | -------- | 86| int32_t AddSensorDevice(const struct SensorDeviceInfo *deviceInfo) | 添加当前类型的传感器设备到传感器设备管理。 | 87| int32_t DeleteSensorDevice(const struct SensorBasicInfo *sensorBaseInfo) | 删除传感器设备管理里指定的传感器设备。 | 88| int32_t ReportSensorEvent(const struct SensorReportEvent *events) | 上报指定类型传感器的数据到用户侧。 | 89| int32_t ReadSensor(struct SensorBusCfg *busCfg, uint16_t regAddr, uint8_t *data, uint16_t dataLen) | 按照配置的总线方式，读取传感器寄存器配置数据。 | 90| int32_t WriteSensor(struct SensorBusCfg *busCfg, uint8_t *writeData, uint16_t len) | 按照配置的总线方式，将传感器配置数据写入寄存器。 | 91| int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group); | 根据传感器总线类型信息，下发寄存器分组配置。 | 92| int32_t GetSensorBaseConfigData(const struct DeviceResourceNode *node, struct SensorCfgData *config) | 根据传感器设备HCS资源配置，获取传感器信息，总线配置信息，属性配置等基本配置信息，并初始化对应的基本配置数据结构体。 | 93| int32_t ParseSensorRegConfig(struct SensorCfgData *config) | 根据传感器设备HCS资源配置，解析寄存器分组信息，并初始化配置数据结构体。 | 94| void ReleaseSensorAllRegConfig(struct SensorCfgData *config) | 释放传感器配置数据结构体里分配的资源。 | 95| int32_t GetSensorBusHandle(struct SensorBusCfg *busCfg) | 获取传感器总线句柄信息。 | 96| int32_t ReleaseSensorBusHandle(struct SensorBusCfg *busCfg) | 释放传感器句柄信息。 | 97 98 99 100Sensor驱动模型要求驱动开发者实现的接口功能，请参考： 101 102**表 3** Sensor驱动模型要求驱动开发者实现的接口列表 103 104| 接口名 | 功能描述 | 105| ----- | -------- | 106| int32_t init(void) | 传感器设备探测成功后，需要对传感器设备初始化配置。 | 107| int32_t Enable(void) | 根据当前传感器设备的HCS配置，下发传感器设备使能操作组的寄存器配置。 | 108| int32_t Disable(void) | 根据当前传感器设备的HCS配置，下发传感器设备去使能操作组的寄存器配置。 | 109| int32_t SetBatch(int64_t samplingInterval, int64_t reportInterval) | 根据数据采样率和数据上报间隔，配置当前传感器设备的数据上报线程处理时间。 | 110| int32_t SetMode(int32_t mode) | 配置当前传感器设备数据上报方式。 | 111| int32_t SetOption(uint32_t option) | 根据可选配置、下发量程和精度等寄存器配置。 | 112| void ReadSensorData(void) | 实现传感器的数据读取函数。 | 113 114 115接口实现参考[开发步骤](#开发步骤)章节。 116 117### 开发步骤 1181. 基于HDF驱动框架，按照驱动Driver Entry程序，完成加速度抽象驱动开发，主要由Bind、Init、Release、Dispatch函数接口实现。 119 120 - 加速度传感器驱动入口函数实现 121 122 ```c 123 /* 注册加速度计传感器入口数据结构体对象 */ 124 struct HdfDriverEntry g_sensorAccelDevEntry = { 125 .moduleVersion = 1, // 加速度计传感器模块版本号 126 .moduleName = "HDF_SENSOR_ACCEL", // 加速度计传感器模块名，要与device_info.hcs文件里的加速度计moduleName字段值一样 127 .Bind = BindAccelDriver, // 加速度计传感器绑定函数 128 .Init = InitAccelDriver, // 加速度计传感器初始化函数 129 .Release = ReleaseAccelDriver, // 加速度计传感器资源释放函数 130 }; 131 132 /* 调用HDF_INIT将驱动入口注册到HDF框架中。在加载驱动时HDF框架会先调用Bind函数，再调用Init函数加载该驱动。当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 */ 133 HDF_INIT(g_sensorAccelDevEntry); 134 ``` 135 136 - 加速度传感器驱动操作接口实现 137 138 ```c 139 /* 加速度计传感器驱动对外提供的服务绑定到HDF框架 */ 140 int32_t AccelBindDriver(struct HdfDeviceObject *device) 141 { 142 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); 143 144 struct AccelDrvData *drvData = (struct AccelDrvData *)OsalMemCalloc(sizeof(*drvData)); 145 if (drvData == NULL) { 146 HDF_LOGE("%s: Malloc accel drv data fail!", __func__); 147 return HDF_ERR_MALLOC_FAIL; 148 } 149 150 drvData->ioService.Dispatch = DispatchAccel; 151 drvData->device = device; 152 device->service = &drvData->ioService; 153 g_accelDrvData = drvData; 154 return HDF_SUCCESS; 155 } 156 157 /* 注册加速度计传感器驱动归一化的接口函数 */ 158 static int32_t InitAccelOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) 159 { 160 CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); 161 162 deviceInfo->ops.Enable = SetAccelEnable; 163 deviceInfo->ops.Disable = SetAccelDisable; 164 deviceInfo->ops.SetBatch = SetAccelBatch; 165 deviceInfo->ops.SetMode = SetAccelMode; 166 deviceInfo->ops.SetOption = SetAccelOption; 167 168 if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), 169 &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { 170 HDF_LOGE("%s: Copy sensor info failed", __func__); 171 return HDF_FAILURE; 172 } 173 174 return HDF_SUCCESS; 175 } 176 /* 提供给差异化驱动的初始化接口，完成加速度器件基本配置信息解析（加速度信息、加速度总线配置、加速度器件探测寄存器配置）、器件探测、器件寄存器解析 */ 177 static int32_t InitAccelAfterDetected(struct SensorCfgData *config) 178 { 179 struct SensorDeviceInfo deviceInfo; 180 CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); 181 /* 初始化加速度计接口函数 */ 182 if (InitAccelOps(config, &deviceInfo) != HDF_SUCCESS) { 183 HDF_LOGE("%s: Init accel ops failed", __func__); 184 return HDF_FAILURE; 185 } 186 /* 注册加速度计设备到传感器管理模块 */ 187 if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { 188 HDF_LOGE("%s: Add accel device failed", __func__); 189 return HDF_FAILURE; 190 } 191 /* 器件寄存器解析 */ 192 if (ParseSensorRegConfig(config) != HDF_SUCCESS) { 193 HDF_LOGE("%s: Parse sensor register failed", __func__); 194 (void)DeleteSensorDevice(&config->sensorInfo); 195 ReleaseSensorAllRegConfig(config); 196 return HDF_FAILURE; 197 } 198 return HDF_SUCCESS; 199 } 200 struct SensorCfgData *AccelCreateCfgData(const struct DeviceResourceNode *node) 201 { 202 …… 203 /* 如果探测不到器件在位，返回进行下个器件探测 */ 204 if (drvData->detectFlag) { 205 HDF_LOGE("%s: Accel sensor have detected", __func__); 206 return NULL; 207 } 208 if (drvData->accelCfg == NULL) { 209 HDF_LOGE("%s: Accel accelCfg pointer NULL", __func__); 210 return NULL; 211 } 212 /* 设备基本配置信息解析 */ 213 if (GetSensorBaseConfigData(node, drvData->accelCfg) != HDF_SUCCESS) { 214 HDF_LOGE("%s: Get sensor base config failed", __func__); 215 goto BASE_CONFIG_EXIT; 216 } 217 /* 如果探测不到器件在位，返回进行下个器件探测 */ 218 if (DetectSensorDevice(drvData->accelCfg) != HDF_SUCCESS) { 219 HDF_LOGI("%s: Accel sensor detect device no exist", __func__); 220 drvData->detectFlag = false; 221 goto BASE_CONFIG_EXIT; 222 } 223 drvData->detectFlag = true; 224 /* 器件寄存器解析 */ 225 if (InitAccelAfterDetected(drvData->accelCfg) != HDF_SUCCESS) { 226 HDF_LOGE("%s: Accel sensor detect device no exist", __func__); 227 goto INIT_EXIT; 228 } 229 return drvData->accelCfg; 230 …… 231 } 232 /* 加速度计传感器驱动初始化入口函数，主要功能为对传感器私有数据的结构体对象进行初始化，传感器HCS数据配置对象空间分配，传感器HCS数据配置初始化入口函数调用，传感器设备探测是否在位功能，传感器数据上报定时器创建，传感器归一化接口注册，传感器设备注册功能 */ 233 int32_t AccelInitDriver(struct HdfDeviceObject *device) 234 { 235 …… 236 /* 工作队列资源初始化 */ 237 if (InitAccelData(drvData) != HDF_SUCCESS) { 238 HDF_LOGE("%s: Init accel config failed", __func__); 239 return HDF_FAILURE; 240 } 241 /* 分配加速度配置信息资源 */ 242 drvData->accelCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->accelCfg)); 243 if (drvData->accelCfg == NULL) { 244 HDF_LOGE("%s: Malloc accel config data failed", __func__); 245 return HDF_FAILURE; 246 } 247 /* 注册寄存器分组信息 */ 248 drvData->accelCfg->regCfgGroup = &g_regCfgGroup[0]; 249 …… 250 return HDF_SUCCESS; 251 } 252 /* 释放驱动初始化时分配的资源 */ 253 void AccelReleaseDriver(struct HdfDeviceObject *device) 254 { 255 CHECK_NULL_PTR_RETURN(device); 256 struct AccelDrvData *drvData = (struct AccelDrvData *)device->service; 257 CHECK_NULL_PTR_RETURN(drvData); 258 /* 器件在位，释放已分配资源 */ 259 if (drvData->detectFlag) { 260 AccelReleaseCfgData(drvData->accelCfg); 261 } 262 OsalMemFree(drvData->accelCfg); 263 drvData->accelCfg = NULL; 264 /* 器件在位，销毁工作队列资源 */ 265 HdfWorkDestroy(&drvData->accelWork); 266 HdfWorkQueueDestroy(&drvData->accelWorkQueue); 267 OsalMemFree(drvData); 268 } 269 ``` 270 2712. 完成加速度传感器驱动的设备信息配置。 272 273 加速度传感器模型使用HCS作为配置描述源码，HCS配置字段请参考[配置管理](driver-hdf-manage.md)介绍。 274 275 ```hcs 276 /* 加速度计传感器设备HCS配置 */ 277 device_sensor_accel :: device { 278 device0 :: deviceNode { 279 policy = 1; // 驱动服务发布的策略 280 priority = 110; // 驱动启动优先级（0-200），值越大优先级越低，建议配置为100，优先级相同则不保证device的加载顺序 281 preload = 0; // 驱动按需加载字段，0表示加载，2表示不加载 282 permission = 0664; // 驱动创建设备节点权限 283 moduleName = "HDF_SENSOR_ACCEL"; // 驱动名称，该字段的值必须和驱动入口结构的moduleName值一致 284 serviceName = "sensor_accel"; // 驱动对外发布服务的名称，必须唯一 285 deviceMatchAttr = "hdf_sensor_accel_driver"; // 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等 286 } 287 } 288 ``` 289 2903. 完成加速度传感器抽象驱动内部接口开发，包括Enable、Disable、SetBatch、SetMode、SetOption、AccelCreateCfgData、AccelReleaseCfgData、AccelRegisterChipOps接口实现。 291 292 ```c 293 /* 不使用函数暂时置空 */ 294 static int32_t SetAccelInfo(struct SensorBasicInfo *info) 295 { 296 (void)info; 297 298 return HDF_ERR_NOT_SUPPORT; 299 } 300 /* 下发使能寄存器组的配置 */ 301 static int32_t SetAccelEnable(void) 302 { 303 int32_t ret; 304 struct AccelDrvData *drvData = AccelGetDrvData(); 305 306 CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); 307 CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM); 308 309 if (drvData->enable) { 310 HDF_LOGE("%s: Accel sensor is enabled", __func__); 311 return HDF_SUCCESS; 312 } 313 314 ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); 315 if (ret != HDF_SUCCESS) { 316 HDF_LOGE("%s: Accel sensor enable config failed", __func__); 317 return ret; 318 } 319 320 ret = OsalTimerCreate(&drvData->accelTimer, SENSOR_TIMER_MIN_TIME, AccelTimerEntry, (uintptr_t)drvData); 321 if (ret != HDF_SUCCESS) { 322 HDF_LOGE("%s: Accel create timer failed[%d]", __func__, ret); 323 return ret; 324 } 325 326 ret = OsalTimerStartLoop(&drvData->accelTimer); 327 if (ret != HDF_SUCCESS) { 328 HDF_LOGE("%s: Accel start timer failed[%d]", __func__, ret); 329 return ret; 330 } 331 drvData->enable = true; 332 333 return HDF_SUCCESS; 334 } 335 /* 下发去使能寄存器组的配置 */ 336 static int32_t SetAccelDisable(void) 337 { 338 int32_t ret; 339 struct AccelDrvData *drvData = AccelGetDrvData(); 340 341 CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); 342 CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM); 343 344 if (!drvData->enable) { 345 HDF_LOGE("%s: Accel sensor had disable", __func__); 346 return HDF_SUCCESS; 347 } 348 349 ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_DISABLE_GROUP]); 350 if (ret != HDF_SUCCESS) { 351 HDF_LOGE("%s: Accel sensor disable config failed", __func__); 352 return ret; 353 } 354 355 ret = OsalTimerDelete(&drvData->accelTimer); 356 if (ret != HDF_SUCCESS) { 357 HDF_LOGE("%s: Accel delete timer failed", __func__); 358 return ret; 359 } 360 drvData->enable = false; 361 362 return HDF_SUCCESS; 363 } 364 /* 配置传感器采样率和数据上报间隔 */ 365 static int32_t SetAccelBatch(int64_t samplingInterval, int64_t interval) 366 { 367 (void)interval; 368 369 struct AccelDrvData *drvData = NULL; 370 371 drvData = AccelGetDrvData(); 372 CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); 373 374 drvData->interval = samplingInterval; 375 376 return HDF_SUCCESS; 377 } 378 /* 设置传感器工作模式，当前支持实时模式 */ 379 static int32_t SetAccelMode(int32_t mode) 380 { 381 return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE; 382 } 383 384 static int32_t SetAccelOption(uint32_t option) 385 { 386 (void)option; 387 return HDF_SUCCESS; 388 } 389 /* 设置传感器可选配置 */ 390 static int32_t SetAccelOption(uint32_t option) 391 { 392 (void)option; 393 return HDF_ERR_NOT_SUPPORT; 394 } 395 ``` 396 3974. 基于HDF驱动框架，按照驱动Driver Entry程序，完成加速度传感器差异化驱动开发，主要由Bind、Init、Release、Dispatch函数接口实现。 398 399 ```c 400 /* 加速度计传感器差异化驱动消息交互 */ 401 static int32_t DispatchBMI160(struct HdfDeviceIoClient *client, 402 int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) 403 { 404 (void)client; 405 (void)cmd; 406 (void)data; 407 (void)reply; 408 409 return HDF_SUCCESS; 410 } 411 /* 加速度计传感器差异化驱动对外提供的服务绑定到HDF框架 */ 412 int32_t Bmi160BindDriver(struct HdfDeviceObject *device) 413 { 414 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); 415 416 struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)OsalMemCalloc(sizeof(*drvData)); 417 if (drvData == NULL) { 418 HDF_LOGE("%s: Malloc Bmi160 drv data fail", __func__); 419 return HDF_ERR_MALLOC_FAIL; 420 } 421 422 drvData->ioService.Dispatch = DispatchBMI160; 423 drvData->device = device; 424 device->service = &drvData->ioService; 425 g_bmi160DrvData = drvData; 426 427 return HDF_SUCCESS; 428 } 429 /* 加速度计传感器差异化驱动初始化 */ 430 int32_t Bmi160InitDriver(struct HdfDeviceObject *device) 431 { 432 int32_t ret; 433 struct AccelOpsCall ops; 434 435 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); 436 struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)device->service; 437 CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); 438 439 ret = InitAccelPreConfig(); 440 if (ret != HDF_SUCCESS) { 441 HDF_LOGE("%s: Init BMI160 bus mux config", __func__); 442 return HDF_FAILURE; 443 } 444 445 drvData->sensorCfg = AccelCreateCfgData(device->property); 446 if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { 447 HDF_LOGD("%s: Creating accelcfg failed because detection failed", __func__); 448 return HDF_ERR_NOT_SUPPORT; 449 } 450 451 ops.Init = NULL; 452 ops.ReadData = ReadBmi160Data; 453 ret = AccelRegisterChipOps(&ops); 454 if (ret != HDF_SUCCESS) { 455 HDF_LOGE("%s: Register BMI160 accel failed", __func__); 456 return HDF_FAILURE; 457 } 458 459 ret = InitBmi160(drvData->sensorCfg); 460 if (ret != HDF_SUCCESS) { 461 HDF_LOGE("%s: Init BMI160 accel failed", __func__); 462 return HDF_FAILURE; 463 } 464 465 return HDF_SUCCESS; 466 } 467 /* 释放驱动初始化时分配的资源 */ 468 void Bmi160ReleaseDriver(struct HdfDeviceObject *device) 469 { 470 ...... 471 if (drvData->sensorCfg != NULL) { 472 AccelReleaseCfgData(drvData->sensorCfg); 473 drvData->sensorCfg = NULL; 474 } 475 OsalMemFree(drvData); 476 } 477 /* 加速度传感器差异化驱动对应的HdfDriverEntry对象 */ 478 struct HdfDriverEntry g_accelBmi160DevEntry = { 479 .moduleVersion = 1, 480 .moduleName = "HDF_SENSOR_ACCEL_BMI160", 481 .Bind = Bmi160BindDriver, 482 .Init = Bmi160InitDriver, 483 .Release = Bmi160ReleaseDriver, 484 }; 485 HDF_INIT(g_accelBmi160DevEntry); 486 ``` 487 4885. 完成加速度传感器差异化驱动中差异化接口ReadData函数实现。 489 490 ```c 491 int32_t ReadBmi160Data(struct SensorCfgData *data) 492 { 493 int32_t ret; 494 struct AccelData rawData = { 0, 0, 0 }; 495 int32_t tmp[ACCEL_AXIS_NUM]; 496 struct SensorReportEvent event; 497 (void)memset_s(&event, sizeof(event), 0, sizeof(event)); 498 ret = ReadBmi160RawData(data, &rawData, &event.timestamp); 499 if (ret != HDF_SUCCESS) { 500 HDF_LOGE("%s: BMI160 read raw data failed", __func__); 501 return HDF_FAILURE; 502 } 503 event.sensorId = SENSOR_TAG_ACCELEROMETER; 504 event.option = 0; 505 event.mode = SENSOR_WORK_MODE_REALTIME; 506 …… 507 ret = ReportSensorEvent(&event); 508 if (ret != HDF_SUCCESS) { 509 HDF_LOGE("%s: BMI160 report data failed", __func__); 510 } 511 return ret; 512 } 513 ``` 514 515### 调测验证 516 517驱动开发完成后，在传感器单元测试里面开发自测试用例，验证驱动基本功能。测试环境采用开发者自测试平台。 518 519```c++ 520static int32_t g_sensorDataFlag = 0; // 标识是否上报传感器数据 521static const struct SensorInterface *g_sensorDev = nullptr; // 保持获取的传感器接口实例地址 522 523/* 订阅者注册数据上报函数 */ 524static int SensorTestDataCallback(struct SensorEvents *event) 525{ 526 if (event == nullptr) { 527 return -1; 528 } 529 float *data = (float*)event->data; 530 printf("time [%lld] sensor id [%d] x-[%f] y-[%f] z-[%f]\n\r", event->timestamp, 531 event->sensorId, (*data), *(data + 1), *(data + g_axisZ)); 532 if (*data > 1e-5) { 533 g_sensorDataFlag = 1; 534 } 535 return 0; 536} 537/* 用例执行前，初始化传感器接口实例 */ 538void HdfSensorTest::SetUpTestCase() 539{ 540 g_sensorDev = NewSensorInterfaceInstance(); 541 if (g_sensorDev == nullptr) { 542 printf("test sensor get module instance failed\n\r"); 543 } 544} 545/* 用例资源释放 */ 546void HdfSensorTest::TearDownTestCase() 547{ 548 if (g_sensorDev != nullptr) { 549 FreeSensorInterfaceInstance(); 550 g_sensorDev = nullptr; 551 } 552} 553/* 传感器驱动测试验证 */ 554HWTEST_F(HdfSensorTest,TestAccelDriver_001, TestSize.Level0) 555{ 556 int32_t sensorInterval = 1000000000; // 数据采样率单位纳秒 557 int32_t pollTime = 5; // 数据采样时间单位秒 558 int32_t accelSensorId = 1; // 加速度传感器类型标识为1 559 int32_t count = 0; 560 int ret; 561 struct SensorInformation *sensorInfo = nullptr; 562 563 ret = g_sensorDev->Register(0, TraditionSensorTestDataCallback) 564 EXPECT_EQ(SENSOR_NULL_PTR, ret); 565 566 ret = g_sensorDev->GetAllSensors(&sensorInfo, &count); 567 EXPECT_EQ(0, ret); 568 if (sensorInfo == nullptr) { 569 EXPECT_NE(nullptr, sensorInfo); 570 return; 571 } 572 /* 打印获取的传感器列表 */ 573 for (int i = 0; i < count; i++) { 574 printf("get sensorId[%d], info name[%s]\n\r", sensorInfo[i]->sensorId, sensorInfo[i]->sensorName); 575 } 576 ret = g_sensorDev->Enable(accelSensorId); 577 EXPECT_EQ(0, ret); 578 g_sensorDataFlag = 0; 579 580 ret = g_sensorDev->SetBatch(accelSensorId, sensorInterval, pollTime); 581 EXPECT_EQ(0, ret); 582 /* 在时间pollTime内，观察输出打印数据 */ 583 OsalSleep(pollTime); 584 EXPECT_EQ(1, g_sensorDataFlag); 585 586 ret = g_sensorDev->Disable(accelSensorId); 587 g_sensorDataFlag = 0; 588 EXPECT_EQ(0, ret); 589 590 ret = g_sensorDev->Unregister(0, TraditionSensorTestDataCallback); 591 EXPECT_EQ(0, ret); 592} 593``` 594 595