OpenHarmony设备开发实战-基于DAYU800的GPIO点灯

已于 2024-06-03 09:14:14 修改
阅读量869 收藏 16
点赞数 24
分类专栏： # OpenHarmony开发经验分享 文章标签： 单片机 嵌入式硬件 harmonyos
于 2024-06-02 22:41:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxs_vip/article/details/139391687
版权

GPIO（General-Purpose Input/Output） 是通用输入/输出端口的简称，是一种允许微控制器或芯片组与外部逻辑电路或其他设备（如传感器、执行器、LED灯等）进行通信的接口。GPIO 引脚可以配置为输入或输出模式，以便微控制器可以读取外部设备的状态或向外部设备发送控制信号。

GPIO 通常具有以下特点：

  1. 通用性：GPIO 引脚是通用的，可以根据需要配置为输入或输出模式。
  2. 可编程性：GPIO 引脚的状态（输入/输出、高电平/低电平）可以通过编程进行控制。
  3. 简单性：GPIO 接口相对简单，容易理解和使用。
  4. 灵活性：GPIO 引脚可以用于各种应用，如控制LED灯、读取按钮状态、与传感器通信等。

在嵌入式系统、微控制器和许多其他类型的电子设备中，GPIO 引脚是非常常见的接口。通过编程控制 GPIO 引脚，可以实现与外部设备的交互，从而扩展微控制器的功能。

点灯是每个嵌入式系统入门的必修课，本文主要介绍在DAYU800开发板上实现在openharmony3.2系统上进行点灯的代码案例。

一、DAYU800开发板硬件接口介绍

如图所示DAYU800开发板有一组20pin 的GPIO

板载 2x10pin 插针，其中有 16 个原生 IO，包括 4个普通 IO，4 对串口，一个 SPI。另外有2个GND，一个5V，一个3.3V。

查阅资料，TH1520 SOC 具有4个GPIO bank，每个bank最大有32个IO，分别如以下：

BankAddresskernel io num
GPIO00xffec005000456-487
GPIO10xffec006000424-455
GPIO20xffe7f34000392-423
GPIO30xffe7f38000360-391
AO_GPIO0xfffff41000328-359
AO_GPIO40xfffff52000296-327
AUDIO_GPIO0xffcb013000-

以俯视底板正面为视角，TOP为左侧，BOTTOM为右侧，GPIO对应关系如下：

从以上可以看出板载20pin插针中，4个普通GPIO对应的数字分别如下表

IOkernel io num
IO1_3427
IO1_4428
IO1_5429
IO1_6430

了解了DAYU800开发板的GPIO接口后我们就可以进一步操作了。

二、搭建点灯环境

为了测试点灯，我们需要给GPIO接个灯。手头上有一片HiSpark_WiFi_IoT_SSL_VER.A红绿灯板，如下图

LED控制原理图如下

将红绿灯板和DAYU800开发版按以下方式接线

红绿灯板DAYU800
GNDGND
3.3V3.3V
YellowIO1_4
RedIO1_5
GreenIO1_6

没有HiSpark_WiFi_IoT_SSL_VER.A可按照自己的需求简单接个灯也可实验，或者直接用万用表测试输出。

三、 使用指令测试GPIO

通过前面的分析，我们可以得到黄灯、红灯、绿灯对应的kernel io num如下：

红绿灯板DAYU800kernel io num
YellowIO1_4428
RedIO1_5429
GreenIO1_6420

可以使用以下指令对GPIO进行相应的操作

黄灯
echo 428 > /sys/class/gpio/export  
echo out > /sys/class/gpio/gpio428/direction 
echo 1 > /sys/class/gpio/gpio428/value  
echo 0 > /sys/class/gpio/gpio428/value
红灯
echo 429 > /sys/class/gpio/export  
echo out > /sys/class/gpio/gpio429/direction 
echo 1 > /sys/class/gpio/gpio429/value  
echo 0 > /sys/class/gpio/gpio429/value
绿灯
echo 430 > /sys/class/gpio/export  
echo out > /sys/class/gpio/gpio430/direction 
echo 1 > /sys/class/gpio/gpio430/value  
echo 0 > /sys/class/gpio/gpio430/value

通过测试我们可以发现IO能正确的控制到相应的灯，那接下去我们来看下如何编写代码。

四、编写代码

4.1代码目录结构

在vendor/hihope/dayu800下面新建sample目录用于存放相关代码。代码目录结构如下

4.2修改dayu800目录下的ohos.build

开始修改代码首先编辑vendor/hihope/dayu800/ohos.build在module_list中添加"//vendor/hihope/dayu800/sample:dayu800_sample"修改后文件内容如下：

{
  "parts": {
    "product_dayu800": {
      "module_list": [
        "//vendor/hihope/dayu800/default_app_config:default_app_config",
        "//vendor/hihope/dayu800/image_conf:custom_image_conf",
        "//vendor/hihope/dayu800/preinstall-config:preinstall-config",
        "//vendor/hihope/dayu800/resourceschedule:resourceschedule",
        "//vendor/hihope/dayu800/etc:product_etc_conf",
        "//vendor/hihope/dayu800/audio:audio_policy_config",
        "//vendor/hihope/dayu800/sample:dayu800_sample"
      ]
    }
  },
  "subsystem": "product_hihope"
}

模块目录//vendor/hihope/dayu800/sample

模块名称dayu800_sample

这样就能编译到sample目录了

4.3新增sample目录下的BUILD.gn

添加vendor/hihope/dayu800/sample/BUILD.gn文件，并输入以下内容。

import("//build/ohos.gni")

group("dayu800_sample") {
  deps = [
    "hardware:hardware"
  ]
}

创建了一个名为"dayu800_sample"的group。group的作用是将多个target（可以是源文件、库文件或可执行文件等）组织在一起，方便进行编译和管理。在这个group中，依赖了一个名为"hardware:hardware"的target。这个依赖关系意味着在编译"dayu800_sample"时，需要先编译并链接"hardware:hardware"这个target。通过使用group，可以更方便地管理项目的编译和构建过程。 

4.4新增sample/hardware目录下的BUILD.gn

新建hardware目录，并添加vendor/hihope/dayu800/sample/hardware/BUILD.gn文件，输入以下内容。

import("//build/ohos.gni")

group("hardware") {
  deps = [
    "gpio:gpio_dayu800"
  ]
}

创建了一个名为"hardware"的组(group)。该组依赖于名为"gpio:gpio_dayu800"的依赖项。这个函数的作用是将"hardware"组与"gpio:gpio_dayu800"依赖项相关联。

4.5新增sample/hardware/gpio目录下的BUILD.gn

新建gpio目录，并添加vendor/hihope/dayu800/sample/hardware/gpio/BUILD.gn文件，输入以下内容。

import("//build/ohos.gni")
import("//build/ohos/ndk/ndk.gni")

ohos_executable("gpio_dayu800") {
  sources = [
    "main.c",
    "gpio_dayu800.c"
  ]

  include_dirs = [ "//commonlibrary/c_utils/base/include" ]

  external_deps = [
    "c_utils:utils",
    "hilog_native:libhilog",
  ]

  install_images = [ "system" ]
  part_name = "product_dayu800"
}

以上定义了一个名为gpio_dayu800的可执行文件目标。该目标包含了两个源文件main.c和gpio_dayu800.c，并指定了包含目录//commonlibrary/c_utils/base/include。该目标依赖于外部库c_utils:utils和hilog_native:libhilog。最后，它指定了将生成的可执行文件安装到system镜像，并将该目标归属于product_dayu800部分。

4.6新增sample/hardware/gpio目录下的gpio_dayu800.c和gpio_dayu800.h

创建vendor/hihope/dayu800/sample/hardware/gpio/gpio_dayu800.c文件，内容如下

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "hilog/log.h"
#include "securec.h"
#include "gpio_dayu800.h"

int DAYU800_GPIO_Export(int gpioNum, int bExport)
{
    int ret = -1;
    char buffer[256] = {0};

    if (bExport) {
        (void) snprintf_s(buffer, sizeof(buffer), sizeof(buffer), "echo %d > %s", gpioNum, DAYU800_GPIO_EXPORT);
    } else {
        (void) snprintf_s(buffer, sizeof(buffer), sizeof(buffer), "echo %d > %s", gpioNum, DAYU800_GPIO_UNEXPORT);
    }

    sighandler_t old_handler;
    old_handler = signal(SIGCHLD, SIG_DFL);
    ret = system(buffer);
    if (ret < 0) {
        HILOG_ERROR(LOG_CORE, "set gpio%{public}d %{public}s failed", gpioNum, bExport == 1 ? "export" : "unexport");
        return DAYU800_GPIO_ERR;
    }
    (void) signal(SIGCHLD, old_handler);
    return ret;
}

int DAYU800_GPIO_SetDirection(int gpioNum, int direction)
{
    int ret_sprintf_s = -1;

    // check gpio export or not
    char gpio_file_name[128];
    (void) memset_s(gpio_file_name, sizeof(gpio_file_name), 0, sizeof(gpio_file_name));
    ret_sprintf_s = snprintf_s(gpio_file_name, sizeof(gpio_file_name), sizeof(gpio_file_name), "%s%d/direction",
                               DAYU800_GPIO_PEX, gpioNum);
    if (ret_sprintf_s != 0) {
    }

    if (access(gpio_file_name, F_OK) != 0) {
        HILOG_ERROR(LOG_CORE, "gpio%{public}d not export", gpioNum);
        return DAYU800_GPIO_NOT_EXPROT_ERROR;
    }
    // set gpio direction

    FILE *fp = NULL;
    fp = fopen(gpio_file_name, "r+");
    if (fp == NULL) {
        HILOG_ERROR(LOG_CORE, "open %{public}s%{public}d/direction failed", DAYU800_GPIO_PEX, gpioNum);
        return DAYU800_GPIO_ERR;
    }

    if (direction == DAYU800_GPIO_DIRECTION_IN) {
        fprintf(fp, "%s", "in");
    } else if (direction == DAYU800_GPIO_DIRECTION_OUT) {
        fprintf(fp, "%s", "out");
    }

    (void) fclose(fp);
    fp = NULL;

    return 0;
}

int DAYU800_GPIO_SetValue(int gpioNum, int value)
{
    int ret_sprintf_s = -1;

    // check gpio export or not
    char gpio_file_name[128];
    (void) memset_s(gpio_file_name, sizeof(gpio_file_name), 0, sizeof(gpio_file_name));
    ret_sprintf_s = snprintf_s(gpio_file_name, sizeof(gpio_file_name), sizeof(gpio_file_name), "%s%d/value",
                               DAYU800_GPIO_PEX, gpioNum);
    if (ret_sprintf_s != 0) {
    }

    if (access(gpio_file_name, F_OK) != 0) {
        HILOG_ERROR(LOG_CORE, "gpio%{public}d not export", gpioNum);
        return DAYU800_GPIO_NOT_EXPROT_ERROR;
    }
    // set gpio value

    FILE *fp = NULL;
    fp = fopen(gpio_file_name, "r+");
    if (fp == NULL) {
        HILOG_ERROR(LOG_CORE, "open %{public}s%{public}d/value failed", DAYU800_GPIO_PEX, gpioNum);
        return DAYU800_GPIO_ERR;
    }

    if (value == DAYU800_GPIO_LOW_LEVE) {
        fprintf(fp, "%s", "0");
    } else if (value == DAYU800_GPIO_HIGH_LEVE) {
        fprintf(fp, "%s", "1");
    }

    (void) fclose(fp);
    fp = NULL;

    return 0;
}

int DAYU800_GPIO_IsExport(int gpioNum, int *value)
{
    int ret_sprintf_s = -1;

    if (value == NULL) {
        return DAYU800_GPIO_ERR;
    }
    // check gpio export or not
    char gpio_file_name[128];
    (void) memset_s(gpio_file_name, sizeof(gpio_file_name), 0, sizeof(gpio_file_name));
    ret_sprintf_s = snprintf_s(gpio_file_name, sizeof(gpio_file_name), sizeof(gpio_file_name), "%s%d/value",
                               DAYU800_GPIO_PEX, gpioNum);
    if (ret_sprintf_s != 0) {
    }

    if (access(gpio_file_name, F_OK) != 0) {
        HILOG_INFO(LOG_CORE, "gpio%{public}d not export", gpioNum);
        *value = DAYU800_GPIO_NOT_EXPORT;
    } else {
        *value = DAYU800_GPIO_EXPORTED;
    }
    return 0;
}

int DAYU800_GPIO_GetDirection(int gpioNum, int *value)
{
    int ret = 0;
    int ret_sprintf_s = -1;

    if (value == NULL) {
        return DAYU800_GPIO_ERR;
    }
    // check gpio export or not
    char gpio_file_name[128];
    (void) memset_s(gpio_file_name, sizeof(gpio_file_name), 0, sizeof(gpio_file_name));
    ret_sprintf_s = snprintf_s(gpio_file_name, sizeof(gpio_file_name), sizeof(gpio_file_name), "%s%d/direction",
                               DAYU800_GPIO_PEX, gpioNum);
    if (ret_sprintf_s != 0) {
    }

    if (access(gpio_file_name, F_OK) != 0) {
        HILOG_ERROR(LOG_CORE, "gpio%{public}d not export", gpioNum);
        return DAYU800_GPIO_NOT_EXPROT_ERROR;
    }
    // get gpio direction

    FILE *fp = NULL;
    char buffer[20] = {0};
    fp = fopen(gpio_file_name, "r");
    if (fp == NULL) {
        HILOG_ERROR(LOG_CORE, "read %{public}s%{public}d/direction failed", DAYU800_GPIO_PEX, gpioNum);
        return DAYU800_GPIO_ERR;
    }
    (void) fread(buffer, sizeof(buffer), 1, fp);
    (void) fclose(fp);
    fp = NULL;
    if (strstr(buffer, "out") != NULL) {
        *value = DAYU800_GPIO_DIRECTION_OUT;
    } else if (strstr(buffer, "in") != NULL) {
        *value = DAYU800_GPIO_DIRECTION_IN;
    } else {
        ret = DAYU800_GPIO_ERR;
    }
    return ret;
}

int DAYU800_GPIO_GetValue(int gpioNum, int *value)
{
    int ret = 0;
    int ret_sprintf_s = -1;

    if (value == NULL) {
        return DAYU800_GPIO_ERR;
    }
    // check gpio export or not
    char gpio_file_name[128];
    (void) memset_s(gpio_file_name, sizeof(gpio_file_name), 0, sizeof(gpio_file_name));
    ret_sprintf_s = snprintf_s(gpio_file_name, sizeof(gpio_file_name), sizeof(gpio_file_name), "%s%d/value",
                               DAYU800_GPIO_PEX, gpioNum);
    if (ret_sprintf_s != 0) {
    }

    if (access(gpio_file_name, F_OK) != 0) {
        HILOG_ERROR(LOG_CORE, "gpio%{public}d not export", gpioNum);
        return DAYU800_GPIO_NOT_EXPROT_ERROR;
    }
    // get gpio value

    FILE *fp = NULL;
    char buffer[20] = {0};
    fp = fopen(gpio_file_name, "r");
    if (fp == NULL) {
        HILOG_ERROR(LOG_CORE, "read %{public}s%{public}d/value failed", DAYU800_GPIO_PEX, gpioNum);
        return DAYU800_GPIO_ERR;
    }
    (void) fread(buffer, sizeof(buffer), 1, fp);
    (void) fclose(fp);
    fp = NULL;
    if (strstr(buffer, "0") != NULL) {
        *value = DAYU800_GPIO_LOW_LEVE;
    } else if (strstr(buffer, "1") != NULL) {
        *value = DAYU800_GPIO_HIGH_LEVE;
    } else {
        ret = DAYU800_GPIO_ERR;
    }
    return ret;
}

创建vendor/hihope/dayu800/sample/hardware/gpio/gpio_dayu800.h文件，内容如下 

#ifndef __DAYU800_GPIO_H__
#define __DAYU800_GPIO_H__

#define DAYU800_GPIO_EXPORT "/sys/class/gpio/export"
#define DAYU800_GPIO_UNEXPORT "/sys/class/gpio/unexport"
#define DAYU800_GPIO_PEX "/sys/class/gpio/gpio"

// hilog
#undef LOG_DOMAIN
#undef LOG_TAG
#define LOG_DOMAIN 0
#define LOG_TAG "GPIO_DAYU800"

// gpios
#define DAYU800_GPI0_1_3 427 /* IO1_3 */
#define DAYU800_GPI0_1_4 428 /* IO1_4 */
#define DAYU800_GPI0_1_5 429 /* IO1_5 */
#define DAYU800_GPI0_1_6 430 /* IO1_6 */

// direction
#define DAYU800_GPIO_DIRECTION_IN 0
#define DAYU800_GPIO_DIRECTION_OUT 1

// is export
#define DAYU800_GPIO_NOT_EXPORT 0
#define DAYU800_GPIO_EXPORTED 1

// errno
#define DAYU800_GPIO_ERR (-1)
#define DAYU800_GPIO_NOT_EXPROT_ERROR (-2)

// value high - low level
#define DAYU800_GPIO_LOW_LEVE 0
#define DAYU800_GPIO_HIGH_LEVE 1

/**
 * set gpio export
 * @param gpioNum gpioNum
 * @param bExport export,0:not export 1:export
 */
int DAYU800_GPIO_Export(int gpioNum, int bExport);

/**
 * set gpio direction
 * @param gpioNum gpioNum
 * @param direction direction,0:in 1:out
 */
int DAYU800_GPIO_SetDirection(int gpioNum, int direction);

/**
 * set gpio value
 * @param gpioNum gpioNum
 * @param value value,0:low 1:high
 */
int DAYU800_GPIO_SetValue(int gpioNum, int value);

/**
 * check gpio export or not
 * @param gpioNum gpioNum
 * @param *value export,0:not export 1:exported
 */
int DAYU800_GPIO_IsExport(int gpioNum, int *value);

/**
 * get gpio direction
 * @param gpioNum gpioNum
 * @param *value direction,0:in 1:out
 */
int DAYU800_GPIO_GetDirection(int gpioNum, int *value);

/**
 * get gpio value
 * @param gpioNum gpioNum
 * @param *value value,0:low 1:high
 */
int DAYU800_GPIO_GetValue(int gpioNum, int *value);

#endif /* __DAYU800_GPIO_H__ */

以上函数提供了对Dayu800开发板GPIO的控制，包括导出、设置方向、设置值、检查导出状态、获取方向和获取值等操作。用于管理Dayu800GPIO的C函数库。以下是每个函数的功能解释：

1、DAYU800_GPIO_Export 函数用于导出或取消导出GPIO。根据输入的bExport参数，函数将构建一个命令行字符串来执行导出或取消导出操作。如果操作成功，函数返回0，否则返回错误代码。

2、DAYU800_GPIO_SetDirection 函数用于设置GPIO的方向。首先，函数检查GPIO是否已导出。然后，它打开GPIO的方向文件，并根据输入的direction参数设置为输入或输出。

3、DAYU800_GPIO_SetValue 函数用于设置GPIO的值。首先，函数检查GPIO是否已导出。然后，它打开GPIO的值文件，并根据输入的value参数设置为低电平或高电平。

4、DAYU800_GPIO_IsExport 函数用于检查GPIO是否已导出。它构建GPIO的值文件路径并检查该文件是否存在。根据检查结果，函数通过value参数返回导出状态。

5、DAYU800_GPIO_GetDirection 函数用于获取GPIO的方向。首先，函数检查GPIO是否已导出。然后，它打开GPIO的方向文件并读取方向值。根据读取的结果，函数通过value参数返回方向值。

6、DAYU800_GPIO_GetValue 函数用于获取GPIO的值。首先，函数检查GPIO是否已导出。然后，它打开GPIO的值文件并读取值。根据读取的结果，函数通过value参数返回值。

4.7新增sample/hardware/gpio目录下的main.c

创建vendor/hihope/dayu800/sample/hardware/gpio/main.c文件，输入以下内容

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#include "gpio_dayu800.h"

int main(int argc, char **argv)
{
    int gpioNum = DAYU800_GPI0_1_3;
    int bExport = DAYU800_GPIO_EXPORTED;
    int direction = DAYU800_GPIO_DIRECTION_OUT;
    int value = DAYU800_GPIO_HIGH_LEVE;
    int getValue = -1;

    // 检查参数数量以确保至少提供了预期的参数数量
    if (argc < 2) {
        printf("Usage 1: %s <gpioNum> \n", argv[0]);
        printf("Usage 2: %s <gpioNum> <value>\n", argv[0]);
        printf("Usage 3: %s <gpioNum> <value> <direction>\n", argv[0]);
        return DAYU800_GPIO_ERR;
    }

    // 判断是否有输入参数，如有，则赋值指定gpio口
    if (argv[1] != NULL) {
        getValue = atoi(argv[1]);
        if (getValue >= DAYU800_GPI0_1_3 && getValue <= DAYU800_GPI0_1_6) {
            gpioNum = getValue;
        } else {
            printf("please input the gpioNum between 427 and 430.\n");
            return DAYU800_GPIO_ERR;
        }
    }

    // 判断gpio口是否已经导出，如未导出则执行对应函数
    DAYU800_GPIO_IsExport(gpioNum, &getValue);
    if (getValue == DAYU800_GPIO_NOT_EXPORT) {
        DAYU800_GPIO_Export(gpioNum, bExport);
    }

    if (argc == 2) {
        // 设置gpio口值取反
        DAYU800_GPIO_GetValue(gpioNum, &getValue);
        if(getValue == DAYU800_GPIO_LOW_LEVE){
            value = DAYU800_GPIO_HIGH_LEVE;
        }else{
            value = DAYU800_GPIO_LOW_LEVE;
        }
        printf("gpioNum:[%d], curvalue:[%d] setvalue:[%d]\n", gpioNum, getValue,value);
    }

    if (argc >=3 && argc <= 4) {
        if (argv[2] != NULL) {
            //读取GPIO口设定值
            getValue = atoi(argv[2]);
            if (getValue >= DAYU800_GPIO_LOW_LEVE && getValue <= DAYU800_GPIO_HIGH_LEVE) {
                value = getValue;
            } else {
                printf("please input the gpio value 0 (low)or 1 (high).\n");
                return DAYU800_GPIO_ERR;
            }
        }

    }

    if (argc == 4) {
        if (argv[3] != NULL) {
            //读取GPIO口输入或输出设定
            getValue = atoi(argv[3]);
            if (getValue >= DAYU800_GPIO_DIRECTION_IN && getValue <= DAYU800_GPIO_DIRECTION_OUT) {
                direction = getValue;
            } else {
                printf("please input the gpio direction 0 (in)or 1 (out).\n");
                return DAYU800_GPIO_ERR;
            }
        }
    }

    // 设置gpio口为输入或输出模式
    DAYU800_GPIO_SetDirection(gpioNum, direction);

    // 设置gpio口电平高低
    DAYU800_GPIO_SetValue(gpioNum, value);

    // 获取对应gpio口的模式并打印
    DAYU800_GPIO_GetDirection(gpioNum, &getValue);
    printf("gpioNum:[%d], direction:[%d]\n", gpioNum, getValue);

    // 获取对应gpio口的电平值并打印
    DAYU800_GPIO_GetValue(gpioNum, &getValue);
    printf("gpioNum:[%d], Value:[%d]\n", gpioNum, getValue);

    return 0;
}

以上函数实现了是用指令对Dayu800开发板的GPIO引脚的操作，根据输入参数的数量和值，函数执行不同的操作，并在终端打印出相应的信息。支持的指令格式如下：

Usage 1: gpio_dayu800 <gpioNum> 
Usage 2: gpio_dayu800 <gpioNum> <value>
Usage 3: gpio_dayu800 <gpioNum> <value> <direction>

五、编译代码

5.1全量编译

如果之前未编译过需要用全编译指令，指令如下

 ./build.sh --product-name dayu800 --gn-args full_mini_debug=false --ccache

 编译完成后可以直接烧录out/dayu800/packages/phone/images下生成的档案。

5.2单模块编译

前提是之前已全量编译过才可以使用单模块编译指令，指令如下

 ./build.sh --product-name dayu800 --ccache --build-target product_dayu800

单模块编译后生成bin文件在out/dayu800/product_dayu800/product_dayu800/目录下的gpio_dayu800

六、验证测试

烧录完整镜像的方式不再重复介绍，可以参考上篇文章，此处介绍用单模块替换验证方式。

6.1 获取hdc工具

除了烧录完整镜像文件，我们还可以通过hdc工具替换，Windows下可以通过安装DevEco Studio工具后下载SDK来获取hdc工具。

下载完成后会安装在用户目录如C:\Users\soonl\AppData\Local\OpenHarmony\Sdk\9\toolchains下面。

当然也可以从每日构建中获取hdc工具，从每日构建 | OpenHarmony CI中下载ohos-sdk全量包，然后找到hdc和libusb_shared.so放到环境变量中即可

cp version-Daily_Version-ohos-sdk-20230523_020127-ohos-sdk.tar.gz ~/Download
tar -xvf version-Daily_Version-ohos-sdk-20230523_020127-ohos-sdk.tar.gz
cd ohos-sdk/linux
unzip toolchains-linux-x64-4.0.7.3-Beta1.zip
cd toolchains
cp hdc libusb_shared.so ~/bin

6.2将 gpio_dayu800推送到开发板

进入hdc工具所在目录，将编译生成的gpio_dayu800拷贝到hdc所在目录，开发板通过Type-C数据线连接到电脑，运行windows自带的“命令提示符”（cmd）窗口

使用以下指令重新挂载DAYU800开发板的文件系统（以读写权限挂载）

hdc shell mount -o remount,rw /

使用一下指令推送到DAYU800开发板/system/bin/目录

hdc file send gpio_dayu800  /system/bin/

操作截图如以下：

6.3 在DAYU800开发板上运行测试程序

使用hdc shell指令进入到开发板终端

hdc shell

接着运行测试指令如

gpio_dayu800 428
gpio_dayu800 429
gpio_dayu800 430
gpio_dayu800 428 0 1
gpio_dayu800 428 1 1

运行结果如图

点灯成功

lxs_vip
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于riscv架构的DAYU800开发板套件介绍
wenfei11471的博客
06-19 857
一、简介 润和-SCDAYU800 开发平台基于平头哥高性能 RISC-V 开源架构曳影 TH1520 芯片，集成4核高性能RISC-V处理器玄铁C910的平头哥曳影1520，AI算力达4TOPs支持蓝牙、音频、视频和摄像头等功能,支持多种视频输入输出接口,并提供丰富的扩展接口，可用于工控平板、智慧大屏、智能NVR、信息发布系统、云终端、车载中控等场景,支...
如何在DAYU800上创建第一个OpenHarmony应用
坚果的博客
11-22 161
为了以赛促学，更好的学习OpenHarmony，大家可以在这儿报名参赛https://competition.atomgit.com/competitionInfo?然后下载申请书https://atomgit.com/lianzhian/RISC-V_OpenHarmony/tree/master/填写申请书。针对目前还没有拿到开发板的同学，我们可以使用预览器先进行开发，等开发板，拿到手之后，我们就可以冲刺啦。创建完成之后，我们就可以在列表里看到了，真机连接之后，IDE上就可以发现设备。
基于DAYU800开发板的OpenHarmony设备发环境搭建
lxs_vip的博客
06-02 858
润和-SCDAYU800 开发平台基于平头哥高性能 RISC-V 开源架构曳影 TH1520 芯片，集成 4 核高性能 RISC-V 处理器玄铁 C910 的平头哥曳影 1520，AI 算力达 4TOPs支持蓝牙、音频、视频和摄像头等功能,支持多种视频输入输出接口,并提供丰富的扩展接口，可用于工控平板、智慧大屏、智能 NVR、信息发布系统、云终端、车载中控等场景,支持医疗成像、视频会议、家用机器人和无人机等中高端应用,广泛用于边缘计算、人工智能、图像识别、多媒体等领域。
OpenHarmony开发-连接开发板调试应用
热门推荐
踏雨歌青春，诗酒趁年华
04-09 2万+
在OpenHarmony开发过程中，连接开发板进行应用调试是一个关键步骤，开发者需要在真实的硬件环境中测试和优化他们的应用。本文详细介绍了OpenHarmony开发中连接开发板调试应用的操作步骤。首先，我们需要搭建OpenHarmony的开发环境，正确安装OpenHarmony-SDK和所需的驱动程序。接着，我们通过USB连接方式将开发板连接到开发机。在连接成功后，我们使用DevEco-Studio部署和启动应用。通过监控应用在开发板上的运行情况，我们可以利用日志输出进行问题诊断。
OpenHarmony实战开发-蓝牙设置开发指导
m0_70749039的博客
05-13 716
蓝牙设置主要提供了开启蓝牙、关闭蓝牙、获取蓝牙状态的方法，帮助开发者实现基本蓝牙功能。
OpenHarmony实战开发-如何使用OpenGL绘制3D图形
m0_70749039的博客
05-23 808
XComponent控件常用于相机预览流的显示和游戏画面的绘制,在OpenHarmony上，可以配合Native Window创建OpenGL开发环境，并最终将OpenGL绘制的图形显示到XComponent控件。本文将采用"Native C++"模板，调用OpenGL ES图形库绘制3D图形（三棱锥），并将结果渲染到页面的XComponent控件中进行展示。同时，还可以在屏幕上通过触摸滑动手势对三棱锥进行旋转，最终得到不同角度的图形并显示到页面。
OpenHarmony开发-系统烧录
踏雨歌青春，诗酒趁年华
04-06 6774
本文详细介绍了烧录OpenHarmony系统到开发板的操作流程。从基础的硬件准备和软件环境设置入手，详细说明了如何配置开发环境、构建系统镜像等过程，详细描述了烧录过程中的关键步骤，以及如何使用专用工具将OpenHarmony系统镜像传输到开发板。同时，文章也列出了烧录过程中可能遇到的常见问题及其解决方案。
OpenHarmony应用开发技巧 - 应用常驻和自启动配置
TiZizzz
07-03 1722
本文档将介绍如何修改系统配置项使自己开发的应用可以获得常驻和自启动的能力。临时配置用于测试配置项是否生效，当生效后可将配置信息拷贝到系统源码中，使配置永久生效。
OpenHarmony应用开发之如何创建DAYU200预览器
坚果的博客
07-03 761
今天我在尝试使用 command 安装 typescript ，它返回此错误： 具体报错看完只有那么有没有对应的解决办法呢，答案当然是有的，接下来看招为全局安装创建一个目录： 配置 npm 以使用新的目录路径： 打开或创建一个 ~/.profile 文件并添加以下行： 返回命令行，更新系统变量： 测试：在不使用 sudo 的情况下全局下载一个包。 如果您使用的是 Z shell (Zsh)，请添加到您的文件中好的成功解决了问题。所以说学习就是遇到问题，解决问题的过程，少年加油吧，相信你可以的。...
Python库 | tencentcloud-sdk-python-dayu-3.0.361.tar.gz
03-11
pip install tencentcloud-sdk-python-dayu-3.0.361 ``` 安装完成后，开发者可以通过导入库并配置好相关参数，如secret_id和secret_key，来调用天御服务的各种接口。例如，初始化一个DayuClient对象，然后调用相关...
Python库 | tencentcloud-sdk-python-dayu-3.0.463.tar.gz
05-23
资源分类：Python库 所属语言：Python 资源全名：tencentcloud-sdk-python-dayu-3.0.463.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Python库 | tencentcloud-sdk-python-dayu-3.0.263.tar.gz
05-23
资源分类：Python库 所属语言：Python 资源全名：tencentcloud-sdk-python-dayu-3.0.263.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
PyPI 官网下载 | tencentcloud-sdk-python-dayu-3.0.359.tar.gz
01-30
资源来自pypi官网。 资源全名：tencentcloud-sdk-python-dayu-3.0.359.tar.gz
基于单片机的多功能计算器的设计与实现电气工程自动化
weixin_45905610的博客
07-05 389
伴随着科技水平的提高，信息化以及自动化技术也被广泛地运用到了国内的各个行业当中，并且取得了良好的成效。在新时期的大环境下，人们对于电子产中的需求量越来越大，对于各类电子产品的要求也变得日益严格，电子产品由于自身的便利性和强大的功能性，也成为了人们工作与生活当中最为重要的组成部分。文中基于单片机的多功能计算器的设计进行了简要论述，并针对如何实现电气工程自动化的目标，给出了一些行之有效的策略，以供参考、借鉴。
【在线词典】项目实现
2201_75563094的博客
07-08 620
C语言 SQLite3数据库 UDP通信 实现在线词典
基于单片机的空调控制器的设计
最新发布
weixin_45905610的博客
07-08 748
以单片机为核心的空调控制器因其体积小、成本低、功能强、简便易行而得到广泛应用。本设计通过 ＡＴ８９Ｓ５２控制ＤＳ１８Ｂ２０摄取实时温度信息，键盘设定温度值、定时时间及状态，ＬＣＤ１６０２显示相应信息的方法，实现了基于单片机的空调控制器系统的设计。最终实验结果表明，本设计能很好地实现温度显示、控制器定时及根据温度启动相应的功能电路等多种功能，具有一定的创新性及实用性。
如何成为一名优秀的OpenHamrony贡献者？.pptx
09-26
如何成为一名优秀的OpenHamrony贡献者？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值