OpenHarmony HDF LED驱动开发 基于小熊派Micro

文章目录

• ​​一、效果展示​​
• ​​二、led控制程序​​

• ​​2.1、led驱动程序​​

• ​​2.1.1、驱动程序​​
• ​​2.1.2、驱动配置​​

• ​​2.2、C应用程序​​
• ​​2.3、JS应用​​

• ​​2.3.1、JS代码​​
• ​​2.3.2、C++接口​​

一、效果展示

小熊派micro OpenHarmony3.0 鸿蒙LED应用

二、led控制程序

本文按照小熊派官方的开发指南完成led应用程序开发，在开发指南的基础上添加一些自己的理解。

LED驱动虽然简单，但能帮助新手快速熟悉OpenHarmony HDF的开发框架，是非常适合新手学习实践的项目。

本文实现一个LED的开关控制的APP，所涉及的内容包括

• led驱动程序
• C应用程序
• JS应用程序

2.1、led驱动程序

使用HDF框架进行驱动开发，分两个部分：驱动程序，驱动配置。

2.1.1、驱动程序

驱动程序的代码在/device/st/driver/led/led.c

其主要是定义驱动程序入口函数，在HDF加载时读取配置信息并初始化GPIO，定义dispatch函数，用于处理与用户层的交互逻辑。

#include "hdf_device_desc.h" 
#include "hdf_log.h"         
#include "device_resource_if.h"
#include "osal_io.h"
#include "osal.h"
#include "osal_mem.h"
#include "gpio_if.h"

#define HDF_LOG_TAG led_driver
#define LED_WRITE_READ 1
enum LedOps {
    LED_OFF,
    LED_ON,  
    LED_TOGGLE,
};
struct Stm32Mp1ILed {
    uint32_t gpioNum;
};
static struct Stm32Mp1ILed g_Stm32Mp1ILed;
uint8_t status = 0;
// 读取驱动私有配置（设备树）
static int32_t Stm32LedReadDrs(struct Stm32Mp1ILed *led, const struct DeviceResourceNode *node)
{
    int32_t ret;
    struct DeviceResourceIface *drsOps = NULL;
    
    drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
    if (drsOps == NULL || drsOps->GetUint32 == NULL) {
        HDF_LOGE("%s: invalid drs ops!", __func__);
        return HDF_FAILURE;
    }
    /* 读取led.hcs里面led_gpio_num的值 */
    ret = drsOps->GetUint32(node, "led_gpio_num", &led->gpioNum, 0); 
    if (ret != HDF_SUCCESS) {
        HDF_LOGE("%s: read led gpio num fail!", __func__);
        return ret;
    }
    return HDF_SUCCESS;
}

// Dispatch是对外提供的服务，用来处理用户态发下来的消息，同时返回数据
int32_t LedDriverDispatch(struct HdfDeviceIoClient *client, int cmdCode, struct HdfSBuf *data, struct HdfSBuf *reply)
{
    uint8_t contrl;
    HDF_LOGE("Led driver dispatch");
    if (client == NULL || client->device == NULL)
    {
        HDF_LOGE("Led driver device is NULL");
        return HDF_ERR_INVALID_OBJECT;
    }

    switch (cmdCode)
    {
    /* 接收到用户态发来的LED_WRITE_READ命令 */
    case LED_WRITE_READ:
        /* 读取data里的数据，赋值给contrl */
        HdfSbufReadUint8(data,&contrl);                  
        switch (contrl)
        {
        /* 开灯 */
        case LED_ON:                                            
            GpioWrite(g_Stm32Mp1ILed.gpioNum, GPIO_VAL_LOW);
            status = 1;
            break;
        /* 关灯 */
        case LED_OFF:                                           
            GpioWrite(g_Stm32Mp1ILed.gpioNum, GPIO_VAL_HIGH);
            status = 0;
            break;
        /* 状态翻转 */
        case LED_TOGGLE:
            if(status == 0)
            {
                GpioWrite(g_Stm32Mp1ILed.gpioNum, GPIO_VAL_LOW);
                status = 1;
            }
            else
            {
                GpioWrite(g_Stm32Mp1ILed.gpioNum, GPIO_VAL_HIGH);
                status = 0;
            }                                        
            break;
        default:
            break;
        }
        /* 把LED的状态值写入reply, 可被带至用户程序 */
        if (!HdfSbufWriteInt32(reply, status))                
        {
            HDF_LOGE("replay is fail");
            return HDF_FAILURE;
        }
        break;
    default:
        break;
    }
    return HDF_SUCCESS;
}

//驱动对外提供的服务能力，将相关的服务接口绑定到HDF框架
int32_t HdfLedDriverBind(struct HdfDeviceObject *deviceObject)
{
    if (deviceObject == NULL)
    {
        HDF_LOGE("Led driver bind failed!");
        return HDF_ERR_INVALID_OBJECT;
    }
    //定义对外提供的服务函数
    static struct IDeviceIoService ledDriver = {
        .Dispatch = LedDriverDispatch,
    };
    //将服务绑定到驱动
    deviceObject->service = (struct IDeviceIoService *)(&ledDriver);
    HDF_LOGD("Led driver bind success");
    return HDF_SUCCESS;
}

// 驱动自身业务初始的接口（设置IO口为输出） HDF框架在加载驱动的时候，会将私有配置信息保存在HdfDeviceObject 中的property里面
int32_t HdfLedDriverInit(struct HdfDeviceObject *device)
{
    struct Stm32Mp1ILed *led = &g_Stm32Mp1ILed;
    int32_t ret;

    if (device == NULL || device->property == NULL) {
        HDF_LOGE("%s: device or property NULL!", __func__);
        return HDF_ERR_INVALID_OBJECT;
    }
    /* 读取hcs私有属性值，gpio引脚号 */
    ret = Stm32LedReadDrs(led, device->property);
    if (ret != HDF_SUCCESS) {
        HDF_LOGE("%s: get led device resource fail:%d", __func__, ret);
        return ret;
    }
    /* 将GPIO管脚配置为输出 */
    ret = GpioSetDir(led->gpioNum, GPIO_DIR_OUT);
    if (ret != 0)
    {
        HDF_LOGE("GpioSerDir: failed, ret %d\n", ret);
        return ret;
    }
    HDF_LOGD("Led driver Init success");
    return HDF_SUCCESS;
}

// 驱动资源释放的接口
void HdfLedDriverRelease(struct HdfDeviceObject *deviceObject)
{
    if (deviceObject == NULL)
    {
        HDF_LOGE("Led driver release failed!");
        return;
    }
    HDF_LOGD("Led driver release success");
    return;
}

// 定义驱动入口的对象，必须为HdfDriverEntry（在hdf_device_desc.h中定义）类型的全局变量
struct HdfDriverEntry g_ledDriverEntry = {
    .moduleVersion = 1,
    .moduleName = "HDF_LED",    //必须与device_info.hcs中的字段一样，用于与驱动设备资源匹配
    .Bind = HdfLedDriverBind,
    .Init = HdfLedDriverInit,
    .Release = HdfLedDriverRelease,
};

// 调用HDF_INIT将驱动入口注册到HDF框架中
HDF_INIT(g_ledDriverEntry);      

在创建完成led.c后，还要把它加入OpenHarmony的构建系统。

在led.c同目录下创建BUILD.gn，内容如下：

• 导入hdf.gni：
• 定义hdf驱动：驱动的源文件。

import("//drivers/adapter/khdf/liteos/hdf.gni")
hdf_driver("hdf_led") {
    sources = [
    "led.c",
    ]
}      

在上层目录的BUILD.gn中的deps中添加"led"目录：

group("drivers") {
  deps = [
    "uart",
    "iwdg",
    "i2c",
    "gpio",
    "led",
    "stm32mp1xx_hal",
    "wifi/driver/hi3881",
    "wifi/driver:hdf_vendor_wifi",
  ]
}      

2.1.2、驱动配置

HDF使用HCS文件来描述设备配置信息。驱动配置包含两个部分：

• HDF框架规定的驱动设备描述：device/st/bearpi_hm_micro/liteos_a/hdf_config/device_info/device_info.hcs
• 驱动的私有配置信息：device/st/bearpi_hm_micro/liteos_a/hdf_config/led/led_config.hcs

HDF所需的驱动设备描述：

这些配置信息是HDF框架所需要的信息。

platform :: host {
            hostName = "platform_host";
            priority = 50;
            device_led :: device {      // led设备节点
                device0 :: deviceNode {   // led驱动的DeviceNode节点
                    policy = 2;       // policy字段是驱动服务发布的策略，在驱动服务管理章节有详细介绍
                    priority = 10;      // 驱动启动优先级（0-200），值越大优先级越低，建议默认配100，优先级相同则不保证device的加载顺序
                    preload = 1;      // 驱动按需加载字段
          permission = 0777;    // 驱动创建设备节点权限
                    moduleName = "HDF_LED"; // 驱动名称，该字段的值必须和驱动入口结构的moduleName相等
                    serviceName = "hdf_led";    // 驱动对外发布服务的名称，必须唯一
                    deviceMatchAttr = "st_stm32mp157_led";    // 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等
                }
            }      

私有配置信息：

私有配置信息是可选的，在这里我们保存着led对应的gpio管脚号。

root {
    LedDriverConfig {
        led_gpio_num = 13;                  //gpio管脚号
        match_attr = "st_stm32mp157_led";   //该字段的值必须和device_info.hcs中的deviceMatchAttr值一致
    }
}      

2.2、C应用程序

驱动程序已经完成了，现在来编写应用程序。

应用程序做的是：绑定hdf驱动提供的服务（通过"hdf_led"，定义在device_info.hcs）并调用dispatch函数与驱动程序通信。通过0、1、2命令来使驱动程序输出高低电平。

需要注意的是应用程序不能直接读写驱动程序的变量、需要通过​

​HdfSBufObtainDefaultSize()​

​来申请内存，通过这个特殊的内存地址来跟驱动通信。

applications\BearPi\BearPi-HM_Micro\samples\my_led_app\my_led_app.c：

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdio.h>
#include "hdf_sbuf.h"
#include "hdf_io_service_if.h"

#define LED_WRITE_READ 1
#define LED_SERVICE "hdf_led"   //这里和hdf.hcs里的节点属性一样

static int SendEvent(struct HdfIoService *service,uint8_t data)
{
    //使用HdfSBufObtainDefaultSize申请内存，这种类型的内存才能用于和驱动程序交换数据
    struct HdfSBuf *send_buf = HdfSBufObtainDefaultSize();
    if(send_buf == NULL)
    {
        printf("send_buf fail\r\n");
        return -1;
    }
    struct HdfSBuf *reply = HdfSBufObtainDefaultSize();
    if(reply == NULL)
    {
        printf("reply fail\r\n");
        goto out;
    }
    
    //将数据写入send_buf
    if (!HdfSbufWriteUint8(send_buf, data))
    {
        printf("write send_buf fail\r\n");
        goto out;
    }
     /* 通过Dispatch发送数据到驱动，同时驱动会将数据写入reply */
    int ret = service->dispatcher->Dispatch(&service->object, LED_WRITE_READ, send_buf, reply);
    if(ret != HDF_SUCCESS)
    {
        printf("Dispatch fail\r\n");
        goto out;
    }
    int replyData = 0;
    //读取reply的数据
    if (!HdfSbufReadInt32(reply, &replyData))
    {
        printf("fail to get service call reply!\r\n");
        goto out;
    }
    //回收内存
out:
    HdfSBufRecycle(send_buf);
    HdfSBufRecycle(reply);
    return 0;
}
int main(int argc,char **argv)
{
    int i;
    
    if(argc < 2)
    {
        printf("error,argc < 1\r\n");
        return -1;
    }
    //获取驱动提供的服务
    struct HdfIoService *service = HdfIoServiceBind(LED_SERVICE);
    if(service == NULL)
    {
        printf("fail get service %s \r\n",LED_SERVICE);
        return -1;
    }
    //给驱动的服务发送数据
    SendEvent(service,atoi(argv[1]));
    
    //退订服务
    HdfIoServiceRecycle(service);
    printf("exit");
    
    return 0;
}      

要将my_led_app.c编译成可执行程序，并放在根文件系统。需要配置构建文件：

在my_led_app.c同目录下创建BUILD.gn：

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

HDF_FRAMEWORKS = "//drivers/framework"

executable("led_lib"){
    output_name = "my_led"
    sources = [ "my_led_app.c" ]
    include_dirs = [
    "$HDF_FRAMEWORKS/ability/sbuf/include",
    "$HDF_FRAMEWORKS/core/shared/include",
    "$HDF_FRAMEWORKS/core/host/include",
    "$HDF_FRAMEWORKS/core/master/include",
    "$HDF_FRAMEWORKS/include/core",
    "$HDF_FRAMEWORKS/include/utils",
    "$HDF_FRAMEWORKS/utils/include",
    "$HDF_FRAMEWORKS/include/osal",
    "//drivers/adapter/uhdf/posix/include",
    "//third_party/bounds_checking_function/include",
    "//base/hiviewdfx/hilog_lite/interfaces/native/innerkits",
    ]
    deps = [
        "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared",
        "//drivers/adapter/uhdf/manager:hdf_core",
        "//drivers/adapter/uhdf/posix:hdf_posix_osal",
    ]
    cflags_c = []
    ldflags = []
}
lite_component("my_led_app")
{
    features = [
        ":led_lib",
    ]
}      

在build/lite/components/applications.json添加如下内容，将my_led_app编译成一个组件：

{
        "component": "my_sample",
        "description": "my samples",
        "optional": "true",
        "dirs": [
        "applications/BearPi/BearPi-HM_Micro/samples/my_first_app",
        "applications/BearPi/BearPi-HM_Micro/samples/my_led_app"
        ],
        "targets": [
        "//applications/BearPi/BearPi-HM_Micro/samples/my_first_app:my_app",
        "//applications/BearPi/BearPi-HM_Micro/samples/my_led_app:my_led_app"
        ],
        "rom": "",
        "ram": "",
        "output": [],
        "adapted_kernel": [ "liteos_a" ],
        "features": [],
        "deps": {
        "components": [],
        "third_party": [ ]
        }
    },      

2.3、JS应用

2.3.1、JS代码

JS程序本质上也是调用了驱动程序所提供的服务来控制Led，与上一节的区别是使用的编程语言不同。JS代码通过​

​app.ledcontrol​

​​来调用C++提供的接口，实际的控制逻辑由C++提供的​

​ledcontrol​

​实现。

首先看应用程序的JS代码：其本质就是调用ledcontrol函数，通过传递不同的参数来实现led的控制。

//灯状态 0是关闭 1是开启 2是切换
var led = {open:1,close:0,change:2}
import app from '@system.app';
export default {
    data: {
        title: 'BearPi-HM Micro',
        statu:'0'
    },
    exit(e){
        app.terminate()
    },
    open(e){
        let that = this
        //调用ledcontrol函数、传递参数code、success、fail、complete
        app.ledcontrol({
            code:led.open,
            success(res){
                that.statu = res.led_status
            },
            fail(res,code){

            },
            complete(){

            }
        })
    },
    close(e){
        let that = this
        app.ledcontrol({
            code:led.close,
            success(res){
                that.statu = res.led_status
            },
            fail(res,code){

            },
            complete(){

            }
        })
    },
    change(e){
        let that = this
        app.ledcontrol({
            code:led.change,
            success(res){
                that.statu = res.led_status
            },
            fail(res,code){

            },
            complete(){

            }
        })
    }
}      

2.3.2、C++接口

JS代码中的app.ledcontrol要能运行起来，需要C++提供对应的函数。

步骤如下：

1、在foundation\ace\ace_engine_lite\frameworks\src\core\modules\app_module.h中public声明ToggleLed函数。

public:
ACE_DISALLOW_COPY_AND_MOVE(AppModule);
AppModule() = default;
~AppModule() = default;
static JSIValue GetInfo(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum);
static JSIValue Terminate(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum);

static JSIValue ToggleLed(const JSIValue thisVal, const JSIValue* args, uint8_t argsNum);      

接着在InitAppModule()中将ToggleLed注册到JS API中，这样JS代码就能通过ledcontrol接口调用ToggleLed函数。

void InitAppModule(JSIValue exports)
{
    JSI::SetModuleAPI(exports, "getInfo", AppModule::GetInfo);
    JSI::SetModuleAPI(exports, "terminate", AppModule::Terminate);
    
    JSI::SetModuleAPI(exports, "ledcontrol", AppModule::ToggleLed);      

2、在foundation\ace\ace_engine_lite\frameworks\src\core\modules\app_module.cpp中实现ToggleLed()

首先添加头文件和宏定义：

#include "hdf_sbuf.h"
#include "hdf_io_service_if.h"

#define LED_WRITE_READ 1
#define LED_SERVICE "hdf_led"      

添加ToggleLed()的定义：将以下代码与2.2 LED应用程序比较、不难看出两者逻辑是相同的，差别在于C++这里需要处理success、fail、complete的回调。

static int OnDevEventReceived(void *priv, uint32_t id, struct HdfSBuf *data)
{
    uint32_t value;
    HdfSbufReadUint32(data, &value);
    HILOG_ERROR(HILOG_MODULE_ACE,"%s: dev event received: %u %u\n", (char *)priv, id, value);

    return HDF_SUCCESS;
}
//向led驱动发送数据并返回结果
static int GpioWriteRead(struct HdfIoService *serv, int32_t eventData, int32_t *val)
{
    int ret = HDF_FAILURE;
    //申请内存用于和HDF驱动通信
    struct HdfSBuf *data = HdfSBufObtainDefaultSize();
    struct HdfSBuf *reply = HdfSBufObtainDefaultSize();

    if (data == NULL || reply == NULL) {
        HILOG_ERROR(HILOG_MODULE_ACE,"fail to obtain sbuf data\n");
        return ret;
    }
    //将eventData的数据复制到data
    if (!HdfSbufWriteUint8(data, (uint8_t)eventData))
    {
        HILOG_ERROR(HILOG_MODULE_ACE,"fail to write sbuf\n");
        HdfSBufRecycle(data);
        HdfSBufRecycle(reply);
        return ret;
    }
    //调用驱动的dispatch函数，向led驱动发送数据并接收返回结果。
    ret = serv->dispatcher->Dispatch(&serv->object, LED_WRITE_READ, data, reply);
    if (ret != HDF_SUCCESS)
    {
        HILOG_ERROR(HILOG_MODULE_ACE,"fail to send service call\n");
        HdfSBufRecycle(data);
        HdfSBufRecycle(reply);
        return ret;
    }
    //读取返回结果到reply
    if (!HdfSbufReadInt32(reply, val))
    {
        HILOG_ERROR(HILOG_MODULE_ACE,"fail to get service call reply\n");
        ret = HDF_ERR_INVALID_OBJECT;
        HdfSBufRecycle(data);
        HdfSBufRecycle(reply);
        return ret;
    }
    HILOG_ERROR(HILOG_MODULE_ACE,"Get reply is: %d\n", val);
    //释放内存
    HdfSBufRecycle(data);
    HdfSBufRecycle(reply);
    return ret;
}
//led控制
JSIValue AppModule::ToggleLed(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum)
{
    HILOG_ERROR(HILOG_MODULE_ACE, "led button pressed.");
    //获取led驱动提供的服务
    struct HdfIoService *serv = HdfIoServiceBind(LED_SERVICE);
    if (serv == NULL)
    {
        HILOG_ERROR(HILOG_MODULE_ACE,"fail to get service2 %s\n", LED_SERVICE);
        return JSI::CreateUndefined();
    }

    if ((args == nullptr) || (argsNum == 0) || (JSI::ValueIsUndefined(args[0]))) {
        return JSI::CreateUndefined();
    }
    //获取JS代码中的success、fail、complete的？
    JSIValue success = JSI::GetNamedProperty(args[0], CB_SUCCESS);
    JSIValue fail = JSI::GetNamedProperty(args[0], CB_FAIL);
    JSIValue complete = JSI::GetNamedProperty(args[0], CB_COMPLETE);
    //获取code的值，即JS代码中的 code:led.open，也就是 0、1、2控制码
    int32_t num = (int32_t)JSI::GetNumberProperty(args[0], "code");

    int32_t replyData = 0;
    //将命令发送到led驱动
    if (GpioWriteRead(serv, num, &replyData))
    {
        //驱动led失败、调用fail、complete函数
        HILOG_ERROR(HILOG_MODULE_ACE,"fail to send event\n");
        JSI::CallFunction(fail, thisVal, nullptr, 0);
        JSI::CallFunction(complete, thisVal, nullptr, 0);
        JSI::ReleaseValueList(success, fail, complete);
        return JSI::CreateUndefined();
    }
    //驱动led成功，返回结果对象
    JSIValue result = JSI::CreateObject();
    //设置结果对象中的led_status属性值。对应js代码中的"that.statu = res.led_status"
    JSI::SetNumberProperty(result, "led_status", replyData);
    //调用success、complete函数
    JSIValue argv[ARGC_ONE] = {result};
    JSI::CallFunction(success, thisVal, argv, ARGC_ONE);
    JSI::CallFunction(complete, thisVal, nullptr, 0);
    JSI::ReleaseValueList(success, fail, complete, result);

    HdfIoServiceRecycle(serv);

    return JSI::CreateUndefined();
}      

3、将编写的源文件添加到编译系统。

首先配置HDF头文件路径：

在foundation\ace\ace_engine_lite\ace_lite.gni中添加HDF头文件路径

ace_lite_include_dirs += [
    "//drivers/framework/ability/sbuf/include",
    "//drivers/framework/include/core",
    "//drivers/framework/include/utils",
    "//drivers/adapter/uhdf/posix/include",
]      

添加编译依赖：

修改foundation\ace\ace_engine_lite\frameworks\BUILD.gn，在public_deps中添加以下代码

"//drivers/adapter/uhdf/manager:hdf_core",      

"//drivers/adapter/uhdf/manager:hdf_core",