【入门到实战】OpenHarmony子系统外设驱动使用:Sensor

4.图像sensor的特性和驱动解析 例子:sensor驱动自己提供操作曝光时间的函数和获取曝光时间的函数,然后将这个函数注册到ISP库和3A算法库,3A算法库根据外部光照强度计算出一个Sensor曝光时间的设置值,ISP库得到这个设置值,然后通过Sensor之前注册的回调函数,把这个值设置到Sensor的硬件寄存器中去,实现整个过程。是为 ISP 配置正确的输入时序。(1)修改驱动源码(sambashar\Hi3518E_SDK_V1.0.3.0\package\mpp\component\isp\sensor\ar0130) 阅读详情

往期鸿蒙5.0全套实战文章必看:(文中附带全栈鸿蒙5.0学习资料)


概述

功能简介

Sensor驱动模型屏蔽硬件器件差异,为上层Sensor服务系统提供稳定的Sensor基础能力接口,包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅,Sensor参数配置等功能。Sensor设备驱动的开发是基于HDF驱动框架基础上,结合操作系统适配层(OSAL)和平台驱动接口(比如I2C/SPI/UART总线等平台资源)能力,屏蔽不同操作系统和平台总线资源差异,实现Sensor驱动“一次开发,多系统部署”的目标。Sensor驱动模型如图1所示。

图 1 Sensor驱动模型图

Sensor驱动模型图

基本概念

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

  • 医学类Sensor:已订阅的sensorId枚举值在128-160范围的为医学类Sensor。

  • 传统类Sensor:已订阅的sensorId枚举值不在128-160范围的为传统类Sensor。

运作机制

通过介绍Sensor驱动模型的加载以及运行流程,对模型内部关键组件以及关联组件之间的关系进行了划分,整体加载流程如图2所示:

图 2 Sensor驱动运行图

Sensor驱动运行图

Sensor驱动模型以标准系统RK3568产品中的加速度传感器驱动为例,介绍整个驱动加载及运行流程:

  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设备管理中。

开发指导

场景介绍

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

接口说明

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中不同器件的公共接口实现;传感器的差异化驱动开发包括不同器件差异化接口的实现。

  1. 开发加速度传感器抽象驱动。

    • 加速度传感器抽象驱动在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值相等
          }
      } 
      
    • 加速度传感器抽象驱动代码实现路径为: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);
        
      • 加速度传感器抽象驱动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;
        }
        
      • 加速度传感器抽象驱动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[0];
            drvData->cb = NULL;
        	
            HDF_LOGI("%s: Init accel driver success", __func__);
            return HDF_SUCCESS;
        }
        
      • 加速度抽象传感器驱动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);
        }
        
      • 加速度传感器抽象驱动内部接口代码实现如下:

        • 提供给差异化驱动的初始化接口,完成加速度传感器器件的基本配置信息解析(加速度传感器信息,加速度传感器总线配置,加速度传感器器件探测寄存器配置),器件探测,器件寄存器解析,具体实现如下:

          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;
          }
          
        • 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[SENSOR_ENABLE_GROUP]);
              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;
          }
          
        • 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[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;
          
              return HDF_SUCCESS;
          }
          
        • 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;
          }
          
        • 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;
          }
          
        • SetOption接口的代码实现如下:

          static int32_t SetAccelOption(uint32_t option)
          {
              (void)option;
              return HDF_SUCCESS;
          }
          
  2. 开发加速度传感器差异化驱动。

    • 加速度传感器差异化驱动在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值相等
          }
      }
      
    • 加速度传感器差异化驱动私有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:negative  0:positive
                       <map> 0:AXIS_X  1:AXIS_Y  2:AXIS_Z
                    */
                    /* sign[AXIS_X], sign[AXIS_Y], sign[AXIS_Z], map[AXIS_X], map[AXIS_Y], map[AXIS_Z] */
                    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
                    ];
                }
            }
        }
        
    • 加速度差异化驱动的代码实现路径: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);
        
      • 加速度传感器差异化驱动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;
        }
        
      • 加速度传感器差异化驱动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;
        }
        
      • 加速度传感器差异化驱动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);
        }
        
      • 加速度传感器差异化驱动内部接口实现。

        需要开发者实现的ReadMxc6655xaData接口函数,在 Mxc6655xaInitDriver函数里面注册此函数,具体实现如下:

        static int32_t ReadMxc6655xaRawData(struct SensorCfgData *data, struct AccelData *rawData, uint64_t *timestamp)
        {
            uint8_t status = 0;
            uint8_t reg[ACCEL_AXIS_BUTT];
            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[ACCEL_X_AXIS_LSB], sizeof(uint8_t));
            CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
        
            ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_X_MSB_ADDR, &reg[ACCEL_X_AXIS_MSB], sizeof(uint8_t));
            CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
        
            ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Y_LSB_ADDR, &reg[ACCEL_Y_AXIS_LSB], sizeof(uint8_t));
            CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
        
            ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Y_MSB_ADDR, &reg[ACCEL_Y_AXIS_MSB], sizeof(uint8_t));
            CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
        
            ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Z_LSB_ADDR, &reg[ACCEL_Z_AXIS_LSB], sizeof(uint8_t));
            CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
        
            ret = ReadSensor(&data->busCfg, MXC6655XA_ACCEL_Z_MSB_ADDR, &reg[ACCEL_Z_AXIS_MSB], sizeof(uint8_t));
            CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
        
            x = SensorConvertData(reg[ACCEL_X_AXIS_MSB], reg[ACCEL_X_AXIS_LSB]);
            y = SensorConvertData(reg[ACCEL_Y_AXIS_MSB], reg[ACCEL_Y_AXIS_LSB]);
            z = SensorConvertData(reg[ACCEL_Z_AXIS_MSB], reg[ACCEL_Z_AXIS_LSB]);
            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[ACCEL_AXIS_NUM];
        
            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[ACCEL_X_AXIS] = (rawData.x * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT;
            tmp[ACCEL_Y_AXIS] = (rawData.y * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT;
            tmp[ACCEL_Z_AXIS] = (rawData.z * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT;
        
            ret = SensorRawDataToRemapData(cfg->direction, tmp, sizeof(tmp) / sizeof(tmp[0]));
            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;
        }
        

调测验证

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

  • 参考测试代码如下:

    #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[i].sensorName, sensorInfo[i].vendorName, sensorInfo[i].sensorTypeId, sensorInfo[i].sensorId);
        }
    
        for (int i = 0; i < count; i++)
        {
            /* 4.设置传感器采样率 */
            ret = g_sensorDev->SetBatch(sensorInfo[i].sensorId, sensorInterval, reportInterval);
            if (ret != 0) {
                printf("SetBatch failed\n ,ret: %d",ret);
                continue;
            }
            printf("SetBatch success\n");
    
            /* 5.使能传感器 */
            ret = g_sensorDev->Enable(sensorInfo[i].sensorId);
            if (ret != 0) {
                continue;
            }
         printf("Enable success\n");
    
         usleep(1000 * 1000);
    
            /* 6.去使能传感器 */
            ret = g_sensorDev->Disable(sensorInfo[i].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");
    }
    
  • 编译文件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"
    }

海思3518E开发笔记4.4——sensor驱动源码分析 目录驱动目录 驱动目录 在SDK的\Hi3518E_SDK_V1.0.3.0\package\mpp\ko底下 hi3518e_isp.ko是isp相关部分驱动 sensor部分的源码在\Hi3518E_SDK_V1.0.3.0\package\mpp\component\isp\sensor中 可以通过Makefile看到编译出来的驱动 编出来的驱动放到了lib目录中 ... 阅读详情

相关推荐

Harmony鸿蒙南向外设驱动开发-Sensor

Sensor驱动模型屏蔽硬件器件差异,为上层Sensor服务系统提供稳定的Sensor基础能力接口,包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅,Sensor参数配置等功能

m0_64420071的博客 2003

图像sensor的特性和驱动解析视频教程-第4/11季-海思

本季课程以配置的2款图像sensor为案例来讲解图像sensor的关键特性和相关数据结构,I2C控制接口和图像数据接口,海思SDK中sensor的驱动框架和编译、部署、加载,sensor调试的一般方法和步骤等。

鸿蒙OpenHarmony【外设驱动使用之Sensor】 子系统

Sensor驱动模型屏蔽硬件器件差异,为上层Sensor服务系统提供稳定的Sensor基础能力接口,包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅,Sensor参数配置等功能。Sensor设备驱动的开发是基于HDF驱动框架基础上,结合操作系统适配层(OSAL)和平台驱动接口(比如I2C/SPI/UART总线等平台资源)能力,屏蔽不同操作系统和平台总线资源差异,实现Sensor驱动“一次开发,多系统部署”的目标。

zxc95279527q的博客 1085

第4季4:图像sensor的驱动源码解析

以下内容源于朱有鹏嵌入式课程的学习与整理,如有侵权请告知删除。

主要记录嵌入式学习与开发过程。 2095

OpenHarmony南向设备开发:子系统外设驱动使用-Sensor

Sensor驱动模型屏蔽硬件器件差异,为上层Sensor服务系统提供稳定的Sensor基础能力接口......

初一十五的博客 1011

鸿蒙南向设备开发(OpenHarmony)Sensor屏蔽硬件器件

Sensor驱动模型屏蔽硬件器件差异,为上层Sensor服务系统提供稳定的Sensor基础能力接口,包括Sensor列表查询、Sensor启停、Sensor订阅及取消订阅,Sensor参数配置等功能。Sensor设备驱动的开发是基于HDF驱动框架基础上,结合操作系统适配层(OSAL)和平台驱动接口(比如I2C/SPI/UART总线等平台资源)能力,屏蔽不同操作系统和平台总线资源差异,实现Sensor驱动“一次开发,多系统部署”的目标。

WEZC156465的博客 1111

OpenHarmony外设驱动使用 (十),Sensor

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

__Benco的博客 1517

OpenHarmony HDF传感器驱动开发

Sensor设备作为外接设备重要组成模块,Sensor驱动模型为上层Sensor服务系统提供稳定的Sensor基础能力接口,包括Sensor列表查询、Sensor使能释放、订阅去订阅、参数设置等。![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/7e89ef0e91c046a38c291de3bf2da24f.png#pic_centerHDI子模块,提供Sensor南向的标准接口定义和实现,其中包括:Dispatch、Register、Enable等。

weixin_62941746的博客 2053

OpenHarmony子系统详解

OpenHarmony子系统详解 【免费下载链接】docs OpenHarmony documentation | OpenHarmony开发者文档 项目地址: https://gitcode.com/openharmony/do...

gitblog_01128的博客 963

RTOS Sensor Framework对比

主流RTOS sensor框架对比

linchuanzhi_886的专栏 1797

OpenHarmony下MAX30100生理信号驱动开发实战

PPG(光电容积脉搏波)是可穿戴设备中获取心率、血氧等关键生理参数的基础信号,其采集依赖高精度、低延迟的传感器驱动。MAX30100作为典型I2C接口PPG传感器,需在OpenHarmony HDF驱动框架下完成设备树适配、中断管理、FIFO数据搬运与Sensor服务对接。本文围绕PPG信号采集原理,解析I2C地址自适应、边缘触发中断配置、环形缓冲区设计等核心工程约束,并结合HDF生命周期、SELinux权限模型与Sensor子系统上报规范,提供从寄存器级操作到标准API数据交付的完整落地路径,适用于嵌入式

weixin_32950759的博客 86

【入门到实战】OpenHarmony南向子系统开发:Sensor服务使用指南

Sensor服务使用.......

Androidbye的博客 371

【OpenHarmony实战开发】第23课-Hdf Framework

该仓主要存放驱动子系统核心源码信息(包括驱动框架、配置管理、配置解析、驱动通用框架模型、硬件通用平台能力接口等),旨在为开发者提供更精准、更高效的开发环境,力求做到一次开发,多系统部署。图 1驱动框架架构图[]()

xzs51job的专栏 257

openharmony5.0.0 sensor子系统详解(一)

OpenHarmony传感器子系统提供统一框架访问各类传感器数据,采用分层架构设计: 驱动框架层(HDF Core) - 提供传感器通用模型和基础驱动框架 传感器驱动层 - 实现具体传感器硬件操作(如加速度计、陀螺仪等) HDI接口层 - 定义标准化硬件抽象接口 传感器服务层 - 管理系统服务、数据处理和分发 传感器框架层 - 为应用提供统一API接口 系统支持JS和Native开发,具备权限控制、高效IPC和电源管理功能,实现从硬件到应用的完整数据流处理。

gkxg001的博客 1456

图学习——04.HAN(异构图注意力网络)

什么是异构图,什么是元路径,什么是HAN,怎么计算attention,节点级别的attention和语义级别的attention

m0_51474171的博客 3001

python blp模型 估计_随机系数Logit模型及Stata实现

欢迎投稿(荐稿)计量经济圈,计量相关都行邮箱:econometrics666@sina.cn作者:北京交通大学经济管理学院博士生,王琦珀。欢迎你加入计量经济圈社群,一起探讨前沿计量理论和实证方法。一、随机系数Logit模型1.背景实证产业组织(Empirical Industrial Organization,EIO)是目前产业组织理论的前沿,其中又以Ariel Pakes为带头人,其近期工作论文...

weixin_42298927的博客 2644

基于OpenHarmony系统HDF Sensor驱动开发

在产品开发时就需要对不同厂家或者同一厂家的不同型号进行适配开发,就会增加开发者的开发难度。为了快速开发或者移植传感器驱动,基于HDF(Hardware Driver Foundation)驱动框架开发了Sensor(传感器)驱动模型。Sensor驱动模型主要为上层提供稳定接口能力,对驱动开发者提供开放的接口实现和抽象的配置接口能力。

weixin_44699830的博客 1935

comfyui从入门到精通二:提示词规则详解

《AI绘画提示词使用全指南》摘要: 本文系统解析AI绘画提示词的核心规则与实用技巧。关键点包括:1) 空格与下划线的本质差异,webui会自动转换但comfyui保留原格式;2) 数字与单词表达(如1girl/one girl)会导致风格变化;3) 三种权重控制方式(数值标注、括号嵌套、位置效应),其中数值标注最直观有效;4) 位置衰减公式揭示提示词排序对效果的影响权重。同时指出当前AI绘画仍存在角色一致性等更复杂的技术瓶颈。全文通过多组对比实验,为创作者提供从基础语法到高阶控制的完整解决方案。

ScottePerk的博客 1936

摄像头驱动CAMERA SENSOR调试流程

【CAMERA SENSOR调试流程】 一、查看原理图,确认camera sensor的通讯接口,一般为MIPI居多。 一个camera 类型的MIPI接口也不复杂,由这几个信号组成: 【MIPI部分】 用于给CPU发送图像帧数据,分为高速模式和控制模式,高速模式用于图像帧数据发送,电压很低,功耗略高,电压在200mv左右。控制模式,电压在1.2V左右。又分别叫做HS(high speed)模式和LP(lower power)模式。 MIPI_MCLK ...

fanx9339的博客 7527

allegro 约束管理Constraint Manager(一)

介绍Cadence allegro 约束管理器CM的使用方法。

weixin_38975819的博客 8732

八大排序算法——(万字图文详解)

本篇博客将对“直接插入排序”、“希尔排序”、“直接选择排序”、“堆排序”、“冒泡排序”、“快速排序”、“归并排序”、“计数排序”进行详细的解析(算法逻辑、具体实现过程、时间复杂度、稳定性),并附以图片帮助大家更好地理解算法逻辑以及实现每个排序的参考代码。

Forward♞的博客 8079

OpenHarmony PIR人体感应驱动开发实战

PIR(被动红外)传感器是物联网中基础且广泛使用的存在检测器件,其核心原理是通过热释电效应感知人体红外辐射变化,并经BISS0001等专用IC调理为数字边沿信号。在OpenHarmony系统中,PIR不再仅是GPIO中断输入,而是需遵循HDF(硬件驱动框架)分层模型,完成platform驱动、host驱动、sensor_service及ArkTS应用的全栈适配。该过程涉及抗干扰滤波设计、HCS配置解耦、SENSOR_TYPE_HUMAN_PRESENCE标准事件契约、分布式IPC通信与权限管控等关键技术环节

weixin_33910137的博客 350

PyQt(Python+Qt)学习随笔:PyQt界面派生类构造方法中super方法的使用

老猿Python博文目录 专栏:使用PyQt开发图形界面Python应用 老猿Python博客地址 在《第15.7节 PyQt入门学习:PyQt5应用构建详细过程介绍》和订阅专栏《第二章、PyQt5应用构建详细过程介绍》中,老猿介绍界面派生类的构造方法如下: class MediaPlayerWin(QtWidgets.QWidget,Ui_UI_PlayerWin): def __i...

老猿Python 2711

OpenHarmony I2C驱动开发实战:从HDF框架到OLED屏幕适配

I2C总线凭借仅需两根线的简洁物理层,成为嵌入式设备连接传感器、屏幕和存储芯片的常用选择。它的开漏结构与复杂时序对工程调试提出了不小要求。在OpenHarmony系统中,I2C外设的适配需要遵循HDF驱动框架的规范,从设备配置文件到驱动入口再到应用层服务,形成一套完整的软硬件打通链路。本文从I2C的工作原理与总线特性切入,分析HDF驱动的层级关系与配置匹配方法,并结合OLED显示屏的实际适配过程,展示读写命令、显存传输的工程实现。同时总结大量真实排障案例,覆盖无ACK、SDA拉低、速率不稳、休眠唤醒失效等常

weixin_34293141的博客 449

已解决pywin32使用报错ImportError: DLL load failed while importing pywintypes: 找不到指定的模块。

已解决在安装pywin32库后import 引入win32com.client后,报错mod = importlib.util.module_from_spec(spec) ImportError: DLL load failed while importing pywintypes: 找不到指定的模块。

c1007857613的专栏 7046

Qt5+Ros+GUI界面

在之前建立的工程的基础上添加一个gui界面。 在ros包中新建一个文件夹,名字叫gui 右击gui文件夹添加一个文件,选择Qt->Qt设计师界面类 选择MainWindow 选择下一步 最后在gui中生成三个文件 mainwindow.cpp、mainwindow.h、mainwindow.ui 但此时,这些新创建的文件和原本的ros工程还没建立任何关系,只是目录下多出了几个文件而已...

二毛的博客 8849
上一篇: 【入门到实战】OpenHarmony子系统外设驱动使用:Pin_auth
下一篇: 【入门到实战】OpenHarmony子系统外设驱动使用:Touchscreen
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值