[文章] 【HarmonyOS HiSpark AI Camera试用连载】基于HDF驱动框架的gpio驱动 - HarmonyOS技术社区 - 电子技术论坛 - 广受欢迎的专业电子论坛
分享 收藏 返回

jf_64182030 关注 私信
[文章]

[文章] 【HarmonyOS HiSpark AI Camera试用连载】基于HDF驱动框架的gpio驱动

本帖最后由 jf_64182030 于 2020-12-29 23:35 编辑

参考文档：
  • GPIO概述
  • GPIO使用指导
  • GPIO使用实例

参考该源码实现类似linux的文件操作接口：file_operations_vfs。

在论坛里搜了一下，发现这位发烧友也是采用了file_operations_vfs的方式实现gpio控制，操作led灯的亮灭。


前言
现在有两种方式实现GPIO的控制：

方式一：通过register_driver的方式，注册file_operations_vfs的一些驱动操作接口，比如open、close、read、write、ioctl等等。这个方法几乎和Linux的驱动接口一模一样，很方便有Linux驱动经验的人员开发。

方式二：通过hdf服务的方式，应用通过服务名称获取服务句柄，然后通过API接口直接获取或者订阅该服务对应的驱动事件。用户空间将数据放在一段共享内存（HdfSBuf），然后将数据和cmd编号发送给内核空间的驱动；驱动也可以触发一个事件，通过一段共享内存（HdfSBuf）将内核空间的数据传递给用户空间，该事件会通知用户空间回调函数进行相应处理。

方式一的方法已经有官方和发烧友的参考例程了，这里就不单独来写了，本文将基于方式二进行说明。看起来方式一和方式二似乎是可以共存的，这个测试可能要放到后面的追加文章了。而且还有驱动如何从hcs配置文件里获取板级配置也还待确定一下。


1. 硬件
(1) LED_light/GPIO2_3
灯板上的D4 LED。

led-d4-sch.png
led-d4-sch1.png


(2) GPIO5_1/UART4_TXD
补光灯。
full-led-sch.png
full-led-sch1.png

(3) LSADC_CH0/GPIO10_3
红外检测。
ldr.png
ldr-sch.png

首先需要选取一个空闲的GPIO管脚，本例程基于Hi3516DV300某开发板，GPIO管脚选择GPIO10_3，换算成GPIO号为83。

Hi3516DV300控制器管理12组GPIO管脚，每组8个。
GPIO号 = GPIO组索引 (0~11) * 每组GPIO管脚数(8) + 组内偏移

举例：GPIO10_3的GPIO号 = 10 * 8 + 3 = 83


编写软件：
2. 在HDF框架的配置文件中添加该驱动的配置信息，如下所示：
$ vi ~/harmony/sdk/vendor/hisi/hi35xx/hi3516dv300/config/device_info/device_info.hcs
  1.         sample_host :: host {
  2.             hostName = "sample_host";
  3.             ...
  4.         }
  5. +++
  6.         gpio_host :: host {
  7.             hostName = "gpio_host";
  8.             gpio_device :: device {
  9.                 device0 :: deviceNode {
  10.                     policy = 2;
  11.                     priority = 100;
  12.                     preload = 0;
  13.                     permission = 0664;
  14.                     moduleName = "gpio_driver";
  15.                     serviceName = "gpio_service";
  16.                 }
  17.             }
  18.         }
  19. +++
  20.         platform :: host {


3. 编写驱动代码
3.1 基于HDF框架编写的gpio驱动代码如下：
$ mkdir -p ~/harmony/sdk/vendor/huawei/hdf/sample/platform/gpio-sample
$ vi ~/harmony/sdk/vendor/huawei/hdf/sample/platform/gpio-sample/gpio_sample.c
  1. #include
  2. #include
  3. #include
  4. #include "hdf_log.h"
  5. #include "hdf_base.h"
  6. #include "hdf_device_desc.h"
  7. #include "gpio_if.h"
  8. #include "osal_io.h"
  9. #include "osal_irq.h"
  10. #include "osal_time.h"

  12. #define HDF_LOG_TAG gpio_driver

  14. // 设置cmd编号，类似于Linux的ioctl命令码。
  15. #define CMD_GPIO_LDR_TEST                   100
  16. #define CMD_GPIO_LED_TEST                   101
  17. #define CMD_GPIO_FILL_LIGHT                 102
  18. // GPIO NUM
  19. #define GPIO_NUM_LDR_GPIO10_3               83  // 10*8+3
  20. #define GPIO_NUM_LED_GPIO2_3                19  // 2*8+3
  21. #define GPIO_NUM_FILL_LIGHT_GPIO5_1         41  // 5*8+1

  23. static uint32_t g_irqCnt;

  25. // 中断服务函数
  26. static int32_t TestCaseGpioIrqHandler(uint16_t gpio, void *data)
  27. {
  28.     HDF_LOGE("%s: irq triggered! on gpio:%u, data=%p", __func__, gpio, data);
  29.     g_irqCnt++; // 如果中断服务函数触发执行，则将全局中断计数加1
  30.     return GpioDisableIrq(gpio);
  31. }

  33. // 测试用例函数
  34. static int32_t gpio_test_ldr_irq_edge(void)
  35. {
  36.     int32_t ret;
  37.     uint16_t valRead;
  38.     uint16_t mode;
  39.     uint16_t gpio = GPIO_NUM_LDR_GPIO10_3; // 待测试的GPIO管脚号
  40.     uint32_t timeout;

  42.     // 将管脚方向设置为输出
  43.     ret = GpioSetDir(gpio, GPIO_DIR_OUT);
  44.     if (ret != HDF_SUCCESS) {
  45.         HDF_LOGE("%s: set dir fail! ret:%d
  46. ", __func__, ret);
  47.         return ret;
  48.     }

  50.     // 先禁止该管脚中断
  51.     ret = GpioDisableIrq(gpio);
  52.     if (ret != HDF_SUCCESS) {
  53.         HDF_LOGE("%s: disable irq fail! ret:%d
  54. ", __func__, ret);
  55.         return ret;
  56.     }

  58.     // 为管脚设置中断服务函数，触发模式为上升沿和下降沿共同触发
  59.     mode = OSAL_IRQF_TRIGGER_RISING | OSAL_IRQF_TRIGGER_FALLING;
  60.     HDF_LOGE("%s: mode:%0x
  61. ", __func__, mode);
  62.     ret = GpioSetIrq(gpio, mode, TestCaseGpioIrqHandler, NULL);
  63.     if (ret != HDF_SUCCESS) {
  64.         HDF_LOGE("%s: set irq fail! ret:%d
  65. ", __func__, ret);
  66.         return ret;
  67.     }

  69.     // 使能此管脚中断
  70.     ret = GpioEnableIrq(gpio);
  71.     if (ret != HDF_SUCCESS) {
  72.         HDF_LOGE("%s: enable irq fail! ret:%d
  73. ", __func__, ret);
  74.         (void)GpioUnSetIrq(gpio);
  75.         return ret;
  76.     }

  78.     g_irqCnt = 0; // 清除全局计数器
  79.     timeout = 0;  // 等待时间清零
  80.     // 等待此管脚中断服务函数触发，等待超时时间为1000毫秒
  81.     while (g_irqCnt <= 0 && timeout < 1000) {
  82.         (void)GpioRead(gpio, &valRead);
  83.         (void)GpioWrite(gpio, (valRead == GPIO_VAL_LOW) ? GPIO_VAL_HIGH : GPIO_VAL_LOW);
  84.         HDF_LOGE("%s: wait irq timeout:%u
  85. ", __func__, timeout);
  86.         OsalMDelay(200); // wait for irq trigger
  87.         timeout += 200;
  88.     }
  89.     (void)GpioUnSetIrq(gpio);
  90.     return (g_irqCnt > 0) ? HDF_SUCCESS : HDF_FAILURE;
  91. }

  93. static void gpio_test_led_blink(uint16_t gpio)
  94. {
  95.     int32_t ret;
  96.     int i = 0;

  98.     // 将管脚方向设置为输出
  99.     ret = GpioSetDir(gpio, GPIO_DIR_OUT);
  100.     if (ret != HDF_SUCCESS) {
  101.         HDF_LOGE("%s: set dir fail! ret:%d
  102. ", __func__, ret);
  103.     }
  104.     //HDF_LOGE("
  105. GpioSetDir GPIO_DIR_OUT");

  107.     for (i = 0; i < 3; i++) {
  108.         ret = GpioWrite(gpio, GPIO_VAL_HIGH);
  109.         if (ret != 0) {
  110.             HDF_LOGE("GpioWrite: failed, ret %d
  111. ", ret);
  112.         }
  113.         //HDF_LOGE("GpioWrite GPIO_VAL_HIGH");

  115.         //OsalMDelay(500); // 500ms, but OsalMDelay work is abnormal.
  116.         OsalMSleep(500);
  117.    
  118.         ret = GpioWrite(gpio, GPIO_VAL_LOW);
  119.         if (ret != 0) {
  120.             HDF_LOGE("GpioWrite: failed, ret %d
  121. ", ret);
  122.         }
  123.         //HDF_LOGE("GpioWrite GPIO_VAL_LOW");

  125.         //OsalMDelay(500); // 500ms
  126.         OsalMSleep(500);
  127.     }
  128. }

  130. // Dispatch是驱动中用来处理用户态发下来的消息的函数。
  131. static int32_t GpioSampleDriverDispatch(struct HdfDeviceIoClient *deviceIoClient, int id, struct HdfSBuf *data, struct HdfSBuf *reply)
  132. {
  133.     HDF_LOGE("%s: received cmd %d", __func__, id);

  135.     switch (id) {
  136.         case CMD_GPIO_LDR_TEST: { // 通常会采用switch case的方式来写。
  137.             const char *readData = HdfSbufReadString(data); // 内核从用户空间获取数据，类似Linux的copy_from_user。
  138.             if (readData != NULL) {
  139.                 HDF_LOGE("%s: read data is: %s", __func__, readData); // 内核打印从用户空间独到的数据。
  140.             }
  141.    
  142.             // GPIO中断检测
  143.             gpio_test_ldr_irq_edge();
  144.    
  145.             // 将向用户空间返回内容修改为字符串
  146.             char *sendData = "come from kernel sapce: CMD_GPIO_LDR_TEST";
  147.             if (!HdfSbufWriteString(reply, sendData)) {
  148.                 HDF_LOGE("%s: fail to write ***uf", __func__);
  149.             }
  150.    
  151.             // 通HdfDeviceSendEvent函数触发用户空间获取驱动上报数据。
  152.             return HdfDeviceSendEvent(deviceIoClient->device, id, data);
  153.         }

  155.         case CMD_GPIO_LED_TEST: {
  156.             const char *readData = HdfSbufReadString(data); // 内核从用户空间获取数据，类似Linux的copy_from_user。
  157.             if (readData != NULL) {
  158.                 HDF_LOGE("%s: read data is: %s", __func__, readData); // 内核打印从用户空间独到>的数据。
  159.             }

  161.             // GPIO test
  162.             gpio_test_led_blink(GPIO_NUM_LED_GPIO2_3);

  164.             // 将向用户空间返回内容修改为字符串
  165.             char *sendData = "come from kernel sapce: CMD_GPIO_LED_TEST";
  166.             if (!HdfSbufWriteString(reply, sendData)) {
  167.                 HDF_LOGE("%s: fail to write ***uf", __func__);
  168.             }

  170.             // 通HdfDeviceSendEvent函数触发用户空间获取驱动上报数据。
  171.             return HdfDeviceSendEvent(deviceIoClient->device, id, data);
  172.         }

  174.         case CMD_GPIO_FILL_LIGHT: {
  175.             const char *readData = HdfSbufReadString(data); // 内核从用户空间获取数据，类似Linux的copy_from_user。
  176.             if (readData != NULL) {
  177.                 HDF_LOGE("%s: read data is: %s", __func__, readData); // 内核打印从用户空间独到>的数据。
  178.             }

  180.             // GPIO test
  181.             gpio_test_led_blink(GPIO_NUM_FILL_LIGHT_GPIO5_1);

  183.             // 将向用户空间返回内容修改为字符串
  184.             char *sendData = "come from kernel sapce: CMD_GPIO_FILL_LIGHT";
  185.             if (!HdfSbufWriteString(reply, sendData)) {
  186.                 HDF_LOGE("%s: fail to write ***uf", __func__);
  187.             }

  189.             // 通HdfDeviceSendEvent函数触发用户空间获取驱动上报数据。
  190.             return HdfDeviceSendEvent(deviceIoClient->device, id, data);
  191.         }

  193.         default: {
  194.             HDF_LOGE("no such cmd id");
  195.             break;
  196.         }
  197.     }

  199.     return HDF_FAILURE;
  200. }

  202. // 驱动资源释放的接口，本例未分配需要回收的资源，因此为空。
  203. static void GpioSampleDriverRelease(struct HdfDeviceObject *deviceObject)
  204. {
  205.     // release resources here
  206.     return;
  207. }

  209. // 用户态获取驱动的服务，获取该服务之后通过服务中的Dispatch方法向驱动发送消息。
  210. static int GpioSampleDriverBind(struct HdfDeviceObject *deviceObject)
  211. {
  212.     if (deviceObject == NULL) {
  213.         return HDF_FAILURE;
  214.     }
  215.     static struct IDeviceIoService testService = {
  216.         // Dispatch是用来处理用户态发下来的消息。
  217.         .Dispatch = GpioSampleDriverDispatch,
  218.     };
  219.     deviceObject->service = &testService;
  220.     return HDF_SUCCESS;
  221. }

  223. // 驱动自身业务初始的接口。
  224. static int GpioSampleDriverInit(struct HdfDeviceObject *deviceObject)
  225. {
  226.     if (deviceObject == NULL) {
  227.         HDF_LOGE("%s::ptr is null!", __func__);
  228.         return HDF_FAILURE;
  229.     }
  230.     HDF_LOGE("gpio driver Init success");
  231.     return HDF_SUCCESS;
  232. }

  234. // 定义驱动入口的对象，必须为HdfDriverEntry（在hdf_device_desc.h中定义）类型的全局变量。
  235. struct HdfDriverEntry g_gpioSampleDriverEntry = {
  236.     .moduleVersion = 1,
  237.     .moduleName = "gpio_driver", // 驱动的关键名称。
  238.     .Bind = GpioSampleDriverBind,
  239.     .Init = GpioSampleDriverInit,
  240.     .Release = GpioSampleDriverRelease,
  241. };

  243. // 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,
  244. // 再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出。
  245. HDF_INIT(g_gpioSampleDriverEntry);

3.2 创建Kconfig
$ cd ~/harmony/sdk/vendor/huawei/hdf/sample/platform/gpio-sample
$ touch Kconfig && vi Kconfig
  1. # Copyright (c) 2020 Huawei Device Co., Ltd.
  2. # Licensed under the Apache License, Version 2.0 (the "License");
  3. # you may not use this file except in compliance with the License.
  4. # You may obtain a copy of the License at
  5. #
  6. #     http://www.apache.org/licenses/LICENSE-2.0
  7. #
  8. # Unless required by applicable law or agreed to in writing, software
  9. # distributed under the License is distributed on an "AS IS" BASIS,
  10. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11. # See the License for the specific language governing permissions and
  12. # limitations under the License.

  14. config DRIVERS_HDF_PLATFORM_GPIO_SAMPLE
  15.     bool "Enable HDF platform GPIO sample driver"
  16.     default n
  17.     depends on DRIVERS_HDF_PLATFORM
  18.     help
  19.       Answer Y to enable HDF platform GPIO sample driver.
修改上层Kconfig
$ vi ~/harmony/sdk/vendor/huawei/hdf/Kconfig
  1. source "../../vendor/huawei/hdf/片 sample/platform/gpio-sample/Kconfig"

3.3 创建Makefile
$ cd ~/harmony/sdk/vendor/huawei/hdf/sample/platform/gpio-sample
$ touch Makefile && vi Makefile
  1. # Copyright (c) 2020 Huawei Device Co., Ltd.
  2. # Licensed under the Apache License, Version 2.0 (the "License");
  3. # you may not use this file except in compliance with the License.
  4. # You may obtain a copy of the License at
  5. #
  6. #     http://www.apache.org/licenses/LICENSE-2.0
  7. #
  8. # Unless required by applicable law or agreed to in writing, software
  9. # distributed under the License is distributed on an "AS IS" BASIS,
  10. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11. # See the License for the specific language governing permissions and
  12. # limitations under the License.

  14. include $(LITEOSTOPDIR)/config.mk
  15. include $(LITEOSTOPDIR)/../../drivers/hdf/lite/lite.mk

  17. MODULE_NAME := gpio_sample

  19. LOCAL_CFLAGS += $(HDF_INCLUDE)

  21. LOCAL_SRCS += gpio_sample.c

  23. # 警告需要关掉，不然unused的变量都会报错！
  24. #LOCAL_CFLAGS += -fstack-protector-strong -Wextra -Wall -Werror
  25. LOCAL_CFLAGS += -fstack-protector-strong

  27. include $(HDF_DRIVER)

3.4 将驱动模块加入编译
$ vi ~/harmony/sdk/vendor/huawei/hdf/hdf_vendor.mk
  1. LITEOS_BASELIB += -lgpio_sample
  2. LIB_SUBDIRS    += $(VENDOR_HDF_DRIVERS_ROOT)/sample/platform/gpio-sample
LITEOS_BASELIB中的hdf_sample为Makefile里的MODULE_NAME名字。

3.5 驱动编译
3.5.1 手动使能驱动源码编译：
$ vi ~/harmony/sdk/kernel/liteos_a/tools/build/config/debug/hi3516dv300_clang.config
  1. LOSCFG_DRIVERS_HDF_LCD=y
  2. LOSCFG_DRIVERS_HDF_LCD_ICN9700=y
  3. LOSCFG_DRIVERS_HDF_PLATFORM_HDF_SAMPLE=y
  4. +LOSCFG_DRIVERS_HDF_PLATFORM_GPIO_SAMPLE=y
让修改生效：
$ cd ~/harmony/sdk/kernel/liteos_a/
$ ./build.sh hi3516dv300 clang debug
  1. sh param:hi3516dv300,clang,debug

3.5.2 编译
$ cd ~/harmony/sdk/
$ python build.py ipcamera_hi3516dv300 -b debug
  1. ohos ipcamera_hi3516dv300 build success!

3.5.3 查看驱动模块gpio_sample存放位置：
~/harmony/sdk$ find -name gpio_sample
  1. ./out/ipcamera_hi3516dv300/obj/kernel/liteos_a/obj/vendor/huawei/hdf/sample/platform/gpio_sample


4. 编写用户程序和驱动交互代码
4.1 基于HDF框架编写的用户态程序和驱动交互的代码如下：
$ mkdir -p ~/harmony/sdk/vendor/huawei/hdf/sample/platform/gpio-sample/app
$ vi ~/harmony/sdk/vendor/huawei/hdf/sample/platform/gpio-sample/app/gpio_sample_app.c
  1. #include
  2. #include
  3. #include "hdf_log.h"
  4. #include "hdf_***uf.h"
  5. #include "hdf_io_service_if.h"
  6. #include
  7. #include
  8. #include
  9. #include

  11. #define HDF_LOG_TAG "gpio_sample_test"
  12. #define GPIO_SERVICE_NAME "gpio_service"  // 服务的关键名称。

  14. // 设置cmd编号，类似于Linux的ioctl命令码。
  15. #define CMD_GPIO_LDR_TEST                   100
  16. #define CMD_GPIO_LED_TEST                   101
  17. #define CMD_GPIO_FILL_LIGHT                 102
  18. // GPIO NUM
  19. #define GPIO_NUM_LDR_GPIO10_3               83  // 10*8+3
  20. #define GPIO_NUM_LED_GPIO2_3                19  // 2*8+3
  21. #define GPIO_NUM_FILL_LIGHT_GPIO5_1         41  // 5*8+1

  23. int g_replyFlag = 0;

  25. // 用户空间回调函数，驱动通过HdfDeviceSendEvent发送事件后，该函数将处理返回数据。
  26. static int OnDevEventReceived(void *priv,  uint32_t id, struct HdfSBuf *data)
  27. {
  28.     const char *string = HdfSbufReadString(data);
  29.     if (string == NULL) {
  30.         HDF_LOGE("fail to read string in event data");
  31.         g_replyFlag = 1;
  32.         return HDF_FAILURE;
  33.     }
  34.     HDF_LOGE("user space received:");
  35.     HDF_LOGE("%s: dev event received: %u %s",  (char *)priv, id, string);
  36.     g_replyFlag = 1;
  37.     return HDF_SUCCESS;
  38. }

  40. // 用户空间给内核驱动发送数据
  41. static int SendEvent(struct HdfIoService *serv, char *eventData, int cmd)
  42. {
  43.     int ret = 0;

  45.     // 获取系统分配的data ***uf。
  46.     struct HdfSBuf *data = HdfSBufObtainDefaultSize();
  47.     if (data == NULL) {
  48.         HDF_LOGE("fail to obtain ***uf data");
  49.         return 1;
  50.     }

  52.     // 获取系统分配的reply ***uf。
  53.     struct HdfSBuf *reply = HdfSBufObtainDefaultSize();
  54.     if (reply == NULL) {
  55.         HDF_LOGE("fail to obtain ***uf reply");
  56.         ret = HDF_DEV_ERR_NO_MEMORY;
  57.         goto out;
  58.     }

  60.     // 将用户空间目标数据放到***uf。
  61.     if (!HdfSbufWriteString(data, eventData)) {
  62.         HDF_LOGE("fail to write ***uf");
  63.         ret = HDF_FAILURE;
  64.         goto out;
  65.     }

  67.     // 通过驱动服务提供的Dispatch实现用户态应用和内核态驱动的信息交互。
  68.     switch (cmd) {
  69.         case 1: {
  70.             ret = serv->dispatcher->Dispatch(&serv->object, CMD_GPIO_LDR_TEST, data, reply);
  71.             if (ret != HDF_SUCCESS) {
  72.                 HDF_LOGE("fail to send service call");
  73.                 goto out;
  74.             }

  76.             break;
  77.         }

  79.         case 2: {
  80.             ret = serv->dispatcher->Dispatch(&serv->object, CMD_GPIO_LED_TEST, data, reply);
  81.             if (ret != HDF_SUCCESS) {
  82.                 HDF_LOGE("fail to send service call");
  83.                 goto out;
  84.             }

  86.             break;
  87.         }

  89.         case 3: {
  90.             ret = serv->dispatcher->Dispatch(&serv->object, CMD_GPIO_FILL_LIGHT, data, reply);
  91.             if (ret != HDF_SUCCESS) {
  92.                 HDF_LOGE("fail to send service call");
  93.                 goto out;
  94.             }

  96.             break;
  97.         }

  99.         default: {
  100.             HDF_LOGE("no such cmd");
  101.             break;
  102.         }
  103.     }

  105.     // 将***uf中获取到的字符串数据放到用户空间变量中。
  106.     const char *replyData = HdfSbufReadString(reply);
  107.     if (replyData == NULL) {
  108.         HDF_LOGE("fail to get service call reply");
  109.         ret = HDF_ERR_INVALID_OBJECT;
  110.         goto out;
  111.     }
  112.     HDF_LOGE("Get reply is: %s", replyData);
  113. out:
  114.     HdfSBufRecycle(data); // 释放用于数据中转的***uf
  115.     HdfSBufRecycle(reply); // 释放用于数据中转的***uf
  116.     return ret;
  117. }

  119. int main(int argc, char **argv)
  120. {
  121.     char *sendData = "come from user sapce: default event info";

  123.     if (argc != 2) {
  124.         HDF_LOGE("Usage:
  125. ./bin/gpio_sample_app 1        CMD_GPIO_LDR_TEST
  126. ./bin/gpio_sample_app 2        CMD_GPIO_LED_TEST
  127. ./bin/gpio_sample_app 3        CMD_GPIO_FILL_LIGHT");
  128.         return HDF_FAILURE;
  129.     }

  131.     // 用户态获取驱动的服务，获取该服务之后通过服务中的Dispatch方法向驱动发送消息。
  132.     struct HdfIoService *serv = HdfIoServiceBind(GPIO_SERVICE_NAME, 0);
  133.     if (serv == NULL) {
  134.         HDF_LOGE("fail to get service %s", GPIO_SERVICE_NAME);
  135.         return HDF_FAILURE;
  136.     }

  138.     // 注册订阅驱动服务的回调函数。
  139.     static struct HdfDevEventlistener listener = {
  140.         .callBack = OnDevEventReceived,
  141.         .priv ="Service0"
  142.     };

  144.     // 当对驱动（同一个host）加载的时机不感知时，可以通过HDF框架提供的订阅机制来订阅该驱动。
  145.     if (HdfDeviceRegisterEventListener(serv, &listener) != HDF_SUCCESS) {
  146.         HDF_LOGE("fail to register event listener");
  147.         return HDF_FAILURE;
  148.     }

  150.     // 用户空间给内核驱动发送数据
  151.     HDF_LOGE("user space send:");
  152.     HDF_LOGE("cmd: %s, send data is: %s", argv[1], sendData);
  153.     if (SendEvent(serv, sendData, atoi(argv[1]))) {
  154.         HDF_LOGE("fail to send event");
  155.         return HDF_FAILURE;
  156.     }

  158.     /* wait for event receive event finishing */
  159.     while (g_replyFlag == 0) {
  160.         sleep(1);
  161.     }

  163.     // 用户态程序注册接收驱动上报事件的操作方法。
  164.     if (HdfDeviceUnregisterEventListener(serv, &listener)) {
  165.         HDF_LOGE("fail to  unregister listener");
  166.         return HDF_FAILURE;
  167.     }

  169.     // 释放驱动服务。
  170.     HdfIoServiceRecycle(serv);
  171.     return HDF_SUCCESS;
  172. }

4.2 编写编译APP源码的BUILD.gn文件
$ vi ~/harmony/sdk/vendor/huawei/hdf/sample/platform/gpio-sample/app/BUILD.gn
  1. # Copyright (c) 2020 Huawei Device Co., Ltd.
  2. # Licensed under the Apache License, Version 2.0 (the "License");
  3. # you may not use this file except in compliance with the License.
  4. # You may obtain a copy of the License at
  5. #
  6. #     http://www.apache.org/licenses/LICENSE-2.0
  7. #
  8. # Unless required by applicable law or agreed to in writing, software
  9. # distributed under the License is distributed on an "AS IS" BASIS,
  10. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11. # See the License for the specific language governing permissions and
  12. # limitations under the License.

  14. import("//build/lite/config/component/lite_component.gni")
  15. import("//build/lite/ndk/ndk.gni")

  17. HDF_FRAMEWORKS = "//drivers/hdf/frameworks"

  19. executable("gpio_sample_app") {
  20.     sources = [
  21.         "gpio_sample_app.c"
  22.     ]

  24.     include_dirs = [
  25.         "$HDF_FRAMEWORKS/ability/***uf/include",
  26.         "$HDF_FRAMEWORKS/core/shared/include",
  27.         "$HDF_FRAMEWORKS/core/host/include",
  28.         "$HDF_FRAMEWORKS/core/master/include",
  29.         "$HDF_FRAMEWORKS/include/core",
  30.         "$HDF_FRAMEWORKS/include/utils",
  31.         "$HDF_FRAMEWORKS/utils/include",
  32.         "$HDF_FRAMEWORKS/include/osal",
  33.         "//third_party/bounds_checking_function/include",
  34.     ]

  36.     deps = [
  37.         "//drivers/hdf/lite/manager:hdf_core",
  38.         "//drivers/hdf/lite/adapter/osal/posix:hdf_posix_osal",
  39.     ]

  41.     public_deps = [
  42.         "//third_party/bounds_checking_function:libsec_shared",
  43.     ]
  44.     defines = [
  45.         "__USER__",
  46.     ]

  48.     cflags = [
  49.         "-Wall",
  50.         "-Wextra",
  51.     ]
  52. }

4.3 将hdf_sample_app.c加入编译
$ vi ~/harmony/sdk/build/lite/product/ipcamera_hi3516dv300.json
  1.     {
  2.       "name": "hdf",
  3.       "component": [
  4.         { "name": "posix", "dir": "//drivers/hdf/lite/posix:hdf_posix", "features":[] },
  5.         { "name": "manager", "dir": "//drivers/hdf/lite/manager:hdf_manager", "features":[] },
  6.         { "name": "wifi", "dir": "//vendor/huawei/hdf/wifi:wifi_firmware", "features":[] },
  7.         { "name": "display", "dir": "//vendor/huawei/hdf/display/hdi:hdi_display", "features":[] },
  8.         { "name": "input", "dir": "//vendor/huawei/hdf/input/hdi:hdi_input", "features":[] },
  9.         { "name": "hdf_sample", "dir": "//vendor/huawei/hdf/sample/platform/uart:hello_uart_sample", "features":[] },
  10.         { "name": "hdf_sample_app", "dir": "//vendor/huawei/hdf/sample/platform/hdf-sample/app:hdf_sample_app", "features":[] },
  11. +        { "name": "gpio_sample_app", "dir": "//vendor/huawei/hdf/sample/platform/gpio-sample/app:gpio_sample_app", "features":[] }
  12.       ]
  13.     },

4.4 应用编译
$ python build.py ipcamera_hi3516dv300 -b debug
$ vi out/ipcamera_hi3516dv300/build.log
  1. [1159/1348] clang obj/vendor/huawei/hdf/sample/platform/gpio-sample/app/gpio_sample_app.o
  2. [1162/1348] LLVM LINK ./bin/gpio_sample_app
通过上面的编译日志可以找到gpio_sample_app应用放在了系统的/bin目录：
  1. ./bin/gpio_sample_app


5. 烧录：
5.1 将系统bin文件拷贝到Windows共享目录中：
$ rm /mnt/hgfs/proj-harmony/images/out/ -rf
$ cp -rf out/ /mnt/hgfs/proj-harmony/images/

5.2 在HiTool工具中依次填入OHOS_Image.bin、rootfs.img、userfs.img的文件位置
E:Share_Spaceproj-harmonyimagesoutipcamera_hi3516dv300

bin_file.png
操作流程如下：
shunxu.png
解决windows-x86-64的PL2303驱动开机后无法使用的办法：每次开机后，在设备管理中找到有问题的设备，鼠标右键先卸载驱动，安装USB-to-Serial Comm Port.exe，要注意的是需要赶在驱动失效前用HiTool将串口占用，系统就不会提示驱动有问题了。
修改一下分区长度：
part.png
点击“烧写”按键后，控制台会提示重启目标板，重启后，系统就自动进入烧写了。

单板初次启动需要修改启动参数，重新上电后登陆会进入uboot中，如果分区位置没有变化则不用执行下面修改启动参数的指令。

hisilicon # setenv bootcmd "mmc read 0x0 0x80000000 0x800 0x3000; go 0x80000000";
hisilicon # setenv bootargs "console=ttyAMA0,115200n8 root=emmc fstype=vfat rootaddr=7M rootsize=15M rw";
hisilicon # saveenv
hisilicon # reset
重启后进入系统。

注释：表示设置启动参数，输出模式为串口输出，波特率为115200，数据位8，rootfs挂载于emmc器件，文件系统类型为vfat，“rootaddr=6M rootsize=14M rw”处对应填入rootfs.img的烧写起始位置与长度，此处与新增rootfs.img文件时所填大小必须相同。


6. 测试
在根目录下，在命令行输入下面命令执行写入的demo程序，显示成功结果如下所示。没执行一次gpio_sample_app将会触发1s时长的红外检测，超时将会自动退出检测。
  1. OHOS # ./bin/gpio_sample_app
  2. // 用户空间给内核驱动发送数据
  3. [HDF:E/"gpio_sample_test"]user space send:
  4. [HDF:E/"gpio_sample_test"]cmd: 1, send data is: come from user sapce: default event info
  5. // 被驱动中用来处理用户态发下来的消息的函数HdfSampleDriverDispatch接收到
  6. [ERR][HDF:E/gpio_driver]GpioSampleDriverDispatch: received cmd 100
  7. [ERR][HDF:E/gpio_driver]GpioSampleDriverDispatch: read data is: come from user sapce: default event info

  9. // gpio中断测试，此时需要将手放到LDR1的前面遮挡一次触发中断，否则驱动将会超时退出。
  10. // 设置模式：双边沿触发
  11. [ERR][HDF:E/gpio_driver]gpio_test_ldr_irq_edge: mode:3
  12. // TestCaseGpioIrqHandler()这个回调函数被执行，说明检测到中断
  13. [ERR][HDF:E/gpio_driver]TestCaseGpioIrqHandler: irq triggered! on gpio:83, data=(nil)
  14. // 在1000ms超时前已经检测到gpio中断
  15. [ERR][HDF:E/gpio_driver]gpio_test_ldr_irq_edge: wait irq timeout:0

  17. // 用户空间收到内核空间返回的数据
  18. [HDF:E/"gpio_sample_test"]Get reply is: come from kernel sapce: CMD_GPIO_LDR_TEST
  19. [HDF:E/"gpio_sample_test"]user space received:
  20. [HDF:E/"gpio_sample_test"]Service0: dev event received: 100 come from user sapce: default event info
  21. [HDF:E/hdf_syscall_adapter]event listener task exit

打印结果的截图：
帮助信息：
帮助信息.png
gpio中断检测成功：
gpio中断检测成功.png
gpio中断检测超时失败：
gpio中断检测失败.png
D4-LED控制：此时D4和处理器所在板子上的两颗绿色LED会闪烁三次。
D4-LED控制.png
补光灯控制：此时两颗红色补光灯会闪烁三次，之所以出现红色可能是该灯需要pwm控制，然后直接控制电平时输入电流太小导致的，这个也暂时没去验证，反正能亮灭就达到了测试目的。
补光灯控制.png


7. 附件：
修改过后的diff文件：
ubuntu@ubuntu20:~/harmony/sdk$ git diff> gpio_sample.diff

`
gpio_sample.zip (5.78 KB)
(下载次数: 2, 2020-12-29 23:26 上传)
led-d4.png

f8cdcd849380ce242398375cad5645c4

更多回帖

我也要说两句 回帖

相关经验

×
发帖