返回发烧友论坛
发 帖  

[文章]OpenHarmony：全流程讲解如何编写RTC平台驱动以及应用程序

老渔翁
2023-09-18 15:45:15
阅读量0
OpenHarmonyRTCRK3568
1
1


1、程序介绍
本程序是基于OpenHarmony标准系统编写的平台驱动案例：RTC
目前已在凌蒙派-RK3568开发板跑通。详细资料请参考官网：https://gitee.com/Lockzhiner-Ele ... platform_device_rtc
详细资料请参考官网：

  • RTC平台驱动开发
  • RTC应用程序开发
2、基础知识
2.1、RTC简介
RTC（real-time clock）为操作系统中的实时时钟设备，为操作系统提供精准的实时时间和定时报警功能。当设备下电后，通过外置电池供电，RTC继续记录操作系统时间；设备上电后，RTC提供实时时钟给操作系统，确保断电后系统时间的连续性。
2.2、RTC驱动开发
在HDF框架中，RTC的接口适配模式采用独立服务模式，在这种模式下，每一个设备对象会独立发布一个设备服务来处理外部访问，设备管理器收到API的访问请求之后，通过提取该请求的参数，达到调用实际设备对象的相应内部方法的目的。独立服务模式可以直接借助HDFDeviceManager的服务管理能力，但需要为每个设备单独配置设备节点，增加内存占用。
独立服务模式下，核心层不会统一发布一个服务供上层使用，因此这种模式下驱动要为每个控制器发布一个服务，具体表现为：

  • 驱动适动开发配者需要实现HdfDriverEntry的Bind钩子函数以绑定服务。

  • device_info.hcs文件中deviceNode的policy字段为1或2，不能为0。
2.2.1、RTC驱动开发接口
为了保证上层在调用RTC接口时能够正确的操作硬件，核心层在//drivers/hdf_core/framework/support/platform/include/rtc/rtc_core.h中定义了以下钩子函数。驱动适配者需要在适配层实现这些函数的具体功能，并与这些钩子函数挂接，从而完成接口层与核心层的交互。
RtcMethod定义：
  1. <div align="left">struct RtcMethod {</div><div align="left">    int32_t (*ReadTime)(struct RtcHost *host, struct RtcTime *time);</div><div align="left">    int32_t (*WriteTime)(struct RtcHost *host, const struct RtcTime *time);</div><div align="left">    int32_t (*ReadAlarm)(struct RtcHost *host, enum RtcAlarmIndex alarmIndex, struct RtcTime *time);</div><div align="left">    int32_t (*WriteAlarm)(struct RtcHost *host, enum RtcAlarmIndex alarmIndex, const struct RtcTime *time);</div><div align="left">    int32_t (*RegisterAlarmCallback)(struct RtcHost *host, enum RtcAlarmIndex alarmIndex, RtcAlarmCallback cb);</div><div align="left">    int32_t (*AlarmInterruptEnable)(struct RtcHost *host, enum RtcAlarmIndex alarmIndex, uint8_t enable);</div><div align="left">    int32_t (*GetFreq)(struct RtcHost *host, uint32_t *freq);</div><div align="left">    int32_t (*SetFreq)(struct RtcHost *host, uint32_t freq);</div><div align="left">    int32_t (*Reset)(struct RtcHost *host);</div><div align="left">    int32_t (*ReadReg)(struct RtcHost *host, uint8_t usrDefIndex, uint8_t *value);</div><div align="left">    int32_t (*WriteReg)(struct RtcHost *host, uint8_t usrDefIndex, uint8_t value);</div><div align="left">};</div>
复制代码
RtcMethod结构体成员的钩子函数功能说明：
微信截图_20230918135400.png
2.2.2、RTC驱动开发步骤
RTC模块适配HDF框架包含以下四个步骤：

  • 实例化驱动入口。
  • 配置属性文件。
  • 实例化RTC控制器对象。
  • 驱动调试。
我们以//drivers/hdf_core/adapter/khdf/linux/platform/rtc/rtc_adapter.c为例（该rtc驱动是建立于Linux rtc子系统基础上创建）。
2.2.2.1、驱动实例化驱动入口
驱动入口必须为HdfDriverEntry（在hdf_device_desc.h中定义）类型的全局变量，且moduleName要和device_info.hcs中保持一致。
HDF框架会将所有加载的驱动的HdfDriverEntry对象首地址汇总，形成一个类似数组的段地址空间，方便上层调用。
一般在加载驱动时HDF会先调用Bind函数，再调用Init函数加载该驱动。当Init调用异常时，HDF框架会调用Release释放驱动资源并退出。
rtc驱动入口参考：
  1. <div align="left">struct HdfDriverEntry g_rtcDriverEntry = {</div><div align="left">    .moduleVersion = 1,</div><div align="left">    .Bind = HiRtcBind,</div><div align="left">    .Init = HiRtcInit,</div><div align="left">    .Release = HiRtcRelease,</div><div align="left">    .moduleName = "HDF_PLATFORM_RTC",<span style="white-space:pre;">        </span>//【必要且与HCS文件中里面的moduleName匹配】</div><div align="left">};</div><div align="left">/* 调用HDF_INIT将驱动入口注册到HDF框架中 */</div><div align="left">HDF_INIT(g_rtcDriverEntry);</div>
复制代码
2.2.2.2、配置属性文件
deviceNode信息与驱动入口注册相关，器件属性值与核心层RTCCntlr成员的默认值或限制范围有密切关系。
本例只有一个RTC控制器，如有多个器件信息，则需要在device_info.hcs文件增加deviceNode信息。
本次案例以rk3568为案例（即文件//vendor/lockzhiner/rk3568/hdf_config/khdf/device_info/device_info.hcs），添加deviceNode描述，具体修改如下：
  1. <div align="left"><span style="font-size:18px;">device_rtc :: device {</span></div><div align="left"><span style="font-size:18px;">    device0 :: deviceNode {</span></div><div align="left"><span style="font-size:18px;">        policy = 2;<span style="white-space:pre;">                                                        </span>// 驱动服务发布的策略，policy大于等于1（用户态可见为2，仅内核态可见为1）</span></div><div align="left"><span style="font-size:18px;">        priority = 30;<span style="white-space:pre;">                                                </span>// 驱动启动优先级</span></div><div align="left"><span style="font-size:18px;">        permission = 0644;<span style="white-space:pre;">                                        </span>// 驱动创建设备节点权限</span></div><div align="left"><span style="font-size:18px;">        moduleName = "HDF_PLATFORM_RTC";<span style="white-space:pre;">        </span>// 驱动名称，该字段的值必须和驱动入口结构的moduleName值一致</span></div><div align="left"><span style="font-size:18px;">        serviceName = "HDF_PLATFORM_RTC";<span style="white-space:pre;">        </span>// 驱动对外发布服务的名称，必须唯一</span></div><div align="left"><span style="font-size:18px;">        deviceMatchAttr = "";<span style="white-space:pre;">                                </span>// 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值一致</span></div><div align="left"><span style="font-size:18px;">    }</span></div><div align="left"><span style="font-size:18px;">}</span></div>
复制代码
2.2.2.3、实例化RTC控制器对象
完成属性文件配置之后，下一步就是以核心层RtcHost对象的初始化为核心，包括驱动适配者自定义结构体（传递参数和数据），实例化RtcHost成员RtcMethod（让用户可以通过接口来调用驱动底层函数），实现HdfDriverEntry成员函数（Bind、Init、Release）。
RtcHost成员钩子函数结构体RtcMethod的实例化，其他成员在Init函数中初始化。
2.2.2.3.png
2.2.2.4、驱动调试
建议先在Linux下修改确认，再移植到OpenHarmony。
2.3、RTC应用开发
RTC主要用于提供实时时间和定时报警功能。
2.3.1、接口说明
RTC模块提供的主要接口如表1所示，具体API详见//drivers/hdf_core/framework/include/platform/rtc_if.h。
RTC驱动API接口功能介绍如下所示：
微信截图_20230918135823.png
（1）RtcOpen
RTC驱动加载成功后，使用驱动框架提供的查询接口并调用RTC设备驱动接口。
  1. DevHandle RtcOpen(void);
复制代码
RtcOpen参数定义如下：
微信截图_20230918135916.png
RtcOpen返回值定义如下：
微信截图_20230918135937.png
假设系统中的RTC设备总线号为0，片选号为0，获取该RTC设备句柄的示例如下：
（1）.png
（2）RtcClose
销毁RTC设备句柄，系统释放对应的资源。
  1. void RtcClose(DevHandle handle);
复制代码
RtcClose返回值定义如下：
微信截图_20230918140139.png
（3）RtcReadTime
系统从RTC读取时间信息，包括年、月、星期、日、时、分、秒、毫秒。
  1. int32_t RtcReadTime(DevHandle handle, struct RtcTime *time);
复制代码
RtcReadTime参数定义如下：
微信截图_20230918140227.png
RtcReadTime返回值定义如下：
微信截图_20230918140249.png
（4）RtcWriteTime
设置RTC时间。
  1. int32_t RtcWriteTime(DevHandle handle, struct RtcTime *time);
复制代码
RtcWriteTime参数定义如下：
微信截图_20230918140330.png

RtcWriteTime返回值定义如下：
微信截图_20230918140352.png

（5）RtcReadAlarm
从rtc模块中读取定时报警时间。
  1. int32_t RtcReadAlarm(DevHandle handle, enum RtcAlarmIndex alarmIndex, struct RtcTime *time);
复制代码
RtcReadAlarm参数定义如下：
微信截图_20230918140431.png

RtcReadAlarm返回值定义如下：
微信截图_20230918140451.png

（6）RtcWriteAlarm
根据报警索引设置RTC报警时间。
  1. int32_t RtcWriteAlarm(DevHandle handle, enum RtcAlarmIndex  alarmIndex, struct RtcTime \*time);
复制代码
RtcWriteAlarm参数定义如下：
微信截图_20230918140547.png

RtcWriteAlarm返回值定义如下：
微信截图_20230918140607.png

（7）RtcRegisterAlarmCallback
系统启动后需要注册RTC定时报警回调函数，报警超时后触发回调函数。
  1. int32_t RtcRegisterAlarmCallback(DevHandle handle, enum RtcAlarmIndex alarmIndex, RtcAlarmCallback cb);
复制代码
RtcRegisterAlarmCallback参数定义如下：
微信截图_20230918140645.png

RtcRegisterAlarmCallback返回值定义如下：
微信截图_20230918140705.png

（8）RtcAlarmInterruptEnable
在启动报警操作前，需要先设置报警中断使能，报警超时后会触发告警回调函数。
  1. int32_t RtcAlarmInterruptEnable(DevHandle handle, enum RtcAlarmIndex alarmIndex, uint8_t enable);
复制代码
RtcAlarmInterruptEnable参数定义如下：
微信截图_20230918140744.png

RtcAlarmInterruptEnable返回值定义如下：
微信截图_20230918140805.png

2.2.2、开发流程
使用rtc的一般流程如下图所示：
RTC设备使用流程图.png

3、程序解析
3.1、准备工作
无
3.2、Linux内核解析
3.2.1、创建Linux内核Git
请参考《OpenHarmony如何为内核打patch》（即Git仓库的//docs/OpenHarmony如何为内核打patch.docx）。
3.2.2、修改设备树PWM7配置
修改//arch/arm64/boot/dts/rockchip/rk3568-lockzhiner-x0.dtsi（即该目录是指已打Patch后的Linux内核，不是OpenHarmony主目录），具体如下所示：
  1. &amp;i2c5 {
  2.         status = "okay";
  3.         ......
  4.         
  5.         hym8563: hym8563@51 {
  6.                 compatible = "haoyu,hym8563";
  7.                 reg = &lt;0x51&gt;;
  8.                 pinctrl-names = "default";
  9.                 pinctrl-0 = <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>&amp;rtc_int</span><span class="token punctuation">&gt;</span></span>;
  11.                 interrupt-parent = <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>&amp;gpio0</span><span class="token punctuation">&gt;</span></span>;
  12.                 interrupts = <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>RK_PD3</span> <span class="token attr-name">IRQ_TYPE_LEVEL_LOW</span><span class="token punctuation">&gt;</span></span>;
  13.         };
  14. }
复制代码
设备树中默认是开启rtc模块的hym8563，读者不用修改。
3.2.3、创建内核patch
请参考《OpenHarmony如何为内核打patch》（即Git仓库的//docs/OpenHarmony如何为内核打patch.docx）。
3.2.4、替换OpenHarmony的内核patch
将制作出的kernel.patch替换到//kernel/linux/patches/linux-5.10/rk3568_patch/kernel.patch即可。
3.2.5、开启内核配置
修改///kernel/linux/config/linux-5.10/arch/arm64/configs/rk3568_standard_defconfig（即该目录是指OpenHarmony主目录），将CONFIG_DRIVERS_HDF_PLATFORM_RTC功能开启，具体如下所示：
  1. CONFIG_DRIVERS_HDF_PLATFORM_RTC=y
复制代码
另外，Linux配置文件中需要定义rtc设备名称定义，具体如下所示：
  1. CONFIG_RTC_SYSTOHC_DEVICE="rtc0"
复制代码
3.3、OpenHarmony配置树配置
3.3.1、device_info.hcs
  1. <p>//vendor/lockzhiner/rk3568/hdf_config/khdf/device_info/device_info.hcs已定义好，具体如下：</p>device_rtc :: device {
  2.     device0 :: deviceNode {
  3.         policy = 2;
  4.         priority = 30;
  5.         permission = 0644;
  6.         moduleName = "HDF_PLATFORM_RTC";
  7.         serviceName = "HDF_PLATFORM_RTC";
  8.         deviceMatchAttr = "";
  9.     }
  10. }
复制代码
注意：

  • device0是rtc模块，一般只需要1个rtc设备即可。
  • policy必须为2，表示对内核态和用户态提供服务。否则，应用程序无法调用。
3.4、OpenHarmony RTC平台驱动
在//drivers/hdf_core/adapter/khdf/linux/platform/rtc/rtc_adapter.c已编写对接Linux RTC驱动的相关代码，具体内容如下：
  1. static inline void HdfTimeToLinuxTime(const struct RtcTime *hdfTime, struct rtc_time *linuxTime)
  2. {
  3.     linuxTime-&gt;tm_sec = hdfTime-&gt;second;
  4.     linuxTime-&gt;tm_min = hdfTime-&gt;minute;
  5.     linuxTime-&gt;tm_hour = hdfTime-&gt;hour;
  6.     linuxTime-&gt;tm_mday = hdfTime-&gt;day;
  7.     linuxTime-&gt;tm_mon = hdfTime-&gt;month - MONTH_DIFF;
  8.     linuxTime-&gt;tm_year = hdfTime-&gt;year - YEAR_BASE;
  9.     linuxTime-&gt;tm_wday = hdfTime-&gt;weekday;
  10.     linuxTime-&gt;tm_yday = rtc_year_days(linuxTime-&gt;tm_mday, linuxTime-&gt;tm_mon, linuxTime-&gt;tm_year);
  11. }
  13. static inline void LinuxTimeToHdfTime(struct RtcTime *hdfTime, const struct rtc_time *linuxTime)
  14. {
  15.     hdfTime-&gt;second = linuxTime-&gt;tm_sec;
  16.     hdfTime-&gt;minute = linuxTime-&gt;tm_min;
  17.     hdfTime-&gt;hour = linuxTime-&gt;tm_hour;
  18.     hdfTime-&gt;day = linuxTime-&gt;tm_mday;
  19.     hdfTime-&gt;month = linuxTime-&gt;tm_mon + MONTH_DIFF;
  20.     hdfTime-&gt;year = linuxTime-&gt;tm_year + YEAR_BASE;
  21.     hdfTime-&gt;weekday = linuxTime-&gt;tm_wday;
  22. }
  24. // 获取Linux环境下的rtc设备接口
  25. static inline struct rtc_device *HdfGetRtcDevice(void)
  26. {
  27.     // 获取Linux环境下的rtc设备接口
  28.     struct rtc_device *dev = rtc_class_open(CONFIG_RTC_SYSTOHC_DEVICE);
  29.     if (dev == NULL) {
  30.         HDF_LOGE("%s: failed to get rtc device", __func__);
  31.     }
  32.     return dev;
  33. }
  35. // 释放Linux环境下的rtc设备接口
  36. static inline void HdfPutRtcDevice(struct rtc_device *dev)
  37. {
  38.     rtc_class_close(dev);
  39. }
  41. static int32_t HiRtcReadTime(struct RtcHost *host, struct RtcTime *hdfTime)
  42. {
  43.     int32_t ret;
  44.     struct rtc_time linuxTime = {0};
  45.     struct rtc_device *dev = HdfGetRtcDevice();                // 获取Linux环境下的rtc设备接口
  47.     (void)host;
  48.     if (dev == NULL) {
  49.         return HDF_FAILURE;
  50.     }
  51.     ret = rtc_read_time(dev, &amp;linuxTime);                        // 直接对Linux环境下的rtc设备接口进行读操作
  52.     if (ret &lt; 0) {
  53.         HDF_LOGE("%s: rtc_read_time error, ret is %d", __func__, ret);
  54.         return ret;
  55.     }
  56.     HdfPutRtcDevice(dev);
  57.     LinuxTimeToHdfTime(hdfTime, &amp;linuxTime);
  58.     return HDF_SUCCESS;
  59. }
复制代码
该部分代码不细述，感兴趣的读者可以去详读。
3.5、应用程序
3.5.1、rtc_test.crtc
相关头文件如下所示：
  1. #include "rtc_if.h"                 // rtc标准接口头文件
复制代码
主函数定义RTC接口调用，具体如下：
  1. int main(int argc, char* argv[])
  2. {
  3.     int32_t ret = 0;
  4.     DevHandle handle = NULL;
  5.     struct RtcTime curTime;
  6.     struct RtcTime alarmTime;
  8.     // 获取RTC设备句柄
  9.     handle = RtcOpen();
  10.     if (handle == NULL) {
  11.         PRINT_ERROR("RtcOpen failed\n");
  12.         return -1;
  13.     }
  15.     // 读取RTC实时时间
  16.     ret = RtcReadTime(handle, &amp;curTime);
  17.     if (ret != 0) {
  18.         PRINT_ERROR("RtcReadTime failed and ret = %d\n", ret);
  19.         goto out;
  20.     }
  21.     printf("RtcReadTime successful\n");
  22.     printf("    year        = %d\n", curTime.year);
  23.     printf("    month       = %d\n", curTime.month);
  24.     printf("    day         = %d\n", curTime.day);
  25.     printf("    hour        = %d\n", curTime.hour);
  26.     printf("    minute      = %d\n", curTime.minute);
  27.     printf("    second      = %d\n", curTime.second);
  28.     printf("    millisecond = %d\n", curTime.millisecond);
  29.    
  30.     // 设置RTC时间
  31.     curTime.year = 2023;
  32.     curTime.month = 8;
  33.     curTime.day = 28;
  34.     curTime.hour = 17;
  35.     curTime.minute = 45;
  36.     curTime.second = 0;
  37.     curTime.millisecond = 0;
  38.     // 写RTC时间信息
  39.     ret = RtcWriteTime(handle, &amp;curTime);
  40.     if (ret != 0) {
  41.         PRINT_ERROR("RtcWriteTime failed and ret = %d\n", ret);
  42.         goto out;
  43.     }
  44.     printf("RtcWriteTime successful\n");
  45.     printf("    year        = %d\n", curTime.year);
  46.     printf("    month       = %d\n", curTime.month);
  47.     printf("    day         = %d\n", curTime.day);
  48.     printf("    hour        = %d\n", curTime.hour);
  49.     printf("    minute      = %d\n", curTime.minute);
  50.     printf("    second      = %d\n", curTime.second);
  51.     printf("    millisecond = %d\n", curTime.millisecond);
  53.     // 该部分代码，驱动尚未完成
  54. #if 0
  55.     // 注册报警A的定时回调函数
  56.     ret = RtcRegisterAlarmCallback(handle, RTC_ALARM_INDEX_A, RtcAlarmCallback_DefaultFunc);
  57.     if (ret != 0) {
  58.         PRINT_ERROR("RtcRegisterAlarmCallback failed and ret = %d\n", ret);
  59.         goto out;
  60.     }
  62.     // 设置RTC报警时间
  63.     alarmTime.year = curTime.year;
  64.     alarmTime.month = curTime.month;
  65.     alarmTime.day = curTime.day;
  66.     alarmTime.hour = curTime.hour;
  67.     alarmTime.minute = curTime.minute;
  68.     alarmTime.second = curTime.second + SLEEP_SEC;
  69.     alarmTime.millisecond = curTime.millisecond;
  70.     // 设置RTC_ALARM_INDEX_A索引定时器报警
  71.     ret = RtcWriteAlarm(handle, RTC_ALARM_INDEX_A, &amp;alarmTime);
  72.     if (ret != 0) {
  73.         PRINT_ERROR("RtcWriteAlarm failed and ret = %d\n", ret);
  74.         goto out;
  75.     }
  77.     // 设置RTC报警中断使能
  78.     ret = RtcAlarmInterruptEnable(handle, RTC_ALARM_INDEX_A, 1);
  79.     if (ret != 0) {
  80.         PRINT_ERROR("RtcAlarmInterruptEnable failed and ret = %d\n", ret);
  81.         goto out;
  82.     }
  84.     sleep(SLEEP_SEC + 5);
  85. #endif
  87. out:
  88.     RtcClose(handle);
  89.     return ret;
  90. }
复制代码
注意：由于目前rtc平台驱动没有定义rtc定时器响应函数接口，故rtc定时回调功能暂时关闭
3.5.2、BUILD.gn
编写应用程序的BUILD.gn，具体内容如下：
  1. import("//build/ohos.gni")
  2. import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni")
  4. print("samples: compile rk3568_rtc_test")
  5. ohos_executable("rk3568_rtc_test") {
  6.   sources = [ "rtc_test.c" ]
  7.   include_dirs = [
  8.     "$hdf_framework_path/include",
  9.     "$hdf_framework_path/include/core",
  10.     "$hdf_framework_path/include/osal",
  11.     "$hdf_framework_path/include/platform",
  12.     "$hdf_framework_path/include/utils",
  13.     "$hdf_uhdf_path/osal/include",
  14.     "$hdf_uhdf_path/ipc/include",
  15.     "//base/hiviewdfx/hilog/interfaces/native/kits/include",
  16.     "//third_party/bounds_checking_function/include",
  17.   ]
  19.   deps = [
  20.     "$hdf_uhdf_path/platform:libhdf_platform",
  21.     "$hdf_uhdf_path/utils:libhdf_utils",
  22.     "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog",
  23.   ]
  25.   cflags = [
  26.     "-Wall",
  27.     "-Wextra",
  28.     "-Werror",
  29.     "-Wno-format",
  30.     "-Wno-format-extra-args",
  31.   ]
  33.   part_name = "product_rk3568"
  34.   install_enable = true
  35. }
复制代码
3.5.3、参与应用程序编译
编辑//vendor/lockzhiner/rk3568/samples/BUILD.gn，开启编译选项。具体如下：
  1. "b09_platform_device_rtc/app:rk3568_rtc_test",
复制代码
4、程序编译
建议使用docker编译方法，运行如下：
  1. hb set -root .
  2. hb set
  3. # 选择lockzhiner下的rk3568编译分支。
  4. hb build -f
复制代码
5、运行结果
运行如下：
  1. # rk3568_rtc_test
  2. RtcReadTime successful
  3.     year        = 2017
  4.     month       = 8
  5.     day         = 5
  6.     hour        = 10
  7.     minute      = 58
  8.     second      = 9
  9.     millisecond = 0
  10. RtcWriteTime successful
  11.     year        = 2023
  12.     month       = 8
  13.     day         = 28
  14.     hour        = 17
  15.     minute      = 45
  16.     second      = 0
  17.     millisecond = 0
  18. #
复制代码
开发板重启，可以发现系统相关时间已经变更为我们案例中的配置。







举报

回帖

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容图片侵权或者其他问题，请联系本站作侵删。 侵权投诉
链接复制成功，分享给好友