论坛 › 鸿蒙 › HarmonyOS鸿蒙开发 (5.0 ) Sensor驱动模型API接口

海哥 发表于 2025-1-12 12:39:55

HarmonyOS鸿蒙开发 (5.0 ) Sensor驱动模型API接口

  鸿蒙开发往期必看：
HarmonyOS NEXT应用开发性能实践总结
一分钟了解”纯血版！鸿蒙HarmonyOS Next应用开发！
“非常具体的” 鸿蒙HarmonyOS Next应用开发学习蹊径！（从零根本入门到醒目）
 “一杯冰美式的时间” 了解鸿蒙HarmonyOS Next应用开发路径！
功能简介

Sensor驱动模型屏蔽硬件器件差异，为上层Sensor服务体系提供稳定的Sensor根本能力接口，包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅，Sensor参数配置等功能。Sensor装备驱动的开发是基于HDF驱动框架根本上，结合操纵体系适配层（OSAL）和平台驱动接口（比如I2C/SPI/UART总线等平台资源）能力，屏蔽差别操纵体系和平台总线资源差异，实现Sensor驱动“一次开发，多体系部署”的目的。Sensor驱动模型如图1所示。
图 1 Sensor驱动模型图
https://i-blog.csdnimg.cn/direct/c503e69714cc4f76930f9aad9c7b07b6.png
基本概念

目前根据sensorId将Sensor分为医学类Sensor、传统类Sensor两种。


[*] 医学类Sensor：已订阅的sensorId摆列值在128-160范围的为医学类Sensor。
[*] 传统类Sensor：已订阅的sensorId摆列值不在128-160范围的为传统类Sensor。
运作机制

通过介绍Sensor驱动模型的加载以及运行流程，对模型内部关键组件以及关联组件之间的关系进行了分别，整体加载流程如图2所示：
图 2 Sensor驱动运行图
https://i-blog.csdnimg.cn/direct/030641e093ec45d5a9dbc5441a3a6c6c.png
Sensor驱动模型以标准体系RK3568产品中的加速度传感器驱动为例，介绍整个驱动加载及运行流程：

[*]从device_info.hcs配置文件中的Sensor Host读取到Sensor装备管理配置信息。
[*]HDF配置框架从HCB数据库中解析Sensor装备管理配置信息，并关联对应装备驱动。
[*]加载并初始化Sensor装备管理驱动。
[*]Sensor装备管理驱动向HDI发布Sensor根本能力接口。
[*]从device_info.hcs配置文件中的Sensor Host读取到加速度传感器驱动配置信息。
[*]加载加速度传感器抽象驱动，调用初始化接口，完成Sensor器件的驱动资源分配和数据处置惩罚队列的创建。
[*]从accel_xxx_config.hcs配置文件中读取到加速度传感器差异化驱动配置和私有化配置信息。
[*]加速度传感器芯片差异化驱动，调用通用配置解析接口，完成器件属性信息解析，器件寄存器解析。
[*]加速度传感器芯片差异化驱动完成器件的探测，并分配加速度传感器配置资源和加速度传感器差异化接口注册。
[*]加速度传感器乐成探测到器件之后，加速度传感器芯片差异化驱动通知加速度传感器抽象驱动，注册加速度传感器装备到Sensor装备管理中。
开发指导

场景介绍



[*]通过重力和陀螺仪传感器数据，能感知装备倾斜和旋转量，提高用户在游戏场景中的体验。
[*]通过接近光传感器数据，感知间隔遮挡物的间隔，使装备可以或许自动亮灭屏，到达防误触目的。例如，手机通话时，如屏幕间隔人脸过近，则自动关闭屏幕，防止误触的同时降低功耗。
[*]通过气压计传感器数据，可以准确的判断装备当前所处的海拔。
[*]通过环境光传感器数据，装备可以或许实现背光自动调治。
[*]通过霍尔传感器数据，装备可以实现皮套功能，皮套合上，手机上开一个小窗口，可降低功耗。
接口说明

Sensor驱动模型对外开放的API接口能力如下：


[*]提供Sensor HDI（Hardware Device Interface）能力接口，简化服务开发。
[*]提供Sensor驱动模型能力接口：

[*]依赖HDF驱动框架实现Sensor器件驱动的加载、器件探测、注册和去注册等能力。
[*]提供同一范例Sensor器件驱动归一接口、寄存器配置解析操纵接口、总线访问抽象接口和平台抽象接口。

[*]提供开发者实现的能力接口：依赖HDF驱动框架的HCS（HDF Configuration Source）配置管理，根据同范例Sensor差异化配置，实现Sensor器件参数序列化配置和器件部分操纵接口，简化Sensor器件驱动开发。
Sensor驱动模型对外开放的API接口能力的具体实现请参考：
表 1 Sensor驱动模型对外API接口功能介绍
注：以下接口枚举的为C接口，接口声明见文件/drivers/peripheral/sensor/interfaces/include。
接口名功能描述int32_t GetAllSensors(struct SensorInformation **sensorInfo, int32_t *count)获取体系中注册的所有传感器信息，一组完整传感器信息包括传感器名字、装备厂商、固件版本号、硬件版本号、传感器范例编号、传感器标识、最大量程、精度、功耗。int32_t Enable(int32_t sensorId)使能指定传感器装备，只有数据订阅者使能传感器后，才能获取订阅的传感器数据。int32_t Disable(int32_t sensorId)去使能指定传感器装备。int32_t SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval)设置指定传感器的数据采样间隔和数据上报间隔。int32_t SetMode(int32_t sensorId, int32_t mode)设置指定传感器的工作模式，差别的工作模式，上报数据方式差别。int32_t SetOption(int32_t sensorId, uint32_t option)设置指定传感器量程，精度等可选配置。int32_t Register(int32_t groupId, RecordDataCallback cb)订阅者根据差别groupId注册传感器数据回调函数，体系会将获取到的传感器数据上报给订阅者。int32_t Unregister(int32_t groupId, RecordDataCallback cb)订阅者根据groupId和回调函数注销对应订阅者的传感器数据回调函数。 Sensor驱动模型对驱动开发者开放的功能接口，驱动开发者无需实现，直接使用，请参考：
表2 Sensor驱动模型对驱动开发者开放的功能接口列表
接口名功能描述int32_t AddSensorDevice(const struct SensorDeviceInfo *deviceInfo)添加当前范例的传感器装备到传感器装备管理。int32_t DeleteSensorDevice(const struct SensorBasicInfo *sensorBaseInfo)删除传感器装备管理里指定的传感器装备。int32_t ReportSensorEvent(const struct SensorReportEvent *events)上报指定范例传感器的数据到用户侧。int32_t ReadSensor(struct SensorBusCfg *busCfg, uint16_t regAddr, uint8_t *data, uint16_t dataLen)按照配置的总线方式，读取传感器寄存器配置数据。int32_t WriteSensor(struct SensorBusCfg *busCfg, uint8_t *writeData, uint16_t len)按照配置的总线方式，将传感器配置数据写入寄存器。int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group);根据传感器总线范例信息，下发寄存器分组配置。int32_t GetSensorBaseConfigData(const struct DeviceResourceNode *node, struct SensorCfgData *config)根据传感器装备HCS资源配置，获取传感器信息，总线配置信息，属性配置等基本配置信息，并初始化对应的基本配置数据布局体。int32_t ParseSensorRegConfig(struct SensorCfgData *config)根据传感器装备HCS资源配置，解析寄存器分组信息，并初始化配置数据布局体。void ReleaseSensorAllRegConfig(struct SensorCfgData *config)开释传感器配置数据布局体里分配的资源。int32_t GetSensorBusHandle(struct SensorBusCfg *busCfg)获取传感器总线句柄信息。int32_t ReleaseSensorBusHandle(struct SensorBusCfg *busCfg)开释传感器句柄信息。 Sensor驱动模型要求驱动开发者实现的接口功能，请参考：
表 3 Sensor驱动模型要求驱动开发者实现的接口列表
接口名功能描述int32_t init(void)传感器装备探测乐成后，必要对传感器装备初始化配置。int32_t Enable(void)根据当前传感器装备的HCS配置，下发传感器装备使能操纵组的寄存器配置。int32_t Disable(void)根据当前传感器装备的HCS配置，下发传感器装备去使能操纵组的寄存器配置。int32_t SetBatch(int64_t samplingInterval, int64_t reportInterval)根据数据采样率和数据上报间隔，配置当前传感器装备的数据上报线程处置惩罚时间。int32_t SetMode(int32_t mode)配置当前传感器装备数据上报方式。int32_t SetOption(uint32_t option)根据可选配置、下发量程和精度等寄存器配置。void ReadSensorData(void)读取传感器数据。 接口实现参考开发步调章节。
开发步调

基于HDF驱动框架，按照驱动Driver Entry程序，以加速度传感器驱动为例，介绍传感器驱动的开发。传感器的驱动开发包括抽象驱动开发和差异化驱动开发两部分。传感器的抽象驱动开发包括同一个传感器id中差别器件的公共接口实现；传感器的差异化驱动开发包括差别器件差异化接口的实现。

[*] 开发加速度传感器抽象驱动。

[*] 加速度传感器抽象驱动在Sensor Host中的配置信息，代码实现路径如下：vendor\hihope\rk3568\hdf_config\khdf\device_info\device_info.hcs。
具体代码实现如下：
/* 加速度计传感器设备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值相等
    }
}
<strong>c</strong>
[*] 加速度传感器抽象驱动代码实现路径为：drivers\hdf_core\framework\model\sensor\driver\accel\sensor_accel_driver.c。

[*] 加速度传感器抽象驱动对应的HdfDriverEntry对象，其中，Driver Entry入口函数定义如下：
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);
<strong>c</strong>
[*] 加速度传感器抽象驱动Bind接口实现如下：
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;
}
<strong>c</strong>
[*] 加速度传感器抽象驱动Init接口实现如下：
int32_t AccelInitDriver(struct HdfDeviceObject *device)
{
    CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
    struct AccelDrvData *drvData = (struct AccelDrvData *)device->service;
    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
       /* 工作队列资源初始化 */
    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) {
      HDF_LOGE("%s: Malloc accel config data failed", __func__);
      return HDF_FAILURE;
    }
        /* 注册寄存器分组信息 */
    drvData->accelCfg->regCfgGroup = &g_regCfgGroup;
    drvData->cb = NULL;
       
    HDF_LOGI("%s: Init accel driver success", __func__);
    return HDF_SUCCESS;
}
<strong>c</strong>
[*] 加速度抽象传感器驱动Release接口在驱动卸载大概Init执行失败时，会调用此接口开释资源，具体实现如下：
void AccelReleaseDriver(struct HdfDeviceObject *device)
{
    CHECK_NULL_PTR_RETURN(device);

    struct AccelDrvData *drvData = (struct AccelDrvData *)device->service;
    CHECK_NULL_PTR_RETURN(drvData);
        /* 器件在位，释放已分配资源 */
    if (drvData->detectFlag && drvData->accelCfg != NULL) {
      AccelReleaseCfgData(drvData->accelCfg);
    }

    OsalMemFree(drvData->accelCfg);
    drvData->accelCfg = NULL;
        /* 器件在位，销毁工作队列资源 */
    HdfWorkDestroy(&drvData->accelWork);
    HdfWorkQueueDestroy(&drvData->accelWorkQueue);
    OsalMemFree(drvData);
}
<strong>c</strong>
[*] 加速度传感器抽象驱动内部接口代码实现如下：

[*] 提供给差异化驱动的初始化接口，完成加速度传感器器件的基本配置信息解析（加速度传感器信息，加速度传感器总线配置，加速度传感器器件探测寄存器配置），器件探测，器件寄存器解析，具体实现如下：
static int32_t InitAccelAfterDetected(struct SensorCfgData *config)
{
    struct SensorDeviceInfo deviceInfo;
    CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM);
        /* 初始化加速度计接口函数 */
    if (InitAccelOps(config, &deviceInfo) != HDF_SUCCESS) {
      HDF_LOGE("%s: Init accel ops failed", __func__);
      return HDF_FAILURE;
    }
        /* 注册加速度计器件到传感器设备管理模块 */
    if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) {
      HDF_LOGE("%s: Add accel device failed", __func__);
      return HDF_FAILURE;
    }
        /* 器件寄存器解析 */
    if (ParseSensorDirection(config) != HDF_SUCCESS) {
      HDF_LOGE("%s: Parse accel direction failed", __func__);
      (void)DeleteSensorDevice(&config->sensorInfo);
      return HDF_FAILURE;
    }

    if (ParseSensorRegConfig(config) != HDF_SUCCESS) {
      HDF_LOGE("%s: Parse sensor register failed", __func__);
      (void)DeleteSensorDevice(&config->sensorInfo);
      ReleaseSensorAllRegConfig(config);
      ReleaseSensorDirectionConfig(config);
      return HDF_FAILURE;
    }
    return HDF_SUCCESS;
}

struct SensorCfgData *AccelCreateCfgData(const struct DeviceResourceNode *node)
{
    struct AccelDrvData *drvData = AccelGetDrvData();
        /* 如果器件不在位，返回进行下个器件探测 */
    if (drvData == NULL || node == NULL) {
      HDF_LOGE("%s: Accel node pointer NULL", __func__);
      return NULL;
    }

    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 (GetSensorBaseConfigData(node, drvData->accelCfg) != HDF_SUCCESS) {
      HDF_LOGE("%s: Get sensor base config failed", __func__);
      goto BASE_CONFIG_EXIT;
    }
        /* 如果器件不在位（存在器件ID的情况），返回进行下个器件探测 */
    if (DetectSensorDevice(drvData->accelCfg) != HDF_SUCCESS) {
      HDF_LOGI("%s: Accel sensor detect device no exist", __func__);
      drvData->detectFlag = false;
      goto BASE_CONFIG_EXIT;
    }
        /* 器件寄存器解析 */
    drvData->detectFlag = true;
    if (InitAccelAfterDetected(drvData->accelCfg) != HDF_SUCCESS) {
      HDF_LOGE("%s: Accel sensor detect device no exist", __func__);
      goto INIT_EXIT;
    }
    return drvData->accelCfg;

INIT_EXIT:
    (void)ReleaseSensorBusHandle(&drvData->accelCfg->busCfg);
BASE_CONFIG_EXIT:
    drvData->accelCfg->root = NULL;
    (void)memset_s(&drvData->accelCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo));
    (void)memset_s(&drvData->accelCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg));
    (void)memset_s(&drvData->accelCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr));
    return drvData->accelCfg;
}
<strong>c</strong>
[*] Enable接口的代码实现如下：
static int32_t SetAccelEnable(void)
{
    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 is enabled", __func__);
      return HDF_SUCCESS;
    }
        /* 设置寄存器 */
    ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup);
    if (ret != HDF_SUCCESS) {
      HDF_LOGE("%s: Accel sensor enable config failed", __func__);
      return ret;
    }
        /* 创建定时器 */
    ret = OsalTimerCreate(&drvData->accelTimer, SENSOR_TIMER_MIN_TIME, AccelTimerEntry, (uintptr_t)drvData);
    if (ret != HDF_SUCCESS) {
      HDF_LOGE("%s: Accel create timer failed[%d]", __func__, ret);
      return ret;
    }
        /* 开启定时器进行数据上报 */
    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;
}
<strong>c</strong>
[*] Disable接口的代码实现如下：
static int32_t SetAccelDisable(void)
{
    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);
    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;

    return HDF_SUCCESS;
}
<strong>c</strong>
[*] SetBatch接口的代码实现如下：
static int32_t SetAccelBatch(int64_t samplingInterval, int64_t interval)
{
    (void)interval;

    struct AccelDrvData *drvData = NULL;

    drvData = AccelGetDrvData();
    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
        /* 给定时器设置采样率 */
    drvData->interval = samplingInterval;

    return HDF_SUCCESS;
}
<strong>c</strong>
[*] SetMode接口的代码实现如下：
static int32_t SetAccelMode(int32_t mode)
{
    if (mode <= SENSOR_WORK_MODE_DEFAULT || mode >= SENSOR_WORK_MODE_MAX) {
      HDF_LOGE("%s: The current mode is not supported", __func__);
      return HDF_FAILURE;
    }

    return HDF_SUCCESS;
}
<strong>c</strong>
[*] SetOption接口的代码实现如下：
static int32_t SetAccelOption(uint32_t option)
{
    (void)option;
    return HDF_SUCCESS;
}
<strong>c</strong>



[*] 开发加速度传感器差异化驱动。

[*] 加速度传感器差异化驱动在Sensor Host中的配置信息，代码实现路径如下：vendor\hihope\rk3568\hdf_config\khdf\device_info\device_info.hcs。
具体代码实现如下：
device_sensor_mxc6655xa :: device {
    device0 :: deviceNode {
      policy = 1;                // policy字段是驱动服务发布的策略
      priority = 120; // 驱动启动优先级（0-200），值越大优先级越低，建议配置为100，优先级相同则不保证device的加载顺序
      preload = 0;    // 驱动按需加载字段，0表示加载，2表示不加载
      permission = 0664; // 驱动创建设备节点权限
      moduleName = "HDF_SENSOR_ACCEL_MXC6655XA"; // 驱动名称，该字段的值必须和驱动入口结构的moduleName值一致
      serviceName = "hdf_accel_mxc6655xa"; // 加速度mxc6655xa对外发布服务的名称，必须唯一
      deviceMatchAttr = "hdf_sensor_accel_mxc6655xa_driver"; // 加速度差异化驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等
    }
}
<strong>c</strong>
[*] 加速度传感器差异化驱动私有HCS配置：

[*] 代码实现路径：vendor\hihope\rk3568\hdf_config\khdf\sensor\accel\mxc6655xa_config.hcs。
[*] 具体代码实现如下：
#include "../sensor_common.hcs"
root {
    accel_mxc6655xa_chip_config : sensorConfig {
      match_attr = "hdf_sensor_accel_mxc6655xa_driver";
      sensorInfo :: sensorDeviceInfo {
            sensorName = "accelerometer";
            vendorName = "memsi_mxc6655xa"; // max string length is 16 bytes
            sensorTypeId = 1; // enum SensorTypeTag
            sensorId = 1; // user define sensor id
            power = 230;
            minDelay = 5000000; // nanosecond
            maxDelay = 200000000; // nanosecond
      }
      sensorBusConfig :: sensorBusInfo {
            busType = 0; // 0:i2c 1:spi
            busNum = 5;
            busAddr = 0x15;
            regWidth = 1; // 1byte
      }
      sensorIdAttr :: sensorIdInfo {
            chipName = "mxc6655xa";
            chipIdRegister = 0x0f;
            chipIdValue = 0x05; // 根据器件ID寄存器，读取的值，或查看相关芯片datasheet手册确认该值
      }
      sensorDirection {
            direction = 1; // chip direction range of value:0-7
            /* <sign> 1:negative0:positive
               <map> 0:AXIS_X1:AXIS_Y2:AXIS_Z
            */
            /* sign, sign, sign, map, map, map */
            convert = [
                0, 0, 0, 0, 1, 2,
                1, 0, 0, 1, 0, 2,
                0, 0, 1, 0, 1, 2,
                0, 1, 0, 1, 0, 2,
                1, 0, 1, 0, 1, 2,
                0, 0, 1, 1, 0, 2,
                0, 1, 1, 0, 1, 2,
                1, 1, 1, 1, 0, 2
            ];
      }
      sensorRegConfig {
            /*regAddr: register address
                value: config register value
                len: size of value
                mask: mask of value
                delay: config register delay time (ms)
                opsType: enum SensorOpsType 0-none 1-read 2-write 3-read_check 4-update_bit
                calType: enum SensorBitCalType 0-none 1-set 2-revert 3-xor 4-left shift 5-right shift
                shiftNum: shift bits
                debug: 0-no debug 1-debug
                save: 0-no save 1-save
            */
            /* regAddr, value, mask, len, delay, opsType, calType, shiftNum, debug, save */
            initSeqConfig = [
                0x7e,    0xb6, 0xff,   1,   5,       2,       0,      0,   0,    0,
                0x7e,    0x10, 0xff,   1,   5,       2,       0,      0,   0,    0
            ];
            enableSeqConfig = [
                0x7e,    0x11, 0xff,   1,   5,       2,       0,      0,   0,    0,
                0x41,    0x03, 0xff,   1,   0,       2,       0,      0,   0,    0,
                0x40,    0x08, 0xff,   1,   0,       2,       0,      0,   0,    0
            ];
            disableSeqConfig = [
                0x7e,    0x10, 0xff,   1,   5,       2,       0,      0,   0,    0
            ];
      }
    }
}
<strong>c</strong>

[*] 加速度差异化驱动的代码实现路径：drivers\peripheral\sensor\chipset\accel\accel_mxc6655xa.c

[*] 加速度传感器差异化驱动对应的HdfDriverEntry对象，其中，Driver Entry入口函数定义如下：
/* 注册加速度mxc6655xa传感器入口数据结构体对象 */
struct HdfDriverEntry g_accelMxc6655xaDevEntry = {
    .moduleVersion = 1, // 加速度mxc6655xa传感器模块版本号
    .moduleName = "HDF_SENSOR_ACCEL_MXC6655XA", // 加速度mxc6655xa传感器模块名，要与device_info.hcs文件里加速度mxc6655xa传感器moduleName字段值一致
    .Bind = Mxc6655xaBindDriver, // 加速度mxc6655xa传感器的绑定函数
    .Init = Mxc6655xaInitDriver, // 加速度mxc6655xa传感器的初始化函数
    .Release = Mxc6655xaReleaseDriver, // 加速度mxc6655xa传感器资源释放函数
};
/* 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出 */
HDF_INIT(g_accelMxc6655xaDevEntry);
<strong>c</strong>
[*] 加速度传感器差异化驱动Bind接口实现如下：
int32_t Mxc6655xaBindDriver(struct HdfDeviceObject *device)
{
    CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);

    struct Mxc6655xaDrvData *drvData = (struct Mxc6655xaDrvData *)OsalMemCalloc(sizeof(*drvData));
    if (drvData == NULL) {
      HDF_LOGE("%s: Malloc MXC6655XA drv data fail", __func__);
      return HDF_ERR_MALLOC_FAIL;
    }

    drvData->ioService.Dispatch = DispatchMXC6655xa;
    drvData->device = device;
    device->service = &drvData->ioService;
    g_mxc6655xaDrvData = drvData;

    return HDF_SUCCESS;
}
<strong>c</strong>
[*] 加速度传感器差异化驱动Init接口实现如下：
int32_t Mxc6655xaInitDriver(struct HdfDeviceObject *device)
{
    int32_t ret;
    struct AccelOpsCall ops;

    CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
    struct Mxc6655xaDrvData *drvData = (struct Mxc6655xaDrvData *)device->service;
    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);

    drvData->sensorCfg = AccelCreateCfgData(device->property);
    if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) {
      HDF_LOGD("%s: Creating accelcfg failed because detection failed", __func__);
      return HDF_ERR_NOT_SUPPORT;
    }

    ops.Init = NULL;
    ops.ReadData = ReadMxc6655xaData;
    ret = AccelRegisterChipOps(&ops);
    if (ret != HDF_SUCCESS) {
      HDF_LOGE("%s: Register MXC6655XA accel failed", __func__);
      return HDF_FAILURE;
    }

    ret = InitMxc6655xa(drvData->sensorCfg);
    if (ret != HDF_SUCCESS) {
      HDF_LOGE("%s: Init MXC6655XA accel failed", __func__);
      return HDF_FAILURE;
    }

    return HDF_SUCCESS;
}
<strong>c</strong>
[*] 加速度传感器差异化驱动Release接口实现如下：
void Mxc6655xaReleaseDriver(struct HdfDeviceObject *device)
{
    CHECK_NULL_PTR_RETURN(device);

    struct Mxc6655xaDrvData *drvData = (struct Mxc6655xaDrvData *)device->service;
    CHECK_NULL_PTR_RETURN(drvData);

    if (drvData->sensorCfg != NULL) {
      AccelReleaseCfgData(drvData->sensorCfg);
      drvData->sensorCfg = NULL;
    }
    OsalMemFree(drvData);
}
<strong>c</strong>
[*] 加速度传感器差异化驱动内部接口实现。
必要开发者实现的ReadMxc6655xaData接口函数，在 Mxc6655xaInitDriver函数里面注册此函数，具体实现如下：
static int32_t ReadMxc6655xaRawData(struct SensorCfgData *data, struct AccelData *rawData, uint64_t *timestamp)
{
    uint8_t status = 0;
    uint8_t reg;
    OsalTimespec time;
    int32_t x;
    int32_t y;
    int32_t z;

    (void)memset_s(&time, sizeof(time), 0, sizeof(time));
    (void)memset_s(reg, sizeof(reg), 0, sizeof(reg));

    CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);

    if (OsalGetTime(&time) != HDF_SUCCESS) {
      HDF_LOGE("%s: Get time failed", __func__);
      return HDF_FAILURE;
    }
    *timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; /* unit nanosecond */

    int32_t ret = ReadSensor(&data->busCfg, MXC6655XA_STATUS_ADDR, &status, sizeof(uint8_t));
    if (ret != HDF_SUCCESS) {
      HDF_LOGE("%s: data status [%u] ret [%d]", __func__, status, ret);
      return HDF_FAILURE;
    }

    ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_X_LSB_ADDR, &reg, sizeof(uint8_t));
    CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");

    ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_X_MSB_ADDR, &reg, sizeof(uint8_t));
    CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");

    ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Y_LSB_ADDR, &reg, sizeof(uint8_t));
    CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");

    ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Y_MSB_ADDR, &reg, sizeof(uint8_t));
    CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");

    ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Z_LSB_ADDR, &reg, sizeof(uint8_t));
    CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");

    ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Z_MSB_ADDR, &reg, sizeof(uint8_t));
    CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");

    x = SensorConvertData(reg, reg);
    y = SensorConvertData(reg, reg);
    z = SensorConvertData(reg, reg);
    rawData->x = x;
    rawData->y = y;
    rawData->z = z;

    return HDF_SUCCESS;
}
/* 读取加速度的event数据，在 Mxc6655xaInitDriver函数里面注册此函数，将数据传给加速度抽象驱动 */
int32_t ReadMxc6655xaData(struct SensorCfgData *cfg, struct SensorReportEvent *event)
{
    int32_t ret;
    struct AccelData rawData = { 0, 0, 0 };
    static int32_t tmp;

    CHECK_NULL_PTR_RETURN_VALUE(cfg, HDF_ERR_INVALID_PARAM);
    CHECK_NULL_PTR_RETURN_VALUE(event, HDF_ERR_INVALID_PARAM);

    ret = ReadMxc6655xaRawData(cfg, &rawData, &event->timestamp);
    if (ret != HDF_SUCCESS) {
      HDF_LOGE("%s: MXC6655XA read raw data failed", __func__);
      return HDF_FAILURE;
    }

    event->sensorId = SENSOR_TAG_ACCELEROMETER;
    event->option = 0;
    event->mode = SENSOR_WORK_MODE_REALTIME;

    rawData.x = rawData.x * MXC6655XA_ACC_SENSITIVITY_2G;
    rawData.y = rawData.y * MXC6655XA_ACC_SENSITIVITY_2G;
    rawData.z = rawData.z * MXC6655XA_ACC_SENSITIVITY_2G;

    tmp = (rawData.x * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT;
    tmp = (rawData.y * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT;
    tmp = (rawData.z * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT;

    ret = SensorRawDataToRemapData(cfg->direction, tmp, sizeof(tmp) / sizeof(tmp));
    if (ret != HDF_SUCCESS) {
      HDF_LOGE("%s: MXC6655XA convert raw data failed", __func__);
      return HDF_FAILURE;
    }

    event->dataLen = sizeof(tmp);
    event->data = (uint8_t *)&tmp;

    return ret;
}
<strong>c</strong>


调考试证

驱动开发完成后，在传感器单元测试里面开发自测试用例，验证驱动基本功能。测试环境采用开发者自测试平台。


[*] 参考测试代码如下：
#include <cmath>
#include <cstdio>
#include <unistd.h>
#include <gtest/gtest.h>
#include <securec.h>
#include "hdf_base.h"
#include "osal_mem.h"
#include "osal_time.h"
#include "sensor_if.h"
#include "sensor_type.h"

using namespace testing::ext;
const struct SensorInterface *g_sensorDev = nullptr;
/* 创建回调函数 */
static int32_t SensorDataCallback(const struct SensorEvents *event)
{
    if (event == NULL) {
      return HDF_FAILURE;
    }

    float *data = (float*)event->data;
    printf("time [%lld] sensor id [%d] x-[%f] y-[%f] z-[%f]\n\r", event->timestamp,
      event->sensorId, (*data), *(data + 1), *(data + 2));

    return HDF_SUCCESS;
}

class HdfSensorTest : public testing::Test {
public:
    static void SetUpTestCase();
    static void TearDownTestCase();
    void SetUp();
    void TearDown();
};

/* 用例执行前，初始化传感器接口实例 */
void HdfSensorTest::SetUpTestCase()
{
    g_sensorDev = NewSensorInterfaceInstance();
    if (g_sensorDev == nullptr) {
      printf("test sensor get module instance failed\n\r");
    }
}
/* 用例资源释放 */
void HdfSensorTest::TearDownTestCase()
{
    if (g_sensorDev != nullptr) {
      FreeSensorInterfaceInstance();
      g_sensorDev = nullptr;
    }
}

void HdfSensorTest::SetUp()
{
}

void HdfSensorTest::TearDown()
{
}

HWTEST_F(HdfSensorTest,TestAccelDriver_001, TestSize.Level0)
{
    int ret;
    struct SensorInformation *sensorInfo = NULL;
    int32_t count = 0;
    int32_t sensorInterval = 200000000; /* 数据采样率设置200毫秒，单位纳秒 */
    int32_t reportInterval = 400000000;

    /* 2.订阅者注册传感器数据回调处理函数 */
    ret = g_sensorDev->Register(TRADITIONAL_SENSOR_TYPE, SensorDataCallback);
    if (ret != 0) {
      return;
    }
    printf("Register success\n");

    /* 3.获取设备支持的Sensor列表 */
    ret = g_sensorDev->GetAllSensors(&sensorInfo, &count);
    if (ret != 0) {
      return;
    }

    printf("GetAllSensors count: %d\n", count);

    for (int i = 0; i < count; i++)
    {
      printf("sensor [%d]: sensorName: %s, vendorName: %s, sensorTypeId: %d, sensorId: %d\n", i,
               sensorInfo.sensorName, sensorInfo.vendorName, sensorInfo.sensorTypeId, sensorInfo.sensorId);
    }

    for (int i = 0; i < count; i++)
    {
      /* 4.设置传感器采样率 */
      ret = g_sensorDev->SetBatch(sensorInfo.sensorId, sensorInterval, reportInterval);
      if (ret != 0) {
            printf("SetBatch failed\n ,ret: %d",ret);
            continue;
      }
      printf("SetBatch success\n");

      /* 5.使能传感器 */
      ret = g_sensorDev->Enable(sensorInfo.sensorId);
      if (ret != 0) {
            continue;
      }
   printf("Enable success\n");

   usleep(1000 * 1000);

      /* 6.去使能传感器 */
      ret = g_sensorDev->Disable(sensorInfo.sensorId);
      if (ret != 0) {
            continue;
      }
      printf("Disable success\n");
    }

    /* 7.取消传感器数据订阅函数 */
    ret = g_sensorDev->Unregister(TRADITIONAL_SENSOR_TYPE, SensorDataCallback);
    if (ret != 0) {
      return;
    }
    printf("Unregister success\n");
}
<strong>c</strong>
[*] 编译文件gn参考代码如下：
import("//build/ohos.gni")
import("//build/test.gni")
import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni")

module_output_path = "drivers_peripheral_sensor/sensor"
ohos_unittest("sensor_test") {
module_out_path = module_output_path
sources = [ "sensor_test.cpp" ]
include_dirs = [
    "//drivers/peripheral/sensor/interfaces/include",
]
deps = [ "//drivers/peripheral/sensor/hal:hdi_sensor" ]

external_deps = [
    "c_utils:utils",
    "hdf_core:libhdf_utils",
    "hiviewdfx_hilog_native:libhilog",
]

cflags = [
    "-Wall",
    "-Wextra",
    "-Werror",
    "-Wno-format",
    "-Wno-format-extra-args",
]

install_enable = true
install_images = [ "vendor" ]
module_install_dir = "bin"
part_name = "unionman_products"
}

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

查看完整版本: HarmonyOS鸿蒙开发 (5.0 ) Sensor驱动模型API接口