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

2020-12-29 23:24:34  180 HiSpark Camera HarmonyOS Hi3516 鸿蒙系统
分享
0
本帖最后由 jf_64182030 于 2020-12-29 23:35 编辑

参考文档:
  • GPIO链接:https://gitee.com/openharmony/docs/blob/master/driver/GPIO.md
  • GPIO概述
  • GPIO使用指导
  • GPIO使用实例

  • Touchscreen开发实例 https://gitee.com/openharmony/docs/blob/master/driver/Touchscreen%E5%BC%80%E5%8F%91%E5%AE%9E%E4%BE%8B.md
参考该源码实现类似linux的文件操作接口:file_operations_vfs。

  • 第六次情迷-鸿蒙OS的GPIO开发(点灯) https://home.elecfans.com/jishu_2023276_1_1.html
论坛里搜了一下,发现这位发烧友也是采用了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.png
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 <fcntl.h>
  2. #include <sys/stat.h>
  3. #include <sys/ioctl.h>
  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"

  11. #define HDF_LOG_TAG gpio_driver

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

  20. static uint32_t g_irqCnt;

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

  28. // 测试用例函数
  29. static int32_t gpio_test_ldr_irq_edge(void)
  30. {
  31.     int32_t ret;
  32.     uint16_t valRead;
  33.     uint16_t mode;
  34.     uint16_t gpio = GPIO_NUM_LDR_GPIO10_3; // 待测试的GPIO管脚号
  35.     uint32_t timeout;

  36.     // 将管脚方向设置为输出
  37.     ret = GpioSetDir(gpio, GPIO_DIR_OUT);
  38.     if (ret != HDF_SUCCESS) {
  39.         HDF_LOGE("%s: set dir fail! ret:%d\n", __func__, ret);
  40.         return ret;
  41.     }

  42.     // 先禁止该管脚中断
  43.     ret = GpioDisableIrq(gpio);
  44.     if (ret != HDF_SUCCESS) {
  45.         HDF_LOGE("%s: disable irq fail! ret:%d\n", __func__, ret);
  46.         return ret;
  47.     }

  48.     // 为管脚设置中断服务函数,触发模式为上升沿和下降沿共同触发
  49.     mode = OSAL_IRQF_TRIGGER_RISING | OSAL_IRQF_TRIGGER_FALLING;
  50.     HDF_LOGE("%s: mode:%0x\n", __func__, mode);
  51.     ret = GpioSetIrq(gpio, mode, TestCaseGpioIrqHandler, NULL);
  52.     if (ret != HDF_SUCCESS) {
  53.         HDF_LOGE("%s: set irq fail! ret:%d\n", __func__, ret);
  54.         return ret;
  55.     }

  56.     // 使能此管脚中断
  57.     ret = GpioEnableIrq(gpio);
  58.     if (ret != HDF_SUCCESS) {
  59.         HDF_LOGE("%s: enable irq fail! ret:%d\n", __func__, ret);
  60.         (void)GpioUnSetIrq(gpio);
  61.         return ret;
  62.     }

  63.     g_irqCnt = 0; // 清除全局计数器
  64.     timeout = 0;  // 等待时间清零
  65.     // 等待此管脚中断服务函数触发,等待超时时间为1000毫秒
  66.     while (g_irqCnt <= 0 && timeout < 1000) {
  67.         (void)GpioRead(gpio, &valRead);
  68.         (void)GpioWrite(gpio, (valRead == GPIO_VAL_LOW) ? GPIO_VAL_HIGH : GPIO_VAL_LOW);
  69.         HDF_LOGE("%s: wait irq timeout:%u\n", __func__, timeout);
  70.         OsalMDelay(200); // wait for irq trigger
  71.         timeout += 200;
  72.     }
  73.     (void)GpioUnSetIrq(gpio);
  74.     return (g_irqCnt > 0) ? HDF_SUCCESS : HDF_FAILURE;
  75. }

  76. static void gpio_test_led_blink(uint16_t gpio)
  77. {
  78.     int32_t ret;
  79.     int i = 0;

  80.     // 将管脚方向设置为输出
  81.     ret = GpioSetDir(gpio, GPIO_DIR_OUT);
  82.     if (ret != HDF_SUCCESS) {
  83.         HDF_LOGE("%s: set dir fail! ret:%d\n", __func__, ret);
  84.     }
  85.     //HDF_LOGE("\nGpioSetDir GPIO_DIR_OUT");

  86.     for (i = 0; i < 3; i++) {
  87.         ret = GpioWrite(gpio, GPIO_VAL_HIGH);
  88.         if (ret != 0) {
  89.             HDF_LOGE("GpioWrite: failed, ret %d\n", ret);
  90.         }
  91.         //HDF_LOGE("GpioWrite GPIO_VAL_HIGH");

  92.         //OsalMDelay(500); // 500ms, but OsalMDelay work is abnormal.
  93.         OsalMSleep(500);
  94.    
  95.         ret = GpioWrite(gpio, GPIO_VAL_LOW);
  96.         if (ret != 0) {
  97.             HDF_LOGE("GpioWrite: failed, ret %d\n", ret);
  98.         }
  99.         //HDF_LOGE("GpioWrite GPIO_VAL_LOW");

  100.         //OsalMDelay(500); // 500ms
  101.         OsalMSleep(500);
  102.     }
  103. }

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

  108.     switch (id) {
  109.         case CMD_GPIO_LDR_TEST: { // 通常会采用switch case的方式来写。
  110.             const char *readData = HdfSbufReadString(data); // 内核从用户空间获取数据,类似Linux的copy_from_user。
  111.             if (readData != NULL) {
  112.                 HDF_LOGE("%s: read data is: %s", __func__, readData); // 内核打印从用户空间独到的数据。
  113.             }
  114.    
  115.             // GPIO中断检测
  116.             gpio_test_ldr_irq_edge();
  117.    
  118.             // 将向用户空间返回内容修改为字符串
  119.             char *sendData = "come from kernel sapce: CMD_GPIO_LDR_TEST";
  120.             if (!HdfSbufWriteString(reply, sendData)) {
  121.                 HDF_LOGE("%s: fail to write sbuf", __func__);
  122.             }
  123.    
  124.             // 通HdfDeviceSendEvent函数触发用户空间获取驱动上报数据。
  125.             return HdfDeviceSendEvent(deviceIoClient->device, id, data);
  126.         }

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

  132.             // GPIO test
  133.             gpio_test_led_blink(GPIO_NUM_LED_GPIO2_3);

  134.             // 将向用户空间返回内容修改为字符串
  135.             char *sendData = "come from kernel sapce: CMD_GPIO_LED_TEST";
  136.             if (!HdfSbufWriteString(reply, sendData)) {
  137.                 HDF_LOGE("%s: fail to write sbuf", __func__);
  138.             }

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

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

  147.             // GPIO test
  148.             gpio_test_led_blink(GPIO_NUM_FILL_LIGHT_GPIO5_1);

  149.             // 将向用户空间返回内容修改为字符串
  150.             char *sendData = "come from kernel sapce: CMD_GPIO_FILL_LIGHT";
  151.             if (!HdfSbufWriteString(reply, sendData)) {
  152.                 HDF_LOGE("%s: fail to write sbuf", __func__);
  153.             }

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

  157.         default: {
  158.             HDF_LOGE("no such cmd id");
  159.             break;
  160.         }
  161.     }

  162.     return HDF_FAILURE;
  163. }

  164. // 驱动资源释放的接口,本例未分配需要回收的资源,因此为空。
  165. static void GpioSampleDriverRelease(struct HdfDeviceObject *deviceObject)
  166. {
  167.     // release resources here
  168.     return;
  169. }

  170. // 用户态获取驱动的服务,获取该服务之后通过服务中的Dispatch方法向驱动发送消息。
  171. static int GpioSampleDriverBind(struct HdfDeviceObject *deviceObject)
  172. {
  173.     if (deviceObject == NULL) {
  174.         return HDF_FAILURE;
  175.     }
  176.     static struct IDeviceIoService testService = {
  177.         // Dispatch是用来处理用户态发下来的消息。
  178.         .Dispatch = GpioSampleDriverDispatch,
  179.     };
  180.     deviceObject->service = &testService;
  181.     return HDF_SUCCESS;
  182. }

  183. // 驱动自身业务初始的接口。
  184. static int GpioSampleDriverInit(struct HdfDeviceObject *deviceObject)
  185. {
  186.     if (deviceObject == NULL) {
  187.         HDF_LOGE("%s::ptr is null!", __func__);
  188.         return HDF_FAILURE;
  189.     }
  190.     HDF_LOGE("gpio driver Init success");
  191.     return HDF_SUCCESS;
  192. }

  193. // 定义驱动入口的对象,必须为HdfDriverEntry(在hdf_device_desc.h中定义)类型的全局变量。
  194. struct HdfDriverEntry g_gpioSampleDriverEntry = {
  195.     .moduleVersion = 1,
  196.     .moduleName = "gpio_driver", // 驱动的关键名称。
  197.     .Bind = GpioSampleDriverBind,
  198.     .Init = GpioSampleDriverInit,
  199.     .Release = GpioSampleDriverRelease,
  200. };

  201. // 调用HDF_INIT将驱动入口注册到HDF框架中,在加载驱动时HDF框架会先调用Bind函数,
  202. // 再调用Init函数加载该驱动,当Init调用异常时,HDF框架会调用Release释放驱动资源并退出。
  203. 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.

  13. config DRIVERS_HDF_PLATFORM_GPIO_SAMPLE
  14.     bool "Enable HDF platform GPIO sample driver"
  15.     default n
  16.     depends on DRIVERS_HDF_PLATFORM
  17.     help
  18.       Answer Y to enable HDF platform GPIO sample driver.
复制代码
修改上层Kconfig
$ vi ~/harmony/sdk/vendor/huawei/hdf/Kconfig
  1. source "../../vendor/huawei/hdf/<a hidefocus="true" style="color: rgb(51, 51, 51); padding-right: 10px; padding-left: 10px; border: 1px solid rgb(205, 205, 205); background: rgb(229, 237, 242); font-family: &quot;Helvetica Neue&quot;, Helvetica, &quot;PingFang SC&quot;, 微软雅黑, Tahoma, Arial, sans-serif; font-size: 14px; display: inline !important;">片 </a>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.

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

  15. MODULE_NAME := gpio_sample

  16. LOCAL_CFLAGS += $(HDF_INCLUDE)

  17. LOCAL_SRCS += gpio_sample.c

  18. # 警告需要关掉,不然unused的变量都会报错!
  19. #LOCAL_CFLAGS += -fstack-protector-strong -Wextra -Wall -Werror
  20. LOCAL_CFLAGS += -fstack-protector-strong

  21. 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 <fcntl.h>
  2. #include <unistd.h>
  3. #include "hdf_log.h"
  4. #include "hdf_sbuf.h"
  5. #include "hdf_io_service_if.h"
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <math.h>

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

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

  20. int g_replyFlag = 0;

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

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

  39.     // 获取系统分配的data sbuf。
  40.     struct HdfSBuf *data = HdfSBufObtainDefaultSize();
  41.     if (data == NULL) {
  42.         HDF_LOGE("fail to obtain sbuf data");
  43.         return 1;
  44.     }

  45.     // 获取系统分配的reply sbuf。
  46.     struct HdfSBuf *reply = HdfSBufObtainDefaultSize();
  47.     if (reply == NULL) {
  48.         HDF_LOGE("fail to obtain sbuf reply");
  49.         ret = HDF_DEV_ERR_NO_MEMORY;
  50.         goto out;
  51.     }

  52.     // 将用户空间目标数据放到sbuf。
  53.     if (!HdfSbufWriteString(data, eventData)) {
  54.         HDF_LOGE("fail to write sbuf");
  55.         ret = HDF_FAILURE;
  56.         goto out;
  57.     }

  58.     // 通过驱动服务提供的Dispatch实现用户态应用和内核态驱动的信息交互
  59.     switch (cmd) {
  60.         case 1: {
  61.             ret = serv->dispatcher->Dispatch(&serv->object, CMD_GPIO_LDR_TEST, data, reply);
  62.             if (ret != HDF_SUCCESS) {
  63.                 HDF_LOGE("fail to send service call");
  64.                 goto out;
  65.             }

  66.             break;
  67.         }

  68.         case 2: {
  69.             ret = serv->dispatcher->Dispatch(&serv->object, CMD_GPIO_LED_TEST, data, reply);
  70.             if (ret != HDF_SUCCESS) {
  71.                 HDF_LOGE("fail to send service call");
  72.                 goto out;
  73.             }

  74.             break;
  75.         }

  76.         case 3: {
  77.             ret = serv->dispatcher->Dispatch(&serv->object, CMD_GPIO_FILL_LIGHT, data, reply);
  78.             if (ret != HDF_SUCCESS) {
  79.                 HDF_LOGE("fail to send service call");
  80.                 goto out;
  81.             }

  82.             break;
  83.         }

  84.         default: {
  85.             HDF_LOGE("no such cmd");
  86.             break;
  87.         }
  88.     }

  89.     // 将sbuf中获取到的字符串数据放到用户空间变量中。
  90.     const char *replyData = HdfSbufReadString(reply);
  91.     if (replyData == NULL) {
  92.         HDF_LOGE("fail to get service call reply");
  93.         ret = HDF_ERR_INVALID_OBJECT;
  94.         goto out;
  95.     }
  96.     HDF_LOGE("Get reply is: %s", replyData);
  97. out:
  98.     HdfSBufRecycle(data); // 释放用于数据中转的sbuf
  99.     HdfSBufRecycle(reply); // 释放用于数据中转的sbuf
  100.     return ret;
  101. }

  102. int main(int argc, char **argv)
  103. {
  104.     char *sendData = "come from user sapce: default event info";

  105.     if (argc != 2) {
  106.         HDF_LOGE("Usage: \n ./bin/gpio_sample_app 1        CMD_GPIO_LDR_TEST\n ./bin/gpio_sample_app 2        CMD_GPIO_LED_TEST\n ./bin/gpio_sample_app 3        CMD_GPIO_FILL_LIGHT");
  107.         return HDF_FAILURE;
  108.     }

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

  115.     // 注册订阅驱动服务的回调函数。
  116.     static struct HdfDevEventlistener listener = {
  117.         .callBack = OnDevEventReceived,
  118.         .priv ="Service0"
  119.     };

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

  125.     // 用户空间给内核驱动发送数据
  126.     HDF_LOGE("user space send:");
  127.     HDF_LOGE("cmd: %s, send data is: %s", argv[1], sendData);
  128.     if (SendEvent(serv, sendData, atoi(argv[1]))) {
  129.         HDF_LOGE("fail to send event");
  130.         return HDF_FAILURE;
  131.     }

  132.     /* wait for event receive event finishing */
  133.     while (g_replyFlag == 0) {
  134.         sleep(1);
  135.     }

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

  141.     // 释放驱动服务。
  142.     HdfIoServiceRecycle(serv);
  143.     return HDF_SUCCESS;
  144. }
复制代码

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.

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

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

  16. executable("gpio_sample_app") {
  17.     sources = [
  18.         "gpio_sample_app.c"
  19.     ]

  20.     include_dirs = [
  21.         "$HDF_FRAMEWORKS/ability/sbuf/include",
  22.         "$HDF_FRAMEWORKS/core/shared/include",
  23.         "$HDF_FRAMEWORKS/core/host/include",
  24.         "$HDF_FRAMEWORKS/core/master/include",
  25.         "$HDF_FRAMEWORKS/include/core",
  26.         "$HDF_FRAMEWORKS/include/utils",
  27.         "$HDF_FRAMEWORKS/utils/include",
  28.         "$HDF_FRAMEWORKS/include/osal",
  29.         "//third_party/bounds_checking_function/include",
  30.     ]

  31.     deps = [
  32.         "//drivers/hdf/lite/manager:hdf_core",
  33.         "//drivers/hdf/lite/adapter/osal/posix:hdf_posix_osal",
  34.     ]

  35.     public_deps = [
  36.         "//third_party/bounds_checking_function:libsec_shared",
  37.     ]
  38.     defines = [
  39.         "__USER__",
  40.     ]

  41.     cflags = [
  42.         "-Wall",
  43.         "-Wextra",
  44.     ]
  45. }
复制代码

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_Space\proj-harmony\images\out\ipcamera_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

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

  15. // 用户空间收到内核空间返回的数据
  16. [HDF:E/"gpio_sample_test"]Get reply is: come from kernel sapce: CMD_GPIO_LDR_TEST
  17. [HDF:E/"gpio_sample_test"]user space received:
  18. [HDF:E/"gpio_sample_test"]Service0: dev event received: 100 come from user sapce: default event info
  19. [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, 下载次数: 1, 下载积分: 积分 -1 分

评论

您需要登录后才可以回帖 登录 | 注册

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

最新文章