Skip to content

D
Docs

OpenHarmony / Docs
大约 2 年 前同步成功

通知 161
Star 293
Fork 28
D
Docs
You need to sign in or sign up before continuing.
未验证 提交 479e31cf 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!1254 add sensor/vibrator file 

Merge pull request !1254 from sunxuejiao/master
上级 3bf254eb 3f16afe5
显示空白变更内容
内联 并排
Showing with 1001 addition and 664 deletion
zh-cn/device-dev/driver/driver-peripherals-sensor-des.md 100644 → 100755
浏览文件 @ 479e31cf
# SENSOR<a name="ZH-CN_TOPIC_0000001078401780"></a> # SENSOR<a name="ZH-CN_TOPIC_0000001078401780"></a>
- [概述](#section3634112111) - [概述](##概述)
- [接口说明](#section20930112117478) - [功能简介](###功能简介)
- [开发步骤](#section1140943382) - [运作机制](###运作机制)
- [开发实例](#section257750691)
- [测试指导](#section106021256121219)
## 概述<a name="section3634112111"></a> - [开发指导](##开发指导)
- [接口说明](#section188213414114)
- [开发步骤](#section7893102915819)
- [开发实例](#section257750691)
- [调测验证](#section106021256121219)
Sensor（传感器）驱动模块为上层Sensor服务系统提供稳定的Sensor基础能力API，包括Sensor列表查询、Sensor启停、Sensor订阅及去订阅，Sensor参数配置等功能；基于HDF（Hardware Driver Foundation）驱动框架开发的Sensor驱动模型，实现跨操作系统迁移，器件差异配置等功能。Sensor驱动模型如下图1所示：
## 概述
### 功能简介
Sensor设备作为外接设备重要组成模块，通过Sensor驱动模型屏蔽硬件器件差异，为上层Sensor服务系统提供稳定的Sensor基础能力接口，包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅，Sensor参数配置等功能；Sensor设备驱动的开发是基于HDF驱动框架基础上，结合操作系统适配层（OSAL）和平台驱动接口（比如I2C/SPI/UART总线等平台资源）能力，屏蔽不同操作系统和平台总线资源差异，实现Sensor驱动“一次开发，多系统部署”的目标。Sensor驱动模型如[图1](#fig10451455446)所示：<a name="section3634112111"></a>
**图 1** Sensor驱动模型图<a name="fig10451455446"></a> **图 1** Sensor驱动模型图<a name="fig10451455446"></a>
![](figures/Sensor驱动模型图.png "Sensor驱动模型图") ![Sensor驱动模型图](figures/Sensor%E9%A9%B1%E5%8A%A8%E6%A8%A1%E5%9E%8B%E5%9B%BE.png)
### 运作机制
通过介绍Sensor驱动模型的加载以及运行流程，对模型内部关键组件以及关联组件之间的关系进行了划分，整体加载流程如[图2](#Sensor驱动模型图)所示：
**图 2** Sensor驱动模型运行图
![Sensor驱动模型运行图](figures/Sensor%E9%A9%B1%E5%8A%A8%E6%A8%A1%E5%9E%8B%E8%BF%90%E8%A1%8C%E5%9B%BE.png)
Sensor驱动模型以标准系统Hi3516DV300产品中的加速度传感器驱动为例，介绍整个驱动加载及运行流程：
1. 从device info HCS 的Sensor Host读取Sensor设备管理配置信息。
2. HDF配置框架从HCB数据库解析Sensor设备管理配置信息，并关联对应设备驱动。
3. 加载并初始化Sensor设备管理驱动。
4. Sensor设备管理驱动向HDI发布Sensor基础能力接口。
5. 从device info HCS 的Sensor Host读取加速度传感器驱动配置信息。
6. 加载加速度传感器抽象驱动，调用初始化接口，完成Sensor器件驱动资源分配和数据处理队列创建。
7. 从accel_xxx_config HCS读取加速度传感器差异化驱动配置和私有化配置信息。
8. 加速度传感器差异化驱动，调用通用配置解析接口，完成器件属性信息解析，器件寄存器解析。
9. 加速度传感器差异化驱动完成器件探测，并分配加速度传感器配置资源，完成加速度传感器差异化接口注册。
10. 加速度传感器探测成功之后，加速度传感器差异化驱动通知加速度传感器抽象驱动，注册加速度传感器设备到Sensor设备管理中。
## 开发指导
### 接口说明<a name="section188213414114"></a>
Sensor驱动模型对外开放的API接口能力如下： Sensor驱动模型对外开放的API接口能力如下：
- 提供Sensor HDI（Hardware Driver Interface）能力接口，简化服务开发。 - 提供Sensor HDI（Hardware Driver Interface）能力接口，简化服务开发。
- 提供Sensor驱动模型能力接口：依赖HDF驱动框架实现Sensor器件驱动的注册、加载、去注册、器件探测等能力，提供同一类型Sensor器件驱动归一接口, 寄存器配置解析操作接口，总线访问抽象接口，平台抽象接口。 - 提供Sensor驱动模型能力接口：
- 依赖HDF驱动框架实现Sensor器件驱动的注册，加载，去注册，器件探测等能力。
- 提供同一类型Sensor器件驱动归一接口, 寄存器配置解析操作接口，总线访问抽象接口，平台抽象接口。
- 提供开发者实现的能力接口：依赖HDF驱动框架的HCS（HDF Configuration Source）配置管理，根据同类型Sensor差异化配置，实现Sensor器件参数序列化配置和器件部分操作接口，简化Sensor器件驱动开发。 - 提供开发者实现的能力接口：依赖HDF驱动框架的HCS（HDF Configuration Source）配置管理，根据同类型Sensor差异化配置，实现Sensor器件参数序列化配置和器件部分操作接口，简化Sensor器件驱动开发。
## 接口说明<a name="section20930112117478"></a> Sensor驱动模型对外开放的API接口能力的具体实现参考[表1](#table203963834718)：
Sensor驱动模型对HDI开放的API接口功能，参考表1。
**表 1** Sensor驱动模型对外API接口功能介绍 **表 1** Sensor驱动模型对外API接口功能介绍
<a name="table203963834718"></a> <a name="table203963834718"></a>
<table><thead align="left"><tr id="row173964834716"><th class="cellrowborder" valign="top" width="8.260000000000002%" id="mcps1.2.4.1.1"><p id="p17401913133218"><a name="p17401913133218"></a><a name="p17401913133218"></a>功能分类</p> <table><thead align="left"><tr id="row173964834716"><th class="cellrowborder" valign="top" width="8.260000000000002%" id="mcps1.2.4.1.1"><p id="p17401913133218"><a name="p17401913133218"></a><a name="p17401913133218"></a>功能分类</p>
</th> </th>
<th class="cellrowborder" valign="top" width="45.4%" id="mcps1.2.4.1.2"><p id="p20921103144918"><a name="p20921103144918"></a><a name="p20921103144918"></a>接口名</p> <th class="cellrowborder" valign="top" width="45.4%" id="mcps1.2.4.1.2"><p id="p20921103144918"><a name="p20921103144918"></a><a name="p20921103144918"></a>接口名</p>
...@@ -38,68 +71,56 @@ Sensor驱动模型对HDI开放的API接口功能，参考表1。 ...@@ -38,68 +71,56 @@ Sensor驱动模型对HDI开放的API接口功能，参考表1。
</td> </td>
<td class="cellrowborder" valign="top" width="45.4%" headers="mcps1.2.4.1.2 "><p id="p11001322173912"><a name="p11001322173912"></a><a name="p11001322173912"></a>int32_t <strong id="b935414557240"><a name="b935414557240"></a><a name="b935414557240"></a>GetAllSensors</strong>(struct SensorInformation **sensorInfo, int32_t *count)</p> <td class="cellrowborder" valign="top" width="45.4%" headers="mcps1.2.4.1.2 "><p id="p11001322173912"><a name="p11001322173912"></a><a name="p11001322173912"></a>int32_t <strong id="b935414557240"><a name="b935414557240"></a><a name="b935414557240"></a>GetAllSensors</strong>(struct SensorInformation **sensorInfo, int32_t *count)</p>
</td> </td>
<td class="cellrowborder" valign="top" width="46.339999999999996%" headers="mcps1.2.4.1.3 "><p id="p199227318499"><a name="p199227318499"></a><a name="p199227318499"></a>获取系统中注册的所有传感器信息，一种类型传感器信息包括传感器名字、设备厂商、固件版本号、硬件版本号、传感器类型编号、传感器标识、最大量程、精度、功耗。</p> <td class="cellrowborder" valign="top" width="46.339999999999996%" headers="mcps1.2.4.1.3 "><p id="p199227318499"><a name="p199227318499"></a><a name="p199227318499"></a>获取系统中注册的所有传感器信息，一组完整传感器信息包括传感器名字、设备厂商、固件版本号、硬件版本号、传感器类型编号、传感器标识、最大量程、精度、功耗。</p>
</td> </td>
</tr> </tr>
<tr id="row1839716854716"><td class="cellrowborder" rowspan="5" valign="top" width="8.260000000000002%" headers="mcps1.2.4.1.1 "><p id="p06071477324"><a name="p06071477324"></a><a name="p06071477324"></a>配置操作</p> <tr id="row1839716854716"><td class="cellrowborder" rowspan="5" valign="top" width="8.260000000000002%" headers="mcps1.2.4.1.1 "><p id="p06071477324"><a name="p06071477324"></a><a name="p06071477324"></a>配置操作</p>
</td> </td>
<td class="cellrowborder" valign="top" width="45.4%" headers="mcps1.2.4.1.2 "><p id="p38874252376"><a name="p38874252376"></a><a name="p38874252376"></a>int32_t <strong id="b199602219271"><a name="b199602219271"></a><a name="b199602219271"></a>Enable</strong>(int32_t sensorId)</p> <td class="cellrowborder" valign="top" width="45.4%" headers="mcps1.2.4.1.2 "><p id="p38874252376"><a name="p38874252376"></a><a name="p38874252376"></a>int32_t <strong id="b199602219271"><a name="b199602219271"></a><a name="b199602219271"></a>Enable</strong>(int32_t sensorId)</p>
</td> </td>
<td class="cellrowborder" valign="top" width="46.339999999999996%" headers="mcps1.2.4.1.3 "><p id="p5922331114916"><a name="p5922331114916"></a><a name="p5922331114916"></a>使能一种传感器设备，只有数据订阅者使能传感器后，才能获取订阅的传感器数据。</p> <td class="cellrowborder" valign="top" width="46.339999999999996%" headers="mcps1.2.4.1.3 "><p id="p5922331114916"><a name="p5922331114916"></a><a name="p5922331114916"></a>使能指定传感器设备，只有数据订阅者使能传感器后，才能获取订阅的传感器数据。</p>
</td> </td>
</tr> </tr>
<tr id="row6397138134713"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p6923143184914"><a name="p6923143184914"></a><a name="p6923143184914"></a>int32_t <strong id="b84601875330"><a name="b84601875330"></a><a name="b84601875330"></a>Disable</strong>(int32_t sensorId)</p> <tr id="row6397138134713"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p6923143184914"><a name="p6923143184914"></a><a name="p6923143184914"></a>int32_t <strong id="b84601875330"><a name="b84601875330"></a><a name="b84601875330"></a>Disable</strong>(int32_t sensorId)</p>
</td> </td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p139231531184912"><a name="p139231531184912"></a><a name="p139231531184912"></a>去使能一种传感器设备。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p139231531184912"><a name="p139231531184912"></a><a name="p139231531184912"></a>去使能指定传感器设备。</p>
</td> </td>
</tr> </tr>
<tr id="row43981283476"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p992473112496"><a name="p992473112496"></a><a name="p992473112496"></a>int32_t <strong id="b16691194511438"><a name="b16691194511438"></a><a name="b16691194511438"></a>SetBatch</strong>(iint32_t sensorId, int64_t samplingInterval, int64_t reportInterval)</p> <tr id="row43981283476"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p992473112496"><a name="p992473112496"></a><a name="p992473112496"></a>int32_t <strong id="b16691194511438"><a name="b16691194511438"></a><a name="b16691194511438"></a>SetBatch</strong>(iint32_t sensorId, int64_t samplingInterval, int64_t reportInterval)</p>
</td> </td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p14924203134910"><a name="p14924203134910"></a><a name="p14924203134910"></a>设置一种传感器的数据采样间隔和数据上报间隔。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p14924203134910"><a name="p14924203134910"></a><a name="p14924203134910"></a>设置指定传感器的数据采样间隔和数据上报间隔。</p>
</td> </td>
</tr> </tr>
<tr id="row439813812472"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p170411511281"><a name="p170411511281"></a><a name="p170411511281"></a>int32_t <strong id="b170414153284"><a name="b170414153284"></a><a name="b170414153284"></a>SetMode</strong>(int32_t sensorTypeId, SensorUser *user, int32_t mode)</p> <tr id="row439813812472"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p170411511281"><a name="p170411511281"></a><a name="p170411511281"></a>int32_t <strong id="b170414153284"><a name="b170414153284"></a><a name="b170414153284"></a>SetMode</strong>(int32_t sensorId, int32_t mode)</p>
</td> </td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p107051159281"><a name="p107051159281"></a><a name="p107051159281"></a>设置一种传感器的工作模式，不同的工作模式，上报数据方式不同。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p107051159281"><a name="p107051159281"></a><a name="p107051159281"></a>设置指定传感器的工作模式，不同的工作模式，上报数据方式不同。</p>
</td> </td>
</tr> </tr>
<tr id="row123998813470"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p492513120494"><a name="p492513120494"></a><a name="p492513120494"></a>int32_t <strong id="b7501191019330"><a name="b7501191019330"></a><a name="b7501191019330"></a>SetOption</strong>(int32_t sensorId, uint32_t option)</p> <tr id="row123998813470"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p492513120494"><a name="p492513120494"></a><a name="p492513120494"></a>int32_t <strong id="b7501191019330"><a name="b7501191019330"></a><a name="b7501191019330"></a>SetOption</strong>(int32_t sensorId, uint32_t option)</p>
</td> </td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p5926031124914"><a name="p5926031124914"></a><a name="p5926031124914"></a>设置一种传感器量程，精度等可选配置。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p5926031124914"><a name="p5926031124914"></a><a name="p5926031124914"></a>设置指定传感器量程，精度等可选配置。</p>
</td> </td>
</tr> </tr>
<tr id="row939914814478"><td class="cellrowborder" rowspan="2" valign="top" width="8.260000000000002%" headers="mcps1.2.4.1.1 "><p id="p1039815743211"><a name="p1039815743211"></a><a name="p1039815743211"></a>数据订阅操作</p> <tr id="row939914814478"><td class="cellrowborder" rowspan="2" valign="top" width="8.260000000000002%" headers="mcps1.2.4.1.1 "><p id="p1039815743211"><a name="p1039815743211"></a><a name="p1039815743211"></a>数据订阅操作</p>
</td> </td>
<td class="cellrowborder" valign="top" width="45.4%" headers="mcps1.2.4.1.2 "><p id="p11530101054411"><a name="p11530101054411"></a><a name="p11530101054411"></a>int32_t <strong id="b0569161217334"><a name="b0569161217334"></a><a name="b0569161217334"></a>Register</strong>(RecordDataCallback cb)</p> <td class="cellrowborder" valign="top" width="45.4%" headers="mcps1.2.4.1.2 "><p id="p11530101054411"><a name="p11530101054411"></a><a name="p11530101054411"></a>int32_t <strong id="b0569161217334"><a name="b0569161217334"></a><a name="b0569161217334"></a>Register</strong>(sensorId, RecordDataCallback cb);</p>
</td>
<td class="cellrowborder" valign="top" width="46.339999999999996%" headers="mcps1.2.4.1.3 "><p id="p892633118493"><a name="p892633118493"></a><a name="p892633118493"></a>订阅者注册传感器数据回调函数，系统会将获取到的传感器数据上报给订阅者。</p>
</td> </td>
</tr> <td class="cellrowborder" valign="top" width="46.339999999999996%" headers="mcps1.2.4.1.3 "><p id="p892633118493"><a name="p892633118493"></a><a name="p892633118493"></a>订阅者根据不同sensorId注册传感器数据回调函数，系统会将获取到的传感器数据上报给订阅者。</p>
<tr id="row10716713314"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p196491214133110"><a name="p196491214133110"></a><a name="p196491214133110"></a>int32_t <strong id="b13758151483317"><a name="b13758151483317"></a><a name="b13758151483317"></a>Unregister</strong>(void)</p>
</td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p5817133119"><a name="p5817133119"></a><a name="p5817133119"></a>订阅者去注册传感器数据回调函数。</p>
</td> </td>
</tr> </tr>
<tr id="row15679121655614"><td class="cellrowborder" rowspan="2" valign="top" width="8.260000000000002%" headers="mcps1.2.4.1.1 "><p id="p6596162112564"><a name="p6596162112564"></a><a name="p6596162112564"></a>接口实例</p> <tr id="row10716713314"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p196491214133110"><a name="p196491214133110"></a><a name="p196491214133110"></a>int32_t <strong id="b13758151483317"><a name="b13758151483317"></a><a name="b13758151483317"></a>Unregister</strong>(sensorId, RecordDataCallback cb)</p>
</td>
<td class="cellrowborder" valign="top" width="45.4%" headers="mcps1.2.4.1.2 "><p id="p13679191616561"><a name="p13679191616561"></a><a name="p13679191616561"></a>const struct SensorInterface *<strong id="b292451515"><a name="b292451515"></a><a name="b292451515"></a>NewSensorInterfaceInstance</strong>(void)</p>
</td> </td>
<td class="cellrowborder" valign="top" width="46.339999999999996%" headers="mcps1.2.4.1.3 "><p id="p19679181612563"><a name="p19679181612563"></a><a name="p19679181612563"></a>创建传感器接口实例。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p5817133119"><a name="p5817133119"></a><a name="p5817133119"></a>订阅者根据sensorId和回调函数注销对应订阅者的传感器数据回调函数。</p>
</td>
</tr>
<tr id="row9680191675612"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p15680111655611"><a name="p15680111655611"></a><a name="p15680111655611"></a>int32_t <strong id="b1144297156"><a name="b1144297156"></a><a name="b1144297156"></a>FreeSensorInterfaceInstance</strong>(void)</p>
</td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p18680916165620"><a name="p18680916165620"></a><a name="p18680916165620"></a>释放传感器接口实例。</p>
</td> </td>
</tr> </tr>
</tbody> </tbody>
</table> </table>
Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无需实现，直接使用，参考[表2](#table1156812588320)：
Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无需实现，直接使用，参考表2： **表2** Sensor驱动模型对驱动开发者开放的功能接口列表
**表 2** Sensor驱动模型对驱动开发者开放的功能接口列表
<a name="table1156812588320"></a> <a name="table1156812588320"></a>
<table><thead align="left"><tr id="row756817584327"><th class="cellrowborder" valign="top" width="8.550855085508552%" id="mcps1.2.4.1.1"><p id="p7568125873219"><a name="p7568125873219"></a><a name="p7568125873219"></a>功能分类</p> <table><thead align="left"><tr id="row756817584327"><th class="cellrowborder" valign="top" width="8.550855085508552%" id="mcps1.2.4.1.1"><p id="p7568125873219"><a name="p7568125873219"></a><a name="p7568125873219"></a>功能分类</p>
</th> </th>
<th class="cellrowborder" valign="top" width="45.53455345534553%" id="mcps1.2.4.1.2"><p id="p1756812582328"><a name="p1756812582328"></a><a name="p1756812582328"></a>接口名</p> <th class="cellrowborder" valign="top" width="45.53455345534553%" id="mcps1.2.4.1.2"><p id="p1756812582328"><a name="p1756812582328"></a><a name="p1756812582328"></a>接口名</p>
...@@ -115,7 +136,7 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无 ...@@ -115,7 +136,7 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无
<td class="cellrowborder" valign="top" width="45.91459145914592%" headers="mcps1.2.4.1.3 "><p id="p356935816328"><a name="p356935816328"></a><a name="p356935816328"></a>添加当前类型的传感器设备到传感器设备管理。</p> <td class="cellrowborder" valign="top" width="45.91459145914592%" headers="mcps1.2.4.1.3 "><p id="p356935816328"><a name="p356935816328"></a><a name="p356935816328"></a>添加当前类型的传感器设备到传感器设备管理。</p>
</td> </td>
</tr> </tr>
<tr id="row195691858113219"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p1156945883215"><a name="p1156945883215"></a><a name="p1156945883215"></a>int32_t <strong id="b1736762975518"><a name="b1736762975518"></a><a name="b1736762975518"></a>DeleteSensorDevice</strong>(int32_t sensorId)</p> <tr id="row195691858113219"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p1156945883215"><a name="p1156945883215"></a><a name="p1156945883215"></a>int32_t <strong id="b1736762975518"><a name="b1736762975518"></a><a name="b1736762975518"></a>DeleteSensorDevice</strong>(const struct SensorBasicInfo *sensorBaseInfo)</p>
</td> </td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p2569145833214"><a name="p2569145833214"></a><a name="p2569145833214"></a>删除传感器设备管理里指定的传感器设备。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p2569145833214"><a name="p2569145833214"></a><a name="p2569145833214"></a>删除传感器设备管理里指定的传感器设备。</p>
</td> </td>
...@@ -125,7 +146,7 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无 ...@@ -125,7 +146,7 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p15691858193220"><a name="p15691858193220"></a><a name="p15691858193220"></a>上报指定类型传感器的数据到用户侧。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p15691858193220"><a name="p15691858193220"></a><a name="p15691858193220"></a>上报指定类型传感器的数据到用户侧。</p>
</td> </td>
</tr> </tr>
<tr id="row17569145814329"><td class="cellrowborder" rowspan="4" valign="top" width="8.550855085508552%" headers="mcps1.2.4.1.1 "><p id="p10589113932619"><a name="p10589113932619"></a><a name="p10589113932619"></a>Sensor抽象总线和平台操作接口</p> <tr id="row17569145814329"><td class="cellrowborder" rowspan="2" valign="top" width="8.550855085508552%" headers="mcps1.2.4.1.1 "><p id="p10589113932619"><a name="p10589113932619"></a><a name="p10589113932619"></a>Sensor抽象总线</p>
</td> </td>
<td class="cellrowborder" valign="top" width="45.53455345534553%" headers="mcps1.2.4.1.2 "><p id="p145705585322"><a name="p145705585322"></a><a name="p145705585322"></a>int32_t <strong id="b15560203515558"><a name="b15560203515558"></a><a name="b15560203515558"></a>ReadSensor</strong>(struct SensorBusCfg *busCfg, uint16_t regAddr, uint8_t *data, uint16_t dataLen)</p> <td class="cellrowborder" valign="top" width="45.53455345534553%" headers="mcps1.2.4.1.2 "><p id="p145705585322"><a name="p145705585322"></a><a name="p145705585322"></a>int32_t <strong id="b15560203515558"><a name="b15560203515558"></a><a name="b15560203515558"></a>ReadSensor</strong>(struct SensorBusCfg *busCfg, uint16_t regAddr, uint8_t *data, uint16_t dataLen)</p>
</td> </td>
...@@ -137,16 +158,6 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无 ...@@ -137,16 +158,6 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p6872112112201"><a name="p6872112112201"></a><a name="p6872112112201"></a>按照配置的总线方式，传感器配置数据写入寄存器。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p6872112112201"><a name="p6872112112201"></a><a name="p6872112112201"></a>按照配置的总线方式，传感器配置数据写入寄存器。</p>
</td> </td>
</tr> </tr>
<tr id="row1667512682014"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p146751426192014"><a name="p146751426192014"></a><a name="p146751426192014"></a>int32_t <strong id="b4725135865517"><a name="b4725135865517"></a><a name="b4725135865517"></a>CreateSensorThread</strong>(struct OsalThread *thread, OsalThreadEntry threadEntry, char *name, void *entryPara)</p>
</td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p10676112612013"><a name="p10676112612013"></a><a name="p10676112612013"></a>创建指定传感器的定时线程，用于传感器数据上报处理。</p>
</td>
</tr>
<tr id="row1594017462410"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p49401442414"><a name="p49401442414"></a><a name="p49401442414"></a>void <strong id="b17586316565"><a name="b17586316565"></a><a name="b17586316565"></a>DestroySensorThread</strong>(struct OsalThread *thread, uint8_t *status);</p>
</td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p69406415243"><a name="p69406415243"></a><a name="p69406415243"></a>销毁传感器创建的定时线程。</p>
</td>
</tr>
<tr id="row19401042245"><td class="cellrowborder" valign="top" width="8.550855085508552%" headers="mcps1.2.4.1.1 "><p id="p694020492417"><a name="p694020492417"></a><a name="p694020492417"></a>通用配置操作接口</p> <tr id="row19401042245"><td class="cellrowborder" valign="top" width="8.550855085508552%" headers="mcps1.2.4.1.1 "><p id="p694020492417"><a name="p694020492417"></a><a name="p694020492417"></a>通用配置操作接口</p>
</td> </td>
<td class="cellrowborder" valign="top" width="45.53455345534553%" headers="mcps1.2.4.1.2 "><p id="p1794064142418"><a name="p1794064142418"></a><a name="p1794064142418"></a>int32_t <strong id="b1740939195611"><a name="b1740939195611"></a><a name="b1740939195611"></a>SetSensorRegCfgArray</strong>(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group);</p> <td class="cellrowborder" valign="top" width="45.53455345534553%" headers="mcps1.2.4.1.2 "><p id="p1794064142418"><a name="p1794064142418"></a><a name="p1794064142418"></a>int32_t <strong id="b1740939195611"><a name="b1740939195611"></a><a name="b1740939195611"></a>SetSensorRegCfgArray</strong>(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group);</p>
...@@ -185,11 +196,12 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无 ...@@ -185,11 +196,12 @@ Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无
</tbody> </tbody>
</table> </table>
Sensor驱动模型要求驱动开发者实现的接口功能，参考表3。 Sensor驱动模型要求驱动开发者实现的接口功能，参考[表3](#table1083014911336)：
**表 3** Sensor驱动模型要求驱动开发者实现的接口列表 **表 3** Sensor驱动模型要求驱动开发者实现的接口列表
<a name="table1083014911336"></a> <a name="table1083014911336"></a>
<table><thead align="left"><tr id="row208301997332"><th class="cellrowborder" valign="top" width="8.41084108410841%" id="mcps1.2.4.1.1"><p id="p1777364318152"><a name="p1777364318152"></a><a name="p1777364318152"></a>功能分类</p> <table><thead align="left"><tr id="row208301997332"><th class="cellrowborder" valign="top" width="8.41084108410841%" id="mcps1.2.4.1.1"><p id="p1777364318152"><a name="p1777364318152"></a><a name="p1777364318152"></a>功能分类</p>
</th> </th>
<th class="cellrowborder" valign="top" width="45.77457745774577%" id="mcps1.2.4.1.2"><p id="p5773174317157"><a name="p5773174317157"></a><a name="p5773174317157"></a>接口名</p> <th class="cellrowborder" valign="top" width="45.77457745774577%" id="mcps1.2.4.1.2"><p id="p5773174317157"><a name="p5773174317157"></a><a name="p5773174317157"></a>接口名</p>
...@@ -202,22 +214,17 @@ Sensor驱动模型要求驱动开发者实现的接口功能，参考表3。 ...@@ -202,22 +214,17 @@ Sensor驱动模型要求驱动开发者实现的接口功能，参考表3。
</td> </td>
<td class="cellrowborder" valign="top" width="45.77457745774577%" headers="mcps1.2.4.1.2 "><p id="p880485195711"><a name="p880485195711"></a><a name="p880485195711"></a>int32_t <strong id="b16497123107"><a name="b16497123107"></a><a name="b16497123107"></a>init</strong>(void)</p> <td class="cellrowborder" valign="top" width="45.77457745774577%" headers="mcps1.2.4.1.2 "><p id="p880485195711"><a name="p880485195711"></a><a name="p880485195711"></a>int32_t <strong id="b16497123107"><a name="b16497123107"></a><a name="b16497123107"></a>init</strong>(void)</p>
</td> </td>
<td class="cellrowborder" valign="top" width="45.81458145814582%" headers="mcps1.2.4.1.3 "><p id="p1480465165710"><a name="p1480465165710"></a><a name="p1480465165710"></a>传感器设备探测成功后，需要对传感器器设备初始化配置。</p> <td class="cellrowborder" valign="top" width="45.81458145814582%" headers="mcps1.2.4.1.3 "><p id="p1480465165710"><a name="p1480465165710"></a><a name="p1480465165710"></a>传感器器设备探测成功后，需要对传感器器设备初始化配置。</p>
</td>
</tr>
<tr id="row10831296333"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p1783115910333"><a name="p1783115910333"></a><a name="p1783115910333"></a>int32_t <strong id="b146831650010"><a name="b146831650010"></a><a name="b146831650010"></a>GetInfo</strong>(struct SensorBasicInfo *info)</p>
</td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p4831139153316"><a name="p4831139153316"></a><a name="p4831139153316"></a>从传感器设备的HCS配置里，获取当前传感器设备的基本信息。</p>
</td> </td>
</tr> </tr>
<tr id="row178311493339"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p208318963320"><a name="p208318963320"></a><a name="p208318963320"></a>int32_t <strong id="b189921571402"><a name="b189921571402"></a><a name="b189921571402"></a>Enable</strong>(void)</p> <tr id="row178311493339"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p208318963320"><a name="p208318963320"></a><a name="p208318963320"></a>int32_t <strong id="b189921571402"><a name="b189921571402"></a><a name="b189921571402"></a>Enable</strong>(void)</p>
</td> </td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p68310953312"><a name="p68310953312"></a><a name="p68310953312"></a>根据当前传感器设备的HCS配置，下发传感器设备使能操作组的寄存器配置。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p68310953312"><a name="p68310953312"></a><a name="p68310953312"></a>根据当前传感器器设备的HCS配置，下发传感器设备使能操作组的寄存器配置。</p>
</td> </td>
</tr> </tr>
<tr id="row0831129153318"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p0831169183314"><a name="p0831169183314"></a><a name="p0831169183314"></a>int32_t <strong id="b13541291106"><a name="b13541291106"></a><a name="b13541291106"></a>Disable</strong>(void)</p> <tr id="row0831129153318"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p0831169183314"><a name="p0831169183314"></a><a name="p0831169183314"></a>int32_t <strong id="b13541291106"><a name="b13541291106"></a><a name="b13541291106"></a>Disable</strong>(void)</p>
</td> </td>
<td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p138314912336"><a name="p138314912336"></a><a name="p138314912336"></a>根据当前传感器设备的HCS配置，下发传感器设备去使能操作组的寄存器配置。</p> <td class="cellrowborder" valign="top" headers="mcps1.2.4.1.2 "><p id="p138314912336"><a name="p138314912336"></a><a name="p138314912336"></a>根据当前传感器器设备的HCS配置，下发传感器设备去使能操作组的寄存器配置。</p>
</td> </td>
</tr> </tr>
<tr id="row178311093334"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p583118920338"><a name="p583118920338"></a><a name="p583118920338"></a>int32_t <strong id="b111117118017"><a name="b111117118017"></a><a name="b111117118017"></a>SetBatch</strong>(int64_t samplingInterval, int64_t reportInterval)</p> <tr id="row178311093334"><td class="cellrowborder" valign="top" headers="mcps1.2.4.1.1 "><p id="p583118920338"><a name="p583118920338"></a><a name="p583118920338"></a>int32_t <strong id="b111117118017"><a name="b111117118017"></a><a name="b111117118017"></a>SetBatch</strong>(int64_t samplingInterval, int64_t reportInterval)</p>
...@@ -242,99 +249,200 @@ Sensor驱动模型要求驱动开发者实现的接口功能，参考表3。 ...@@ -242,99 +249,200 @@ Sensor驱动模型要求驱动开发者实现的接口功能，参考表3。
</tr> </tr>
</tbody> </tbody>
</table> </table>
接口实现参考[开发实例](#section257750691)章节。
接口实现参考[SENSOR](#section257750691)章节。 ### 开发步骤<a name="section7893102915819"></a>
1. 基于HDF驱动框架，按照驱动Driver Entry程序，完成加速度抽象驱动开发，主要由Bind、Init、Release、Dispatch函数接口实现。
2. 完成加速度传感器驱动的设备信息配置。
3. 完成加速度传感器抽象驱动内部接口开发，包括Enable、Disable、SetBatch、SetMode、SetOption、AccelCreateCfgData、AccelReleaseCfgData、AccelRegisterChipOps接口实现。
4. 基于HDF驱动框架，按照驱动Driver Entry程序，完成加速度传感器差异化驱动开发，主要有Bind、Init、Release、Dispatch函数接口实现。
5. 完成加速度传感器差异化驱动中差异化接口ReadData函数实现。
6. 新增文件脚本适配。
## 开发步骤<a name="section1140943382"></a> >![](../public_sys-resources/icon-note.gif) **说明：**
>
>- 传感器驱动模型已经提供一部分能力集，包括驱动设备管理能力、抽象总线和平台操作接口能力、通用配置操作接口能力、配置解析操作接口能力，接口参考[表2](#table1156812588320)。
>
>- 需要开发人员实现部分有：传感器部分操作接口（[表3](#table1083014911336))和传感器HCS差异化数据配置。
> - 驱动基本功能验证。
Sensor驱动是基于HDF框架、Platform和OSAL基础接口进行开发，不区分操作系统和芯片平台，为不同Sensor器件提供统一的驱动模型。本篇开发指导以加速度计传感器为例，介绍传感器驱动开发。 ### 开发实例<a name="section257750691"></a>
1. 加速度计传感器驱动注册。HDF驱动框架会提供统一的驱动管理模型，通过加速计传感器模块配置信息，识别并加载对应模块驱动。 基于HDF驱动模型，加载启动加速度计传感器驱动，代码形式如下，具体原理可参考[HDF驱动开发指南](driver-hdf-development.md)。本例中加速度传感器选择博世BMI160，其通讯接口方式选择I2C。
2. 加速度计传感器驱动初始化和去初始化。HDF驱动框架通过init入口函数，依次启动传感器设备驱动加载和分配传感器设备数据配置资源。HDF驱动框架通过release函数，释放驱动加载的资源和配置。
3. 加速度计传感器寄存器组配置解析。不同类型传感器需要在hcs里配置器件对应的HCS配置文件，然后再设备驱动启动过程中探测器件是否在位，然后加载对应的配置文件，生成配置的结构体对象。
4. 加速度计传感器驱动操作接口实现。实现各个类型传感器归一化驱动接口，如init，GetInfo，Enable，Disable，SetBatch，SetMode，SetOption，ReadSensorData等函数，完成传感器驱动配置下发和数据上报功能。
>![](../public_sys-resources/icon-note.gif) **说明：** 1. 加速度传感器驱动入口注册
>传感器驱动模型已经提供一部分能力集，包括驱动设备管理能力，抽象总线和平台操作接口能力，通用配置操作接口能力，配置解析操作接口能力，接口参考[表2](#table1156812588320)。需要开发人员实现部分有：1、传感器部分操作接口（[表3](#table1083014911336)）；2、传感器HCS差异化数据配置；3、驱动基本功能验证。
## 开发实例<a name="section257750691"></a> - 加速度传感器驱动入口函数实现
基于HDF驱动模型，加载启动加速度计传感器驱动，代码形式如下，具体原理可参考[HDF驱动开发指南](driver-hdf-development.md)。加速度计传感器选择通讯接口方式为I2C，厂家选择博世BMI160加速度计传感器。 ```
/* 注册加速度计传感器入口数据结构体对象 */
struct HdfDriverEntry g_sensorAccelDevEntry = {
.moduleVersion = 1, //加速度计传感器模块版本号
.moduleName = "HDF_SENSOR_ACCEL", //加速度计传感器模块名，要与device_info.hcs文件里的加速度计moduleName字段值一样
.Bind = BindAccelDriver, // 加速度计传感器绑定函数
.Init = InitAccelDriver, // 加速度计传感器初始化函数
.Release = ReleaseAccelDriver, // 加速度计传感器资源释放函数
};
1. 加速度计传感器驱动入口注册 /* 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 */
HDF_INIT(g_sensorAccelDevEntry);
```
- 加速度计传感器驱动入口函数实现 - 加速度传感器设备配置描述
``` 加速度传感器模型使用HCS作为配置描述源码，HCS配置字段请参考[配置管理](driver-hdf-manage.md)介绍。
/* 注册加速度计传感器入口数据结构体对象 */
struct HdfDriverEntry g_sensorAccelDevEntry = {
.moduleVersion = 1, /* 加速度计传感器模块版本号 */
.moduleName = "HDF_SENSOR_ACCEL", /* 加速度计传感器模块名，要与device_info.hcs文件里的加速度计moduleName字段值一样*/
.Bind = BindAccelDriver, /* 加速度计传感器绑定函数 */
.Init = InitAccelDriver, /* 加速度计传感器初始化函数 */
.Release = ReleaseAccelDriver, /* 加速度计传感器资源释放函数 */
};
/* 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 */
HDF_INIT(g_sensorAccelDevEntry);
```
- 加速度计传感器设备配置描述 ```
/* 加速度计传感器设备HCS配置 */
device_sensor_accel :: device {
device0 :: deviceNode {
policy = 1; // 驱动服务发布的策略
priority = 110; // 驱动启动优先级（0-200），值越大优先级越低，建议配置为100，优先级相同则不保证device的加载顺序
preload = 0; // 驱动按需加载字段，0表示加载，2表示不加载
permission = 0664; // 驱动创建设备节点权限
moduleName = "HDF_SENSOR_ACCEL"; // 驱动名称，该字段的值必须和驱动入口结构的moduleName值一致
serviceName = "sensor_accel"; // 驱动对外发布服务的名称，必须唯一
deviceMatchAttr = "hdf_sensor_accel_driver"; // 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等
}
}
```
加速度计传感器模型使用HCS作为配置描述源码，HCS配置字段详细介绍参考[配置管理](driver-hdf-manage.md)介绍。 2. 加速度传感器驱动操作接口实现
``` 开发者需要根据每种类型的传感器实现归一化接口。
/* 加速度计传感器设备HCS配置 */
device_sensor_accel :: device { ```
device0 :: deviceNode { /* 不使用函数暂时置空 */
policy = 1; /* policy字段是驱动服务发布的策略 */ static int32_t SetAccelInfo(struct SensorBasicInfo *info)
priority = 105; /* 驱动启动优先级（0-200），值越大优先级越低，建议默认配100，优先级相同则不保证device的加载顺序 */ {
preload = 2; /* 驱动按需加载字段，0表示加载，2表示不加载 */ (void)info;
permission = 0664; /* 驱动创建设备节点权限 */
moduleName = "HDF_SENSOR_ACCEL"; /* 驱动名称，该字段的值必须和驱动入口结构的moduleName值一致 */ return HDF_ERR_NOT_SUPPORT;
serviceName = "sensor_accel"; /* 驱动对外发布服务的名称，必须唯一 */
deviceMatchAttr = "hdf_sensor_accel_driver"; /* 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等 */
} }
} /* 下发使能寄存器组的配置 */
``` static int32_t SetAccelEnable(void)
{
int32_t ret;
struct AccelDrvData *drvData = AccelGetDrvData();
1. 加速度计传感器驱动初始化和去初始化 CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM);
- 初始化入口函数init if (drvData->enable) {
HDF_LOGE("%s: Accel sensor is enabled", __func__);
return HDF_SUCCESS;
}
``` ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_ENABLE_GROUP]);
/* 加速度计传感器驱动对外提供的服务绑定到HDF框架 */ if (ret != HDF_SUCCESS) {
int32_t BindAccelDriver(struct HdfDeviceObject *device) HDF_LOGE("%s: Accel sensor enable config failed", __func__);
{ return ret;
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); }
static struct IDeviceIoService service = { ret = OsalTimerCreate(&drvData->accelTimer, SENSOR_TIMER_MIN_TIME, AccelTimerEntry, (uintptr_t)drvData);
.object = {0}, if (ret != HDF_SUCCESS) {
.Dispatch = DispatchAccel, HDF_LOGE("%s: Accel create timer failed[%d]", __func__, ret);
}; return ret;
device->service = &service; }
ret = OsalTimerStartLoop(&drvData->accelTimer);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: Accel start timer failed[%d]", __func__, ret);
return ret;
}
drvData->enable = true;
return HDF_SUCCESS; return HDF_SUCCESS;
} }
/*在探测到器件在位后，需要调用RegisterAccelChipOps注册差异化适配函数*/ /* 下发去使能寄存器组的配置 */
int32_t RegisterAccelChipOps(struct AccelOpsCall *ops) static int32_t SetAccelDisable(void)
{ {
struct AccelDrvData *drvData = NULL; int32_t ret;
struct AccelDrvData *drvData = AccelGetDrvData();
CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM);
if (!drvData->enable) {
HDF_LOGE("%s: Accel sensor had disable", __func__);
return HDF_SUCCESS;
}
ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_DISABLE_GROUP]);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: Accel sensor disable config failed", __func__);
return ret;
}
ret = OsalTimerDelete(&drvData->accelTimer);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: Accel delete timer failed", __func__);
return ret;
}
drvData->enable = false;
CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); return HDF_SUCCESS;
}
/* 配置传感器采样率和数据上报间隔 */
static int32_t SetAccelBatch(int64_t samplingInterval, int64_t interval)
{
(void)interval;
struct AccelDrvData *drvData = NULL;
drvData = AccelGetDrvData(); drvData = AccelGetDrvData();
drvData->ops.Init = ops->Init; CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
drvData->ops.ReadData = ops->ReadData;
drvData->interval = samplingInterval;
return HDF_SUCCESS; return HDF_SUCCESS;
} }
/* 挂载加速度计传感器驱动归一化的接口函数 */ /* 设置传感器工作模式，当前支持实时模式 */
static int32_t InitAccelOps(struct SensorDeviceInfo *deviceInfo) static int32_t SetAccelMode(int32_t mode)
{ {
struct AccelDrvData *drvData = AccelGetDrvData(); return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE;
}
static int32_t SetAccelOption(uint32_t option)
{
(void)option;
return HDF_SUCCESS;
}
/* 设置传感器可选配置 */
static int32_t SetAccelOption(uint32_t option)
{
(void)option;
return HDF_ERR_NOT_SUPPORT;
}
```
3. 加速度传感器驱动初始化和去初始化
```
/* 加速度计传感器驱动对外提供的服务绑定到HDF框架 */
int32_t AccelBindDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct AccelDrvData *drvData = (struct AccelDrvData *)OsalMemCalloc(sizeof(*drvData));
if (drvData == NULL) {
HDF_LOGE("%s: Malloc accel drv data fail!", __func__);
return HDF_ERR_MALLOC_FAIL;
}
drvData->ioService.Dispatch = DispatchAccel;
drvData->device = device;
device->service = &drvData->ioService;
g_accelDrvData = drvData;
return HDF_SUCCESS;
}
/* 挂载加速度计传感器驱动归一化的接口函数 */
static int32_t InitAccelOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo)
{
CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM);
(void)memset_s((void *)deviceInfo, sizeof(*deviceInfo), 0, sizeof(*deviceInfo));
deviceInfo->ops.GetInfo = SetAccelInfo;
deviceInfo->ops.Enable = SetAccelEnable; deviceInfo->ops.Enable = SetAccelEnable;
deviceInfo->ops.Disable = SetAccelDisable; deviceInfo->ops.Disable = SetAccelDisable;
deviceInfo->ops.SetBatch = SetAccelBatch; deviceInfo->ops.SetBatch = SetAccelBatch;
...@@ -342,224 +450,188 @@ static int32_t InitAccelOps(struct SensorDeviceInfo *deviceInfo) ...@@ -342,224 +450,188 @@ static int32_t InitAccelOps(struct SensorDeviceInfo *deviceInfo)
deviceInfo->ops.SetOption = SetAccelOption; deviceInfo->ops.SetOption = SetAccelOption;
if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo),
&drvData->accelCfg->sensorInfo, sizeof(drvData->accelCfg->sensorInfo)) != EOK) { &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) {
HDF_LOGE("%s: copy sensor info failed", __func__); HDF_LOGE("%s: Copy sensor info failed", __func__);
return HDF_FAILURE; return HDF_FAILURE;
} }
/* 传感器类型标识可以在数据HCS配置文件里面配置，也可以在此处 */
drvData->accelCfg->sensorInfo.sensorTypeId = SENSOR_TAG_ACCELEROMETER;
drvData->accelCfg->sensorInfo.sensorId = SENSOR_TAG_ACCELEROMETER;
return HDF_SUCCESS; return HDF_SUCCESS;
} }
/* 传感器寄存器初始化操作 */ /* 提供给差异化驱动的初始化接口，完成加速度器件基本配置信息解析（加速度信息，加速度总线配置，加速度器件探测寄存器配置），器件探测，器件寄存器解析 */
static int32_t InitAccelAfterConfig(void) static int32_t InitAccelAfterDetected(struct SensorCfgData *config)
{ {
struct SensorDeviceInfo deviceInfo; struct SensorDeviceInfo deviceInfo;
CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM);
if (InitAccelConfig() != HDF_SUCCESS) { /* 初始化加速度计接口函数 */
HDF_LOGE("%s: init accel config failed", __func__); if (InitAccelOps(config, &deviceInfo) != HDF_SUCCESS) {
HDF_LOGE("%s: Init accel ops failed", __func__);
return HDF_FAILURE; return HDF_FAILURE;
} }
/* 注册加速度计设备到传感器管理模块 */
if (InitAccelOps(&deviceInfo) != HDF_SUCCESS) { if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) {
HDF_LOGE("%s: init accel ops failed", __func__); HDF_LOGE("%s: Add accel device failed", __func__);
return HDF_FAILURE; return HDF_FAILURE;
} }
/* 器件寄存器解析 */
if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { if (ParseSensorRegConfig(config) != HDF_SUCCESS) {
HDF_LOGE("%s: add accel device failed", __func__); HDF_LOGE("%s: Parse sensor register failed", __func__);
(void)DeleteSensorDevice(&config->sensorInfo);
ReleaseSensorAllRegConfig(config);
return HDF_FAILURE; return HDF_FAILURE;
} }
return HDF_SUCCESS; return HDF_SUCCESS;
}
/*通过器件探测函数，挂载器件差异化函数接口*/
static int32_t DetectAccelChip(void)
{
int32_t num;
int32_t ret;
int32_t loop;
struct AccelDrvData *drvData = AccelGetDrvData();
CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM);
num = sizeof(g_accelDetectIfList) / sizeof(g_accelDetectIfList[0]);
for (loop = 0; loop < num; ++loop) {
if (g_accelDetectIfList[loop].DetectChip != NULL) {
ret = g_accelDetectIfList[loop].DetectChip(drvData->accelCfg);
if (ret == HDF_SUCCESS) {
drvData->detectFlag = true;
break;
} }
struct SensorCfgData *AccelCreateCfgData(const struct DeviceResourceNode *node)
{
……
/* 如果探测不到器件在位，返回进行下个器件探测 */
if (drvData->detectFlag) {
HDF_LOGE("%s: Accel sensor have detected", __func__);
return NULL;
} }
if (drvData->accelCfg == NULL) {
HDF_LOGE("%s: Accel accelCfg pointer NULL", __func__);
return NULL;
} }
/* 设备基本配置信息解析 */
if (loop == num) { if (GetSensorBaseConfigData(node, drvData->accelCfg) != HDF_SUCCESS) {
HDF_LOGE("%s: detect accel device failed", __func__); HDF_LOGE("%s: Get sensor base config failed", __func__);
goto BASE_CONFIG_EXIT;
}
/* 如果探测不到器件在位，返回进行下个器件探测 */
if (DetectSensorDevice(drvData->accelCfg) != HDF_SUCCESS) {
HDF_LOGI("%s: Accel sensor detect device no exist", __func__);
drvData->detectFlag = false; drvData->detectFlag = false;
return HDF_FAILURE; goto BASE_CONFIG_EXIT;
} }
return HDF_SUCCESS; drvData->detectFlag = true;
} /* 器件寄存器解析 */
/* 加速度计传感器驱动初始化入口函数，主要功能为对传感器私有数据的结构体对象进行初始化，传感器HCS数据配置对象空间分配，传感器HCS数据配置初始化入口函数调用，传感器设备探测是否在位功能，传感器数据上报定时器创建，传感器归一化接口挂载，传感器设备注册功能 */ if (InitAccelAfterDetected(drvData->accelCfg) != HDF_SUCCESS) {
int32_t InitAccelDriver(struct HdfDeviceObject *device) HDF_LOGE("%s: Accel sensor detect device no exist", __func__);
{ goto INIT_EXIT;
/* 获取传感器私有数据结构体对象 */
struct AccelDrvData *drvData = AccelGetDrvData();
/* 同类型传感器不同厂家设备探测时，判断此类型传感器是否已经在位，若已经在位，无需再继续探测，直接返回 */
if (drvData->detectFlag) {
HDF_LOGE("%s: accel sensor have detected", __func__);
return HDF_SUCCESS;
} }
return drvData->accelCfg;
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); ……
/* 分配存放传感器数据配置的私有结构体数据对象，需要在驱动释放时释放分配的资源空间 */ }
drvData->accelCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*cfg)); /* 加速度计传感器驱动初始化入口函数，主要功能为对传感器私有数据的结构体对象进行初始化，传感器HCS数据配置对象空间分配，传感器HCS数据配置初始化入口函数调用，传感器设备探测是否在位功能，传感器数据上报定时器创建，传感器归一化接口挂载，传感器设备注册功能 */
int32_t InitAccelDriver(struct HdfDeviceObject *device)
{
int32_t AccelInitDriver(struct HdfDeviceObject *device)
{
……
/* 工作队列资源初始化 */
if (InitAccelData(drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: Init accel config failed", __func__);
return HDF_FAILURE;
}
/* 分配加速度配置信息资源 */
drvData->accelCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->accelCfg));
if (drvData->accelCfg == NULL) { if (drvData->accelCfg == NULL) {
HDF_LOGE("%s: malloc sensor config data failed", __func__); HDF_LOGE("%s: Malloc accel config data failed", __func__);
return HDF_FAILURE; return HDF_FAILURE;
} }
/* 挂接寄存器分组信息 */
drvData->accelCfg->regCfgGroup = &g_regCfgGroup[0]; drvData->accelCfg->regCfgGroup = &g_regCfgGroup[0];
/* 初始化传感器配置数据主要是解析传感器通讯总线配置类型信息，传感器基本信息，传感器属性信息，传感器是否在位信息，寄存器分组信息 */ ……
if (GetSensorBaseConfigData(device->property, drvData->accelCfg) != HDF_SUCCESS) { return HDF_SUCCESS;
HDF_LOGE("%s: get sensor base config failed", __func__);
goto Base_CONFIG_EXIT;
}
if (DetectAccelChip() != HDF_SUCCESS) {
HDF_LOGE("%s: accel sensor detect device no exist", __func__);
goto DETECT_CHIP_EXIT;
}
drvData->detectFlag = true;
if (ParseSensorRegConfig(drvData->accelCfg) != HDF_SUCCESS) {
HDF_LOGE("%s: detect sensor device failed", __func__);
goto REG_CONFIG_EXIT;
} }
if (InitAccelAfterConfig() != HDF_SUCCESS) { /* 释放驱动初始化时分配的资源 */
HDF_LOGE("%s: init accel after config failed", __func__); void AccelReleaseDriver(struct HdfDeviceObject *device)
goto INIT_EXIT; {
CHECK_NULL_PTR_RETURN(device);
struct AccelDrvData *drvData = (struct AccelDrvData *)device->service;
CHECK_NULL_PTR_RETURN(drvData);
/* 器件在位，释放已分配资源 */
if (drvData->detectFlag) {
AccelReleaseCfgData(drvData->accelCfg);
} }
HDF_LOGI("%s: init accel driver success", __func__);
return HDF_SUCCESS;
INIT_EXIT:
DestroySensorThread(&drvData->thread, &drvData->threadStatus);
(void)DeleteSensorDevice(SENSOR_TAG_ACCELEROMETER);
REG_CONFIG_EXIT:
ReleaseSensorAllRegConfig(drvData->accelCfg);
(void)ReleaseSensorBusHandle(&drvData->accelCfg->busCfg);
DETECT_CHIP_EXIT:
drvData->detectFlag = false;
BASE_CONFIG_EXIT:
drvData->accelCfg->root = NULL;
drvData->accelCfg->regCfgGroup = NULL;
OsalMemFree(drvData->accelCfg);
drvData->accelCfg = NULL;
return HDF_FAILURE;
}
/* 释放驱动初始化时分配的资源 */
void ReleaseAccelDriver(struct HdfDeviceObject *device)
{
(void)device;
struct AccelDrvData *drvData = NULL;
drvData = AccelGetDrvData();
(void)DestroySensorThread(&drvData->thread, &drvData->threadStatus);
(void)DeleteSensorDevice(SENSOR_TAG_ACCELEROMETER);
drvData->detectFlag = false;
if (drvData->accelCfg != NULL) {
drvData->accelCfg->root = NULL;
drvData->accelCfg->regCfgGroup = NULL;
ReleaseSensorAllRegConfig(drvData->accelCfg);
(void)ReleaseSensorBusHandle(&drvData->accelCfg->busCfg);
OsalMemFree(drvData->accelCfg); OsalMemFree(drvData->accelCfg);
drvData->accelCfg = NULL; drvData->accelCfg = NULL;
/* 器件在位，销毁工作队列资源 */
HdfWorkDestroy(&drvData->accelWork);
HdfWorkQueueDestroy(&drvData->accelWorkQueue);
OsalMemFree(drvData);
} }
```
drvData->initStatus = false; 4. 加速度传感器差异化驱动私有HCS配置实现
}
```
1. 加速度计传感器寄存器组配置信息
加速度计传感器数据配置只需要按照模板配置即可，基于模板配置的解析功能已经在**InitSensorConfigData**函数完成，只需初始化时调用即可。如果有新增配置项，需要同步修改此函数。 - 为了方便开发者使用传感器HCS私有配置，在sensor_common.hcs里面定义通用的传感器配置模板，加速度传感器直接引用模板修改对应的属性值即可。
``` ```
加速度计传感器数据配置模板(accel_config.hcs) accel sensor common config template
root { root {
sensorAccelConfig { sensorAccelConfig {
accelChipConfig { accelChipConfig {
/* 传感器设备信息模板 */ /* 传感器设备信息模板 */
template sensorInfo { template sensorInfo {
sensorName = "accelerometer"; /* 加速度计名字，字符最大长度16字节 */ sensorName = "accelerometer"; // 加速度计名字，字符最大长度16字节
vendorName = "borsh_bmi160"; /* 传感器设备厂商，字符最大长度16字节 */ vendorName = "borsh_bmi160"; // 传感器设备厂商，字符最大长度16字节
firmwareVersion = "1.0"; /* 传感器固件版本号，默认1.0，字符最大长度16字节 */ firmwareVersion = "1.0"; // 传感器固件版本号，默认1.0，字符最大长度16字节
hardwareVersion = "1.0"; /* 传感器硬件版本号，默认1.0，字符最大长度16字节 */ hardwareVersion = "1.0"; // 传感器硬件版本号，默认1.0，字符最大长度16字节
sensorTypeId = 1; /* 传感器类型编号，详见{@link SensorTypeTag} */ sensorTypeId = 1; // 传感器类型编号，详见{@link SensorTypeTag}
sensorId = 1; /* 传感器的标识号，有传感器驱动开发者定义，推荐用{@link SensorTypeTag}枚举 */ sensorId = 1; // 传感器的标识号，有传感器驱动开发者定义，推荐用{@link SensorTypeTag}枚举
maxRange = 8; /* 传感器的最大量程,根据开发者需要配置 */ maxRange = 8; // 传感器的最大量程,根据开发者需要配置
precision = 0; /* 传感器的精度，与上报数据配合使用，上报数据结构体{@link SensorEvents } */ accuracy = 0; // 传感器的精度，与上报数据配合使用，上报数据结构体{@link SensorEvents }
power = 230; /* 传感器的功耗 */ power = 230; // 传感器的功耗
} }
/* 传感器使用的总线类型和配置信息模板 */ /* 传感器使用的总线类型和配置信息模板 */
template sensorBusConfig { template sensorBusConfig {
busType = 0; /* 0:i2c 1:spi */ busType = 0; // 0:i2c 1:spi
busNum = 6; /* 芯片上分配给传感器的器件号 */ busNum = 6; // 芯片上分配给传感器的器件号
busAddr = 0; /* 芯片上分配给传感器的地址 */ busAddr = 0; // 芯片上分配给传感器的地址
regWidth = 1; /* 传感器寄存器地址宽度 */ regWidth = 1; // 传感器寄存器地址宽度
regBigEndian = 0; /* 传感器寄存器大小端 */ regBigEndian = 0; // 传感器寄存器大小端
} }
/* 传感器设备属性模板 */ /* 传感器设备属性模板 */
template sensorAttr { template sensorAttr {
chipName = ""; /* 传感器芯片名字 */ chipName = ""; // 传感器芯片名字
chipIdRegister = 0xf; /* 传感器在位检测寄存器地址 */ chipIdRegister = 0xf; // 传感器在位检测寄存器地址
chipIdValue = 0xd1; /* 校验传感器在位检测寄存器值 */ chipIdValue = 0xd1; // 校验传感器在位检测寄存器值
} }
} }
} }
} }
```
/* 根据不同器件硬件差异，修改模板配置，不修改的就会默认采用模板配置 */ - 开发者使用传感器HCS配置，在accel_config.hcs里面配置通用的传感器模板，加速度传感器直接引用模板并修改对应的属性值，在此基础上新增寄存器配置，生成accel_bmi160_config.hcs配置文件。
root {
sensorAccelConfig { ```
accel_bmi160_chip_config : accelChipConfig { /* 根据不同器件硬件差异，修改模板配置，不修改的就会默认采用模板配置 */
match_attr = "hdf_sensor_accel_driver"; /* 需要和加速度计传感器设备配置match_attr字段保持一致 */ #include "accel_config.hcs"
accelInfo :: sensorInfo { root {
vendorName = "borsh_bmi160"; accel_bmi160_chip_config : sensorConfig {
sensorTypeId = 1; match_attr = "hdf_sensor_accel_bmi160_driver";
sensorId = 1; sensorInfo :: sensorDeviceInfo {
} vendorName = "borsh_bmi160"; // max string length is 16 bytes
accelBusConfig :: sensorBusConfig { sensorTypeId = 1; // enum SensorTypeTag
busType = 0; /* i2c通讯方式 */ sensorId = 1; // user define sensor id
}
sensorBusConfig:: sensorBusInfo {
busType = 0; // 0:i2c 1:spi
busNum = 6; busNum = 6;
busAddr = 0x68; busAddr = 0x68;
regWidth = 1; /* 1字节位宽 */ regWidth = 1; // 1btye
} }
accelAttr :: sensorAttr { sensorIdAttr :: sensorIdInfo{
chipName = "bmi160"; chipName = "bmi160";
chipIdRegister = 0x00; chipIdRegister = 0x00;
chipIdValue = 0xd1; chipIdValue = 0xd1;
} }
accelRegConfig { sensorRegConfig {
/* regAddr: 寄存器地址 /* regAddr: register address
value: 寄存器值 value: config register value
mask: 寄存器值的掩码 len: size of value
len: 寄存器值的数据长度(字节) mask: mask of value
delay: 配置寄存器延时(ms) delay: config register delay time (ms)
opsType:操作类型 0-无 1-读 2-写 3-读并检查 4-位更新 opsType: enum SensorOpsType 0-none 1-read 2-write 3-read_check 4-update_bit
calType: 计算类型 0-无 1-写 2-取反 3-异或 4-左移 5-右移 calType: enum SensorBitCalType 0-none 1-set 2-revert 3-xor 4-left shift 5-right shift
shiftNum: 移动位数 shiftNum: shift bits
debug: 调试开关，0-调试关闭 1-调试打开 debug: 0-no debug 1-debug
save: 保存数据开关，0-不保存数据 1-保存数据 save: 0-no save 1-save
*/ */
/* 传感器寄存器操作分组，按照分组进行有序配置 */ /* regAddr, value, mask, len, delay, opsType, calType, shiftNum, debug, save */
/* 寄存器地址, 寄存器值, 寄存器值的掩码, 寄存器值的数据长度, 配置寄存器延时, 操作类型, 计算类型, 移动位数, 调试开关, 保存开关 */
/* 初始化寄存器组 */ /* 初始化寄存器组 */
initSeqConfig = [ initSeqConfig = [
0x7e, 0xb6, 0xff, 1, 5, 2, 0, 0, 0, 0, 0x7e, 0xb6, 0xff, 1, 5, 2, 0, 0, 0, 0,
...@@ -578,277 +650,173 @@ root { ...@@ -578,277 +650,173 @@ root {
} }
} }
} }
} ```
```
1. 加速度计传感器驱动操作接口实现
开发者需要根据每种类型的传感器实现归一化接口。 5. 加速度传感器差异化驱动实现
``` - 定义加速度传感器差异化驱动对应的HdfDriverEntry对象，其中Driver Entry入口函数定义如下：
/* 不使用函数暂时置空 */
static int32_t SetAccelInfo(struct SensorBasicInfo *info)
{
(void)info;
return HDF_ERR_NOT_SUPPORT; ```
} struct HdfDriverEntry g_accelBmi160DevEntry = {
/* 下发使能寄存器组的配置 */ .moduleVersion = 1,
static int32_t SetAccelEnable(void) .moduleName = "HDF_SENSOR_ACCEL_BMI160",
{ .Bind = Bmi160BindDriver,
int32_t ret; .Init = Bmi160InitDriver,
struct AccelDrvData *drvData = AccelGetDrvData(); .Release = Bmi160ReleaseDriver,
};
CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM); HDF_INIT(g_accelBmi160DevEntry)；
ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); ```
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: accel sensor disable config failed", __func__);
return HDF_FAILURE;
}
drvData->threadStatus = SENSOR_THREAD_RUNNING; - Bind驱动接口实例化。
```
int32_t Bmi160BindDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)OsalMemCalloc(sizeof(*drvData));
if (drvData == NULL) {
HDF_LOGE("%s: Malloc Bmi160 drv data fail", __func__);
return HDF_ERR_MALLOC_FAIL;
}
drvData->ioService.Dispatch = DispatchBMI160;
drvData->device = device;
device->service = &drvData->ioService;
g_bmi160DrvData = drvData;
return HDF_SUCCESS; return HDF_SUCCESS;
}
/* 下发去使能寄存器组的配置 */
static int32_t SetAccelDisable(void)
{
int32_t ret;
struct AccelDrvData *drvData = AccelGetDrvData();
CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM);
ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_DISABLE_GROUP]);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: accel sensor disable config failed", __func__);
return HDF_FAILURE;
} }
```
drvData->threadStatus = SENSOR_THREAD_STOPPED; - Init驱动接口实例化。
return HDF_SUCCESS;
}
/* 配置传感器采样率和数据上报间隔 */
static int32_t SetAccelBatch(int64_t samplingInterval, int64_t interval)
{
(void)interval;
struct AccelDrvData *drvData = AccelGetDrvData();
drvData->interval = samplingInterval;
return HDF_SUCCESS;
}
/* 设置传感器工作模式，当前支持实时模式 */
static int32_t SetAccelMode(int32_t mode)
{
return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE;
}
/* 设置传感器可选配置 */
static int32_t SetAccelOption(uint32_t option)
{
(void)option;
return HDF_ERR_NOT_SUPPORT;
}
```
- 差异化处理接口
``` ```
/* 器件探测时，如果探测成功，则注册差异化处理函数到accel驱动模型里 */ int32_t Bmi160InitDriver(struct HdfDeviceObject *device)
int32_t DetectAccelBim160Chip(struct SensorCfgData *data)
{ {
int32_t ret; ……
struct AccelOpsCall ops; /* 加速度计差异化初始化配置 */
CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
if (strcmp(ACCEL_CHIP_NAME_BMI160, data->sensorAttr.chipName) != 0) {
return HDF_SUCCESS;
}
ret = InitAccelPreConfig(); ret = InitAccelPreConfig();
if (ret != HDF_SUCCESS) { if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: init BMI160 bus mux config", __func__); HDF_LOGE("%s: Init BMI160 bus mux config", __func__);
return HDF_FAILURE; return HDF_FAILURE;
} }
if (DetectSensorDevice(data) != HDF_SUCCESS) { /* 创建传感器配置数据接口，完成器件探测，私有数据配置解析 */
return HDF_FAILURE; drvData->sensorCfg = AccelCreateCfgData(device->property);
if (drvData->sensorCfg == NULL) {
return HDF_ERR_NOT_SUPPORT;
} }
/* 注册差异化接口 */
/* 差异化处理函数 */ ops.Init = NULL;
ops.Init = InitBmi160;
ops.ReadData = ReadBmi160Data; ops.ReadData = ReadBmi160Data;
ret = RegisterAccelChipOps(&ops); ret = AccelRegisterChipOps(&ops);
if (ret != HDF_SUCCESS) { if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: register BMI160 accel failed", __func__); HDF_LOGE("%s: Register BMI160 accel failed", __func__);
(void)ReleaseSensorBusHandle(&data->busCfg);
return HDF_FAILURE; return HDF_FAILURE;
} }
return HDF_SUCCESS; /* 初始化器件配置 *、
} ret = InitBmi160(drvData->sensorCfg);
/* 初始化处理函数 */
static int32_t InitBmi160(struct SensorCfgData *data)
{
int32_t ret;
CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]);
if (ret != HDF_SUCCESS) { if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: bmi160 sensor init config failed", __func__); HDF_LOGE("%s: Init BMI160 accel failed", __func__);
return HDF_FAILURE; return HDF_FAILURE;
} }
return HDF_SUCCESS; return HDF_SUCCESS;
} }
/* 数据处理函数 */ ```
- Release驱动接口实例化。
```
void Bmi160ReleaseDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN(device);
struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)device->service;
CHECK_NULL_PTR_RETURN(drvData);
AccelReleaseCfgData(drvData->sensorCfg);
drvData->sensorCfg = NULL;
OsalMemFree(drvData);
}
```
6. 加速度传感器差异化函数接口实现
需要开发者实现的ReadBmi160Data接口函数，在Bmi160InitDriver函数里面注册此函数。
```
int32_t ReadBmi160Data(struct SensorCfgData *data) int32_t ReadBmi160Data(struct SensorCfgData *data)
{ {
int32_t ret; int32_t ret;
struct AccelData rawData = { 0, 0, 0 }; struct AccelData rawData = { 0, 0, 0 };
int32_t tmp[ACCEL_AXIS_NUM]; int32_t tmp[ACCEL_AXIS_NUM];
struct SensorReportEvent event; struct SensorReportEvent event;
(void)memset_s(&event, sizeof(event), 0, sizeof(event)); (void)memset_s(&event, sizeof(event), 0, sizeof(event));
ret = ReadBmi160RawData(data, &rawData, &event.timestamp); ret = ReadBmi160RawData(data, &rawData, &event.timestamp);
if (ret != HDF_SUCCESS) { if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: BMI160 read raw data failed", __func__);
return HDF_FAILURE; return HDF_FAILURE;
} }
event.sensorId = SENSOR_TAG_ACCELEROMETER; event.sensorId = SENSOR_TAG_ACCELEROMETER;
event.option = 0; event.option = 0;
event.mode = SENSOR_WORK_MODE_REALTIME; event.mode = SENSOR_WORK_MODE_REALTIME;
……
rawData.x = rawData.x * BMI160_ACC_SENSITIVITY_2G;
rawData.y = rawData.y * BMI160_ACC_SENSITIVITY_2G;
rawData.z = rawData.z * BMI160_ACC_SENSITIVITY_2G;
tmp[ACCEL_X_AXIS] = (rawData.x * SENSOR_1K_UNIT) / SENSOR_CONVERT_UNIT;
tmp[ACCEL_Y_AXIS] = (rawData.y * SENSOR_1K_UNIT) / SENSOR_CONVERT_UNIT;
tmp[ACCEL_Z_AXIS] = (rawData.z * SENSOR_1K_UNIT) / SENSOR_CONVERT_UNIT;
event.dataLen = sizeof(tmp);
event.data = (uint8_t *)&tmp;
ret = ReportSensorEvent(&event); ret = ReportSensorEvent(&event);
return ret;
}
```
- 数据处理函数
创建传感器定时器，按照配置的采样率定时采样，并上报给数据订阅者。
```
/* 传感器定时工作线程 */
static int32_t ReadAccelDataThreadWorker(void *arg)
{
(void)arg;
int64_t interval;
struct AccelDrvData *drvData = AccelGetDrvData();
drvData->threadStatus = SENSOR_THREAD_START;
while (true) {
if (drvData->threadStatus == SENSOR_THREAD_RUNNING) {
if (drvData->ops.ReadData != NULL) {
(void)drvData->ops.ReadData(drvData->accelCfg);
}
interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT));
OsalMSleep(interval);
} else if (drvData->threadStatus == SENSOR_THREAD_DESTROY) {
break;
} else {
OsalMSleep(ACC_DEFAULT_SAMPLING_200_MS / SENSOR_CONVERT_UNIT / SENSOR_CONVERT_UNIT);
}
if ((!drvData->initStatus) || (drvData->interval < 0) || drvData->threadStatus != SENSOR_THREAD_RUNNING) {
continue;
}
}
return HDF_SUCCESS;
}
/* 创建传感器定时器和器件初始化 */
static int32_t InitAccelConfig(void)
{
int32_t ret;
struct AccelDrvData *drvData = AccelGetDrvData();
if (drvData->threadStatus != SENSOR_THREAD_NONE && drvData->threadStatus != SENSOR_THREAD_DESTROY) {
HDF_LOGE("%s: accel thread have created", __func__);
return HDF_SUCCESS;
}
ret = CreateSensorThread(&drvData->thread, ReadAccelDataThreadWorker, "hdf_sensor_accel", drvData);
if (ret != HDF_SUCCESS) { if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: accel create thread failed", __func__); HDF_LOGE("%s: BMI160 report data failed", __func__);
drvData->threadStatus = SENSOR_THREAD_NONE;
return HDF_FAILURE;
} }
return ret;
CHECK_NULL_PTR_RETURN_VALUE(drvData->ops.Init, HDF_ERR_INVALID_PARAM);
ret = drvData->ops.Init(drvData->accelCfg);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: accel create thread failed", __func__);
drvData->threadStatus = SENSOR_THREAD_NONE;
return HDF_FAILURE;
} }
drvData->initStatus = true; ```
return HDF_SUCCESS;
}
```
- 主要的数据结构 7. 主要的数据结构
``` ```
/* 传感器转换单位*/ /* 传感器2g对应灵敏度转换值 */
#define SENSOR_CONVERT_UNIT 1000 #define BMI160_ACC_SENSITIVITY_2G 61
#define SENSOR_1K_UNIT 1024 /* 传感器数据采样寄存器地址 */
/* 传感器2g对应灵敏度转换值 */ #define BMI160_ACCEL_X_LSB_ADDR 0X12
#define BMI160_ACC_SENSITIVITY_2G 61 #define BMI160_ACCEL_X_MSB_ADDR 0X13
/* 传感器数据采样寄存器地址 */ #define BMI160_ACCEL_Y_LSB_ADDR 0X14
#define BMI160_ACCEL_X_LSB_ADDR 0X12 #define BMI160_ACCEL_Y_MSB_ADDR 0X15
#define BMI160_ACCEL_X_MSB_ADDR 0X13 #define BMI160_ACCEL_Z_LSB_ADDR 0X16
#define BMI160_ACCEL_Y_LSB_ADDR 0X14 #define BMI160_ACCEL_Z_MSB_ADDR 0X17
#define BMI160_ACCEL_Y_MSB_ADDR 0X15 #define BMI160_STATUS_ADDR 0X1B
#define BMI160_ACCEL_Z_LSB_ADDR 0X16 /* 传感器数据维度 */
#define BMI160_ACCEL_Z_MSB_ADDR 0X17 enum AccelAxisNum {
/* 传感器数据维度 */
enum AccelAxisNum {
ACCEL_X_AXIS = 0, ACCEL_X_AXIS = 0,
ACCEL_Y_AXIS = 1, ACCEL_Y_AXIS = 1,
ACCEL_Z_AXIS = 2, ACCEL_Z_AXIS = 2,
ACCEL_AXIS_NUM = 3, ACCEL_AXIS_NUM = 3,
}; };
/* 传感器每个维度值 */ /* 传感器每个维度值 */
struct AccelData { struct AccelData {
int32_t x; int32_t x;
int32_t y; int32_t y;
int32_t z; int32_t z;
}; };
/* 传感器私有数据结构体 */ /* 传感器私有数据结构体 */
struct AccelDrvData { struct AccelDrvData {
struct IDeviceIoService ioService;
struct HdfDeviceObject *device;
HdfWorkQueue accelWorkQueue;
HdfWork accelWork;
OsalTimer accelTimer;
bool detectFlag; bool detectFlag;
uint8_t threadStatus; bool enable;
uint8_t initStatus;
int64_t interval; int64_t interval;
struct SensorCfgData *accelCfg; struct SensorCfgData *accelCfg;
struct OsalThread thread;
struct AccelOpsCall ops; struct AccelOpsCall ops;
}; };
/* 差异化适配函数 */ /* 差异化适配函数 */
struct AccelOpsCall { struct AccelOpsCall {
int32_t (*Init)(struct SensorCfgData *data); int32_t (*Init)(struct SensorCfgData *data);
int32_t (*ReadData)(struct SensorCfgData *data); int32_t (*ReadData)(struct SensorCfgData *data);
}; };
``` ```
## 测试指导<a name="section106021256121219"></a> ### 调测验证<a name="section106021256121219"></a>
驱动开发完成后，在传感器单元测试里面开发自测试用例，验证驱动基本功能。测试环境采用开发者自测试平台。 驱动开发完成后，在传感器单元测试里面开发自测试用例，验证驱动基本功能。测试环境采用开发者自测试平台。
``` ```
/* 标识是否上报传感器数据 */ static int32_t g_sensorDataFlag = 0; //标识是否上报传感器数据
static int32_t g_sensorDataFlag = 0; static const struct SensorInterface *g_sensorDev = nullptr; //保持获取的传感器接口实例地址
/* 保持获取的传感器接口实例地址 */
static const struct SensorInterface *g_sensorDev = nullptr;
/* 订阅者注册数据上报函数 */ /* 订阅者注册数据上报函数 */
static int SensorTestDataCallback(struct SensorEvents *event) static int SensorTestDataCallback(struct SensorEvents *event)
...@@ -883,14 +851,14 @@ void HdfSensorTest::TearDownTestCase() ...@@ -883,14 +851,14 @@ void HdfSensorTest::TearDownTestCase()
/* 传感器驱动测试验证 */ /* 传感器驱动测试验证 */
HWTEST_F(HdfSensorTest,TestAccelDriver_001, TestSize.Level0) HWTEST_F(HdfSensorTest,TestAccelDriver_001, TestSize.Level0)
{ {
int32_t sensorInterval = 1000000000; /* 数据采样率单位纳秒 */ int32_t sensorInterval = 1000000000; // 数据采样率单位纳秒
int32_t pollTime = 5; /* 数据采样时间单位秒 */ int32_t pollTime = 5; // 数据采样时间单位秒
int32_t accelSensorId = 1; /* 加速度计传感器类型标识为1 */ int32_t accelSensorId = 1; // 加速度传感器类型标识为1
int32_t count = 0; int32_t count = 0;
int ret; int ret;
struct SensorInformation *sensorInfo = nullptr; struct SensorInformation *sensorInfo = nullptr;
ret = g_sensorDev->Register(SensorTestDataCallback) ret = g_sensorDev->Register(0, TraditionSensorTestDataCallback)
EXPECT_EQ(SENSOR_NULL_PTR, ret); EXPECT_EQ(SENSOR_NULL_PTR, ret);
ret = g_sensorDev->GetAllSensors(&sensorInfo, &count); ret = g_sensorDev->GetAllSensors(&sensorInfo, &count);
...@@ -917,7 +885,7 @@ HWTEST_F(HdfSensorTest,TestAccelDriver_001, TestSize.Level0) ...@@ -917,7 +885,7 @@ HWTEST_F(HdfSensorTest,TestAccelDriver_001, TestSize.Level0)
g_sensorDataFlag = 0; g_sensorDataFlag = 0;
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
ret = g_sensorDev->Unregister(); ret = g_sensorDev->Unregister(0, TraditionSensorTestDataCallback);
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
} }
``` ```
......
zh-cn/device-dev/driver/driver-peripherals-vibrator-des.md 0 → 100755
浏览文件 @ 479e31cf
# Vibrator
- [概述](##概述)
- [功能简介](###功能简介)
- [运作机制](###运作机制)
- [开发指导](##开发指导)
- [接口说明](###接口说明)
- [开发步骤](###开发步骤)
- [开发实例](###开发实例)
## 概述
### 功能简介
为了快速开发传感器驱动，基于HDF（Hardware Driver Foundation）驱动框架开发了马达驱动模型。马达设备模型抽象，屏蔽设备驱动与系统交互的实现，为硬件服务层提供统一稳定的驱动接口能力，为驱动开发者提供开放的接口实现和抽象的配置接口能力。用于不同操作系统马达设备部件的部署指导和马达设备部件驱动的开发。马达驱动模型如[图1](马达驱动模型图)所示：
**图 1** 马达驱动模型图
![Vibrator驱动模型](figures/Vibrator%E9%A9%B1%E5%8A%A8%E6%A8%A1%E5%9E%8B.png)
### 运作机制
通过介绍马达驱动模型的加载以及运行流程，对模型内部关键组件以及关联组件之间的关系进行了划分，整体加载流程如[图2](#马达驱动运行图)所示：
**图2** 马达驱动运行图
![Vibrator驱动运行图](figures/Vibrator%E9%A9%B1%E5%8A%A8%E8%BF%90%E8%A1%8C%E5%9B%BE.png)
马达驱动模型以标准系统Hi3516DV300产品为例，介绍整个驱动加载及运行流程：
1. 从device info HCS 的Vibrator Host读取Vibrator管理配置信息。
2. 解析Vibrator配置信息，并关联对应设备驱动。
3. 从linear_vibrator_config HCS读取Vibrator数据配置信息。
4. 解析Vibrator数据配置信息，并关联对应Haptic驱动。
5. 客户端下发Vibrator Stub控制到服务端。
6. 服务端调用Vibrator Stub控制。
7. 启动马达抽象驱动接口。
8. Haptic中起线程，解析效果模块。
9. Haptic调用马达抽象驱动中的Start接口。
10. 马达抽象驱动调用马达差异化驱动中的Start接口。
## 开发指导
### 接口说明
马达驱动模型支持静态HCS配置和动态参数两种振动效果配置能力。马达硬件服务调用StartOnce接口动态配置持续振动；调用Start接口启动静态配置的振动效果。马达驱动模型对HDI开放的API接口能力，参考[表1](马达驱动模型对外API接口能力介绍)。
**表 1** 马达驱动模型对外API接口能力介绍
| 接口名 | 功能描述 |
| -------------------------------------- | -------------------------------------------------------- |
| int32_t StartOnce(uint32_t duration) | 按照指定持续时间触发振动马达，duration为振动持续时长。 |
| int32_t Start(const char *effectType) | 按照指定预置效果启动马达，effectType表示预置的预置效果。 |
| int32_t Stop(enum VibratorMode mode) | 按照指定的振动模式停止马达振动。 |
### 开发步骤
Vibrator驱动模型为上层马达硬件服务层提供稳定的马达控制能力接口，包括马达一次振动、马达效果配置震动、马达停止。基于HDF（Hardware Driver Foundation）驱动框架开发的马达驱动模型，实现跨操作系统迁移、器件差异配置等功能。马达具体的开发步骤如下：
1. 基于HDF驱动框架，按照驱动Driver Entry程序，完成马达抽象驱动开发，主要由Bind、Init、Release、Dispatch函数接口实现，配置资源和HCS解析。
2. 创建马达效果模型，解析马达效果HCS配置。
3. 完成马达振动和停止接口开发，会根据振动效果的模式创建和销毁定时器。
4. 马达驱动模型提供给开发者马达驱动差异化接口，开发者实现差异化接口。
### 开发实例
1. 马达驱动的初始化和去初始化
- 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数，再调用Init函数加载该驱动。当Init调用异常时，HDF框架会调用Release释放驱动资源并退出马达驱动模型，使用HCS作为配置描述源码。HCS配置字段详细介绍参考[配置管理](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/driver/driver-hdf-manage.md)。其中Driver Entry入口函数定义如下：
```
/* 注册马达抽象驱动入口数据结构体对象 */
struct HdfDriverEntry g_vibratorDriverEntry = {
.moduleVersion = 1, //马达模块版本号
.moduleName = "HDF_VIBRATOR", //马达模块名，要与device_info.hcs文件里的马达moduleName字段值一样
.Bind = BindVibratorDriver, //马达绑定函数
.Init = InitVibratorDriver, //马达初始化函数
.Release = ReleaseVibratorDriver, //马达资源释放函数
};
HDF_INIT(g_vibratorDriverEntry);
```
- 基于HDF驱动框架，按照驱动Driver Entry程序，完成马达抽象驱动开发，主要由Bind、Init、Release、Dispatch函数接口实现。
```
/* 马达驱动对外发布的能力 */
static int32_t DispatchVibrator(struct HdfDeviceIoClient *client,
int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
{
int32_t loop;
for (loop = 0; loop < sizeof(g_vibratorCmdHandle) / sizeof(g_vibratorCmdHandle[0]); ++loop) {
if ((cmd == g_vibratorCmdHandle[loop].cmd) && (g_vibratorCmdHandle[loop].func != NULL)) {
return g_vibratorCmdHandle[loop].func(data, reply);
}
}
return HDF_SUCCESS;
}
/* 马达驱动对外提供的服务绑定到HDF框架 */
int32_t BindVibratorDriver(struct HdfDeviceObject *device)
{
struct VibratorDriverData *drvData = NULL;
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(device, HDF_FAILURE);
drvData = (struct VibratorDriverData *)OsalMemCalloc(sizeof(*drvData));
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_MALLOC_FAIL);
drvData->ioService.Dispatch = DispatchVibrator;
drvData->device = device;
device->service = &drvData->ioService;
g_vibratorDrvData = drvData;
return HDF_SUCCESS;
}
/* 马达驱动初始化入口函数*/
int32_t InitVibratorDriver(struct HdfDeviceObject *device)
{
struct VibratorDriverData *drvData = NULL;
drvData->mode = VIBRATOR_MODE_BUTT;
drvData->state = VIBRATOR_STATE_IDLE;
......
if (CreateVibratorHaptic(device) != HDF_SUCCESS) {
HDF_LOGE("%s: init workQueue fail!", __func__);
return HDF_FAILURE;
}
return HDF_SUCCESS;
}
/* 释放马达驱动初始化时分配的资源 */
void ReleaseVibratorDriver(struct HdfDeviceObject *device)
{
struct VibratorDriverData *drvData = NULL;
......
(void)DestroyVibratorHaptic();
(void)OsalMutexDestroy(&drvData->mutex);
(void)OsalMemFree(drvData);
g_vibratorDrvData = NULL;
}
```
- 马达设备管理模块负责系统中马达器件接口发布，在系统启动过程中，HDF框架机制通过马达 Host里设备HCS配置信息，加载设备管理驱动。
```
/* 马达设备HCS配置 */
vibrator :: host {
hostName = "vibrator_host";
device_vibrator :: device {
device0 :: deviceNode {
policy = 2; //驱动服务发布的策略
priority = 100; //驱动启动优先级（0-200），值越大优先级越低，建议配置100，优先级相同则不保证device的加载顺序
preload = 0; //驱动按需加载字段，0表示加载，2表示不加载
permission = 0664; //驱动创建设备节点权限
moduleName = "HDF_VIBRATOR"; //驱动名称，该字段的值必须和驱动入口结构的moduleName值一致
serviceName = "hdf_misc_vibrator"; //驱动对外发布服务的名称，必须唯一
deviceMatchAttr = "hdf_vibrator_driver"; //驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等
}
}
```
2. 创建马达效果模型，解析马达效果HCS配置。
- 创建马达效果模型。
```
/* 创建马达效果模型，分配资源，解析马达HCS配置 */
int32_t CreateVibratorHaptic(struct HdfDeviceObject *device)
{
struct VibratorHapticData *hapticData = NULL;
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(device, HDF_FAILURE);
hapticData = (struct VibratorHapticData *)OsalMemCalloc(sizeof(*hapticData));
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(hapticData, HDF_ERR_MALLOC_FAIL);
g_vibratorHapticData = hapticData;
hapticData->supportHaptic = false;
if (OsalMutexInit(&hapticData->mutex) != HDF_SUCCESS) {
HDF_LOGE("%s: fail to init mutex", __func__);
goto EXIT;
}
DListHeadInit(&hapticData->effectSeqHead);
/* 解析马达效果HCS配置 */
if (ParserVibratorHapticConfig(device->property) != HDF_SUCCESS) {
HDF_LOGE("%s: parser haptic config fail!", __func__);
goto EXIT;
}
return HDF_SUCCESS;
EXIT:
OsalMemFree(hapticData);
return HDF_FAILURE;
}
```
- 马达效果模型使用HCS作为配置描述源码，HCS配置字段详细介绍参考[配置管理](https://gitee.com/openharmony/docs/blob/master/zh-cn/device-dev/driver/driver-hdf-manage.md)。
```
/* 马达数据配置模板（vibrator_config.hcs） */
root {
vibratorConfig {
boardConfig {
match_attr = "hdf_vibrator_driver"; //需要和马达设备配置match_attr字段保持一致
vibratorAttr {
/* 0:转子 1:线性 */
deviceType = 1; //设备类型
supportPreset = 1; //支持的预设类型
}
vibratorHapticConfig {
haptic_clock_timer {
effectName = "haptic.clock.timer";
type = 1; // 0 内置模式, 1 时间序列
seq = [600, 600, 200, 600]; // 时间序列
}
haptic_default_effect {
effectName = "haptic.default.effect";
type = 0;
seq = [0, 3, 800, 1];
}
}
}
}
}
```
3. 完成马达振动和停止接口开发，会根据振动效果的模式创建和销毁定时器。
马达硬件服务调用StartOnce接口动态配置持续振动时间；调用StartEffect接口启动静态配置的振动效果，为驱动开发者提供抽象的配置接口能力。
```
/* 按照指定持续时间触发振动马达，duration为振动持续时长 */
static int32_t StartOnce(struct HdfSBuf *data, struct HdfSBuf *reply)
{
uint32_t duration;
int32_t ret;
struct VibratorEffectCfg config;
struct VibratorDriverData *drvData = GetVibratorDrvData();
(void)reply;
......
config.cfgMode = VIBRATOR_MODE_ONCE;
config.duration = duration;
config.effect = NULL;
/* 据振动效果的模式创建 */
ret = StartHaptic(&config);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: start haptic fail!", __func__);
return ret;
}
return HDF_SUCCESS;
}
/* 按照预置效果启动马达，effectType表示预置的预置效果 */
static int32_t StartEffect(struct HdfSBuf *data, struct HdfSBuf *reply)
{
int32_t ret;
const char *effect = NULL;
struct VibratorEffectCfg config;
struct VibratorDriverData *drvData = GetVibratorDrvData();
(void)reply;
......
config.cfgMode = VIBRATOR_MODE_PRESET;
config.duration = 0;
config.effect = effect;
ret = StartHaptic(&config);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: start haptic fail!", __func__);
return ret;
}
return HDF_SUCCESS;
}
/* 按照指定的振动模式停止马达振动 */
static int32_t Stop(struct HdfSBuf *data, struct HdfSBuf *reply)
{
int32_t ret;
int32_t mode;
struct VibratorDriverData *drvData = GetVibratorDrvData();
(void)reply;
......
/* 停止马达效果振动，销毁马达定时器 */
ret = StopHaptic();
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: stop haptic fail!", __func__);
return ret;
}
(void)OsalMutexLock(&drvData->mutex);
drvData->mode = VIBRATOR_MODE_BUTT;
(void)OsalMutexUnlock(&drvData->mutex);
return HDF_SUCCESS;
}
```
4. 马达驱动模型提供给开发者马达驱动差异化接口，开发者实现差异化接口。
- 此接口在差异化器件驱动初始化成功时，注册差异实现接口，方便实现器件差异的驱动接口。
```
/* 注册马达差异化实现接口 */
int32_t RegisterVibrator(struct VibratorOps *ops)
{
struct VibratorDriverData *drvData = GetVibratorDrvData();
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(ops, HDF_FAILURE);
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(drvData, HDF_FAILURE);
(void)OsalMutexLock(&drvData->mutex);
drvData->ops.Start = ops->Start;
drvData->ops.StartEffect = ops->StartEffect;
drvData->ops.Stop = ops->Stop;
(void)OsalMutexUnlock(&drvData->mutex);
return HDF_SUCCESS;
}
```
- 马达驱动模型提供给开发者马达驱动差异化接口，具体实现如下：
```
/* 按照指定持续时间触发马达线性驱动 */
static int32_t StartLinearVibrator()
{
int32_t ret;
struct VibratorLinearDriverData *drvData = GetLinearVibratorData();
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(drvData, HDF_FAILURE);
......
ret = GpioWrite(drvData->gpioNum, GPIO_VAL_LOW);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: pull gpio%d to %d level failed", __func__, drvData->gpioNum, GPIO_VAL_LOW);
return ret;
}
return HDF_SUCCESS;
}
/* 按照预置振动效果启动马达线性驱动 */
static int32_t StartEffectLinearVibrator(uint32_t effectType)
{
(void)effectType;
HDF_LOGE("%s: vibrator set build-in effect no support!", __func__);
return HDF_SUCCESS;
}
/* 按照指定的振动模式停止马达线性驱动 */
static int32_t StopLinearVibrator()
{
int32_t ret;
struct VibratorLinearDriverData *drvData = GetLinearVibratorData();
CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(drvData, HDF_FAILURE);
......
ret = GpioWrite(drvData->gpioNum, GPIO_VAL_HIGH);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: pull gpio%d to %d level failed", __func__, drvData->gpioNum, GPIO_VAL_HIGH);
return ret;
}
return HDF_SUCCESS;
}
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或