物联网实验指导手册 - build1-20220914.md · 唯教授/hi3861_hdu_iot_application_cy

**物联网实验指导手册**

[TOC]

# 1、开发环境搭建

## 1.1 资源获取

### 1.1.1 硬件获取

* 可以从老师渠道获取。
* 淘宝店购买。

### 1.1.2 软件获取

**（注意：以下软件包仅用于教学，未经允许不得转发用于商业用途）**

| 工具名称    | 用途说明                          | 版本要求   | 获取渠道                                                     |
| ----------- | --------------------------------- | ---------- | ------------------------------------------------------------ |
| VirtualBox  | Windows安装Ubuntu系统所需的虚拟机 | 6.1.36版本 | [VirtualBox下载链接](https://download.virtualbox.org/virtualbox/6.1.36/VirtualBox-6.1.36-152435-Win.exe) |
| Ubuntu20.04 | 编译环境所需的Linux系统           | 20.04.版本 | [Ubuntu20.04下载链接](https://repo.huaweicloud.com/ubuntu-releases/20.04/ubuntu-20.04.4-desktop-amd64.iso) |
| VScode      | 代码阅读和编辑所需的IDE工具       | 1.70.1版本 | [VScode下载链接](https://az764295.vo.msecnd.net/stable/6d9b74a70ca9c7733b29f0456fd8195364076dda/VSCodeUserSetup-x64-1.70.1.exe) |

## 1.2 编译环境搭建

### 1.2.1 VirtualBox的安装

- 双击在 **1.1.2 软件获取章节下载** 的VirtualBox-6.1.36-152435-Win.exe 安装包，点击下一步，安装VirtualBox。

- 点击浏览按钮，修改VirtualBox的安装路径，然后点击确定按钮，再点击下一步。

- 当出现下面的界面，点击下一步。

- 当出现下面的界面，点击是。

- 当出现下面的安装界面时，点击安装。

- 点击完成，即可完成VirtualBox的安装。

### 1.2.2 Ubuntu20.04的安装

#### 步骤1：导入Ubuntu20.04镜像到VirtualBox

- 打开VirtualBox，点击新建

- 修改虚拟机的名称为hispark，然后修改Ubuntu系统的安装文件夹，把典型配置为linux,然后版本选择 Ubuntu(64-bit)，然后再点击下一步。

- 修改Ubuntu的运行内存大小为4G，然后点击下一步。

- 选择现在创建虚拟硬盘，然后点击创建按钮。

- 选择VDI（VirtualBox磁盘映像），然后点击下一步。

- 选择动态分配，然后点击下一步。

- 修改磁盘空间大小为100GB，然后点击创建按钮。

- 点击设置按钮，选择常规选项，在高级选项处，把共享粘贴板和拖放都设置为双向，然后点击OK按钮。

- 点击VirtualBox的设置，然后点击系统，选择处理器，把处理器的数量改为4。
- 注意：如果您的处理器小于等于4个的话，请把处理器数量改小一些。

- 点击网络，选择网卡2，勾选启动网络连接，选择仅主机网络，点击OK。

- 点击设置按钮，选择存储，然后选择没有盘片，点击光盘按钮，点击选择虚拟盘。

- 选择 **1.1.2 软件获取章节下载**的Ubuntu20.04的镜像文件，然后点击打开按钮。

- 然后点击设置的OK按钮。

- 点击启动，启动Ubuntu系统

#### 步骤2：Ubuntu系统的安装

- 选择中文(简体)，然后点击安装Ubuntu。

- 如果您安装Ubuntu的时候和我一样，因为分辨率问题，导致界面显示不全，无法看到下面的按钮，您需要按住组合键 ``` Ctrl+Alt+t```打开终端面板，然后输入 ```xrandr -s 1920x1080``` 后敲回车，修改Ubuntu的分辨率。

- 选择Chinese，然后点击继续按钮。

- 将安装Ubuntu时下载更新的勾选去掉，然后点击继续按钮。

- 点击现在安装。

- 点击继续按钮。

- 选择上海，然后点击继续按钮。

- 设置好账号和密码，点击继续按钮，此处的账号和密码即为您Ubuntu的登录所需的账号和密码。
- 请按照本文的配置来，账号为：hispark，密码为：hispark。

- 开始安装各种软件。

- Ubuntu安装完成后，点击现在重启按钮。

- 当出现此类弹窗，点击跳过即可。若Ubuntu弹出是否更新的弹窗，点击取消即可。我们先暂时不更新。

- 点击virtualbox的设备，点击安装增强功能

- 当弹出 弹窗询问是否运行自启动软件时，点击取消。
- 此时左边任务栏会多出一个光盘一样的图标，点击并打开光盘图标，进入该文件夹内。

- 在光盘文件夹的空白处，鼠标右键，点击在终端打开。

- 执行下面的命令，进行增强功能的安装。

```
sudo apt-get install  gcc make perl -y

sudo ./VBoxLinuxAdditions.run
```

- 安装成功后，重启一下Ubuntu

#### 步骤3：更新软件

- 当Ubuntu重启之后，点击Ubuntu桌面左下角九个点图标，然后打开软件和更新图标。

- 点击Ubuntu软件，在**下载自**处点击下拉框，选择其他站点。

- 在**中国**下方选择**阿里云**，然后点击选择服务器。

- 此时弹出认证对话框，输入您的Ubuntu登录密码，本文为hispark。

- 点击关闭按钮，然后有对话框时，点击重新载入，此时会有一段时间的软件更新，耐心等待即可。

- 更新完成后，在Ubuntu的桌面，点击鼠标右键，点击在终端打开，打开终端窗口。

- 在终端输入下面两条命令，进行软件更新

```
sudo apt-get update
sudo apt-get upgrade -y
```

#### 步骤4：配置Ubuntu的samba服务

* 执行下面的命令，下载samba服务

```
sudo apt-get install samba samba-common -y 
```

![image-20220817174159666](pic/image-20220817174159666.png)

* 执行下面的命令，配置samba服务，本文配置的密码为hispark

```
sudo chmod 777 /home/hispark

sudo smbpasswd -a hispark
```

![image-20220817174400834](pic/image-20220817174400834.png)

* 执行下面的命令，打开samba的配置文件smb.conf，然后把下面的内容全部粘贴到smb.conf文件的末尾。

```
sudo gedit /etc/samba/smb.conf
```

```sh
[hispark]
	comment = share folder
	browseable = yes
	path = /home/hispark  # sambe共享的文件夹，这里的hispark为本文的账号名，请根据您的Ubuntu账号名进行修改
	public = yes
	available = yes
	guest ok = no
	writable = yes
	valid users = hispark 
	create mask = 0777
	directory mask = 0777
```

* 执行下面的命令，重启samba 服务器

```
sudo service smbd restart
```

* 执行下面的命令，安装net-tools工具

```
sudo apt install net-tools  -y
```

* 执行下面的命令，查看Ubuntu的IP地址，本文docker的IP地址是 192.168.56.104

```
ifconfig
```

* 点击Windows的此电脑，鼠标右键，选择映射网络驱动器

![](pic/image-20220915163005580.png)

* 输入\\\您Ubuntu的IP地址\hispark，然后点击完成，本文的账号为：hispark，密码为：hispark

```
\\192.168.56.101\share
```

* 注意：下方的\\\192.168.56.101\share中的192.168.56.101，是本文ubuntu的IP地址，每个人的ubuntu的IP地址可能不一样，这里需要注意。

* 这样Ubuntu的家目录就能够在Windows的磁盘下面显示了。这样您就可以方便的进行Windows和Ubuntu之间的文件共享了。

### 1.2.3 Docker镜像的安装

#### 步骤1：安装Docker软件

- 在终端输入下面的命令，安装docker工具

```
sudo apt install docker.io -y
```

#### 步骤2：配置docker用户权限

* 在Ubuntu的终端，执行下面的命令，配置docker用户的权限

```shell
sudo groupadd docker

sudo gpasswd -a $USER docker

newgrp docker

sudo chmod a+rw /var/run/docker.sock
```

#### 步骤3：下载Docker镜像文件到Ubuntu

* 在Ubuntu的终端，执行下面命令下载docker镜像到Ubuntu，这里需要一点时间，请耐心等待。

```sh
docker pull hispark/hi3861_hdu_iot_application:1.0
```

![](pic/image-20220915163537648.png)

#### 步骤4：查看docker image信息

- 输入下面的命令，查看docker image的具体信息

```
docker image ls
```

![](pic/image-20220915165557088.png)

#### 步骤4：启动docker编译环境

- 执行下面的命令，启动docker编译环境，其中第一个openharmony为自定义的docker的名字，3bd9d23df244为我Ubuntu下docker的IMAGE ID，这里请根据自己docker image ID的不同自行修改。

```shell
docker run -itd -p 2222:22 -v /home/hispark/code:/home/hispark --name openharmony 3bd9d23df244

# -p：2222:22 linux的2222端口映射到容器22端口, 访问linux的2222端口即可访问容器的ssh
# -v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射
# --name：为创建的容器命名。
```

![](pic/image-20220915171304259.png)

- **注意：如果您的Ubuntu重启之后，需要再次启动dcoker编译环境的话**，需要执行下面的命令

```sh
# 查看当前运⾏的docker实例状态
docker ps -a

# 在上⼀条指显示结果列表中，查看openharmony的STATUS
# 如为 Exited，则需要执⾏下⾯这条指令，再次启动
# 如为 Up，则跳过下⾯这条指令
docker start openharmony

# 进⼊docker编译环境
docker exec -it openharmony bash
# 执⾏后，出现类似如下信息，说明再次进⼊成功
# root@hispark:/home/openharmony#
```

* 如果您想退出docker的编译环境，需要执行下面的命令。

```
exit
```

### 1.2.4 下载代码

* 在docker编译环境的终端，执行下面的命令，进行代码的下载。

```
 cd /home/hispark
 
 git clone https://gitee.com/HiSpark_group/hi3861_hdu_iot_application.git
```

![](pic/image-20220915173309384.png)

* 在docker编译环境终端，执行下面的命令，退出docker环境。

```
exit
```

* 执行下面的命令，进入Ubuntu的 /home/hispark目录下,然后添加权限，"code"为步骤四映射文件夹，用户可以自己指定。

```
cd /home/hispark

sudo chown hispark:hispark code -R
```

### 1.2.5 Vscode的安装

*  双击在**1.1.2 软件获取章节下载**的VScode安装包，windows下安装，点击下一步进行安装。

* 点击浏览按钮，选择VScode的安装路径，然后点击下一步。

* 出现下方界面，点击下一步。

* 出现下方界面，点击下一步。

* 出现下方界面，点击安装。

* 出现下方界面，点击完成。

## 1.3 运行第一个程序Hello world

### 1.3.1 编写第一个程序HelloWorld

#### 步骤1：代码加载

* 点击VScode 左上角的File，然后点击Open Folder

* 选择ubuntu共享目录的 /home/openharmony/hi3861_hdu_iot_application/src/applications/sample/wifi-iot/app/，然后点击选择文件夹。

* 代码导入成功后，当出现下面的对话框，勾选复选框，然后点击 yes按钮即可。

#### 步骤2：编写业务代码

* 点击代码资源列表的空白处，然后鼠标右键，然后点击New Folder。

* 新建一个helloworld的文件夹。

* 点击helloworld文件夹，然后鼠标右键，点击New File。

* 创建一个helloworld_demo.c的c源文件。

* 将下方的代码复制到helloworld_demo.c文件中

```c
#include <stdio.h> // c语言的标准库文件
#include "ohos_init.h"		// 提供用于openharmony初始化和启动服务

void HelloWorld(void)       
{
    // 打印一下 helloworld!的字符串
    printf("helloworld! \r\n"); 
}

// APP_FEATURE_INIT()是openharmony封装好的函数入口，实现main函数的功能。
APP_FEATURE_INIT(HelloWorld);   
```

#### 步骤3：编写构建业务代码的BUILD.gn

* 在helloworld文件夹中创建一个BUILD.gn的文件。

* 将下方的代码复制到BUILD.gn文件中。

```python
static_library("helloworld_demo") {
  sources = [
    "helloworld_demo.c",
  ]
  include_dirs = [
    "//base/iot_hardware/peripheral/interfaces/kits",
    ]
}
```

- 其中：
  - static_library：将sources中的源文件编译后生成``helloworld_demo``库文件
  - sources：实现本工程的功能需要编译的所有.c源文件。
  - include_dirs：sources中的所有.c源文件所包含的头文件的路径。

#### 步骤4：修改构建工程的BUILD.gn

* 打开/home/openharmony/hi3861_hdu_iot_application/src/applications/sample/wifi-iot/app/目录下的BUILD.gn文件
* 将features字段的内容替换为 ``helloworld:helloworld_demo``
  * 第一个helloworld指的是需要编译的工程目录
  * 第二个helloworld_demo指的是applications/sample/wifi-iot/app/helloworld_demo/BUILD.gn文件中的静态库，名称为helloworld_demo

### 1.3.2 代码编译

* 在docker编译环境的终端，执行下面的命令，进入代码的src目录，然后安装hb工具。

```
cd /home/openharmony/hi3861_hdu_iot_application/src/

pip install build/lite
```

* 在docker的命令行终端，执行下面的命令，进行编译前的配置，当出现 **[OHOS INFO] Input code path:**的时候，输入 ``.``号，然后敲回车；然后出现**hisilicon>wifiiot_hispark_pegasus**的提示时，直接敲回车即可配置成功。

```
hb set
```

* 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb  build  -f
```

* 编译成功后，会在 /home/openharmony/hi3861_hdu_iot_application/src/out/hispark_pegasus/wifiiot_hispark_pegasus/目录下生成 Hi3861的镜像文件 Hi3861_wifiiot_app_allinone.bin。

### 1.3.3 硬件环境准备

#### 1.3.3.1 硬件准备

* 参考第五章HiSpark小车组装的内容，进行硬件的组装。

#### 1.3.3.2 串口驱动的安装

* 步骤1：先使用配套的Type-C数据线，将开发板与电脑的USB口进行直连，并且接开关拨到右侧，使开发板能够正常工作。如下图所示。

* 步骤2：点击进入https://www.wch.cn/downloads/CH341SER_EXE.html，下载CH340G驱动。

* 步骤3：双击刚下载好的CH341SER.EXE驱动，进入安装界面，点击安装按钮即可，驱动安装成功后，再点击确定按钮。

* 步骤4：打开Windows的设备管理器，查看串口设备，若未出现CH340串口设备，请检查驱动是否安装正常。

### 1.3.4 镜像烧录

#### 步骤1：下载HiBurn镜像烧录工具

**（注意：以下软件包仅用于教学，未经允许不得转发用于商业用途）**

* 访问下面的链接，下载HiBurn镜像烧录工具

```
http://www.hihope.org/download/download.aspx?mtt=34
```

* 将下载下来的压缩包进行解压，然后进入tools文件夹中，把openocd压缩包进行解压，HiBurn工具在tools\openocd\drivers\目录下

#### 步骤2：加载镜像到HiBurn工具中

* 双击打开HiBurn.exe烧录工具，点击**Refresh按钮**，使HiBurn能够识别到开发板的串口设备。
* 点击**COM的下拉框**，选择与设备管理器一致的CH340的串口号，也就是与Hi3861连接的串口号。
* 点击**Select file按钮**，选择刚在docker中编译生成的Hi3861_wifiiot_app_allinone.bin镜像文件
* 勾选**Auto burn**。

#### 步骤3：烧录镜像到开发板

* 点击connect按钮，进行镜像的烧录，当出现Connecting...的时候，按一下**开发板的RST键。**

* 当出现下面的进度条，就说明正在进行镜像的烧录

* 当出现下面的打印信息，说明镜像已经烧录成功，然后**再点击HiBurn的Disconnect按钮**，与开发板断开连接。

### 1.3.5 运行HelloWorld程序

#### 步骤1：下载SSCOM串口工具

**（注意：以下软件包仅用于教学，未经允许不得转发用于商业用途）**

- 访问下面的链接，下载HiBurn镜像烧录工具

```
http://www.hihope.org/download/download.aspx?mtt=34
```

- 将下载下来的压缩包进行解压，然后进入tools文件夹中，双击打开sscom5.13.1.exe 串口工具

#### 步骤2：使用SSCOM接收开发板的串口数据

* 首先点击串口工具的刷新按钮，使串口工具能够识别到开发板的串口设备。
* 点击端口号的下拉框，选择与设备管理器一致的COM口
* 再点击打开串口按钮，开始接收开发板的串口数据。

#### 步骤3：运行helloworld程序

* 按一下开发板的RST键，让开发板系统运行起来。

* 通过串口工具可以看到 helloworld！已经打印出来，说明我们编写的helloworld程序已经成功在开发板上运行起来了。

# 2、基础实验

## 2.1 GPIO实验-主芯片GPIO输出实验

### 2.1.1 实验目的

* 本实验通过控制主芯片GPIO 9输出高低电平，实现对交通灯LED3红灯亮灭的控制。

### 2.1.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件配置：将MOTOR_EN拨码开关由ON拨到OFF，硬件搭建如下图所示：

[]:

### 2.1.3 接口说明

#### 2.1.3.1 IoTGpioInit()

| **定义：** | unsigned int IoTGpioInit(unsigned int id); |
| ------------ | --------------------------------------------------------- |
| **功能：** | 初始化指定的IO |
| **参数：** | id:指定的IO号 |
| **返回值：** | IOT_SUCCESS：初始化成功 IOT_FAILURE:初始化失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_gpio.h |

#### 2.1.3.2 IoSetFunc()

| **定义：** | unsigned int IoSetFunc(unsigned int id, unsigned char val); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 配置指定IO的复用功能 |
| **参数：** | id:指定的IO号 val:配置的复用功能 |
| **返回值：** | IOT_SUCCESS：配置成功 IOT_FAILURE:配置失败 |
| **依赖：** | ./iot_gpio_ex.h |

#### 2.1.3.3 IoTGpioSetDir()

| **定义：** | unsigned int IoTGpioSetDir(unsigned int id, IotGpioDir dir); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 设置指定IO的管脚方向 |
| **参数：** | id:指定的IO号 dir:GPIO管脚方向(IOT_GPIO_DIR_IN、IOT_GPIO_DIR_OUT) |
| **返回值：** | IOT_SUCCESS：设置成功 IOT_FAILURE：设置失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_gpio.h |

#### 2.1.3.4 IoTGpioSetOutputVal()

| **定义：** | unsigned int IoTGpioSetOutputVal(unsigned int id, IotGpioValue val); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 设置指定IO的输出电平 |
| **参数：** | id:指定的IO号 val:GPIO管脚的输出电平（IOT_GPIO_VALUE0、IOT_GPIO_VALUE1） |
| **返回值：** | IOT_SUCCESS：设置成功 IOT_FAILURE：设置失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_gpio.h |

### 2.1.4 实验流程

* 步骤1：复制led_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
        └─ sample
            └─ wifi-iot
            	└─ app
                	├─ BUILD.gn
                	└─led_control
                        ├─ BUILD.gn  
                        ├─ hal_iot_gpio_ex.c
                        ├─ iot_gpio_ex.h
                        └─ led_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加led_control:led_control。注：第一个led_control指的是需要编译的工程目录，第二个led_control指的是applications/sample/wifi-iot/app/led_control/BUILD.gn文件中的静态库，名称为led_control。

```c
import("//build/lite/config/component/lite_component.gni")
lite_component("app") {
  features = [ "led_control:led_control", ]
}
```

* 步骤3：LED亮灭原理：通过GPIO口输出高低电平控制LED亮灭。

从硬件原理图可以分析出LED3红灯对应的管脚是GPIO09，因此我们需要通过控制GPIO09的高低电平输出，来控制LED3的亮灭。

```c
1 #include <stdio.h>
2 #include <unistd.h>
3 
4 #include "iot_gpio_ex.h"
5 #include "ohos_init.h"
6 #include "cmsis_os2.h"
7 #include "iot_gpio.h"
8 
9 static void LedExampleEntry(void)
10 {
11 // LED3的GPIO初始化
12 IoTGpioInit(IOT_IO_NAME_GPIO_9);
13 // 设置GPIO9的管脚复用关系为GPIO
14 IoSetFunc(IOT_IO_NAME_GPIO_9, IOT_IO_FUNC_GPIO_9_GPIO);
15 // GPIO方向设置为输出
16 IoTGpioSetDir(IOT_IO_NAME_GPIO_9, IOT_GPIO_DIR_OUT);
17 
18 for (int i = 0; i < 10; i++) {
19 // 设置GPIO09输出高电平点亮红色交通灯LED3
20 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE1);
21 
22 // 延时函数毫秒（设置高电平持续时间）
23 hi_sleep(1000);
24 // 设置GPIO09输出低电平熄灭红色交通灯LED3
25 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE0);
26 // 延时函数毫秒（设置低电平持续时间）
27 hi_sleep(1000);
28 }
29 }
30 
31 static void LedControlTask(void)
32 {
33 osThreadAttr_t attr;
34 
35 attr.name = "LedCntrolDemo";
36 attr.attr_bits = 0U;
37 attr.cb_mem = NULL;
38 attr.cb_size = 0U;
39 attr.stack_mem = NULL;
40 attr.stack_size = 1024; /* 堆栈大小为1024 */
41 attr.priority = osPriorityNormal;
42 // 报错
43 if (osThreadNew((osThreadFunc_t)LedExampleEntry, NULL, &attr) == NULL) {
44 printf("[LedExample] Failed to create LedTask!\n");
45 }
46 }
47 
48 APP_FEATURE_INIT(LedControlTask);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤6：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.1.5 实验结果

* 软件烧录成功后，按一下开发板的RESET按键复位开发板，可以看到LED3灯先亮起然后熄灭，循环10次后LED3灯熄灭，说明我们使用GPIO控制LED灯的实验成功。LED的实验效果图如下图所示。

### 2.1.6 扩展实验

* 本实验学习了如何点亮一个灯，请学生做如下实验：
  
  * 1、通过控制GPIO 5，GPIO6的高低电平的输出，从而控制左侧电机前进后退。 
  
  提示：GPIO5,GPIO6同时置高，左侧电机前进；GPIO 5，GPIO6同时置低，左侧电机后退。

## 2.2 GPIO实验-主芯片GPIO输入实验

### 2.2.1 实验目的

* 本实验通过使用主芯片GPIO 0和GPIO 1输入功能，实现对左右侧电机编码器A相中断的计数。

### 2.2.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件配置：将J13跳帽跳至C2A-GPIO 0，J27跳帽跳至C2B-GPIO 12；硬件搭建如下图所示：

### 2.2.3 接口说明

#### 2.2.3.1 IoSetPull()

| **定义：** | **unsigned int IoSetPull(unsigned int id, IotIoPull val);** |
| ------------ | ----------------------------------------------------------- |
| **功能：** | 设置指定GPIO的上下拉功能 |
| **参数：** | id:指定的IO号 val：待设置的上下拉状态 |
| **返回值：** | IOT_SUCCESS：设置成功 IOT_FAILURE：设置失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_gpio.h |

#### 2.2.3.2 IoTGpioRegisterIsrFunc()

| **定义：** | unsigned int IoTGpioRegisterIsrFunc(unsigned int id, IotGpioIntType intType,IotGpioIntPolarity intPolarity, GpioIsrCallbackFunc func, char *arg); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 设置指定GPIO的中断功能 |
| 参数： | id:指定的IO号 intType：中断类型 intPolarity：中断极性 func：中断触发时的回调函数 arg：中断回调函数中使用的参数的指针 |
| **返回值：** | IOT_SUCCESS：设置成功 IOT_FAILURE：设置失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_gpio.h |

#### 2.2.3.3 IoTGpioGetInputVal()

| **定义：** | unsigned int IoTGpioGetInputVal(unsigned int id, IotGpioValue *val); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 读取指定GPIO管脚的高低电平 |
| **参数：** | id:指定的IO号 val：返回读取的GPIO管脚电平值的指针 |
| **返回值：** | IOT_SUCCESS：读取成功 IOT_FAILURE：读取失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_gpio.h |

### 2.2.4 实验流程

* 步骤1：复制encoder_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
       └─ sample
           └─ wifi-iot
           └─ app
              ├─ BUILD.gn
              └─encoder_control
                      ├─ BUILD.gn  
                      ├─ hal_iot_gpio_ex.c
                      ├─ iot_gpio_ex.h
                      └─ encoder_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加encoder_control:encoder_control。注：第一个encoder_control指的是需要编译的工程目录，第二个encoder_control指的是applications/sample/wifi-iot/app/ encoder_control /BUILD.gn文件中的静态库，名称为encoder_control。

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

lite_component("app") {
  features = [ "encoder_control:encoder_control", ]
}
```

* 步骤3：原理：Hi3861 GPIO口都带有中断功能，根据外设中断，将IO口设置为输入（输出），上拉（下拉），上升沿（下降沿）触发。

从硬件原理图可以分析出左侧电机编码器对应的是GPIO0_0和GPIO0_12，因此我们需要配置GPIO0_0和GPIO0_12为中断模式，且为上升沿触发，核心代码如方下所示:

```c
1 /*
2 电机编码器的相关API接口
3 */
4 
5 #include <stdio.h>
6 #include <stdlib.h>
7 
8 #include "ohos_init.h"
9 #include "cmsis_os2.h"
10 #include "iot_gpio.h"
11 #include "hi_io.h"
12 #include "iot_gpio_ex.h"
13 #include "hi_time.h"
14 
15 static int encoderLeftACounter = 0;
16 static int encoderLeftBCounter = 0;
17 static int rc = 0;
18 volatile static int rt = 0;
19 
20 /* 左电机中断处理函数 */
21 static void LeftACounterHandler(void) {
22 encoderLeftACounter++;
23 if (encoderLeftACounter == 1 && encoderLeftBCounter == 0) {
24 rc = 1;
25 }
26 if (rc == 1) {
27 printf("A , forward, encoderLeftACounter = %d\r\n", encoderLeftACounter);
28 }
29 }
30 
31 /* 左电机中断处理函数 */
32 static void LeftBCounterHandler(void) {
33 encoderLeftBCounter++;
34 if (encoderLeftACounter == 0 && encoderLeftBCounter == 1) {
35 rc = 2;
36 }
37 if (rc == 2) {
38 printf("B, backward, encoderLeftBCounter = %d\r\n", encoderLeftBCounter);
39 }
40 }
41 
42 void EncoderInit(void)
43 {
44 // 左侧电机编码器A相的GPIO初始化
45 IoTGpioInit(IOT_IO_NAME_GPIO_0);
46 // 设置GPIO0的管脚复用关系为GPIO
47 IoSetFunc(IOT_IO_NAME_GPIO_0, IOT_IO_FUNC_GPIO_0_GPIO);
48 // GPIO0方向设置为输入
49 IoTGpioSetDir(IOT_IO_NAME_GPIO_0, IOT_GPIO_DIR_IN);
50 // 设置GPIO0为上拉功能
51 IoSetPull(IOT_IO_NAME_GPIO_0, IOT_IO_PULL_UP);
52 // 使能GPIO0的中断功能, 上升沿触发中断，rightACounterHandler为中断的回调函数
53 IoTGpioRegisterIsrFunc(IOT_IO_NAME_GPIO_0, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_RISE_LEVEL_HIGH, LeftACounterHandler, NULL);
54 
55 // 左侧电机编码器B相的GPIO初始化
56 IoSetFunc(IOT_IO_NAME_GPIO_12, IOT_IO_FUNC_GPIO_12_GPIO);
57 // 设置GPIO1的管脚复用关系为GPIO
58 IoTGpioSetDir(IOT_IO_NAME_GPIO_12, IOT_GPIO_DIR_IN);
59 // 设置GPIO1为上拉功能
60 IoSetPull(IOT_IO_NAME_GPIO_12, IOT_IO_PULL_UP);
61 // 使能GPIO1的中断功能, 上升沿触发中断，rightBCounterHandler 为中断的回调函数
62 IoTGpioRegisterIsrFunc(IOT_IO_NAME_GPIO_12, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_RISE_LEVEL_HIGH, LeftBCounterHandler, NULL); // 上升沿触发中断
63 }
64 
65 void EncoderEntry(void)
66 {
67 // 左侧电机编码器初始化
68 EncoderInit();
69 }
70 
71 static void EncoderControlTask(void)
72 {
73 osThreadAttr_t attr;
74 
75 attr.name = "LedCntrolDemo";
76 attr.attr_bits = 0U;
77 attr.cb_mem = NULL;
78 attr.cb_size = 0U;
79 attr.stack_mem = NULL;
80 attr.stack_size = 1024; /* 堆栈大小为1024 */
81 attr.priority = osPriorityNormal;
82 // 报错
83 if (osThreadNew((osThreadFunc_t)EncoderEntry, NULL, &attr) == NULL) {
84 printf("[LedExample] Failed to create LedTask!\n");
85 }
86 }
87 
88 APP_FEATURE_INIT(EncoderControlTask);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.2.5 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，可以看到当我们转动小车的左轮时，电机编码器会产生中断，从而进入中断的回调函数，可以在串口工具中看到具体的中断回调函数的打印信息，说明主芯片GPIO输入功能，实现对左编码器中断监测，电机前转A相触发，电机后转B相触发。中断时的打印信息如下所示。

前进A相：

![](pic/image-20220921192354624.png)

后退B相：

![](pic/image-20220921192507726.png)

### 2.2.6 扩展实验

* 本实验学习了通过使用主芯片GPIO输入功能，实现对左侧编码器中断的监测计数，请学生做如下实验：
  
  * 1、让编码器与电机同时工作，并计数，每一秒通过串口打印当前计数，计数500次停止。
  
  			提示：GPIO 5和GPIO 6高低电平控制电机转动；
  
  		   GPIO 0和GPIO 12实现左侧编码器中断计数；

## 2.3 GPIO实验-IO扩展芯片GPIO输出实验

### 2.3.1 实验目的

* 本实验内容：IO扩展芯片通过I2C读写实现IO3_0-IO15输出电平高低，实现控制左三色车灯的亮灭。**扩展芯片手册(型号：pca95555D,118；品牌：NXP)获取：https://so.szlcsc.com/global.html?k=pca95555&hot-key=，点击数据手册进行下载**。

### 2.3.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件搭建如下图所示：

### 2.3.3 实验流程

* 步骤1：复制tricolor_lamp_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
       └─ sample
       └─ wifi-iot
            └─ app
                ├─ BUILD.gn
                └─tricolor_lamp_control
                         ├─ BUILD.gn  
                         ├─ hal_iot_gpio_ex.c
                         ├─ iot_gpio_ex.h
                         ├─ pca9555.c
                         ├─ pca9555.h
                         └─ tricolor_lamp_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加tricolor_lamp_control: TraColorLampControl。注：tricolor_lamp_control指的是需要编译的工程目录，TraColorLampControl指的是applications/sample/wifi-iot/app/tricolor_lamp_control/BUILD.gn文件中的静态库，名称为TraColorLampControl。

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

lite_component("app") {
  features = [ "tricolor_lamp_control:TraColorLampControl", ]
}
```

* 步骤3：原理：I2C通信原理：I2C通信中，主机通过时钟线SCL发送时钟信号，通过数据线SDA发送数据（包括从机地址、指令、数据包等），在发送完一帧数据后，需要等待从机的响应，才能继续发送下一帧数据，因此I2C属于同步通信。

从硬件原理图可以分析出左三色车灯的红、绿、蓝分别对应IO扩展芯片的IO1_3,IO1_4,IO1_5，如果三灯全亮的话会亮白灯，因此需要分别控制IO扩展芯片的IO1_3，IO1_4, IO1_5的高低电平输出，来控制左三色车灯的亮灭。关键代码如下所示：

```c
1 #include "pca9555.h"
2 #include <stdio.h>
3 #include <unistd.h>
4 #include "hi_timer.h"
5 
6 #include "ohos_init.h"
7 #include "cmsis_os2.h"
8 #include "iot_gpio_ex.h"
9 #include "iot_gpio.h"
10 
11 static void TraColorLampControl(void)
12 {
13 // IO扩展芯片初始化
14 PCA9555Init();
15 // 配置IO扩展芯片的part1的所有管脚为输出
16 SetPCA9555GpioValue(PCA9555_PART1_IODIR, 0x00);
17 // 配置左右三色车灯全灭
18 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, LED_OFF);
19 
20 /*
21 控制左三色车灯跑马灯，红、绿、蓝、白：每隔一秒一次亮
22 红灯：IO1_3 ==> 0000 1000 ==> 0x08
23 绿灯：IO1_4 ==> 0001 0000 ==> 0x10
24 蓝灯：IO1_5 ==> 0010 0000 ==> 0x20
25 白灯：三灯全亮 ==> 0011 1000 ==> 0x38
26 */
27 while (1) {
28 // 设置红灯：IO1_3 输出高电平点亮左车红灯
29 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, 0x08);
30 // 延时函数毫秒（设置高电平持续时间）
31 hi_sleep(1000);
32 // 设置 绿灯：IO1_4 输出高电平点亮左车绿灯
33 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, 0x10);
34 // 延时函数毫秒（设置低电平持续时间）
35 hi_sleep(1000);
36 // 蓝灯：IO1_5 输出高电平点亮左车蓝灯
37 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, 0x20);
38 // 延时函数毫秒（设置高电平持续时间）
39 hi_sleep(1000);
40 // 设置 IO1_3 IO1_4 IO1_5 都输出高电平，左车亮白灯
41 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, 0x38);
42 // 延时函数毫秒（设置低电平持续时间）
43 hi_sleep(1000);
44 }
45 }
46 
47 static void TraColorLampControlEntry(void)
48 { 
49 osThreadAttr_t attr;
50 attr.name = "LedCntrolDemo";
51 attr.attr_bits = 0U;
52 attr.cb_mem = NULL;
53 attr.cb_size = 0U;
54 attr.stack_mem = NULL;
55 attr.stack_size = 1024; /* 堆栈大小为1024 */
56 attr.priority = osPriorityNormal;
57 // 报错
58 if (osThreadNew((osThreadFunc_t)TraColorLampControl, NULL, &attr) == NULL) {
59 printf("[LedExample] Failed to create LedTask!\n");
60 }
61 }
62 
63 APP_FEATURE_INIT(TraColorLampControlEntry);
```

- 步骤15：修改.device/soc/hisilicon/hi3861v100/sdk_liteos/build/config/usr_config.mk文件。在这个配置文件中打开I2C驱动宏。搜索字段CONFIG_I2C_SUPPORT ，并打开I2C。配置如下：

```
  # CONFIG_I2C_SUPPORT is not set
  CONFIG_I2C_SUPPORT=y
  ```

- 步骤4：编译工程代码
  
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.3.4 实验结果

* 软件烧录成功后，按一下开发板的RESET按键复位开发板，可以看到小车左边车灯每隔一秒依次亮红灯、绿灯、蓝灯、白灯，说明我们使用IO扩展芯片的GPIO控制三色车灯的实验成功。三色车灯的实验效果图如下图所示。

### 2.3.5 扩展实验

* 本实验学习了如何使用IO扩展芯片的GPIO控制三色车灯，请学生做如下实验：
  * 1、同时控制左右两个三色车灯4s内红，绿，蓝，白灯循环一次。
  
      提示：左右三色灯IO1_0-IO1_5。

## 2.4 GPIO实验-IO扩展芯片GPIO输入实验

### 2.4.1 实验目的

* 本实验通过I2C读写IO扩展芯片实现按键输入功能。**扩展芯片手册(型号：pca95555D,118；品牌：NXP)获取：https://so.szlcsc.com/global.html?k=pca95555&hot-key=，点击数据手册进行下载**。

### 2.4.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件搭建如下图所示：

### 2.4.3 实验流程

* 步骤1：复制 button_control 目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```c
.
└─applications
      └─ sample
         └─ wifi-iot
            └─ app
               ├─ BUILD.gn
               └─button_control
                      ├─ BUILD.gn  
                      ├─ hal_iot_gpio_ex.c
                      ├─ iot_gpio_ex.h
                      ├─ pca9555.c
                      ├─ pca9555.h
                      └─ button_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加button_control: button_control。注：第一个button_control指的是需要编译的工程目录，第二个button_control指的是applications/sample/wifi-iot/app/ button_control /BUILD.gn文件中的静态库，名称为button_control。

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

lite_component("app") {
  features = [ "button_control:button_control", ]
}
```

从硬件原理图可以分析出按键S3对应的是IO0_2,按键S4对应的是IO0_3,按键S5对应的是IO0_4，因此我们需要分别使用IO扩展芯片的IO0_2，IO0_3, IO0_4的输入功能，监测按键S3、S4、S5的按压中断事件。关键代码如下所示：

```c
1 #include "pca9555.h"
2 #include <stdio.h>
3 #include <unistd.h>
4 #include "hi_timer.h"
5 
6 #include "ohos_init.h"
7 #include "cmsis_os2.h"
8 #include "iot_gpio_ex.h"
9 #include "iot_gpio.h"
10 #include "iot_errno.h"
11 #include "hi_errno.h"
12 
13 volatile static int g_buttonState = 0;
14 
15 void OnFuncKeyPressed(const char *arg)
16 {
17 (void) arg;
18 g_buttonState = 1;
19 }
20 
21 void FuncKeyInit(void)
22 {
23 uint8_t write[2] = {0X12, 0x34};
24 
25 // 使能GPIO11的中断功能, OnFuncKeyPressed 为中断的回调函数
26 IoTGpioRegisterIsrFunc(IOT_IO_NAME_GPIO_11, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_FALL_LEVEL_LOW, OnFuncKeyPressed, NULL);
27 
28 // S3:IO0_2,S4:IO0_3,S5:IO0_4 0001 1100 => 0x1c 将IO0_2,IO0_3,IO0_4方向设置为输入，1为输入，0位输出
29 SetPCA9555GpioValue(PCA9555_PART0_IODIR, 0x1c);
30 
31 // 使能IO扩展芯片的中断寄存器
32 IoTI2cWrite(0, 0XD4, write, 2);
33 }
34 
35 void GetFunKeyState(void)
36 {
37 uint8_t ext_io_state = 0;
38 uint8_t ext_io_state_d = 0;
39 uint8_t status;
40 
41 while(1) {
42 if (g_buttonState == 1) {
43 uint8_t diff;
44 status = PCA9555I2CReadByte(&ext_io_state);
45 if(status != IOT_SUCCESS) {
46 printf("i2c error!\r\n");
47 ext_io_state = 0;
48 ext_io_state_d = 0;
49 g_buttonState = 0;
50 continue;
51 }
52 
53 diff = ext_io_state ^ ext_io_state_d;
54 if (diff == 0) {
55 printf("diff = 0! state:%0X, %0X\r\n", ext_io_state, ext_io_state_d);
56 }
57 if ((diff & 0x04) && ((ext_io_state & 0x04) == 0)) {
58 printf("button1 pressed,\r\n");
59 } else if ((diff & 0x08) && ((ext_io_state & 0x08) == 0)) {
60 printf("button2 pressed \r\n");
61 } else if ((diff & 0x10) && ((ext_io_state & 0x10) == 0)) {
62 printf("button3 pressed \r\n");
63 }
64 status = PCA9555I2CReadByte(&ext_io_state);
65 ext_io_state_d = ext_io_state;
66 g_buttonState = 0;
67 }
68 usleep(20);
69 }
70 }
71 
72 static void ButtonControl(void)
73 {
74 printf("ButtonControl\r\n");
75 // IO扩展芯片初始化
76 PCA9555Init();
77 // 配置IO扩展芯片的part1的所有管脚为输出
78 SetPCA9555GpioValue(PCA9555_PART1_IODIR, 0x00);
79 // 配置左右三色车灯全灭
80 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, LED_OFF);
81 
82 // 按键中断初始化
83 FuncKeyInit();
84 
85 // 获取实时的按键状态
86 GetFunKeyState();
87 }
88 
89 static void ButtonControlEntry(void)
90 { 
91 osThreadAttr_t attr;
92 attr.name = "LedCntrolDemo";
93 attr.attr_bits = 0U;
94 attr.cb_mem = NULL;
95 attr.cb_size = 0U;
96 attr.stack_mem = NULL;
97 attr.stack_size = 1024; /* 堆栈大小为1024 */
98 attr.priority = osPriorityNormal;
99 // 报错
100 if (osThreadNew((osThreadFunc_t)ButtonControl, NULL, &attr) == NULL) {
101 printf("[LedExample] Failed to create LedTask!\n");
102 }
103 }
104 
105 APP_FEATURE_INIT(ButtonControlEntry);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.4.4 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，当我们按下按键S3时，串口工具会打印button1 pressed，当我们按下按键S4时，串口工具会打印button2 pressed，当我们按下按键S5时，串口工具会打印button3 pressed，说明我们使用IO扩展芯片GPIO的输入功能，实现对按键中断监测的实验成功。串口的打印信息如下所示。

![](pic/image-20220921201042165.png)

### 2.4.5 扩展实验

* 本实验学习了IO扩展芯片实现按键输入功能，请学生做如下实验：
  * 1、按键S1控制左右三色灯亮红色，按键S2控制左右三色灯亮蓝色，按键S3控制左右三色灯亮绿色。
  
      提示：代码参考2.3节，2.4节。

## 2.5 GPIO综合实验

### 2.5.1 实验目的

* 本实验通过使用主芯片GPIO的输入和输出功能，实现对超声波的驱动。

### 2.5.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.接线要求：超声波模块-J1，J26：GPIO7 - TRIG，J6跳线帽去掉；硬件搭建如下图所示：

<img src="pic/image-20220916111808500.png" style="zoom: 50%;"/> <img src="pic/image-20220916111934216.png" style="zoom: 67%;" />
 
 ![](pic/image-20220921203553211.png)

### 2.5.3 实验流程

* 步骤1：复制hcsr04_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
      └─ sample
         └─ wifi-iot
            └─ app
                ├─ BUILD.gn
                └─hcsr04_control
                         ├─ BUILD.gn  
                         ├─ hal_iot_gpio_ex.c
                         ├─ iot_gpio_ex.h
                         └─ hcsr04.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加hcsr04_control: hcsr04_control。注：第一个hcsr04_control指的是需要编译的工程目录，第二个hcsr04_control指的是applications/sample/wifi-iot/app/ hcsr04_control/BUILD.gn文件中的静态库，名称为hcsr04_control。

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

lite_component("app") {
  features = [ "hcsr04_control:hcsr04_control", ]
}
```

* 步骤3：超声波实现原理只需要提供一个 10uS 以上脉冲触发信号，该模块内部将发出 8 个 40kHz 周期电平并检测回波。一旦检测到有回波信号则输出回响信号 。回响信号的脉冲宽度与所测的距离成正比。由此通过发射信号到收到的回响信号时间间隔可以计算得到距离。公式：距离=高电平时间*声速（340M/S）/2；建议测量周期为 60ms 以上，以防止发射信号对回响信号的影响。

从硬件原理图可以分析出超声波传感器对应的管脚是ECHO_GPIO08和TRIG_GPIO07,关键代码如下所示：

```c
1 /*
2 HCSR05 超声波模块的相关API接口
3 */
4 #include <stdio.h>
5 #include <stdlib.h>
6 
7 #include "ohos_init.h"
8 #include "cmsis_os2.h"
9 #include "iot_gpio.h"
10 #include "hi_io.h"
11 #include "iot_gpio_ex.h"
12 
13 void Hcsr04Init(void)
14 {
15 // 设置超声波Echo为输入模式
16 // 设置GPIO8功能（设置为GPIO功能）
17 IoSetFunc(IOT_IO_NAME_GPIO_8, IOT_IO_FUNC_GPIO_8_GPIO);
18 // 设置GPIO8为输入方向
19 IoTGpioSetDir(IOT_IO_NAME_GPIO_8, IOT_GPIO_DIR_IN);
20 
21 // 设置GPIO7功能（设置为GPIO功能）
22 IoSetFunc(IOT_IO_NAME_GPIO_7, IOT_IO_FUNC_GPIO_7_GPIO);
23 // 设置GPIO7为输出方向
24 IoTGpioSetDir(IOT_IO_NAME_GPIO_7, IOT_GPIO_DIR_OUT);
25 }
26 
27 float GetDistance(void)
28 {
29 // 定义变量
30 static unsigned long start_time = 0, time = 0;
31 float distance = 0.0;
32 static char line[32] = {0};
33 IotGpioValue value = IOT_GPIO_VALUE0;
34 unsigned int flag = 0;
35 
36 // 设置GPIO7输出低电平
37 /* 给trig发送至少10us的高电平脉冲，以触发传感器测距 */
38 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_7, IOT_GPIO_VALUE1);
39 // 延时函数（设置高电平持续时间）
40 hi_udelay(20);
41 // 设置GPIO7输出高电平
42 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_7, IOT_GPIO_VALUE0);
43 /* 计算与障碍物之间的距离 */
44 while (1) {
45 // 获取GPIO8的输入电平状态
46 IoTGpioGetInputVal(IOT_IO_NAME_GPIO_8, &value);
47 //判断GPIO8的输入电平是否为高电平并且flag为0
48 if ( value == IOT_GPIO_VALUE1 && flag == 0) {
49 // 获取系统时间
50 start_time = hi_get_us();
51 // 将flag设置为1
52 flag = 1;
53 }
54 //判断GPIO8的输入电平是否为低电平并且flag为1
55 if (value == IOT_GPIO_VALUE0 && flag == 1) {
56 // 获取高电平持续时间
57 time = hi_get_us() - start_time;
58 break;
59 }
60 }
61 // 计算距离障碍物距离（340米/秒 转换为 0.034厘米/微秒）
62 distance = time * 0.034 / 2;
63 printf("distance is %0.2f cm\r\n", distance);
64 return distance;
65 }
66 
67 void Hcsr04SampleTask()
68 {
69 while (1) {
70 GetDistance();
71 osDelay(10);
72 }
73 
74 }
75 
76 void Hcsr04SampleEntry(void)
77 {
78 // 初始化超声波传感器
79 osThreadAttr_t attr;
80 Hcsr04Init();
81 IoTWatchDogDisable();
82 attr.name = "Hcsr04SampleTask";
83 attr.attr_bits = 0U;
84 attr.cb_mem = NULL;
85 attr.cb_size = 0U;
86 attr.stack_mem = NULL;
87 attr.stack_size = 1024 * 5; /* 堆栈大小为1024 */
88 attr.priority = osPriorityNormal;
89 
90 if (osThreadNew((osThreadFunc_t)Hcsr04SampleTask, NULL, &attr) == NULL) {
91 printf("[Hcsr04SampleTask] Failed to create Hcsr04SampleTask!\n");
92 }
93 }
94 APP_FEATURE_INIT(Hcsr04SampleEntry);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.5.4 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，可以看到超声波测量出来的距离信息在串口工具中打印出来,说明通过使用主芯片GPIO的输入和输出功能，实现对超声波传感器的驱动实验成功。

![](pic/image-20220921203118703.png)

### 2.5.5 扩展实验

* 本实验学习了通过使用主芯片GPIO的输入和输出功能，实现超声波测距，请学生做如下实验：
  * 1、通过超声波模块实现控制左右两个三色灯亮不同颜色，当距离小于某个值，三色车灯亮红灯，大于某个值，三色车灯亮白灯。
  
      提示：参考GPIO-IO扩展芯片输出实验

## 2.6 PWM实验-芯片自带PWM实验

### 2.6.1 实验目的

* 本实验通过使用芯片自带的PWM功能，实现对左右电机前进后退。

### 2.6.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件配置：MOTOR_EN拨码开光拨到ON，硬件搭建如下图所示：

### 2.6.3 接口说明

#### 2.6.3.1 IoTPwmInit()

| **定义：** | unsigned int IoTPwmInit(unsigned int port); |
| ------------ | -------------------------------------------------------- |
| **功能：** | 初始化指定PWM端口 |
| **参数：** | Port：指定的PWM端口 |
| **返回值：** | IOT_SUCCESS：初始化成功 IOT_FAILURE：初始化失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_pwm.h |

#### 2.6.3.2 IoTPwmStart()

| 定义： | unsigned int IoTPwmStart(unsigned int port, unsigned short duty, unsigned int freq); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 启动PWM信号输出 |
| **参数：** | Port：指定的PWM端口 duty：指PWM信号输出的占空比。该值范围为1到99 freq：指PWM信号输出的频率。取值范围为:[1, 65535] |
| **返回值：** | IOT_SUCCESS：启动成功 IOT_FAILURE：启动失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_pwm.h |

#### 2.6.3.3 IoTPwmStop()

| **定义：**   | unsigned   int IoTPwmStop(unsigned int port);            |
| ------------ | -------------------------------------------------------- |
| **功能：**   | 停止PWM信号输出                                          |
| **参数：**   | Port：指定的PWM端口                                      |
| **返回值：** | IOT_SUCCESS：停止成功    IOT_FAILURE：停止失败           |
| **依赖：**   | //base/iot_hardware/peripheral/interfaces/kits/iot_pwm.h |

#### 2.6.3.4 IoTPwmDeinit()

| 定义：   | unsigned   int IoTPwmDeinit(unsigned int port);          |
| -------- | -------------------------------------------------------- |
| 功能：   | 去初始化指定PWM端口                                      |
| 参数：   | Port：指定的PWM端口                                      |
| 返回值： | IOT_SUCCESS：设置成功    IOT_FAILURE：设置失败           |
| 依赖：   | //base/iot_hardware/peripheral/interfaces/kits/iot_pwm.h |

### 2.6.4 实验流程

* 步骤1：复制04 MainChipPWM/motor_control/目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
     └─ sample
         └─ wifi-iot
            └─ app
               ├─ BUILD.gn
               └─motor_control
                      ├─ BUILD.gn  
                      ├─ hal_iot_gpio_ex.c
                      ├─ iot_gpio_ex.h
                      └─ motor_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加motor_control: motor_control。注：第一个motor_control指的是需要编译的工程目录，第二个motor_control指的是applications/sample/wifi-iot/app/ motor_control /BUILD.gn文件中的静态库，名称为motor_control。

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

lite_component("app") {
  features = [ "motor_control:motor_control", ]
}
```

* 步骤3：PWM原理：脉冲宽度调制，即在一个周期内存在不同极性的电平状态；PWM频率：指一秒钟内从高电平时间在到低电平时间，再从低电平跳到高电平的瞬间次数，也就是一秒钟内有多少个PWM的周期，f = T / 1(HZ)；PWM周期：是指一秒钟内从高电平时间在到低电平时间，T = f / 1(s)；PWM周期：是指一秒钟内从高电平时间在到低电平时间，T = f / 1(s)。

从硬件原理图可以分析出左轮的直流电机对应的是PWM_GPIO05、PWM_GPIO06，右轮直流电机对应的是PWM_GPIO09、PWM_GPIO10,核心代码如方下所示:

```c
1 /*
2 GA12-N20 直流减速电机的相关API接口
3 	左轮：IB:GPIO5, IA: GPIO6
4 右轮：IB:GPIO9, IA: GPIO10
5 */
6 #include <stdio.h>
7 #include <unistd.h>
8 
9 #include "iot_gpio_ex.h"
10 #include "ohos_init.h"
11 #include "cmsis_os2.h"
12 #include "iot_gpio.h"
13 
14 #define IOT_PWM_PORT_PWM0 0
15 #define IOT_PWM_PORT_PWM1 1
16 #define IOT_PWM_PORT_PWM2 2
17 #define IOT_PWM_PORT_PWM3 3
18 
19 // PWM取值：[1, 65535]
20 // 左轮向前
21 void LeftWheelForword(void)
22 {
23 IoTPwmStart(IOT_PWM_PORT_PWM2, 50, 65535);
24 }
25 
26 // 左轮向后
27 void LeftWheelBackword(void)
28 {
29 IoTPwmStart(IOT_PWM_PORT_PWM3, 50, 65535);
30 }
31 
32 // 左轮停止转动
33 void LeftWheelStop(void)
34 {
35 IoTPwmStop(IOT_PWM_PORT_PWM2);
36 IoTPwmStop(IOT_PWM_PORT_PWM3);
37 }
38 
39 // 右轮向前
40 void RightWheelForword(void)
41 {
42 IoTPwmStart(IOT_PWM_PORT_PWM1, 50, 65535);
43 }
44 
45 // 右轮向后
46 void RightWheelBackword(void)
47 {
48 IoTPwmStart(IOT_PWM_PORT_PWM0, 50, 65535);
49 }
50 
51 // 右轮停止转动
52 void RightWheelStop(void)
53 {
54 IoTPwmStop(IOT_PWM_PORT_PWM0);
55 IoTPwmStop(IOT_PWM_PORT_PWM1);
56 }
57 
58 void GA12N20Init(void)
59 {
60 // 左电机GPIO5,GPIO6初始化
61 IoTGpioInit(IOT_IO_NAME_GPIO_5);
62 IoTGpioInit(IOT_IO_NAME_GPIO_6);
63 // 左电机GPIO9, GPIO10初始化
64 IoTGpioInit(IOT_IO_NAME_GPIO_9);
65 IoTGpioInit(IOT_IO_NAME_GPIO_10);
66 
67 // 设置GPIO5的管脚复用关系为PWM2输出
68 IoSetFunc(IOT_IO_NAME_GPIO_5, IOT_IO_FUNC_GPIO_5_PWM2_OUT);
69 // 设置GPIO6的管脚复用关系为PWM3输出
70 IoSetFunc(IOT_IO_NAME_GPIO_6, IOT_IO_FUNC_GPIO_6_PWM3_OUT);
71 // 设置GPIO9的管脚复用关系为PWM0输出
72 IoSetFunc(IOT_IO_NAME_GPIO_9, IOT_IO_FUNC_GPIO_9_PWM0_OUT);
73 // 设置GPIO10的管脚复用关系为PWM01输出
74 IoSetFunc(IOT_IO_NAME_GPIO_10, IOT_IO_FUNC_GPIO_10_PWM1_OUT);
75 
76 // GPIO5方向设置为输出
77 IoTGpioSetDir(IOT_IO_NAME_GPIO_5, IOT_GPIO_DIR_OUT);
78 // GPIO6方向设置为输出
79 IoTGpioSetDir(IOT_IO_NAME_GPIO_6, IOT_GPIO_DIR_OUT);
80 // GPIO9方向设置为输出
81 IoTGpioSetDir(IOT_IO_NAME_GPIO_9, IOT_GPIO_DIR_OUT);
82 // GPIO10方向设置为输出
83 IoTGpioSetDir(IOT_IO_NAME_GPIO_9, IOT_GPIO_DIR_OUT);
84 // 初始化PWM2
85 IoTPwmInit(IOT_PWM_PORT_PWM2);
86 // 初始化PWM3
87 IoTPwmInit(IOT_PWM_PORT_PWM3);
88 // 初始化PWM0
89 IoTPwmInit(IOT_PWM_PORT_PWM0);
90 // 初始化PWM1
91 IoTPwmInit(IOT_PWM_PORT_PWM1);
92 
93 //先使两个电机处于停止状态
94 RightWheelStop();
95 LeftWheelStop();
96 }
97 
98 void GA12N205Task(void)
99 {
100 // 初始化电机模块
101 GA12N20Init();
102 // 实现左电机向前转动
103 LeftWheelForword();
104 // 实现右电机向前转动
105 RightWheelForword();
106 }
107 
108 void GA12N20SampleEntry(void)
109 {
110 // 初始化电机
111 osThreadAttr_t attr;
112 IoTWatchDogDisable();
113 attr.name = "GA12N205Task";
114 attr.attr_bits = 0U;
115 attr.cb_mem = NULL;
116 attr.cb_size = 0U;
117 attr.stack_mem = NULL;
118 attr.stack_size = 1024 * 5; /* 堆栈大小为1024 */
119 attr.priority = osPriorityNormal;
120 
121 if (osThreadNew((osThreadFunc_t)GA12N205Task, NULL, &attr) == NULL) {
122 printf("[GA12N205Task] Failed to create Hcsr04SampleTask!\n");
123 }
124 }
125 
126 APP_FEATURE_INIT(GA12N20SampleEntry);
```

- 步骤4：修改.device/soc/hisilicon/hi3861v100/sdk_liteos/build/config/usr_config.mk文件。在这个配置文件中打开PWM驱动宏。搜索字段CONFIG_PWM_SUPPORT ，并打开PWM。配置如下：
  
  ```
  # CONFIG_PWM_SUPPORT is not set
  CONFIG_PWM_SUPPORT=y
  ```
  
- 步骤5：编译工程代码
  
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤6：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.6.5 实验结果

* 软件烧录成功后，按一下开发板的RESET按键复位开发板，可以看到小车可以正常的往前行驶，说明我们使用芯片自带的PWM功能，实现对电机控制的实验成功。

### 2.6.6 扩展实验

* 本实验学习了通过使用芯片自带的PWM功能，实现对电机的控制，请学生做如下实验：

* 1、  通过使用PWM功能，实现对蜂鸣器的控制；

提示：GPIO 12复用PWM3实现蜂鸣器鸣响。

* 2、  通过使用芯片自带的PWM功能，实现对黄色交通灯亮度的控制；

提示：GPIO 5复用PWM2功能，实现对黄色交通灯亮度的控制。

## 2.7 PWM实验-GPIO模拟PWM实验

### 2.7.1 实验目的

* 本实验通过使用GPIO模拟PWM的功能，实现对舵机的控制。

### 2.7.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件搭建如下图所示：

### 2.7.3 实验流程

* 步骤1：复制sg92r_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
     └─ sample
        └─ wifi-iot
           └─ app
             ├─ BUILD.gn
             └─sg92r_control
                    ├─ BUILD.gn  
                    ├─ hal_iot_gpio_ex.c
                    ├─ iot_gpio_ex.h
                    └─ sg92r_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加sg92r_control: sg92r_control。注：第一个sg92r_control指的是需要编译的工程目录，第二个sg92r_control指的是applications/sample/wifi-iot/app/ sg92r_control /BUILD.gn文件中的静态库，名称为sg92r_control。

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

lite_component("app") {
  features = [ "sg92r_control:sg92r_control", ]
}
```

* 步骤3：Sg92r舵机原理：Sg92舵机的控制需要产生一个20ms的脉冲信号，以0.5ms到2.5ms的高电平来控制舵机的角度；高电平持续时间对应角度如下表所示。

| 高电平持续时间 | 角度 |
    | -------------- | ---- |
    | 0.5ms          | 0°   |
    | 1.0ms          | 45°  |
    | 1.5ms          | 90°  |
    | 2.0ms          | 135° |
    | 2.5ms          | 180° |

从硬件原理图可以分析PWM舵机对应的是PWM_GPIO02，因此我们可以通过使用GPIO02模拟PWM，实现对舵机的驱动，核心代码如方下所示:

```c
1 /*
2 SG92R舵机的相关API接口
3 */
4 
5 #include <stdio.h>
6 #include <stdlib.h>
7 
8 #include "ohos_init.h"
9 #include "cmsis_os2.h"
10 #include "iot_gpio.h"
11 #include "hi_io.h"
12 #include "iot_gpio_ex.h"
13 #include "hi_time.h"
14 
15 #define COUNT 10
16 
17 void SetAngle(unsigned int duty)
18 {
19 unsigned int time = 20000;
20 
21 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_2, IOT_GPIO_VALUE1);
22 hi_udelay(duty);
23 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_2, IOT_GPIO_VALUE0);
24 hi_udelay(time - duty);
25 }
26 
27 /* The steering gear is centered
28 1、依据角度与脉冲的关系，设置高电平时间为1500微秒
29 2、不断地发送信号，控制舵机居中
30 */
31 void RegressMiddle(void)
32 {
33 unsigned int angle = 1500;
34 for (int i = 0; i < COUNT; i++) {
35 SetAngle(angle);
36 }
37 }
38 
39 /* Turn 90 degrees to the right of the steering gear
40 1、依据角度与脉冲的关系，设置高电平时间为500微秒
41 2、不断地发送信号，控制舵机向右旋转90度
42 */
43 /* Steering gear turn right */
44 void EngineTurnRight(void)
45 {
46 unsigned int angle = 500;
47 for (int i = 0; i < COUNT; i++) {
48 SetAngle(angle);
49 }
50 }
51 
52 /* Turn 90 degrees to the left of the steering gear
53 1、依据角度与脉冲的关系，设置高电平时间为2500微秒
54 2、不断地发送信号，控制舵机向左旋转90度
55 */
56 /* Steering gear turn left */
57 void EngineTurnLeft(void)
58 {
59 unsigned int angle = 2500;
60 for (int i = 0; i < COUNT; i++) {
61 SetAngle(angle);
62 }
63 }
64 
65 void S92RInit(void)
66 {
67 // PWM舵机对应的GPIO是GPIO02
68 // 初始化 GPIO02
69 IoTGpioInit(IOT_IO_NAME_GPIO_2);
70 // 设置GPIO02的管脚复用关系为GPIO
71 IoSetFunc(IOT_IO_NAME_GPIO_2, IOT_IO_FUNC_GPIO_2_GPIO);
72 // 设置GPIO02的方向为输出
73 IoTGpioSetDir(IOT_IO_NAME_GPIO_2, IOT_GPIO_DIR_OUT);
74 }
75 
76 void Sg92RTask(void)
77 {
78 unsigned int time = 200;
79 // 初始化PWM舵机
80 S92RInit();
81 
82 while (1) {
83 /* 舵机归中 */
84 RegressMiddle();
85 hi_sleep(time);
86 
87 /* 舵机左转90度 */
88 EngineTurnLeft();
89 hi_sleep(time);
90 
91 /* 舵机归中 */
92 RegressMiddle();
93 hi_sleep(time);
94 
95 /* 舵机右转90度 */
96 EngineTurnRight();
97 hi_sleep(time);
98 
99 /* 舵机归中 */
100 RegressMiddle();
101 hi_sleep(time);
102 }
103 }
104 
105 void Sg92rSampleEntry(void)
106 {
107 osThreadAttr_t attr;
108 IoTWatchDogDisable();
109 attr.name = "Sg92RTask";
110 attr.attr_bits = 0U;
111 attr.cb_mem = NULL;
112 attr.cb_size = 0U;
113 attr.stack_mem = NULL;
114 attr.stack_size = 1024 * 5; /* 堆栈大小为1024 */
115 attr.priority = osPriorityNormal;
116 
117 if (osThreadNew((osThreadFunc_t)Sg92RTask, NULL, &attr) == NULL) {
118 printf("[GA12N205Task] Failed to create Hcsr04SampleTask!\n");
119 }
120 }
121 
122 APP_FEATURE_INIT(Sg92rSampleEntry);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.7.4 实验结果

* 软件烧录成功后，按一下开发板的RESET按键复位开发板，可以看到小车的舵机模块一直在循环的进行舵机归中，舵机左转90度，舵机归中，舵机右转90度，舵机归中的操作，说明我们使用GPIO模拟PWM的功能，实现对舵机控制的实验成功。

### 2.7.5 扩展实验

* 本实验学习了通过使用GPIO模拟PWM的功能，实现对舵机的控制，请学生做如下实验：
  * 1、通过使用GPIO模拟PWM的功能，实现对蜂鸣器的控制。
  
      提示：蜂鸣器鸣响通过GPIO12高低电平持续时间，实现模拟PWM信号。

## 2.8 I2C实验-单I2C轮询实验

### 2.8.1 实验目的

* 本实验通过使用单I2C轮询的功能，实现对电量的检测，并将实时电量在OLED屏幕上面显示。**电量检测芯片手册(型号：CW2015CHBD；品牌：Cellwise赛微)获取：https://so.szlcsc.com/global.html?k=CW2015&hot-key=LM358DR2G，点击数据手册进行下载**。

### 2.8.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；
* 2.接线：INT_CW2015 - IO0_7，I2C0_SDA_GPIO 13，I2C0_SDA_GPIO 14；硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 2.8.3 接口说明

#### 2.8.3.1 IoTI2cInit()

| **定义：** | unsigned int IoTI2cInit(unsigned int id, unsigned int baudrate); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 以指定的波特率初始化I2C设备。 |
| **参数：** | id:I2C设备ID baudrate：指定的I2C波特率 |
| **返回值：** | IOT_SUCCESS：初始化成功 IOT_FAILURE：初始化失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_i2c.h |

#### 2.8.3.2 IoTI2cDeinit()

| **定义：**   | unsigned   int IoTI2cDeinit(unsigned int id);            |
| ------------ | -------------------------------------------------------- |
| **功能：**   | 去初始化I2c设备                                          |
| **参数：**   | id：I2C设备ID                                            |
| **返回值：** | IOT_SUCCESS：去初始化成功    IOT_FAILURE：去初始化失败   |
| **依赖：**   | //base/iot_hardware/peripheral/interfaces/kits/iot_i2c.h |

#### 2.8.3.3 IoTI2cWrite()

| 定义： | unsigned int IoTI2cWrite(unsigned int id, unsigned short deviceAddr, const unsigned char *data, unsigned int dataLen); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 将数据写入I2C设备 |
| **参数：** | id：I2C设备id deviceAddr：I2C设备地址 data：指向要写入的数据的指针 dataLen：指向要写入的数据长度 |
| **返回值：** | IOT_SUCCESS：数据写入成功 IOT_FAILURE：数据写入失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_i2c.h |

#### 2.8.3.4 IoTI2cRead()

| **定义：** | unsigned int IoTI2cRead(unsigned int id, unsigned short deviceAddr, unsigned char *data, unsigned int dataLen); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 从I2C设备读取数据 |
| **参数：** | id：I2C设备id deviceAddr：I2C设备地址 data：表示指向要读取的数据的指针 dataLen：表示要读取的数据长度 |
| **返回值：** | IOT_SUCCESS：数据读取成功 IOT_FAILURE：数据读取失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_i2c.h |

#### 2.8.3.5 IoTI2cSetBaudrate()

| **定义：** | unsigned int IoTI2cSetBaudrate(unsigned int id, unsigned int baudrate); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 设置I2C设备的波特率 |
| **参数：** | id：I2C设备ID baudrate：指定的I2C波特率口 |
| **返回值：** | IOT_SUCCESS：设置成功 IOT_FAILURE：设置失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_i2c.h |

### 2.8.4 实验流程

* 步骤1：复制cw2015_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
     └─ sample
        └─ wifi-iot
            └─ app
               ├─ BUILD.gn
               └─cw2015_control
                     ├─ BUILD.gn  
                     ├─ hal_iot_gpio_ex.c
                     ├─ iot_gpio_ex.h
                     ├─ oled_ssd1306.c
                     ├─ oled_ssd1306.h
                     ├─ oled_fonts.h
                     └─ cw2015_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加cw2015_control:cw2015_control。注：第一个cw2015_control指的是需要编译的工程目录，第二个cw2015_control指的是applications/sample/wifi-iot/app/ cw2015_control /BUILD.gn文件中的静态库，名称为cw2015_control。

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

lite_component("app") {
  features = [ "cw2015_control:cw2015_control", ]
}
```

* 步骤3：I2C通信原理：I2C通信中，主机通过时钟线SCL发送时钟信号，通过数据线SDA发送数据（包括从机地址、指令、数据包等），在发送完一帧数据后，需要等待从机的响应，才能继续发送下一帧数据，因此I2C属于同步通信。

从硬件原理图可以分析出电源监控传感器与开发板板子通过 I2C0(SDA_GPIO13、SCL_GPIO14) 连接，通讯波特率为 400K,因此我们代码需要通过 I2C 的读写函数读回电池电量值，核心代码如方下所示:

```c
1 #include "oled_ssd1306.h"
2 #include <stdio.h>
3 #include <stdint.h>
4 #include <string.h>
5 #include <unistd.h>
6 
7 #include "ohos_init.h"
8 #include "cmsis_os2.h"
9 #include "iot_gpio_ex.h"
10 #include "iot_i2c.h"
11 #include "iot_gpio.h"
12 #include "iot_errno.h"
13 #include "hi_errno.h"
14 #include "hi_i2c.h"
15 
16 #define IOT_I2C_IDX_BAUDRATE (400 * 1000)
17 #define CW2015_I2C_IDX 0
18 #define IOT_PWM_PORT_PWM3 3
19 #define CW2015_READ_ADDR (0XC5)
20 #define CW2015_WRITE_ADDR (0XC4)
21 #define WRITELEN 2
22 
23 /**
24 * @berf i2c read
25 * @param hi_u8 reg_high_8bit_cmd:Transmit register value 8 bits high
26 * @param hi_u8 reg_low_8bit_cmd:Transmit register value low 8 bits
27 * @param hi_u8* recv_data:Receive data buff
28 * @param hi_u8 send_len:Sending data length
29 * @param hi_u8 read_len:Length of received data
30 */
31 uint32_t Cw20_WriteRead(uint8_t reg_high_8bit_cmd, uint8_t send_len, uint8_t read_len)
32 {
33 uint32_t status =0;
34 uint32_t ret = 0;
35 uint8_t recvData[888] = {0};
36 hi_i2c_data i2c_write_cmd_addr ={0};
37 uint8_t send_user_cmd[1] = {reg_high_8bit_cmd};
38 memset(recvData, 0x0, sizeof(recvData));
39 i2c_write_cmd_addr.send_buf = send_user_cmd;
40 i2c_write_cmd_addr.send_len = send_len;
41 
42 i2c_write_cmd_addr.receive_buf = recvData;
43 i2c_write_cmd_addr.receive_len = read_len;
44 
45 status = hi_i2c_writeread(CW2015_I2C_IDX, CW2015_READ_ADDR, &i2c_write_cmd_addr);
46 if (status != HI_ERR_SUCCESS) {
47 printf("I2cRead() failed, %0X!\n", status);
48 return status;
49 }
50 ret = recvData[0];
51 return ret;
52 }
53 
54 uint32_t Cw20_Write(uint8_t addr, uint8_t writedata, uint32_t buffLen)
55 {
56 uint8_t buffer[2] = {addr, writedata};
57 uint32_t retval = IoTI2cWrite(CW2015_I2C_IDX, CW2015_WRITE_ADDR, buffer, buffLen);
58 if (retval != IOT_SUCCESS) {
59 printf("IoTI2cWrite(%02X) failed, %0X!\n", buffer[0], retval);
60 return retval;
61 }
62 printf("IoTI2cWrite(%02X)\r\n", buffer[0]);
63 return IOT_SUCCESS;
64 }
65 
66 void CW2015Init()
67 {
68 // 初始化I2C设备0，并指定波特率为400k
69 IoTI2cInit(CW2015_I2C_IDX, IOT_I2C_IDX_BAUDRATE);
70 // 设置I2C设备0的波特率为400k
71 IoTI2cSetBaudrate(CW2015_I2C_IDX, IOT_I2C_IDX_BAUDRATE);
72 // 设置GPIO13的管脚复用关系为I2C0_SDA
73 IoSetFunc(IOT_IO_NAME_GPIO_13, IOT_IO_FUNC_GPIO_13_I2C0_SDA);
74 // 设置GPIO14的管脚复用关系为I2C0_SCL
75 IoSetFunc(IOT_IO_NAME_GPIO_14, IOT_IO_FUNC_GPIO_14_I2C0_SCL);
76 // 使电量检测模块从sleep mode变为wake up mode
77 Cw20_Write(0x0A, 0x00, 1);
78 }
79 
80 float GetVoltage(void)
81 {
82 uint8_t buff[2] = {0};
83 float voltage = 0;
84 uint32_t temp = 0;
85 // 读取电压的前6位
86 buff[0] = Cw20_WriteRead(0x02, 1, 1);
87 // 读取电压的后8位
88 buff[1] = Cw20_WriteRead(0x03, 1, 1);
89 // 通过位运算最后得到14位的A/D测量值
90 temp = (buff[0] << 8) | buff[1];
91 // 通过计算得到最终的电压值 （CW2015的电压分辨率为305uV）
92 voltage = temp * 305.0 / 1;
93 
94 return voltage;
95 }
96 
97 static void CW2015Task(void)
98 {
99 static char line[32] = {0};
100 float voltage = 0.0;
101 
102 // I2C0初始化
103 CW2015Init();
104 // OLED初始化
105 OledInit();
106 OledFillScreen(0);
107 while (1) {
108 voltage = GetVoltage();
109 // 将获取到的电源格式化为字符串
110 snprintf(line, sizeof(line), "voltage: %.2f", voltage);
111 /* 在OLED屏幕的第20列5行显示1行 */
112 OledShowString(20, 5, line, 1);
113 usleep(20);
114 }
115 }
116 
117 void CW2015SampleEntry(void)
118 {
119 osThreadAttr_t attr;
120 IoTWatchDogDisable();
121 attr.name = "Sg92RTask";
122 attr.attr_bits = 0U;
123 attr.cb_mem = NULL;
124 attr.cb_size = 0U;
125 attr.stack_mem = NULL;
126 attr.stack_size = 1024 * 5; /* 堆栈大小为1024 */
127 attr.priority = osPriorityNormal;
128 
129 if (osThreadNew((osThreadFunc_t)CW2015Task, NULL, &attr) == NULL) {
130 printf("[GA12N205Task] Failed to create Hcsr04SampleTask!\n");
131 }
132 }
133 
134 APP_FEATURE_INIT(CW2015SampleEntry);
```

* 步骤4：修改.device/soc/hisilicon/hi3861v100/sdk_liteos/build/config/usr_config.mk文件。在这个配置文件中打开I2C驱动宏。搜索字段CONFIG_I2C_SUPPORT ，并打开I2C。配置如下：

```
    # CONFIG_I2C_SUPPORT is not set
    CONFIG_I2C_SUPPORT=y
    ```

- 步骤5：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤6：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.8.5 实验结果

* 软件烧录成功后，按一下开发板的RESET按键复位开发板，可以看到OLED屏幕上面实时显示此时小车的电压信息，说明我们使用单I2C轮询的功能，实现对电量的检测的实验成功。

### 2.8.6 扩展实验

* 本实验学习了通过使用单I2C轮询的功能，实现对电量的检测，请学生做如下实验：
 
 * 1、 使用单I2C轮询的功能，实现与RTC进行通信，OLED屏幕显示万年历。
 
 	提示：RTC 芯片手册（编号：C2924605，型号： INS5699S） 获取：https://so.szlcsc.com/global.html?k=C2924605&hot-key=LM358DR2G，点击数据手册进行下载。硬件接线：I2C0_SDA_GPIO 13，I2C0_SDA_GPIO 14，INT_RTC - IO0_5
 
 * 原理：先通过I2C设置RTC时间，在读取RTC寄存器，并将时间显示在屏幕上。
 
 * 部分代码参考：
 
 ```c
 1 #include <stdio.h>
 2 #include <stdint.h>
 3 #include <string.h>
 4 #include <unistd.h>
 5 #include "ohos_init.h"
 6 #include "cmsis_os2.h"
 7 
 8 #include <app_demo_rtc.h>
 9 #include "oled_fonts.h"
 10 #include "oled_ssd1306.h"
 11 #include "iot_gpio_ex.h"
 12 #include "iot_i2c.h"
 13 #include "iot_gpio.h"
 14 #include "iot_errno.h"
 15 #include "hi_errno.h"
 16 
 17 #define IOT_I2C_IDX_BAUDRATE (400 * 1000)
 18 #define INS5902_I2C_IDX 0
 19 
 20 #define INS5902_ADDRESS 0x64 //1101000
 21 #define INS5902_WRITE_ADDRESS 0x64 
 22 #define INS5902_READ_ADDRESS 0x65
 23 #define INS5902_REG_ARRAY_LEN 2
 24 #define RTC_REG_TIME_BUF 2
 25 #define SEND_BUF_LEN 3
 26 #define SEND_SET_REG_LEN 2
 27 #define SEND_READ_DATA_LEN 1
 28 #define INS5902_TASK_STAK_SIZE (1024*2)
 29 #define INS5902_TASK_PRIORITY (25)
 30 #define MONTH_SETTING ((hi_u8)0x05)
 31 #define DELAY_TIME ((hi_u32)10000)
 32 
 33 /*INS5902 reg*/
 34 typedef enum {
 35 RTC_SECOND =0,
 36 RTC_MINUTE,
 37 RTC_HOUR,
 38 RTC_DAY,
 39 RTC_DATE,
 40 RTC_MONTH,
 41 RTC_YEAR,
 42 }rct_reg;
 43 
 44 typedef struct 
 45 {
 46 uint8_t rtc_second[RTC_REG_TIME_BUF];
 47 uint8_t rtc_minue[RTC_REG_TIME_BUF];
 48 uint8_t rtc_hour[RTC_REG_TIME_BUF];
 49 uint8_t rtc_day[RTC_REG_TIME_BUF];
 50 uint8_t rtc_date[RTC_REG_TIME_BUF];
 51 uint8_t rtc_month[RTC_REG_TIME_BUF];
 52 uint8_t rtc_year[RTC_REG_TIME_BUF];
 53 }ins5902_rtc_type;
 54 
 55 /*gpio init */
 56 void gpio_init() {
 57 // 设置GPIO13的管脚复用关系为I2C0_SDA
 58 IoSetFunc(IOT_IO_NAME_GPIO_13, IOT_IO_FUNC_GPIO_13_I2C0_SDA);
 59 // 设置GPIO14的管脚复用关系为I2C0_SCL
 60 IoSetFunc(IOT_IO_NAME_GPIO_14, IOT_IO_FUNC_GPIO_14_I2C0_SCL);
 61 }
 62 
 63 uint32_t ins5902_i2c_write(uint8_t reg_addr, uint8_t high_8, uint8_t low_8, uint8_t reg_len)
 64 {
 65 uint8_t temp1 = 0;
 66 uint8_t temp2 = 0;
 67 temp1 = (high_8 / 10 * 16) + (high_8 % 10); //Hexadecimal to BCD
 68 temp2 = (low_8 / 10 * 16) + (low_8 % 10); //Hexadecimal to BCD
 69 uint8_t buffer[3] = {reg_addr, temp1, temp2};
 70 uint32_t retval = IoTI2cWrite(INS5902_I2C_IDX, INS5902_WRITE_ADDRESS, buffer, reg_len);
 71 if (retval != IOT_SUCCESS) {
 72 printf("IoTI2cWrite(%02X) failed, %0X!\n", buffer[0], retval);
 73 return retval;
 74 }
 75 printf("IoTI2cWrite(%02X)\r\n", buffer[0]);
 76 return IOT_SUCCESS;
 77 }
 78 
 79 
 80 uint32_t ins5902_write(uint8_t reg_addr, uint8_t high_8)
 81 {
 82 uint8_t buffer[2] = {reg_addr, high_8};
 83 uint32_t buffLen = 2;
 84 uint32_t retval = IoTI2cWrite(INS5902_I2C_IDX, INS5902_WRITE_ADDRESS, buffer, buffLen);
 85 if (retval != IOT_SUCCESS) {
 86 printf("IoTI2cWrite(%02X) failed, %0X!\n", buffer[0], retval);
 87 return retval;
 88 }
 89 printf("IoTI2cWrite(%02X)\r\n", buffer[0]);
 90 return IOT_SUCCESS;
 91 }
 92 
 93 uint8_t ins5902_read(uint8_t rtc_reg, uint32_t recv_len, uint8_t *rct_buf)
 94 {
 95 // ins5902_rtc_type read_rtc;
 96 uint8_t recv_data[INS5902_REG_ARRAY_LEN] = { 0 };
 97 /* Request memory space */
 98 memset(rct_buf, 0x00, sizeof(rct_buf));
 99 memset(recv_data, 0x0, sizeof(recv_data));
 100 
 101 uint32_t status = IoTI2cRead(INS5902_I2C_IDX, INS5902_READ_ADDRESS, recv_data, recv_len);
 102 if (status != HI_ERR_SUCCESS) {
 103 printf("===== Error: ins5902 sencor I2C read status = 0x%x! =====\r\n", status);
 104 return status;
 105 }
 106 
 107 switch (rtc_reg) {
 108 case RTC_SECOND:
 109 rct_buf[0] = recv_data[0];
 110 break;
 111 case RTC_MINUTE:
 112 rct_buf[0] = recv_data[0];
 113 break;
 114 case RTC_HOUR:
 115 rct_buf[0] = recv_data[0];
 116 break;
 117 case RTC_DAY :
 118 rct_buf[0] = recv_data[0]; 
 119 break;
 120 case RTC_DATE:
 121 rct_buf[0] = recv_data[0];
 122 break; 
 123 case RTC_MONTH:
 124 rct_buf[0] = recv_data[0]; 
 125 break; 
 126 case RTC_YEAR:
 127 rct_buf[0] = recv_data[0]; 
 128 break; 
 129 default:
 130 break;
 131 }
 132 return rct_buf;
 133 }
 134 /*rtc timer setting*/
 135 void rct_set_init(void)
 136 {
 137 uint32_t ret;
 138 ins5902_rtc_type rct_time_set ={0};
 139 rct_time_set.rtc_second[0] = 30;
 140 rct_time_set.rtc_minue[0] = 04;
 141 rct_time_set.rtc_hour[0] = 17;
 142 rct_time_set.rtc_day[0] = 6;
 143 rct_time_set.rtc_date[0] = 4;
 144 rct_time_set.rtc_month[0] = 6;
 145 rct_time_set.rtc_year[0] = 22;
 146 //set second
 147 ret = ins5902_i2c_write(RTC_SECOND, rct_time_set.rtc_second[0], NULL, SEND_SET_REG_LEN);
 148 if (ret != HI_ERR_SUCCESS) {
 149 printf("Failed to second cmd\r\n");
 150 }
 151 hi_udelay(DELAY_TIME); 
 152 //set minute
 153 ret = ins5902_i2c_write(RTC_MINUTE, rct_time_set.rtc_minue[0], NULL, SEND_SET_REG_LEN);
 154 if (ret != HI_ERR_SUCCESS) {
 155 printf("Failed to minute cmd\r\n");
 156 }
 157 hi_udelay(DELAY_TIME); 
 158 //set hour
 159 ret = ins5902_i2c_write(RTC_HOUR, rct_time_set.rtc_hour[0], NULL, SEND_SET_REG_LEN);
 160 if (ret != HI_ERR_SUCCESS) {
 161 printf("Failed to hour cmd\r\n");
 162 }
 163 hi_udelay(DELAY_TIME);
 164 //set day
 165 ret = ins5902_i2c_write(RTC_DAY, rct_time_set.rtc_day[0], NULL, SEND_SET_REG_LEN);
 166 if (ret != HI_ERR_SUCCESS) {
 167 printf("Failed to day cmd\r\n");
 168 }
 169 hi_udelay(DELAY_TIME);
 170 //set date
 171 ret = ins5902_i2c_write(RTC_DATE, rct_time_set.rtc_date[0], NULL, SEND_SET_REG_LEN);
 172 if (ret != HI_ERR_SUCCESS) {
 173 printf("Failed to date cmd\r\n");
 174 }
 175 hi_udelay(DELAY_TIME); 
 176 //set month
 177 ret = ins5902_i2c_write(RTC_MONTH, rct_time_set.rtc_month[0], NULL, SEND_SET_REG_LEN);
 178 if (ret != HI_ERR_SUCCESS) {
 179 printf("Failed to month cmd\r\n");
 180 }
 181 hi_udelay(DELAY_TIME); 
 182 //set year
 183 ret = ins5902_i2c_write(RTC_YEAR, rct_time_set.rtc_year[0], NULL, SEND_SET_REG_LEN);
 184 if (ret != HI_ERR_SUCCESS) {
 185 printf("Failed to year cmd\r\n");
 186 }
 187 hi_udelay(DELAY_TIME); 
 188 }
 189 
 190 uint8_t int_to_char(int dec, uint8_t *str)
 191 {
 192 uint8_t str1[40] = {0};
 193 	int j = 0;
 194 int k = 0;
 195 int i = 0;
 196 
 197 	i = (hi_s32)dec;//The integral part of a floating point number
 198 	while (i > 0) {
 199 		str1[j++] = i % 10 + '0';
 200 		i = i / 10;
 201 	}
 202 
 203 	for (k = 0;k < j;k++) {
 204 		str[k] = str1[j-1-k];//The extracted integer parts are stored in another array in positive order
 205 	}
 206 return str;
 207 }
 208 
 209 uint8_t GetWeek(uint8_t weekdata)
 210 {
 211 uint8_t res = 0;
 212 if (weekdata == 40) {
 213 res = 6;
 214 } else if (weekdata == 20) {
 215 res = 5;
 216 } else if (weekdata == 10) {
 217 res = 4;
 218 } else if (weekdata == 8) {
 219 res = 3;
 220 } else if (weekdata == 4) {
 221 res = 2;
 222 } else if (weekdata == 2) {
 223 res = 1;
 224 } else if (weekdata == 1) {
 225 res = 7;
 226 }
 227 return res;
 228 }
 229 
 230 /*read rtc time*/
 231 void rtc_timer(void)
 232 {
 233 uint8_t rct_read_data[2] ={0};
 234 ins5902_rtc_type rtc_data ={0};
 235 int temp_second =0;
 236 int temp_minute =0;
 237 int temp_hour =0;
 238 int temp_day =0;
 239 int temp_date =0;
 240 int temp_month =0;
 241 int temp_year =0;
 242 uint8_t ch_year[3] ={0};
 243 uint8_t ch_month[3] ={0};
 244 uint8_t ch_day[3] ={0};
 245 uint8_t ch_date[3] ={0};
 246 uint8_t ch_hour[3] ={0};
 247 uint8_t ch_minute[3] ={0};
 248 uint8_t ch_second[3] ={0};
 249 
 250 // 初始化I2C设备0，并指定波特率为400k
 251 IoTI2cInit(INS5902_I2C_IDX, IOT_I2C_IDX_BAUDRATE);
 252 // 设置I2C设备0的波特率为400k
 253 IoTI2cSetBaudrate(INS5902_I2C_IDX, IOT_I2C_IDX_BAUDRATE);
 254 /*ssd1306 config init*/
 255 OledInit();
 256 OledFillScreen(0);
 257 // rct_set_init(); //Set RTC initial time 1.第一次启动set time, 掉电后自动跑，请不要设置时间
 258 ins5902_write(0x21, 0x80); // 开启电池
 259 while (1) {
 260 /*----------------------second--------------*/
 261 ins5902_i2c_write(0x00, NULL, NULL, SEND_READ_DATA_LEN); 
 262 ins5902_read(RTC_SECOND, SEND_READ_DATA_LEN, rct_read_data);
 263 if (rtc_data.rtc_second[0] != rct_read_data[0]) {
 264 rtc_data.rtc_second[0] = rct_read_data[0];
 265 temp_second = rct_read_data[0]/16*10 + rct_read_data[0]%16;
 266 int_to_char(temp_second, ch_second);
 267 if (temp_second>=10) { 
 268 OledShowString(48, 6, ch_second, 1);
 269 } else {
 270 OledShowString(48, 6, "0", 1);
 271 OledShowString(56, 6, ch_second, 1);
 272 }
 273 OledShowString(64, 6, " ", 1);
 274 } 
 275 /*----------------------minute--------------*/
 276 ins5902_i2c_write(0x01, NULL, NULL, SEND_READ_DATA_LEN); 
 277 ins5902_read(RTC_MINUTE, SEND_READ_DATA_LEN, rct_read_data);
 278 if (rtc_data.rtc_minue[0] != rct_read_data[0]) {
 279 rtc_data.rtc_minue[0] = rct_read_data[0];
 280 temp_minute = rct_read_data[0]/16*10 + rct_read_data[0]%16;
 281 int_to_char(temp_minute, ch_minute);
 282 if (temp_minute >= 10) {
 283 OledShowString(24, 6, ch_minute, 1); 
 284 OledShowString(40, 6, ":", 1); 
 285 } else {
 286 OledShowString(24, 6, "0", 1); 
 287 OledShowString(32, 6, ch_minute, 1); 
 288 OledShowString(40, 6, ":", 1); 
 289 }
 290 OledShowString(56, 6, "0", 1); 
 291 }
 292 
 293 /*----------------------hour--------------*/
 294 ins5902_i2c_write(0x02, NULL, NULL, SEND_READ_DATA_LEN); 
 295 ins5902_read(RTC_HOUR, SEND_READ_DATA_LEN, rct_read_data);
 296 if (rtc_data.rtc_hour[0] != rct_read_data[0]) {
 297 rtc_data.rtc_hour[0] = rct_read_data[0];
 298 temp_hour = rct_read_data[0]/16*10 + rct_read_data[0]%16;
 299 int_to_char(temp_hour, ch_hour);
 300 if (temp_hour >= 10) {
 301 OledShowString(0, 6, ch_hour, 1);
 302 OledShowString(16, 6, ":", 1);
 303 } else {
 304 OledShowString(0, 6, "0", 1);
 305 OledShowString(8, 6, ch_hour, 1);
 306 OledShowString(16, 6, ":", 1);
 307 }
 308 OledShowString(64, 6, " ", 1);
 309 }
 310 
 311 /*----------------------day-------------*/
 312 ins5902_i2c_write(0x03, NULL, NULL, SEND_READ_DATA_LEN); 
 313 ins5902_read(RTC_DAY, SEND_READ_DATA_LEN, rct_read_data);
 314 if (rtc_data.rtc_day[0] != rct_read_data[0]) {
 315 rtc_data.rtc_day[0] = rct_read_data[0];
 316 temp_day = rct_read_data[0]/16*10 + rct_read_data[0]%16;
 317 temp_day = GetWeek(temp_day);
 318 int_to_char(temp_day, ch_day);
 319 OledShowString(72, 6, "week:", 1);
 320 OledShowString(112, 6, ch_day, 1);
 321 }
 322 /*----------------------date--------------*/
 323 ins5902_i2c_write(0x04, NULL, NULL, SEND_READ_DATA_LEN); 
 324 ins5902_read(RTC_DATE, SEND_READ_DATA_LEN, rct_read_data);
 325 if (rtc_data.rtc_date[0] != rct_read_data[0]) {
 326 rtc_data.rtc_date[0] = rct_read_data[0];
 327 temp_date = rct_read_data[0]/16*10 + rct_read_data[0]%16;
 328 int_to_char(temp_date, ch_date);
 329 if (temp_date >= 10) { 
 330 OledShowString(89, 4, ch_date, 1);
 331 } else {
 332 OledShowString(89, 4, "0", 1);
 333 OledShowString(97, 4, ch_date, 1);
 334 }
 335 OledShowString(105, 4, " ", 1);
 336 }
 337 
 338 /*----------------------month--------------*/
 339 ins5902_i2c_write(0x05, NULL, NULL, SEND_READ_DATA_LEN); 
 340 ins5902_read(RTC_MONTH, SEND_READ_DATA_LEN, rct_read_data);
 341 if (rtc_data.rtc_month[0] != rct_read_data[0]) {
 342 rtc_data.rtc_month[0] = rct_read_data[0];
 343 temp_month = rct_read_data[0]/16*10 + rct_read_data[0]%16;
 344 int_to_char(temp_month, ch_month);
 345 if (temp_month >= 10) {
 346 OledShowString(65, 4, ch_month, 1);
 347 OledShowString(81, 4, "-", 1); 
 348 } else {
 349 OledShowString(65, 4, "0", 1);
 350 OledShowString(73, 4, ch_month, 1);
 351 OledShowString(81, 4, "-", 1);
 352 }
 353 }
 354 
 355 /*----------------------year--------------*/
 356 ins5902_i2c_write(0x06, NULL, NULL, SEND_READ_DATA_LEN); 
 357 ins5902_read(RTC_YEAR, SEND_READ_DATA_LEN, rct_read_data);
 358 if (rtc_data.rtc_year[0] != rct_read_data[0]) {
 359 rtc_data.rtc_year[0] = rct_read_data[0];
 360 temp_year = rct_read_data[0]/16*10 + rct_read_data[0]%16;
 361 int_to_char(temp_year, ch_year);
 362 OledShowString(25, 4, "20", 1);
 363 OledShowString(41, 4, ch_year, 1);
 364 OledShowString(57, 4, "-", 1);
 365 OledShowString(104, 4, " ", 1);
 366 }
 367 hi_sleep(1);
 368 }
 369 
 370 }
 371 
 372 static void RTCSampleEntry(void)
 373 {
 374 osThreadAttr_t attr;
 375 
 376 attr.name = "RTCTask";
 377 attr.attr_bits = 0U;
 378 attr.cb_mem = NULL;
 379 attr.cb_size = 0U;
 380 attr.stack_mem = NULL;
 381 attr.stack_size = 1024;
 382 attr.priority = 25;
 383 
 384 if (osThreadNew((osThreadFunc_t)rtc_timer, NULL, &attr) == NULL) {
 385 printf("[LedExample] Failed to create LedTask!\n");
 386 }
 387 }
 388 
 389 APP_FEATURE_INIT(RTCSampleEntry);
 ```

## 2.9 I2C实验-中断触发实验

### 2.9.1 实验目的

* 本实验通过使用I2C中断触发的功能，实现对NFC的驱动。NFC 芯片手册（型号： FM11NT081D）获取： https://www.fmsh.com/2ac114a8-ce2d-aa9d-cef4-ad3919eeb513/，选择 FM11NT081D 芯片型号 进行下载。

### 2.9.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.接线方式：J7-NFC；硬件搭建如下图所示：

### 2.9.3 实验流程

* 步骤1：复制nfc_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
	└─ sample
    	└─ wifi-iot
        	└─ app
            	├─ BUILD.gn
                └─ nfc_control
                	├─ BUILD.gn  
                    ├─ hal_iot_gpio_ex.c
                    ├─ iot_gpio_ex.h
                    ├─ pca9555.c
                    ├─ pca9555.h
                    └─ nfc_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加nfc_control: nfc_control。注：第一个nfc_control指的是需要编译的工程目录，第二个nfc_control指的是applications/sample/wifi-iot/app/ nfc_control /BUILD.gn文件中的静态库，名称为nfc_control。

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

lite_component("app") {
  features = [ "nfc_control:nfc_control", ]
}
```

* 步骤3：原理：FM11NT081D使用I2C通信，INT_NFC在IO扩展芯片IO0_6上（默认为高，低有效），CS_NFC在IO扩展芯片I01_6上，当CS_NFC脚为低时，正常通信，手机靠近NFC之后，NFC产生中断，使IO扩展芯片IO0_6被拉低，触发IO扩展芯片中断，实现了I2C中断触发。

从硬件原理图可以分析出中断脚对应的是GPIO11，SDA对应的是GPIO13，SCL对应的是GPIO14,核心代码如方下所示:

```c
1 #include <stdio.h>
2 #include <unistd.h>
3 #include "ohos_init.h"
4 #include "cmsis_os2.h"
5 #include "iot_gpio_ex.h"
6 #include "iot_gpio.h"
7 #include "iot_i2c.h"
8 #include "pca9555.h"
9 #include "iot_errno.h"
10 #include "hi_i2c.h"
11 
12 #define NFC_EERROM_BASE_ADD (0x0010)
13 #define NFC_EERROM_FINALY_ADDR (0x0384)
14 #define NFC_CMD_LEN (2)
15 #define NFC_WECHAT_NDEF_LEN (34)
16 #define READ_NFC_WECHAT_NDEF_LEN (50)
17 #define NFC_TOUTIAO_NDEF_LEN (47)
18 #define READ_NFC_TOUTIAO_NDEF_LEN (63)
19 #define NFC_EERROM_READ_BUFF_LEN_MAX (888)
20 #define C081_NFC_ADDR (0xAE)
21 #define I2C_WR (0x00)
22 #define I2C_RD (0x01)
23 #define C081_NFC_WRITE_ADDR (C081_NFC_ADDR|I2C_WR)
24 #define C081_NFC_READ_ADDR (C081_NFC_ADDR|I2C_RD)
25 #define FM11_E2_USER_ADDR (0x0010)
26 #define FM11_E2_MAUNF_ADDR (0x03FF)
27 #define FM11_E2_BLOCK_SIZE (16)
28 #define DEFAULT_MD_LEN (128)
29 #define RIGHR_MOVE_8_BIT (8)
30 #define NFC_NDEF_MAX_LEN (888)
31 #define OLED_I2C_BAUDRATE 400*1000
32 #define C081_NFC_ADDR2 (0x78)
33 
34 volatile static int g_buttonState = 0;
35 
36 unsigned char ndefFile[NFC_NDEF_MAX_LEN] = {
37 // 淘宝
38 0x03, 0x23,
39 0xd4, 0x0f, 0x11, 0x61, 0x6e, 0x64, 0x72, 0x6f,
40 0x69, 0x64, 0x2e, 0x63, 0x6f, 0x6d, 0x3a, 0x70,
41 0x6b, 0x67, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x61,
42 0x6f, 0x62, 0x61, 0x6f, 0x2e, 0x74, 0x61, 0x6f,
43 0x62, 0x61, 0x6f,
44 // 微信
45 /*0x03,0x20,
46 0xd4, 0x0f,0x0e, 0x61, 0x6e, 0x64, 0x72, 0x6f,
47 0x69, 0x64,0x2e, 0x63, 0x6f, 0x6d, 0x3a, 0x70,
48 0x6b, 0x67,0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x65,
49 0x6e, 0x63,0x65, 0x6e, 0x74, 0x2e, 0x6d, 0x6d,*/
50 };
51 
52 static unsigned int C081NfcI2cWrite(unsigned char regHigh8bitCmd,
53 unsigned char regLow8bitCmd, unsigned char* recvData, unsigned char sendLen)
54 {
55 unsigned int status =0;
56 IotI2cData c081NfcI2cWriteCmdAddr ={0};
57 unsigned char sendUserCmd[64] = {regHigh8bitCmd, regLow8bitCmd};
58 
59 c081NfcI2cWriteCmdAddr.sendBuf = sendUserCmd;
60 c081NfcI2cWriteCmdAddr.sendLen = 2 + sendLen;
61 for (unsigned int i=0; i < sendLen; i++) {
62 sendUserCmd[2+i] = *(recvData + i);
63 }
64 status = IoTI2cWrite(PCA9555_I2C_IDX, C081_NFC_ADDR & 0xFE,
65 c081NfcI2cWriteCmdAddr.sendBuf, c081NfcI2cWriteCmdAddr.sendLen);
66 if (status != IOT_SUCCESS) {
67 printf("I2cWrite(%02X) failed, %0X!\n", sendUserCmd[0], status);
68 return status;
69 }
70 
71 return IOT_SUCCESS;
72 }
73 
74 /*8
75 	@berf EEPROM page write
76 	@param unsigned char *pBuffer: Send data buff
77 	@param unsigned short WriteAddr:Send register address
78 	@param unsigned char datalen:Sending data length
79 */
80 void EepWritePage(unsigned char *pBuffer, unsigned short WriteAddr, unsigned char datalen)
81 {
82 unsigned int status;
83 if (pBuffer == NULL) {
84 printf("eepWritePage buffer is null\r\n");
85 }
86 status = C081NfcI2cWrite((unsigned char)((WriteAddr & 0xFF00) >> 8),
87 (unsigned char)(WriteAddr & 0x00FF), pBuffer, datalen);
88 hi_udelay(10000); //The delay time must be 10ms
89 }
90 
91 /**
92 @berf write EEPROM
93 @param unsigned short addr:eeprom address
94 @param unsigned int len:Write data length
95 @param unsigned char *wbuf:write data buff
96 */
97 void Fm11nt081dWriteEeprom(unsigned short baseAddr, unsigned int len, unsigned char *wbuf)
98 {
99 	unsigned char offset = 0;
100 unsigned char *writeBuff = wbuf;
101 unsigned int writeLen = len;
102 unsigned short addr = baseAddr;
103 if (writeBuff == NULL) {
104 printf("write ndef is null\r\n");
105 return;
106 }
107 if (addr < FM11_E2_USER_ADDR || addr >= FM11_E2_MAUNF_ADDR) {
108 offset = FM11_E2_BLOCK_SIZE - (addr % FM11_E2_BLOCK_SIZE);
109 printf("offset = %d, writeLen = %d\r\n", offset, writeLen);
110 if (writeLen > offset) {
111 EepWritePage(writeBuff, addr, offset);
112 addr += offset;
113 writeBuff += offset;
114 writeLen -= offset;
115 } else {
116 EepWritePage(writeBuff, addr, writeLen);
117 writeLen = 0;
118 }
119 }
120 while (writeLen) {
121 if (writeLen >= FM11_E2_BLOCK_SIZE) {
122 EepWritePage(writeBuff, addr, FM11_E2_BLOCK_SIZE);
123 addr += FM11_E2_BLOCK_SIZE;
124 writeBuff += FM11_E2_BLOCK_SIZE;
125 writeLen -= FM11_E2_BLOCK_SIZE;
126 } else {
127 EepWritePage(writeBuff, addr, writeLen);
128 writeLen = 0;
129 }
130 }
131 }
132 
133 /**
134 * @berf i2c read
135 * @param unsigned char reg_high_8bit_cmd:Transmit register value 8 bits high
136 * @param unsigned char reg_low_8bit_cmd:Transmit register value low 8 bits
137 * @param unsigned char* recv_data:Receive data buff
138 * @param unsigned char send_len:Sending data length
139 * @param unsigned char read_len:Length of received data
140 */
141 unsigned int WriteRead(unsigned char regHigh8bitCmd, unsigned char regLow8bitCmd,
142 unsigned char sendLen, unsigned char readLen)
143 {
144 unsigned int status = 0;
145 unsigned char recvData[888] = {0};
146 hi_i2c_data c081NfcI2cWriteCmdAddr ={0};
147 unsigned char sendUserCmd[2] = {regHigh8bitCmd, regLow8bitCmd};
148 (void)memset_s(&recvData, sizeof(unsigned char), 0x0, sizeof(recvData));
149 
150 c081NfcI2cWriteCmdAddr.send_buf = sendUserCmd;
151 c081NfcI2cWriteCmdAddr.send_len = sendLen;
152 
153 c081NfcI2cWriteCmdAddr.receive_buf = recvData;
154 c081NfcI2cWriteCmdAddr.receive_len = readLen;
155 
156 status = hi_i2c_writeread(PCA9555_I2C_IDX, C081_NFC_ADDR | I2C_RD, &c081NfcI2cWriteCmdAddr);
157 if (status != IOT_SUCCESS) {
158 printf("hi_i2c_writeread failed, %0X!\n", status);
159 return status;
160 }
161 
162 printf("FM11nt081d read ndef data\r\n");
163 for (int i = 0; i < readLen; i++) {
164 printf("0x%x ", recvData[i]);
165 }
166 return IOT_SUCCESS;
167 }
168 
169 /**
170 * @berf read EEPROM
171 * @param unsigned char *dataBuff:Read data and save it in buff
172 * @param unsigned short ReadAddr:Read address
173 * @param unsigned short len:Read length
174 */
175 unsigned int Fm11nt081ReadEep(unsigned short ReadAddr, unsigned short len)
176 {
177 unsigned int status;
178 
179 status = WriteRead((unsigned char)((ReadAddr & 0xFF00)>>8), (unsigned char)(ReadAddr & 0x00FF), 2, len);
180 
181 return IOT_SUCCESS;
182 }
183 
184 /*NFC chip configuration, usually do not call NFC init*/
185 void NFCInit(void)
186 {
187 unsigned char wbuf[5] = {0x05, 0x78, 0xF7, 0x90, 0x02}; //Chip default configuration
188 /*The CSN pin is masked when the byte is read and turned on when the EEP is written*/
189 IoTWatchDogDisable();
190 hi_udelay(100);
191 
192 Fm11nt081dWriteEeprom(0x3B1, 1, &wbuf[1]);
193 Fm11nt081dWriteEeprom(0x3B5, 1, &wbuf[3]);
194 Fm11nt081dWriteEeprom(NFC_EERROM_BASE_ADD, NFC_TOUTIAO_NDEF_LEN, ndefFile);
195 Fm11nt081ReadEep(NFC_EERROM_BASE_ADD, READ_NFC_TOUTIAO_NDEF_LEN);
196 return 0;
197 }
198 
199 void OnNFCRead()
200 {
201 g_buttonState = 1;
202 
203 }
204 
205 void GetFunKeyState(void)
206 {
207 uint8_t ext_io_state = 0;
208 uint8_t ext_io_state_d = 0;
209 uint8_t status;
210 
211 while(1) {
212 if (g_buttonState == 1) {
213 uint8_t diff;
214 status = PCA9555I2CReadByte(&ext_io_state);
215 if(status != IOT_SUCCESS) {
216 printf("i2c error!\r\n");
217 ext_io_state = 0;
218 ext_io_state_d = 0;
219 g_buttonState = 0;
220 continue;
221 }
222 
223 diff = ext_io_state ^ ext_io_state_d;
224 if (diff == 0) {
225 }
226 if ((diff & 0x40) && ((ext_io_state & 0x40) == 0)) {
227 // 当有设备读取NFC时，此时会触发NFC的中断，打印 read nfc
228 printf("read nfc \r\n");
229 }
230 status = PCA9555I2CReadByte(&ext_io_state);
231 ext_io_state_d = ext_io_state;
232 g_buttonState = 0;
233 }
234 usleep(20);
235 }
236 }
237 
238 /*app nfc demo*/
239 void NFCDemoTask()
240 {
241 PCA9555Init();
242 // 配置IO扩展芯片的part1的所有管脚为输出
243 SetPCA9555GpioValue(PCA9555_PART1_IODIR, 0x00);
244 // 配置左右三色车灯全灭
245 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, LED_OFF);
246 // 配置IO0_6方向设置为输入，1为输入，0为输出
247 SetPCA9555GpioValue(PCA9555_PART0_IODIR, 0x40);
248 
249 // 使能GPIO11的中断功能, OnNFCRead 为中断的回调函数
250 IoTGpioRegisterIsrFunc(IOT_IO_NAME_GPIO_11, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_FALL_LEVEL_LOW, OnNFCRead, NULL);
251 
252 NFCInit();
253 GetFunKeyState();
254 }
255 
256 void C081NFCExampleEntry(void)
257 {
258 osThreadAttr_t attr;
259 
260 attr.name = "NFCDemoTask";
261 attr.attr_bits = 0U;
262 attr.cb_mem = NULL;
263 attr.cb_size = 0U;
264 attr.stack_mem = NULL;
265 attr.stack_size = 5 * 1024;
266 attr.priority = osPriorityNormal;
267 
268 if (osThreadNew((osThreadFunc_t)NFCDemoTask, NULL, &attr) == NULL) {
269 printf("[NFCDemoTask] Falied to create NFCDemoTask!\n");
270 }
271 }
272 
273 APP_FEATURE_INIT(C081NFCExampleEntry);
```

- 步骤4：修改.device/soc/hisilicon/hi3861v100/sdk_liteos/build/config/usr_config.mk文件。在这个配置文件中打开I2C驱动宏。搜索字段CONFIG_I2C_SUPPORT ，并打开I2C。配置如下：

```
  # CONFIG_I2C_SUPPORT is not set
  CONFIG_I2C_SUPPORT=y
  ```

- 步骤5：编译工程代码
  
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤6：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.9.4 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，当我们使用手机靠近小车的NFC模块时，会拉起手机的淘宝应用，同时可以看到串口打印出read nfc的字样，说明我们使用I2C中断触发的功能，实现对NFC驱动的实验成功。串口打印信息如下所示。

![](pic/image-20220922103623047.png)

### 2.9.5 扩展实验

* 本实验学习了通过使用I2C中断触发的功能，实现对NFC的驱动，请学生做如下实验：
  * 1、通过使用I2C中断触发功能，实现电池电量检测中断触发，当电量低于3.3V时，蜂鸣器报警。
  
      提示：参考单I2C轮询实验。硬件接线：INT_CW2015 - IO0_7，I2C0_SDA - GPIO 13，I2C0_SCL - GPIO 14;

## 2.10 I2C实验-I2C总线实验

### 2.10.1 实验目的

* 本实验通过使用I2C总线，实现同时轮询多个设备如:电量检测（CW2015），陀螺仪、OLED屏、IO扩展芯片，NFC。陀螺仪芯片手册（编号：C94048，型 号： LSM6DSMTR）获取：https://so.szlcsc.com/global.html?k=LSM6DSM&hot-key=LM358DR2G， 点击数据手册进行下载。

### 2.10.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；
* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 2.10.3 实验流程

* 步骤1：复制i2c_bus_demo目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
      └─ sample
         └─ wifi-iot
            └─ app
            	├─ BUILD.gn
                └─i2c_bus_demo
                        ├─ BUILD.gn
                        ├─ cw2015.c
                        ├─ cw2015.h
                        ├─ fm11nt081.c
                        ├─ fm11nt081.h
                        ├─ hal_iot_gpio_ex.c
                        ├─ iot_gpio_ex.h
                        ├─ pca9555.c
                        ├─ pca9555.h
                        ├─ lsm6ds.c
                        ├─ lsm6ds.h
                        ├─ oled_fonts.h 
                        ├─ oled_ssd1306.c
                        ├─ oled_ssd1306.h
                        └─ i2c_bus_demo.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加i2c_bus_demo: i2c_bus_demo。注：第一个i2c_bus_demo指的是需要编译的工程目录，第二个i2c_bus_demo指的是applications/sample/wifi-iot/app/ i2c_bus_demo/BUILD.gn文件中的静态库，名称为i2c_bus_demo。

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

lite_component("app") {
  features = [ "i2c_bus_demo:i2c_bus_demo", ]
}
```

* 步骤4：原理：I2C通信中，主机通过时钟线SCL发送时钟信号，通过数据线SDA发送数据（包括从机地址、指令、数据包等），在发送完一帧数据后，需要等待从机的响应，才能继续发送下一帧数据，因此I2C属于同步通信。一个I2C主设备可以与多个I2C从设备通信。

根据原理图可以发现NFC，陀螺仪，IO扩展芯片，OLED屏幕都使用同一个I2C通路I2C0，硬件：I2C0_SDA - GPIO 13，I2C0_SCL - GPIO 14。NFC，IO扩展芯片，OLED参考前面章节，这里提供陀螺仪部分代码以及I2C总线代码。

```c
1 #include <math.h>
2 #include <stdlib.h>
3 #include <string.h> // For memcpy
4 
5 #include <hi_time.h>
6 
7 #include <stdio.h>
8 #include <unistd.h>
9 
10 #include "lsm6ds.h"
11 #include "iot_gpio_ex.h"
12 
13 #include "ohos_init.h"
14 #include "cmsis_os2.h"
15 
16 #include "iot_i2c.h"
17 #include "iot_errno.h"
18 #include "hi_errno.h"
19 #include "hi_i2c.h"
20 #include "iot_gpio.h"
21 #include "ssd1306_conf.h"
22 #include "ssd1306_fonts.h"
23 #include "ssd1306.h"
24 
25 #define LSM6DS_I2C_IDX 0
26 #define IOT_I2C_IDX_BAUDRATE 4 // 400k
27 
28 #define Kp 100.0f // 比例增益支配率收敛到加速度计/磁强计
29 #define Ki 0.002f // 积分增益支配率的陀螺仪偏见的衔接
30 #define halfT 0.001f // 采样周期的一半
31 
32 extern void car_forward();
33 extern void car_backward();
34 extern void car_right(void);
35 
36 float q0 = 1, q1 = 0, q2 = 0, q3 = 0; // 四元数的元素，代表估计方向
37 float exInt = 0, eyInt = 0, ezInt = 0; // 按比例缩小积分误差
38 float Yaw, Pitch, Roll; // 偏航角，俯仰角，翻滚角
39 static float yaw_conv = 0.0f; 
40 
41 /**
42 * @berf i2c read
43 * @param hi_u8 reg_high_8bit_cmd:Transmit register value 8 bits high
44 * @param hi_u8 reg_low_8bit_cmd:Transmit register value low 8 bits
45 * @param hi_u8* recv_data:Receive data buff
46 * @param hi_u8 send_len:Sending data length
47 * @param hi_u8 read_len:Length of received data
48 */
49 uint32_t LSM6DS_WriteRead(uint8_t reg_high_8bit_cmd, uint8_t send_len, uint8_t read_len)
50 {
51 uint32_t status =0;
52 uint8_t recvData[888] = {0};
53 uint32_t ret = 0;
54 hi_i2c_data c081nfc_i2c_write_cmd_addr ={0};
55 uint8_t send_user_cmd[1] = {reg_high_8bit_cmd};
56 
57 memset(recvData, 0x0, sizeof(recvData));
58 c081nfc_i2c_write_cmd_addr.send_buf = send_user_cmd;
59 c081nfc_i2c_write_cmd_addr.send_len = send_len;
60 
61 c081nfc_i2c_write_cmd_addr.receive_buf = recvData;
62 c081nfc_i2c_write_cmd_addr.receive_len = read_len;
63 
64 status = hi_i2c_writeread(LSM6DS_I2C_IDX, LSM6DS_READ_ADDR, &c081nfc_i2c_write_cmd_addr);
65 if (status != IOT_SUCCESS) {
66 printf("I2cRead() failed, %0X!\n", status);
67 return status;
68 }
69 ret = recvData[0];
70 return ret;
71 }
72 
73 uint32_t LSM6DS_ReadCont(uint8_t reg_addr, uint8_t* buffer, uint16_t read_len)
74 {
75 uint32_t status;
76 hi_i2c_data i2c_attr;
77 
78 i2c_attr.send_buf = &reg_addr;
79 i2c_attr.send_len = 1;
80 i2c_attr.receive_buf = buffer;
81 i2c_attr.receive_len = read_len;
82 
83 status = hi_i2c_writeread(LSM6DS_I2C_IDX, LSM6DS_READ_ADDR, &i2c_attr);
84 for (int i = 0; i < read_len; i++) {
85 printf("0x%x ", buffer[i]);
86 }
87 printf("\r\n");
88 return status;
89 }
90 
91 static uint32_t LSM6DS_Write(uint8_t addr, uint8_t writedata, uint32_t buffLen)
92 {
93 uint8_t buffer[2] = {addr, writedata};
94 uint32_t retval = IoTI2cWrite(LSM6DS_I2C_IDX, LSM6DS_WRITE_ADDR, buffer, buffLen);
95 if (retval != IOT_SUCCESS) {
96 printf("IoTI2cWrite(%02X) failed, %0X!\n", buffer[0], retval);
97 return retval;
98 }
99 printf("IoTI2cWrite(%02X)\r\n", buffer[0]);
100 return IOT_SUCCESS;
101 }
102 
103 #define EXEUTION_FREQ 5 //单位ms
104 
105 void GetLSM6DS()
106 {
107 while (1) {
108 msleep(5);
109 Lsm_Get_RawAcc();
110 }
111 }
112 
113 void LSM6DS_Init()
114 {
115 //LSM6DS_Write(LSM6DSL_CTRL3_C, 0x30, 2);
116 LSM6DS_Write(LSM6DSL_CTRL3_C, 0x34, 2);
117 
118 LSM6DS_Write(LSM6DSL_CTRL2_G , 0X4C, 2); // 角速度陀螺仪配置2000dps ,104Hz
119 LSM6DS_Write(LSM6DSL_CTRL10_C, 0x38, 2); // timer en, pedo en, tilt en ??
120 
121 //LSM6DS_Write(LSM6DSL_CTRL1_XL, 0x43, 2); // 加速度配置量程为2g,104Hz, lpf1_bw_sel=1, bw0_xl=1;
122 LSM6DS_Write(LSM6DSL_CTRL1_XL, 0x4F, 2); // 加速度配置量程为8g,104Hz, lpf1_bw_sel=1, bw0_xl=1;
123 
124 LSM6DS_Write(LSM6DSL_TAP_CFG, 0x10, 2);
125 LSM6DS_Write(LSM6DSL_WAKE_UP_DUR, 0x00, 2);
126 LSM6DS_Write(LSM6DSL_WAKE_UP_THS, 0x02, 2);
127 // LSM6DS_Write(LSM6DSL_MD1_CFG, 0x20, 2);
128 LSM6DS_Write(LSM6DSL_TAP_THS_6D, 0x40, 2);
129 LSM6DS_Write(LSM6DSL_CTRL8_XL, 0x01, 2);
130 return IOT_SUCCESS;
131 }
132 
133 // /*互补滤波算法*/
134 // float q0 = 1,q1 = 0,q2 = 0,q3 = 0; //表示估计方向的四元数元素
135 // float exInt = 0,eyInt = 0,ezInt = 0; //比例积分误差
136 
137 void IMU_YAW_CAL(float gyroZ)
138 {
139 static float dt = 0.03; // 间隔8ms
140 // static int g_GetZeroOffset = 0;
141 // static float gyroZ_offset = 0.0f;
142 static float yaw = 0.0f, temp = 0.0f;
143 
144 // 除去零偏
145 #if 0
146 static int a = 0;
147 a++;
148 if (hi_get_seconds() <= 5) {
149 printf("---------times-----------:%d\n", a);
150 }
151 #endif
152 
153 if (fabs(gyroZ) < 0.04) {
154 temp = 0;
155 } else {
156 temp = gyroZ * dt;
157 }
158 yaw += temp;
159 yaw_conv = yaw * 57.32;
160 // 360°一个循环
161 if (fabs(yaw_conv) > 360.0f) {
162 if ((yaw_conv) < 0) {
163 yaw_conv += 360.0f;
164 } else {
165 yaw_conv -= 360.0f;
166 }
167 }
168 printf("yaw_conv:%.05f\n", yaw_conv);
169 }
170 
171 void IMU_Attitude_cal(float gx, float gy, float gz, float ax, float ay, float az)
172 {
173 float norm;
174 float vx, vy, vz;
175 float ex, ey, ez;
176 float atan2_x, atan2_y;
177 float atan2_x_yaw, atan2_y_yaw;
178 
179 norm = (float)sqrt((float)(ax*ax + ay*ay + az*az));
180 ax = ax / norm; // ax normalize
181 ay = ay / norm; // ay normalize
182 az = az / norm; // az normalize
183 
184 // 估计方向的重力
185 vx = 2*(q1*q3 - q0*q2);
186 vy = 2*(q0*q1 + q2*q3);
187 vz = q0*q0 - q1*q1 - q2*q2 + q3*q3;
188 
189 // 经叉积并求出误差
190 ex = (ay*vz - az*vy);
191 ey = (az*vx - ax*vz);
192 ez = (ax*vy - ay*vx);
193 
194 // 积分误差比例积分增益
195 exInt = exInt + ex*Ki;
196 eyInt = eyInt + ey*Ki;
197 ezInt = ezInt + ez*Ki;
198 
199 // 调整后的陀螺仪测量
200 gx = gx + Kp*ex + exInt;
201 gy = gy + Kp*ey + eyInt;
202 gz = gz + Kp*ez + ezInt;
203 
204 // 整合四元数率和正常化 
205 q0 = q0 + (-q1*gx - q2*gy - q3*gz)*halfT;
206 q1 = q1 + (q0*gx + q2*gz - q3*gy)*halfT;
207 q2 = q2 + (q0*gy - q1*gz + q3*gx)*halfT;
208 q3 = q3 + (q0*gz + q1*gy - q2*gx)*halfT;
209 
210 // 正常化四元
211 norm = sqrt(q0*q0 + q1*q1 + q2*q2 + q3*q3);
212 q0 = q0 / norm;
213 q1 = q1 / norm;
214 q2 = q2 / norm;
215 q3 = q3 / norm;
216 
217 // 俯仰角
218 Pitch = asin(-2 * q1 * q3 + 2 * q0* q2) * 180 / 3.14;
219 // 横滚角
220 // printf("forward:%.02f, backward:%.02f\n", fabs(2 * q2 * q3 + 2 * q0 * q1), fabs(-2 * q1 * q1 - 2 * q2* q2 + 1));
221 atan2_x = -2 * q1 * q1 - 2 * q2* q2 + 1;
222 atan2_y = 2 * q2 * q3 + 2 * q0 * q1;
223 if (atan2_x > 0) {
224 Roll = atan(atan2_y / atan2_x) * 180 / 3.14;
225 } else if (atan2_x < 0 && atan2_y >= 0) {
226 Roll = atan(atan2_y / atan2_x) * 180 / 3.14 + 180;
227 } else if (atan2_x < 0 && atan2_y < 0) {
228 Roll = atan(atan2_y / atan2_x) * 180 / 3.14 - 180;
229 } else if (atan2_y > 0 && atan2_x == 0) {
230 Roll = 90;
231 } else if (atan2_y < 0 && atan2_x == 0) {
232 Roll = -90;
233 } else {
234 printf("undefined\n");
235 }
236 printf("Pitch:%.02f, Roll:%.02f\n", Pitch, Roll);
237 static char line[32] = {0};
238 ssd1306_SetCursor(0, 30);
239 snprintf(line, sizeof(line), "Pitch:%.2f", Pitch, Roll);
240 ssd1306_DrawString(line, Font_7x10, White);
241 }
242 
243 void Lsm_Get_RawAcc()
244 {
245 // float angle_x,angle_y,angle_z;
246 uint8_t buf[12] = {0};
247 int16_t acc_x = 0, acc_y = 0, acc_z = 0;
248 float acc_x_conv = 0, acc_y_conv = 0, acc_z_conv = 0;
249 int16_t ang_rate_x = 0, ang_rate_y = 0, ang_rate_z = 0;
250 float ang_rate_x_conv = 0, ang_rate_y_conv = 0, ang_rate_z_conv = 0;
251 float ang_rate_x_cal = 0, ang_rate_y_cal = 0, ang_rate_z_cal = 0;
252 float ang_rate_z_yaw = 0;
253 
254 static char line[32] = {0};
255 if ((LSM6DS_WriteRead(LSM6DSL_STATUS_REG, 1, 1) & 0x03)!=0) {
256 
257 if (IOT_SUCCESS != LSM6DS_ReadCont(LSM6DSL_OUTX_L_G, buf, 12)) {
258 printf("i2c read error!\n");
259 }
260 else {
261 ang_rate_x = (buf[1] << 8) + buf[0];
262 ang_rate_y = (buf[3] << 8) + buf[2];
263 ang_rate_z = (buf[5] << 8) + buf[4];
264 acc_x = (buf[7] << 8) + buf[6];
265 acc_y = (buf[9] << 8) + buf[8];
266 acc_z = (buf[11] << 8) + buf[10];
267 
268 ang_rate_x_conv = (3.14 * ang_rate_x) / 180 ;
269 ang_rate_y_conv = (3.14 * ang_rate_y) / 180;
270 ang_rate_z_conv = (3.14 * ang_rate_z) / 180;
271 ang_rate_x_cal = ang_rate_x_conv / 14.29;
272 ang_rate_y_cal = ang_rate_y_conv / 14.29;
273 ang_rate_z_cal = ang_rate_z_conv / 14.29;
274 acc_x_conv = acc_x / 4098.36;
275 acc_y_conv = acc_y / 4098.36;
276 acc_z_conv = acc_z / 4098.36;
277 printf("lsm trans acc: %.2f, %.2f, %.2f \n ang: %.2f, %.2f, %.2f, ang_cal: %.2f, %.2f, %.2f\n ",
278 acc_x_conv, acc_y_conv, acc_z_conv, ang_rate_x_conv, ang_rate_y_conv, ang_rate_z_conv, ang_rate_x_cal, ang_rate_y_cal, ang_rate_z_cal);
279 IMU_Attitude_cal(ang_rate_x_conv, ang_rate_y_conv, ang_rate_z_conv, acc_x_conv, acc_y_conv, acc_z_conv);
280 IMU_YAW_CAL(ang_rate_z_cal);
281 }
282 }
283 }
```

```c
1 #include <stdio.h>
2 #include <unistd.h>
3 #include "hi_timer.h"
4 
5 #include "ssd1306_conf.h"
6 #include "ssd1306_fonts.h"
7 #include "ssd1306.h"
8 #include "cw2015.h"
9 #include "lsm6ds.h"
10 #include "pca9555.h"
11 
12 #include "ohos_init.h"
13 #include "cmsis_os2.h"
14 #include "iot_gpio_ex.h"
15 #include "iot_gpio.h"
16 #include "iot_errno.h"
17 #include "hi_errno.h"
18 
19 
20 int g_buttonState = 0;
21 
22 void OnFuncKeyPressed(const char *arg)
23 {
24 (void) arg;
25 g_buttonState = 1;
26 }
27 
28 void GetFunKeyState(void)
29 {
30 uint8_t ext_io_state = 0;
31 uint8_t ext_io_state_d = 0;
32 uint8_t status;
33 uint8_t intLowFlag = 0;
34 uint32_t cTick = 0;
35 IotGpioValue value = 0;
36 
37 while(1) {
38 if (g_buttonState == 1) {
39 uint8_t diff;
40 status = PCA9555I2CReadByte(&ext_io_state);
41 diff = ext_io_state ^ ext_io_state_d;
42 if ((diff & 0x04) && ((ext_io_state & 0x04) == 0)) {
43 printf("S3 prassed\r\n");
44 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_5, IOT_GPIO_VALUE0);
45 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE1);
46 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_10, IOT_GPIO_VALUE0);
47 } else if ((diff & 0x08) && ((ext_io_state & 0x08) == 0)) {
48 printf("S4 prassed\r\n");
49 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_5, IOT_GPIO_VALUE0);
50 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE0);
51 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_10, IOT_GPIO_VALUE1);
52 } else if ((diff & 0x10) && ((ext_io_state & 0x10) == 0)) {
53 printf("S5 prassed\r\n");
54 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_5, IOT_GPIO_VALUE1);
55 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE0);
56 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_10, IOT_GPIO_VALUE0);
57 }
58 ext_io_state_d = ext_io_state;
59 g_buttonState = 0;
60 } else {
61 if (IoTGpioGetInputVal(IOT_IO_NAME_GPIO_11, &value) == IOT_SUCCESS) {
62 if (value == 1) {
63 intLowFlag = 0;
64 } else {
65 if (intLowFlag == 0) {
66 cTick = hi_get_milli_seconds();
67 intLowFlag = 1;
68 } else {
69 if ((hi_get_milli_seconds() - cTick) > 2) {
70 status = PCA9555I2CReadByte(&ext_io_state);
71 intLowFlag = 0;
72 }
73 }
74 }
75 }
76 }
77 }
78 }
79 
80 // 电量检测模块Task
81 void CW2015Task(int* arg)
82 {
83 (void) arg;
84 static char line[32] = {0};
85 float voltage = 0.0;
86 
87 while (1) {
88 voltage = GetVoltage();
89 // 将获取到的电源格式化为字符串
90 ssd1306_SetCursor(0, 15);
91 snprintf(line, sizeof(line), "voltage: %.2f", voltage);
92 ssd1306_DrawString(line, Font_7x10, White);
93 ssd1306_UpdateScreen();
94 usleep(10000);
95 }
96 }
97 
98 // NFC模块task
99 void NFCTask(int* arg)
100 {
101 NFCInit(); // 初始化NFC模块
102 }
103 
104 void LSM6DSTask(int* arg)
105 {
106 (void) arg;
107 GetLSM6DS();
108 }
109 
110 // 功能按键task
111 void FunKeyTask(int* arg)
112 {
113 // 获取实时的按键状态
114 GetFunKeyState();
115 }
116 
117 void TrafficLightInit(void)
118 {
119 // LED3的GPIO初始化
120 IoTGpioInit(IOT_IO_NAME_GPIO_9);
121 // 设置GPIO9的管脚复用关系为GPIO
122 IoSetFunc(IOT_IO_NAME_GPIO_9, IOT_IO_FUNC_GPIO_9_GPIO);
123 // GPIO方向设置为输出
124 IoTGpioSetDir(IOT_IO_NAME_GPIO_9, IOT_GPIO_DIR_OUT);
125 
126 // LED5的GPIO初始化
127 IoTGpioInit(IOT_IO_NAME_GPIO_10);
128 // 设置GPIO9的管脚复用关系为GPIO
129 IoSetFunc(IOT_IO_NAME_GPIO_10, IOT_IO_FUNC_GPIO_10_GPIO);
130 // GPIO方向设置为输出
131 IoTGpioSetDir(IOT_IO_NAME_GPIO_10, IOT_GPIO_DIR_OUT);
132 
133 // LED4的GPIO初始化
134 IoTGpioInit(IOT_IO_NAME_GPIO_5);
135 // 设置GPIO5的管脚复用关系为GPIO
136 IoSetFunc(IOT_IO_NAME_GPIO_5, IOT_IO_FUNC_GPIO_5_GPIO);
137 // GPIO方向设置为输出
138 IoTGpioSetDir(IOT_IO_NAME_GPIO_5, IOT_GPIO_DIR_OUT);
139 
140 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_5, IOT_GPIO_VALUE0);
141 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE0);
142 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_10, IOT_GPIO_VALUE0);
143 }
144 
145 void I2CBusInit(void)
146 {
147 PCA9555Init(); // 初始化PCA9555 扩展IO芯片模块
148 // 配置IO扩展芯片的part1的所有管脚为输出
149 SetPCA9555GpioValue(PCA9555_PART1_IODIR, 0x00);
150 // 配置左右三色车灯全灭
151 SetPCA9555GpioValue(PCA9555_PART1_OUTPUT, LED_OFF);
152 CW2015Init(); // 电量检测模块
153 LSM6DS_Init(); // 陀螺仪模块初始化
154 ssd1306_Init(); // 初始化 SSD1306 OLED模块
155 ssd1306_Fill(Black);
156 TrafficLightInit(); // 交通灯初始化
157 
158 // 使能GPIO11的中断功能, OnFuncKeyPressed 为中断的回调函数
159 IoTGpioRegisterIsrFunc(IOT_IO_NAME_GPIO_11, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_FALL_LEVEL_LOW, OnFuncKeyPressed, NULL);
160 
161 // S3:IO0_2,S4:IO0_3,S5:IO0_4 0001 1100 => 0x1c 将IO0_2,IO0_3,IO0_4方向设置为输入，1为输入，0位输出
162 SetPCA9555GpioValue(PCA9555_PART0_IODIR, 0x1c);
163 
164 uint8_t write[2] = {0X12, 0x30};
165 // 使能IO扩展芯片的中断寄存器
166 IoTI2cWrite(0, 0XD4, write, 2);
167 // 从指定地址的PCA9555器件的指定寄存器读一字节数据
168 }
169 
170 void I2CBusExampleEntry(void)
171 {
172 osThreadAttr_t attr;
173 
174 I2CBusInit();
175 IoTWatchDogDisable();
176 
177 attr.name = "NFCTask";
178 attr.attr_bits = 0U;
179 attr.cb_mem = NULL;
180 attr.cb_size = 0U;
181 attr.stack_mem = NULL;
182 attr.stack_size = 5 * 1024;
183 attr.priority = osPriorityNormal;
184 
185 // NFC
186 if (osThreadNew(NFCTask, NULL, &attr) == NULL) {
187 printf("[NFCTask] Failed to create NFCTask!\n");
188 }
189 
190 // 电量监测
191 attr.name = "CW2015Task";
192 if (osThreadNew(CW2015Task, NULL, &attr) == NULL) {
193 printf("[CW2015Task] Failed to create CW2015Task!\n");
194 }
195 
196 // 功能按键
197 attr.name = "FunKeyTask";
198 if (osThreadNew(FunKeyTask, NULL, &attr) == NULL) {
199 printf("[FunKeyTask] Failed to create FunKeyTask!\n");
200 }
201 
202 // 陀螺仪
203 attr.name = "LSM6DSTask";
204 if (osThreadNew(LSM6DSTask, NULL, &attr) == NULL) {
205 printf("[LSM6DSTask] Failed to create LSM6DSTask!\n");
206 }
207 }
208 
209 APP_FEATURE_INIT(I2CBusExampleEntry);
```

```
  # CONFIG_I2C_SUPPORT is not set
  CONFIG_I2C_SUPPORT=y
  ```

- 步骤5：编译工程代码
  
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤6：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.10.4 实验结果

* 软件烧录成功后，按一下开发板的RESET按键复位开发板，可以在OLED屏幕上面看到陀螺仪俯仰角实时数据以及电池电量数据，当手机靠近小车的NFC模块时，NFC会拉起手机的淘宝应用，且可以通过S3、S4、S5功能按键来控制三个交通灯的亮灭，说明我们使用I2C总线，实现同时轮询多个设备的实验成功。

### 2.10.5 扩展实验

* 本实验学习了通过使用I2C总线，实现同时轮询多个设备如:电量检测，陀螺仪、OLED屏、按键扩展中断，请学生做如下实验：

* 1.通过I2C总线，实现RTC在OLED屏幕实时显示万年历，并同时将陀螺仪，超声波数据也显示在OLED上。

提示：参考单I2C轮询实验，GPIO综合实验。

## 2.11 ADC实验

### 2.11.1 实验目的

* 本实验通过使用主芯片的ADC功能，实现对红外对管的驱动。

### 2.11.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.接线方式：J27,J26跳线帽去除，同时J6 GPIO7 - RIN，J5 GPIO12 - LIN；硬件搭建如下图所示：

![](pic/image-20220922150521392.png) <img src="pic/image-20220922150548774.png" style="zoom: 67%;" />

### 2.11.3 接口说明

#### 2.11.3.1 AdcRead()

| **定义：** | unsigned int AdcRead(IotAdcChannelIndex channel, unsigned const short *data, IotAdcEquModelSel equModel, IotAdcCurBais curBais, unsigned const short rstCnt); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 根据输入参数从指定的ADC通道读取一段采样数据 |
| **参数：** | channel：表示指定的ADC通道 data：表示指向存储读取数据的地址的指针 eqmodel表示方程模型 curBais表示模拟功率控制模式 rstCnt表示从重置到转换开始的时间计数(一次计数是334ns，其值需在0~0xFF0之间) |
| **返回值：** | IOT_SUCCESS：ADC数据读取成功 IOT_FAILURE：ADC数据读取失败 |
| **依赖：** | ./iot_adc.h |

### 2.11.4 实验流程

* 步骤1：复制lth1550_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
      └─ sample
          └─ wifi-iot
             └─ app
                ├─ BUILD.gn
                └─lth1550_control
                      ├─ BUILD.gn  
                      ├─ hal_iot_gpio_ex.c
                      ├─ iot_gpio_ex.h
                      ├─ hal_iot_adc.c
                      ├─ iot_adc.h
                      └─ lth1550_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加lth1550_control:lth1550_control。注：第一个lth1550_control指的是需要编译的工程目录，第二个lth1550_control指的是applications/sample/wifi-iot/app/ lth1550_control /BUILD.gn文件中的静态库，名称为lth1550_control。

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

lite_component("app") {
  features = [ "lth1550_control:lth1550_control", ]
}
```

步骤4：原理：ADC即模拟-数字转换器，可以将连续变化的模拟信号转换为数字信号，进而使用数字电路进行处理，称之为数字信号处理。

从硬件原理图可以分析出左红外对管对应的是GPIO12，右红外对管对应的是GPIO07，通过ADC通道从传感器读回数据，核心代码如方下所示:

```c
1 /*
2 ADC的相关API接口
3 */
4 #include <stdio.h>
5 #include <unistd.h>
6 
7 #include "ohos_init.h"
8 #include "cmsis_os2.h"
9 #include "iot_gpio_ex.h"
10 #include "iot_gpio.h"
11 #include "iot_adc.h"
12 #include "hi_adc.h"
13 #include "iot_errno.h"
14 
15 void Lth1550Init(void)
16 {
17 // 红外对管对应的GPIO，左：ADC0_GPIO12，右：ADC3_GPIO07
18 // GPIO07初始化
19 IoTGpioInit(IOT_IO_NAME_GPIO_7);
20 // 设置GPIO07的管脚复用关系为GPIO
21 IoSetFunc(IOT_IO_NAME_GPIO_7, IOT_IO_FUNC_GPIO_7_GPIO);
22 // 设置GPIO07的管脚方向为入
23 IoTGpioSetDir(IOT_IO_NAME_GPIO_7, IOT_GPIO_DIR_IN);
24 
25 // GPIO12初始化
26 IoTGpioInit(IOT_IO_NAME_GPIO_12);
27 // 设置GPIO012的管脚复用关系为GPIO
28 IoSetFunc(IOT_IO_NAME_GPIO_12, IOT_IO_FUNC_GPIO_12_GPIO);
29 // 设置GPIO12的管脚方向为入
30 IoTGpioSetDir(IOT_IO_NAME_GPIO_12, IOT_GPIO_DIR_IN);
31 }
32 
33 void GetInfraredData(hi_adc_channel_index idx)
34 {
35 unsigned short data = 0;
36 int ret = 0;
37 
38 //ADC_Channal_6 自动识别模式 CNcomment:4次平均算法模式 CNend */
39 ret = AdcRead(idx, &data, IOT_ADC_EQU_MODEL_4, IOT_ADC_CUR_BAIS_DEFAULT, 0xff);
40 if (ret != HI_ERR_SUCCESS) {
41 printf("hi_adc_read failed\n");
42 }
43 
44 if (IOT_ADC_CHANNEL_0 == idx) {
45 printf("Left ADC value is %d \r\n",data);
46 } else if (IOT_ADC_CHANNEL_3 == idx) {
47 printf("Right ADC value is %d \r\n",data);
48 }
49 }
50 
51 static void adcTask(void)
52 {
53 // 初始化红外对管
54 Lth1550Init();
55 // 获取当前采集到的红外对管的ADC值
56 while (1) {
57 GetInfraredData(IOT_ADC_CHANNEL_3);
58 GetInfraredData(IOT_ADC_CHANNEL_0);
59 usleep(20);
60 }
61 }
62 
63 void ADCExampleEntry(void)
64 {
65 osThreadAttr_t attr;
66 IoTWatchDogDisable();
67 
68 attr.name = "adcTask";
69 attr.attr_bits = 0U;
70 attr.cb_mem = NULL;
71 attr.cb_size = 0U;
72 attr.stack_mem = NULL;
73 attr.stack_size = 5 * 1024;
74 attr.priority = osPriorityNormal;
75 
76 if (osThreadNew(adcTask, NULL, &attr) == NULL) {
77 printf("[LSM6DSTask] Failed to create LSM6DSTask!\n");
78 }
79 }
80 
81 APP_FEATURE_INIT(ADCExampleEntry);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.11.5 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，当我们将红色对管置于黑色或者白色的背景下，串口打印出来的ADC数据有明显的变化，说明我们使用主芯片的ADC功能，实现对红外对管驱动的实验成功。注意：如果要使用小车的红外对管，需要使用跳线帽选择J5和J6的2、3脚，不然无法检测到数据。

![](pic/image-20220922172056067.png)

### 2.11.6 扩展实验

* 本实验学习了通过使用主芯片的ADC功能，实现对红外对管的驱动，请学生做如下实验：

* 1.GPIO 7 和GPIO 12 复用ADC功能，实现小车哪一边在黑色背景下，哪边电机停止，哪一边在白色背景下，哪边电机就转动。

提示：参考主芯片GPIO输出实验。

## 2.12 串口实验

### 2.12.1 实验目的

* 本实验通过使用主芯片的UART，实现串口的自收自发功能。

### 2.12.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件配置：串口引出J4，需J13跳帽跳至TX-GPIO 0，J12跳帽跳至RX-GPIO 1，J4跳帽跳至TX-RX（单独实验需要，其他实验去掉）；硬件搭建如下图所示：

### 2.12.3 接口说明

#### 2.12.3.1 IoTUartInit()

| **定义：** | unsigned int IoTUartInit(unsigned int id, const IotUartAttribute *param); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 初始化指定的UART端口 |
| **参数：** | id：表示UART设备的端口号 param：表示指向UART属性的指针 |
| **返回值：** | IOT_SUCCESS：初始化成功 IOT_FAILURE：初始化失败 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_uart.h |

#### 2.12.3.2 IoTUartRead()

| 定义： | int IoTUartRead(unsigned int id, unsigned char *data, unsigned int dataLen); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 从UART设备中读取指定长度的数据 |
| **参数：** | id：表示UART设备的端口号 data：表示指向要读取数据的起始地址的指针 dataLen：表示要读取的字节数 |
| **返回值：** | 数据读取成功：返回成功读取的字节数 数据读取失败：返回 -1 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_uart.h |

#### 2.12.3.3 IoTUartWrite()

| 定义： | int IoTUartWrite(unsigned int id, const unsigned char *data, unsigned int dataLen); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 将指定长度的数据写入UART设备 |
| **参数：** | id：表示UART设备的端口号 data：表示指向要写入的数据的起始地址的指针 dataLen：表示要写入的字节数 |
| **返回值：** | 数据写入成功：返回成功写入的字节数 数据写入失败：返回 -1 |
| **依赖：** | //base/iot_hardware/peripheral/interfaces/kits/iot_uart.h |

#### 2.12.3.4 IoTUartDeinit()

| **定义：**   | unsigned   int IoTUartDeinit(unsigned int id);            |
| ------------ | --------------------------------------------------------- |
| **功能：**   | 去初始化指定的UART端口                                    |
| **参数：**   | id：表示UART设备的端口号                                  |
| **返回值：** | IOT_SUCCESS：去初始化成功   IOT_FAILURE：去初始化失败     |
| **依赖：**   | //base/iot_hardware/peripheral/interfaces/kits/iot_uart.h |

### 2.12.4 实验流程

* 步骤1：复制uart_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
     └─ sample
         └─ wifi-iot
            └─ app
                ├─ BUILD.gn
                └─ uart_control
                      ├─ BUILD.gn  
                      ├─ hal_iot_gpio_ex.c
                      ├─ iot_gpio_ex.h
                      └─ uart_control.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加uart_control: uart_control。注：第一个uart_control指的是需要编译的工程目录，第二个uart_control指的是applications/sample/wifi-iot/app/ uart_control /BUILD.gn文件中的静态库，名称为uart_control。

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

lite_component("app") {
  features = [ "uart_control:uart_control", ]
}
```

* 步骤3：UART通信原理：数据从一个设备UART的发送引脚（Tx） 流向另一个设备UART的接收（Rx） 引脚。

由于默认UART 0为调试串口对应的是GPIO03和GPIO04,一般情况下不修改；与其他设备通信使用UART 1或者UART 2,本实验使用的是UART1，对应的就是GPIO00（UART1的TX）和GPIO01（UART1的RT），核心代码如方下所示:

- 步骤4：修改.device/soc/hisilicon/hi3861v100/sdk_liteos/build/config/usr_config.mk文件。在这个配置文件中打开UART驱动宏。搜索字段CONFIG_UART1_SUPPORT ，并打开I2C。配置如下：
  
  ```
  # CONFIG_UART1_SUPPORT is not set
  CONFIG_UART1_SUPPORT =y
  ```
  
- 步骤5：编译工程代码
  
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤6：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 2.12.5 实验结果

* 注意：需要把TX和RX通过跳线帽连接，可以参考实验要求。
* 软件烧录成功后，打开串口工具，按一下开发板的RESET按键复位开发板，可以看到串口打印出来了写入UART1的数据，说明使用主芯片的UART，实现串口的自收自发功能的实验成功。串口打印信息如下所示。

![](pic/image-20220922181224894.png)

### 2.12.6 扩展实验

* 本实验通过使用主芯片的UART，实现串口的自收自发功能，请学生做如下实验：
  * 1、两个队伍之间通信，通过按键相互控制另外一个车的红色交通灯亮灭。
  
      提示：一辆车按S1按键发送亮灭标志，另一辆车通过UART串口接收到标志，实现控制红色交通灯亮灭。
  
## 2.13 基础WiFi实验

### 2.13.1 实验目的

* 本实验主要学习Hi3861V100的STA和AP模式。

### 2.13.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；
* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 2.13.3 接口说明

* STA模式

#### 2.12.3.1 ConnectToHotspot()

| **定义：**   | int ConnectToHotspot(WifiDeviceConfig* apConfig);           |
| ------------ | ----------------------------------------------------------- |
| **功能：**   | 连接WiFi                                                    |
| **参数：**   | WiFi相关参数比如SSID,密码                                   |
| **返回值：** | 1：成功                                                     |
| **依赖：**   | //foundation/communication/wifi_lite/interfaces/wifiservice |

#### 2.12.3.2 DisconnectWithHotspot()

| 定义：     | void DisconnectWithHotspot(int netId);                      |
| ---------- | ----------------------------------------------------------- |
| **功能：   | 断开WiFi                                                    |
| **参数：** | WiFi对应的netId                                             |
| **返回值： | 无                                                          |
| **依赖：** | //foundation/communication/wifi_lite/interfaces/wifiservice |

* AP模式

#### 2.12.3.3 StartHotspot()

| 定义：     | int StartHotspot(const HotspotConfig* config);              |
| ---------- | ----------------------------------------------------------- |
| **功能：** | 开启AP                                                      |
| **参数：** | AP参数包括：IP地址，默认网关，子网掩码                      |
| **返回值： | 0：成功                                                     |
| **依赖：** | //foundation/communication/wifi_lite/interfaces/wifiservice |

#### 2.12.3.4 StopHotspot()

| **定义：**   | void StopHotspot(void);                                     |
| ------------ | ----------------------------------------------------------- |
| **功能：**   | 断开AP                                                      |
| **参数：**   | 无                                                          |
| **返回值：** | 无                                                          |
| **依赖：**   | //foundation/communication/wifi_lite/interfaces/wifiservice |

### 2.13.4 实验流程

* 步骤1：复制wifi_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```
.
└─applications
     └─ sample
         └─ wifi-iot
            └─ app
                ├─ BUILD.gn
                └─ wifi_control
                      ├─ BUILD.gn  
                      ├─ wifi_connect_demo.c
                      ├─ wifi_connecter.c
                      ├─ wifi_connecter.h
                      ├─ wifi_hotspot_demo.c
                      ├─ wifi_starter.c
                      └─ wifi_starter.h
```

* 步骤2：修改applications/sample/wifi-iot/app/ wifi_control /目录下的BUILD.gn，如果使用Hi3861V100 STA模式，将"wifi_starter.c"和"wifi_hotspot_demo.c"屏蔽，如果使用Hi3861V100 AP模式，将"wifi_connecter.c"和"wifi_connect_demo.c"屏蔽。

```c
static_library("wifi_control") {
  sources = [
    #"wifi_connecter.c",
    "wifi_starter.c",
    #"wifi_connect_demo.c",
    "wifi_hotspot_demo.c",
  ]

include_dirs = [
    "./",
    "//utils/native/lite/include",
    "//kernel/liteos_m/kal/cmsis",
    "//base/iot_hardware/peripheral/interfaces/kits",
    "//foundation/communication/wifi_lite/interfaces/wifiservice",
    "//vendor/hisi/hi3861/hi3861/third_party/lwip_sack/include",
    ]
}
```

* 步骤3：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加wifi_control: wifi_control。注：第一个wifi_controll指的是需要编译的工程目录，第二个wifi_controll指的是applications/sample/wifi-iot/app/ uart_control /BUILD.gn文件中的静态库，名称为wifi_control。

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

lite_component("app") {
  features = [ "wifi_control:wifi_control", ]
}
```

* 步骤4：Hi3861V100作为STA模式，核心代码如下所示。
```c
1 #include "wifi_device.h"
2 #include "cmsis_os2.h"
3 
4 #include "lwip/netifapi.h"
5 #include "lwip/api_shell.h"
6 
7 static void PrintLinkedInfo(WifiLinkedInfo* info)
8 {
9     if (!info) return;
10 
11     static char macAddress[32] = {0};
12     unsigned char* mac = info->bssid;
13     snprintf(macAddress, sizeof(macAddress), "%02X:%02X:%02X:%02X:%02X:%02X",
14         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
15     printf("bssid: %s, rssi: %d, connState: %d, reason: %d, ssid: %s\r\n",
16         macAddress, info->rssi, info->connState, info->disconnectedReason, info->ssid);
17 }
18 
19 static volatile int g_connected = 0;
20 
21 static void OnWifiConnectionChanged(int state, WifiLinkedInfo* info)
22 {
23     if (!info) return;
24 
25     printf("%s %d, state = %d, info = \r\n", __FUNCTION__, __LINE__, state);
26     PrintLinkedInfo(info);
27 
28     if (state == WIFI_STATE_AVALIABLE) {
29         g_connected = 1;
30     } else {
31         g_connected = 0;
32     }
33 }
34 
35 static void OnWifiScanStateChanged(int state, int size)
36 {
37     printf("%s %d, state = %X, size = %d\r\n", __FUNCTION__, __LINE__, state, size);
38 }
39 
40 static WifiEvent g_defaultWifiEventListener = {
41     .OnWifiConnectionChanged = OnWifiConnectionChanged,
42     .OnWifiScanStateChanged = OnWifiScanStateChanged
43 };
44 
45 static struct netif* g_iface = NULL;
46 
47 int ConnectToHotspot(WifiDeviceConfig* apConfig)
48 {
49     WifiErrorCode errCode;
50     int netId = -1;
51 
52     errCode = RegisterWifiEvent(&g_defaultWifiEventListener);
53     printf("RegisterWifiEvent: %d\r\n", errCode);
54 
55     errCode = EnableWifi();
56     printf("EnableWifi: %d\r\n", errCode);
57 
58     errCode = AddDeviceConfig(apConfig, &netId);
59     printf("AddDeviceConfig: %d\r\n", errCode);
60 
61     g_connected = 0;
62     errCode = ConnectTo(netId);
63     printf("ConnectTo(%d): %d\r\n", netId, errCode);
64 
65     while (!g_connected) { // wait until connect to AP
66         osDelay(10);
67     }
68     printf("g_connected: %d\r\n", g_connected);
69 
70     g_iface = netifapi_netif_find("wlan0");
71     if (g_iface) {
72         err_t ret = netifapi_dhcp_start(g_iface);
73         printf("netifapi_dhcp_start: %d\r\n", ret);
74 
75         osDelay(100); // wait DHCP server give me IP
76         ret = netifapi_netif_common(g_iface, dhcp_clients_info_show, NULL);
77         printf("netifapi_netif_common: %d\r\n", ret);
78     }
79     return netId;
80 }
81 
82 void DisconnectWithHotspot(int netId)
83 {
84     if (g_iface) {
85         err_t ret = netifapi_dhcp_stop(g_iface);
86         printf("netifapi_dhcp_stop: %d\r\n", ret);
87     }
88 
89     WifiErrorCode errCode = Disconnect(); // disconnect with your AP
90     printf("Disconnect: %d\r\n", errCode);
91 
92     errCode = UnRegisterWifiEvent(&g_defaultWifiEventListener);
93     printf("UnRegisterWifiEvent: %d\r\n", errCode);
94 
95     RemoveDevice(netId); // remove AP config
96     printf("RemoveDevice: %d\r\n", errCode);
97 
98     errCode = DisableWifi();
99     printf("DisableWifi: %d\r\n", errCode);
100 }
```

Hi3861V100作为AP模式，核心代码如下所示。
```c
1 #include "wifi_starter.h"
2 #include "cmsis_os2.h"
3 
4 #include "lwip/netifapi.h"
5 
6 static volatile int g_hotspotStarted = 0;
7 
8 static void OnHotspotStateChanged(int state)
9 {
10     printf("OnHotspotStateChanged: %d.\r\n", state);
11     if (state == WIFI_HOTSPOT_ACTIVE) {
12         g_hotspotStarted = 1;
13     } else {
14         g_hotspotStarted = 0;
15     }
16 }
17 
18 static volatile int g_joinedStations = 0;
19 
20 static void PrintStationInfo(StationInfo* info)
21 {
22     if (!info) return;
23     static char macAddress[32] = {0};
24     unsigned char* mac = info->macAddress;
25     snprintf(macAddress, sizeof(macAddress), "%02X:%02X:%02X:%02X:%02X:%02X",
26         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
27     printf(" PrintStationInfo: mac=%s, reason=%d.\r\n", macAddress, info->disconnectedReason);
28 }
29 
30 static void OnHotspotStaJoin(StationInfo* info)
31 {
32     g_joinedStations++;
33     PrintStationInfo(info);
34     printf("+OnHotspotStaJoin: active stations = %d.\r\n", g_joinedStations);
35 }
36 
37 static void OnHotspotStaLeave(StationInfo* info)
38 {
39     g_joinedStations--;
40     PrintStationInfo(info);
41     printf("-OnHotspotStaLeave: active stations = %d.\r\n", g_joinedStations);
42 }
43 
44 WifiEvent g_defaultWifiEventListener = {
45     .OnHotspotStaJoin = OnHotspotStaJoin,
46     .OnHotspotStaLeave = OnHotspotStaLeave,
47     .OnHotspotStateChanged = OnHotspotStateChanged,
48 };
49 
50 static struct netif* g_iface = NULL;
51 
52 int StartHotspot(const HotspotConfig* config)
53 {
54     WifiErrorCode errCode = WIFI_SUCCESS;
55 
56     errCode = RegisterWifiEvent(&g_defaultWifiEventListener);
57     printf("RegisterWifiEvent: %d\r\n", errCode);
58 
59     errCode = SetHotspotConfig(config);
60     printf("SetHotspotConfig: %d\r\n", errCode);
61 
62     g_hotspotStarted = 0;
63     errCode = EnableHotspot();
64     printf("EnableHotspot: %d\r\n", errCode);
65 
66     while (!g_hotspotStarted) {
67         osDelay(10);
68     }
69     printf("g_hotspotStarted = %d.\r\n", g_hotspotStarted);
70 
71     g_iface = netifapi_netif_find("ap1");
72     if (g_iface) {
73         ip4_addr_t ipaddr;
74         ip4_addr_t gateway;
75         ip4_addr_t netmask;
76 
77         IP4_ADDR(&ipaddr,  192, 168, 1, 1);     /* input your IP for example: 192.168.1.1 */
78         IP4_ADDR(&gateway, 192, 168, 1, 1);     /* input your gateway for example: 192.168.1.1 */
79         IP4_ADDR(&netmask, 255, 255, 255, 0);   /* input your netmask for example: 255.255.255.0 */
80         err_t ret = netifapi_netif_set_addr(g_iface, &ipaddr, &netmask, &gateway);
81         printf("netifapi_netif_set_addr: %d\r\n", ret);
82 
83         ret = netifapi_dhcps_start(g_iface, 0, 0);
84         printf("netifapi_dhcp_start: %d\r\n", ret);
85     }
86     return errCode;
87 }
88 
89 void StopHotspot(void)
90 {
91     if (g_iface) {
92         err_t ret = netifapi_dhcps_stop(g_iface);
93         printf("netifapi_dhcps_stop: %d\r\n", ret);
94     }
95 
96     WifiErrorCode errCode = UnRegisterWifiEvent(&g_defaultWifiEventListener);
97     printf("UnRegisterWifiEvent: %d\r\n", errCode);
98 
99     errCode = DisableHotspot();
100     printf("EnableHotspot: %d\r\n", errCode);
101 }
```
### 2.13.5 实验结果

* 如果Hi3861作为STA模式，打开SSCOM串口工具，Hi3861连接WiFi成功后出现如下打印：

![](pic/image-20220919161056658.png)

* 如果Hi3861作为AP模式，打开SSCOM串口工具，手机可以搜索到HiSpark-AP，同时串口出现如下打印：

![](pic/image-20220919160653134.png)

# 3、操作系统实验

## 3.1 线程

### 3.1.1 实验目的

* 掌握如何使用多线程编程，实现对多个外设的控制。

### 3.1.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件搭建如下图所示：

### 3.1.3 接口说明

#### 3.1.3.1 osThreadNew  ()

| 定义： | osThreadId_t osThreadNew (osThreadFunc_t func, void *argument, const osThreadAttr_t *attr); |
| ------ | ------------------------------------------------------------ |
| 功能 | 创建一个线程并将其添加到活动线程 |
| 参数 | func：线程函数 argument：参数指针，作为开始参数传递给线程函数 attr:线程属性；NULL：默认值 |
| 返回值 | 创建成功：返回线程ID 创建失败：返回NULL |
| 依赖 | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

| 接口名称              | 函数说明                                               |
| --------------------- | ------------------------------------------------------ |
| osThreadGetName       | 获取指定线程的名字                                     |
| osThreadGetId         | 获取当前运行线程的线程ID                               |
| osThreadGetState      | 获取当前线程的状态                                     |
| osThreadSetPriority   | 设置指定线程的优先级                                   |
| osThreadGetPriority   | 获取当前线程的优先级                                   |
| osThreadYield         | 将运行控制转交给下一个处于READY状态的线程              |
| osThreadSuspend       | 挂起指定线程的运行                                     |
| osThreadResume        | 恢复指定线程的运行                                     |
| osThreadDetach        | 分离指定的线程（当线程终止运行时，线程存储可以被回收） |
| osThreadJoin          | 等待指定线程终止运行                                   |
| osThreadExit          | 终止当前线程的运行                                     |
| osThreadTerminate     | 终止指定线程的运行                                     |
| osThreadGetStackSize  | 获取指定线程的栈空间大小                               |
| osThreadGetStackSpace | 获取指定线程的未使用的栈空间大小                       |
| osThreadGetCount      | 获取活跃线程数                                         |
| osThreadEnumerate     | 获取线程组中的活跃线程数                               |

* 以上接口依赖的头文件是：//third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h

### 3.1.4 实验流程

* 步骤1：复制thread_demo目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```c
└─applications
         └─ sample
            └─ wifi-iot
	            └─ app
	                ├─ BUILD.gn
	                └─thread_demo
                         ├─ BUILD.gn  
                         └─ thread_demo.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加thread_demo: thread_demo。注：第一个thread_demo指的是需要编译的工程目录，第二个thread_demo指的是applications/sample/wifi-iot/app/ thread_demo/BUILD.gn文件中的静态库，名称为thread_demo。

```c
import("//build/lite/config/component/lite_component.gni")
lite_component("app") {
  features = [ "thread_demo:thread_demo", ]
}
```

* 步骤3：修改核心代码

```c
1 #include <stdio.h>
2 #include <unistd.h>
3 
4 #include "iot_gpio_ex.h"
5 #include "iot_pwm.h"
6 #include "iot_gpio.h"
7 #include "ohos_init.h"
8 #include "cmsis_os2.h"
9 
10 #define STACK_SIZE 1024
11 #define OS_DELAY 500000
12 #define IOT_PWM_PORT_PWM2 2 // GPIO5对应的是PWM2
13 #define PWM_CHANGE_TIMES 99 // PWM循环输出的次数
14 #define PWM_FREQ 65535 // PWM分频倍数
15 #define PWM_DELAY_10US 10 // PWM循环一次延迟的时间
16 
17 void YellowLedControl(void *arg)
18 {
19 (void)arg;
20 unsigned int i;
21 
22 while(1) {
23 for (i = 0; i < PWM_CHANGE_TIMES; i++) {
24 IoTPwmStart(IOT_PWM_PORT_PWM2, i, PWM_FREQ);
25 usleep(PWM_DELAY_10US);
26 }
27 i = 0;
28 }
29 }
30 
31 void RedLedControl(void *arg)
32 {
33 (void)arg;
34 while (1) {
35 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE1);
36 // 延时函数毫秒（设置高电平持续时间）
37 usleep(OS_DELAY);
38 // 设置GPIO09输出低电平熄灭红色交通灯LED3
39 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE0);
40 usleep(OS_DELAY);
41 }
42 }
43 
44 void LedGpioInit(void)
45 {
46 IoTGpioInit(IOT_IO_NAME_GPIO_9); // RED LED的GPIO初始化
47 IoSetFunc(IOT_IO_NAME_GPIO_9, IOT_IO_FUNC_GPIO_9_GPIO); // 设置GPIO9的管脚复用关系为GPIO
48 IoTGpioSetDir(IOT_IO_NAME_GPIO_9, IOT_GPIO_DIR_OUT); // GPIO9方向设置为输出
49 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE0); // 设置GPIO09输出低电平,熄灭红色交通灯LED
50 
51 IoTGpioInit(IOT_IO_NAME_GPIO_5); // 初始化GPIO5管脚
52 IoSetFunc(IOT_IO_NAME_GPIO_5, IOT_IO_FUNC_GPIO_5_PWM2_OUT); // 设置GPIO5的管脚复用关系为PWM
53 IoTGpioSetDir(IOT_IO_NAME_GPIO_5, IOT_GPIO_DIR_OUT); // 设置GPIO5的管脚方向为输出
54 IoTPwmInit(IOT_PWM_PORT_PWM2); // 初始化GPIO5为PWM2
55 }
56 
57 void ThreadExampleEntry(void)
58 {
59 osThreadAttr_t attr;
60 
61 LedGpioInit();
62 IoTWatchDogDisable();
63 
64 attr.name = "RedLedControl";
65 attr.attr_bits = 0U;
66 attr.cb_mem = NULL;
67 attr.cb_size = 0U;
68 attr.stack_mem = NULL;
69 attr.stack_size = STACK_SIZE;
70 attr.priority = osPriorityNormal;
71 
72 // 创建一个线程，并注册一个回调函数RedLedControl，控制红色LED灯每隔1秒钟闪烁一次
73 if (osThreadNew((osThreadFunc_t)RedLedControl, NULL, &attr) == NULL) {
74 printf("[RedLedControl] osThreadNew Falied to create RedLedControl!\n");
75 }
76 
77 // 创建第二个线程，注册回调函数为GreenLedControl,控制绿色LED灯，实现呼吸灯效果
78 attr.name = "YellowLedControl";
79 attr.priority = osPriorityNormal;
80 if (osThreadNew((osThreadFunc_t)YellowLedControl, NULL, &attr) == NULL) {
81 printf("[YellowLedControl] osThreadNew Falied to create YellowLedControl!\n");
82 }
83 }
84 
85 APP_FEATURE_INIT(ThreadExampleEntry);

```

* 步骤4：在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb  build  -f
```

* 步骤5：烧录程序到开发板，参考1.3.4节的内容即可。

### 3.1.5 实验结果

* 软件烧录成功后，按一下开发板的RESET按键复位开发板，小车的红色LED屏幕会每隔1秒钟闪烁一次，并控制黄色LED灯，实现呼吸灯的效果，说明我们使用多线程来控制多个外设的实验成功。

### 3.1.6 扩展实验

* 本实验学习了如何使用多线程编程，请学生做如下实验：
  * 1、创建两个线程，一个线程用来实时获取电量检测模块的数据，另外一个线程用来实时获取陀螺仪的数据。

## 3.2 信号量

### 3.2.1 实验目的

* 通过使用信号量，在不同线程中访问共享资源，来模拟交通灯的实验。

### 3.2.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

* 3.硬件搭建如下图所示：

### 3.2.3 接口说明

#### 3.2.3.1 osSemaphoreNew()

| **定义：** | osSemaphoreId_t osSemaphoreNew(uint32_t max_count, uint32_t initial_count,const osSemaphoreAttr_t *attr); |
| ---------- | ------------------------------------------------------------ |
| **功能：** | 创建初始化信号量对象 |
| **参数：** | max_count:可用令牌的最大数量 initial_count：可用令牌的初始数量 attr:信号量属性；NULL：默认值 |
| **返回值** | 创建成功：返回信号量ID 创建失败：返回NULL |
| **依赖：** | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

#### 3.2.3.2 osSemaphoreGetName ()

| **定义：**   | const char   *osSemaphoreGetName (osSemaphoreId_t semaphore_id); |
| ------------ | ------------------------------------------------------------ |
| **功能：**   | 获取信号量对象的名称                                         |
| **参数：**   | semaphore_id：信号量ID                                       |
| **返回值：** | 创建成功：将名称返回以null结尾的字符串   创建失败：返回NULL  |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h          |

#### 3.2.3.3 osSemaphoreAcquire ()

| **定义：** | osStatus_t osSemaphoreAcquire (osSemaphoreId_t semaphore_id, uint32_t timeout); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 获取信号量令牌，如果没有可用令牌则会超时 |
| **参数：** | semaphore_id:信号量ID timeout：CMSIS_RTOS_TimeOutValue或在没有超时的情况下为0。 |
| **返回值：** | 返回指示函数执行状态的状态码 |
| **依赖：** | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

#### 3.2.3.4 osSemaphoreRelease ()

| **定义：**   | osStatus_t   osSemaphoreRelease (osSemaphoreId_t semaphore_id); |
| ------------ | ------------------------------------------------------------ |
| **功能：**   | 释放信号量令牌，直到初始化最大计数                           |
| **参数：**   | semaphore_id:信号量ID                                        |
| **返回值：** | 返回指示函数执行状态的状态码                                 |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h          |

#### 3.2.3.5 osSemaphoreGetCount ()

| **定义：**   | uint32_t   osSemaphoreGetCount (osSemaphoreId_t semaphore_id); |
| ------------ | ------------------------------------------------------------ |
| **功能：**   | 获取当前信号量令牌计数                                       |
| **参数：**   | semaphore_id:信号量ID                                        |
| **返回值：** | 返回可用令牌数                                               |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h          |

#### 3.2.3.6 osSemaphoreDelete ()

| **定义：**   | osStatus_t   osSemaphoreDelete (osSemaphoreId_t semaphore_id); |
| ------------ | ------------------------------------------------------------ |
| **功能：**   | 删除信号量对象                                               |
| **参数：**   | semaphore_id:信号量ID                                        |
| **返回值：** | 返回指示函数执行状态的状态码                                 |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h          |

### 3.2.4 实验流程

* 步骤1：复制semaphore_demo目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```c
.
└─applications
         └─ sample
            └─ wifi-iot
            	└─ app
               	 	├─ BUILD.gn
                	└─semaphore_demo
                         ├─ BUILD.gn  
                         └─ semaphore_demo.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加semaphore_demo:semaphore_demo。注：第一个semaphore_demo指的是需要编译的工程目录，第二个semaphore_demo指的是applications/sample/wifi-iot/app/ semaphore_demo /BUILD.gn文件中的静态库，名称为semaphore_demo。

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

lite_component("app") {
  features = [ "semaphore_demo:semaphore_demo", ]
}
```

* 步骤3：原理：信号量是一种实现任务间通信的机制，实现任务之间同步或临界资源的互斥访问。在多任务操作系统中，不同的任务之间需要同步运行，信号量功能可以为用户提供这方面的支持。当任务申请(Pend)信号量时，如果申请成功，则信号量的计数值递减，如若申请失败，则挂起在该信号量的等待任务队列上，一旦有任务释放该信号量，则等待任务队列中的任务被唤醒开始执行。代码如下：

```c
1 #include <stdio.h>
2 #include <unistd.h>
3 
4 #include "ohos_init.h"
5 #include "cmsis_os2.h"
6 
7 #define SIDE_WOLK_DELAY 5 // 人行道持续工作5秒
8 #define MOTOR_WAY_DELAY 10 // 机动车道持续工作10秒
9 #define NUM 1
10 #define STACK_SIZE 1024
11 
12 osSemaphoreId_t traffic_light; // 交通灯信号量
13 
14 // 人行道线程
15 void SideWalkThread(void *arg)
16 {
17 unsigned int cout;
18 (void)arg;
19 
20 while (NUM) {
21 // 获取交通灯信号量令牌
22 osSemaphoreAcquire(traffic_light, osWaitForever);
23 printf("**************Pedestrians pass and vehicles stop**************\r\n");
24 for (cout = 5; cout > 0; cout--) {
25 printf("[SideWalkThread] Countdown for sidewalk work %d \r\n", cout);
26 osDelay(100); // 10ms * 100 = 1s
27 }
28 // 释放交通灯信号量
29 osSemaphoreRelease(traffic_light);
30 }
31 }
32 
33 // 机动车道线程
34 void MotorWayThread(void *arg)
35 {
36 unsigned int cout;
37 (void)arg;
38 while (NUM) {
39 // 获取交通灯信号量令牌
40 osSemaphoreAcquire(traffic_light, osWaitForever);
41 printf("**************Vehicles pass and pedestrians stop**************\r\n");
42 for (cout = 10; cout > 0; cout--) {
43 printf("[MotorWayThread] Countdown for MotorWay work %d\r\n", cout);
44 osDelay(100); // 10ms * 100 = 1s
45 }
46 // 释放交通灯信号量
47 osSemaphoreRelease(traffic_light);
48 }
49 }
50 
51 static void SemaphoreDemoEntry(void)
52 {
53 osThreadAttr_t attr;
54 
55 attr.name = "SideWalkThread";
56 attr.attr_bits = 0U;
57 attr.cb_mem = NULL;
58 attr.cb_size = 0U;
59 attr.stack_mem = NULL;
60 attr.stack_size = STACK_SIZE;
61 attr.priority = osPriorityNormal;
62 
63 // 创建一个线程，回调函数是SideWalkThread，用来执行人行道的工作
64 if (osThreadNew((osThreadFunc_t)SideWalkThread, NULL, &attr) == NULL) {
65 printf("[SideWalkThread] Failed to create SideWalkThread!\n");
66 }
67 
68 // 创建另一个线程，回调函数是MotorWayThread，用来执行机动车道线程的工作
69 if (osThreadNew((osThreadFunc_t)MotorWayThread, NULL, &attr) == NULL) {
70 printf("[MotorWayThread] Failed to create MotorWayThread!\n");
71 }
72 
73 // 创建一个交通灯的信号量，可用令牌的最大数量为1，可用令牌的初始化数量为0
74 traffic_light = osSemaphoreNew(1, 0, NULL);
75 if (traffic_light == NULL) {
76 printf("Falied to create Semaphore!\n");
77 }
78 
79 // 释放交通灯信号量
80 osSemaphoreRelease(traffic_light);
81 }
82 
83 APP_FEATURE_INIT(SemaphoreDemoEntry);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 3.2.5 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，可以从串口工具看到，当人行道线程获取到交通灯信号量时，会输出 Pedestrians pass and vehicles stop，此时人行道进入倒计时5秒的工作状态，此时机动车道处于等待状态，5秒后，释放交通灯信号量，此时机动车道线程获取到交通灯信号量，会输出Vehicles pass and pedestrians stop，此时机动车道进入倒计时10秒的工作状态，此时人行道处于等待状态，10秒后释放交通灯信号量，然后再次进入循环，说明我们通过使用信号量，在不同线程中访问共享资源，来模拟交通灯的实验成功。

![](pic/image-20220922203912354.png)

### 3.2.6 扩展实验

* 本实验通过使用信号量，在不同线程中访问共享资源，来模拟交通灯的实验，请学生做如下实验：
  * 1、通过使用信号量，实现生产者消费者的实验。

## 3.3 定时器

### 3.3.1 实验目的

* 本实验通过使用定时器，来实现宠物喂食机的定时投喂的功能。

### 3.3.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；
* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 3.3.3 接口说明

####

| **定义：** | osTimerId_t osTimerNew (osTimerFunc_t func, osTimerType_t type, void *argument, const osTimerAttr_t *attr); |
| ---------- | ------------------------------------------------------------ |
| **功能：** | 创建并初始化计时器 |
| **参数：** | func：指向回调函数的指针 type：osTimerOnce表示一次触发, osTimerPeriodic表示周期性行为 argument：计数器回调函数的参数 attr ：定时器属性；NULL：默认值 |
| **返回值** | 创建成功：返回定时器ID 创建失败：返回NULL |
| **依赖：** | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

#### 3.3.3.2 osTimerGetName ()

| **定义：**   | const char   *osTimerGetName (osTimerId_t timer_id);        |
| ------------ | ----------------------------------------------------------- |
| **功能：**   | 获取定时器的名称                                            |
| **参数：**   | timer_id：定时器ID                                          |
| **返回值：** | 创建成功：将名称返回以null结尾的字符串   创建失败：返回NULL |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h         |

#### 3.3.3.3 osTimerStart ()

| **定义：** | osStatus_t osTimerStart (osTimerId_t timer_id, uint32_t ticks); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 启动或重新启动定时器 |
| **参数：** | timer_id：定时器ID ticks：CMSIS_RTOS_TimeOutValue定时器的“时间刻度”值。 |
| **返回值：** | 返回指示函数执行状态的状态码 |
| **依赖：** | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

#### 3.3.3.4 osTimerStop ()

| **定义：**   | osStatus_t   osTimerStop (osTimerId_t timer_id);    |
| ------------ | --------------------------------------------------- |
| **功能：**   | 停止定时器                                          |
| **参数：**   | timer_id：定时器ID                                  |
| **返回值：** | 返回指示函数执行状态的状态码                        |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

#### 3.3.3.5 osTimerIsRunning ()

| **定义：**   | uint32_t   osTimerIsRunning (osTimerId_t timer_id); |
| ------------ | --------------------------------------------------- |
| **功能：**   | 检查定时器是否正在运行                              |
| **参数：**   | timer_id：定时器ID                                  |
| **返回值：** | 返回1：正在运行；返回0,：未在运行。                 |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

#### 3.3.3.6 osTimerDelete ()

| **定义：**   | osStatus_t   osTimerDelete (osTimerId_t timer_id);  |
| ------------ | --------------------------------------------------- |
| **功能：**   | 删除定时器                                          |
| **参数：**   | timer_id：定时器ID                                  |
| **返回值：** | 返回指示函数执行状态的状态码                        |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

### 3.3.4 实验流程

* 步骤1：复制timer_demo目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```c
.
└─applications
         └─ sample
            └─ wifi-iot
            	└─ app
                	├─ BUILD.gn
                	└─timer_demo
                         ├─ BUILD.gn  
                         └─ timer_demo.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加timer_demo: timer_demo。注：第一个timer_demo指的是需要编译的工程目录，第二个timer_demo指的是applications/sample/wifi-iot/app/ timer_demo /BUILD.gn文件中的静态库，名称为timer_demo。

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

lite_component("app") {
  features = [ "timer_demo:timer_demo", ]
}
```

* 步骤3：原理：软件定时器使用了系统的一个队列和一个任务资源，软件定时器的触发遵循队列规则，先进先出。定时时间短的定时器总是比定时时间长的靠近队列头，满足优先被触发的准则。
    软件定时器以Tick为基本计时单位，当用户创建并启动一个软件定时器时，LiteOS会根据当前系统Tick时间及用户设置的定时时间间隔确定该定时器的到期Tick时间，并将该定时器控制结构挂入计时全局链表。
    当Tick中断到来时，在Tick中断处理函数中扫描软件定时器的计时全局链表，看是否有定时器超时，若有则将超过的定时器记录下来。
    Tick中断处理函数结束后，软件定时器任务（优先级为最高）被唤醒，在该任务中调用之前记录下来的定时器的超时回调函数。代码如下：

```c
1 #include <stdio.h>
2 #include <string.h>
3 #include <unistd.h>
4 
5 #include "ohos_init.h"
6 #include "cmsis_os2.h"
7 
8 #define STACK_SIZE 1024
9 /*定义一个count变量，用于控制投喂的次数*/
10 static int count = 0;
11 
12 void FeedSomeFood(void *arg)
13 {
14 (void)arg;
15 count++;
16 printf("[Timer_demo] Start feeding count is %d \r\n", count);
17 }
18 
19 void TimerThread(void *arg)
20 {
21 (void)arg;
22 osTimerId_t id;
23 uint32_t timerDelay;
24 osStatus_t status;
25 
26 // 创建一个周期性的定时器,回调函数是FeedSomeFood，用于宠物喂食机的投喂
27 id = osTimerNew(FeedSomeFood, osTimerPeriodic, NULL, NULL);
28 if (id == NULL) {
29 printf("[Timer_demo] osTimerNew failed.\r\n");
30 } else {
31 printf("[Timer_demo] osTimerNew success.\r\n");
32 }
33 
34 // 开始计时100个时钟周期,一个时钟周期是10ms，100个时钟周期就是1s
35 status = osTimerStart(id, 100);
36 if (status != osOK) {
37 printf("[Timer_demo] osTimerStart failed.\r\n");
38 } else {
39 printf("[Timer_demo] osTimerStart success.\r\n");
40 }
41 
42 // 投喂5次后，停止投喂
43 while (count < 5) {
44 osDelay(10);
45 }
46 
47 // 停止定时器
48 status = osTimerStop(id);
49 printf("[Timer_demo] Timer Stop, status :%d. \r\n", status);
50 
51 // 删除定时器
52 status = osTimerDelete(id);
53 printf("[Timer_demo] Timer Delete, status :%d. \r\n", status);
54 }
55 
56 void TimerExampleEntry(void)
57 {
58 osThreadAttr_t attr;
59 
60 IoTWatchDogDisable();
61 
62 attr.name = "TimerThread";
63 attr.attr_bits = 0U;
64 attr.cb_mem = NULL;
65 attr.cb_size = 0U;
66 attr.stack_mem = NULL;
67 attr.stack_size = STACK_SIZE;
68 attr.priority = osPriorityNormal;
69 
70 // 创建一个线程，并注册一个回调函数 TimerThread，控制红色LED灯每隔1秒钟闪烁一次
71 if (osThreadNew((osThreadFunc_t)TimerThread, NULL, &attr) == NULL) {
72 printf("[Timer_demo] osThreadNew Falied to create TimerThread!\n");
73 }
74 }
75 
76 
77 APP_FEATURE_INIT(TimerExampleEntry);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可。

### 3.3.5 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，可以从串口工具看到，首先会创建一个定时器，然后开启定时器，当100个时钟周期后，就会调用一次宠物喂食机的投喂功能，投喂5次后，就会停止定时器，然后删除定时器，当出现如下的打印信息，就说明使用定时器，来实现宠物喂食机的定时投喂的实验成功。

![](pic/image-20220922205220658.png)

### 3.3.6 扩展实验

* 本实验通过使用定时器，来实现宠物喂食机的定时投喂的功能，请学生做如下实验：
  * 1、通过使用定时器，模拟交通灯的警报功能，每隔30秒钟开启蜂鸣器一次，一次响5秒钟。

## 3.4 中断处理

### 3.4.1 实验目的

* 本实验内容：主要实现中断机理认知与定时器中断实验案例。

### 3.4.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；
* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 3.4.3 接口说明

#### 3.4.3.1 osSemaphoreNew()

| **定义：** | HI_EXTERN hi_xtal_clock hi_get_xtal_clock(hi_void); |
| ---------- | ------------------------------------------------------------ |
| **功能：** | 创建初始化信号量对象 |
| **参数：** | max_count:可用令牌的最大数量 initial_count：可用令牌的初始数量 attr:信号量属性；NULL：默认值 |
| **返回值** | 创建成功：返回信号量ID 创建失败：返回NULL |
| **依赖：** | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

#### 3.4.3.2 osSemaphoreGetName ()

| **定义：**   | hi_u32 hi_int_lock(hi_void)；                               |
| ------------ | ----------------------------------------------------------- |
| **功能：**   | 获取信号量对象的名称                                        |
| **参数：**   | semaphore_id：信号量ID                                      |
| **返回值：** | 创建成功：将名称返回以null结尾的字符串   创建失败：返回NULL |
| **依赖：**   | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h         |

#### 3.4.3.3 osSemaphoreAcquire ()

| **定义：** | hi_u32 hi_irq_request(hi_u32 vector, hi_u32 flags, irq_routine routine, hi_u32 param); |
| ------------ | ------------------------------------------------------------ |
| **功能：** | 获取信号量令牌，如果没有可用令牌则会超时 |
| **参数：** | semaphore_id:信号量ID timeout：CMSIS_RTOS_TimeOutValue或在没有超时的情况下为0。 |
| **返回值：** | 返回指示函数执行状态的状态码 |
| **依赖：** | //third_party/cmsis/CMSIS/RTOS2/Include/cmsis_os2.h |

### 3.4.4 实验流程

* 步骤1：复制interrupt_demo目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

```c
.
└─applications
         └─ sample
            └─ wifi-iot
            	└─ app
               	 	├─ BUILD.gn
                	└─interrupt_demo
                         ├─ BUILD.gn  
                         └─ interrupt_demo.c
```

* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加interrupt_demo:interrupt_demo。注：第一个interrupt_demo指的是需要编译的工程目录，第二个指的是applications/sample/wifi-iot/app/interrupt_demo/BUILD.gn文件中的静态库，名称为interrupt_demo。

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

lite_component("app") {
  features = [ "interrupt_demo:interrupt_demo", ]
}
```

* 步骤3：原理：中断是指CPU暂停执行当前程序，转而执行新程序的过程。中断相关的硬件可以划分为3类：

●设备：发起中断的源，当设备需要请求CPU时，产生一个中断信号，该信号连接至中断控制器。

●中断控制器：接收中断输入并上报给CPU。可以设置中断源的优先级、触发方式、打开和关闭等操作。

●CPU软中断： 由CPU软件发起的中断，一般用于操作系统的模式和线程切换。

使用场景：

当有中断请求产生时，CPU暂停当前的任务，转而去响应外设请求。用户通过中断申请，注册中断处理程序，可以指定CPU响应中断请求时所执行的具体操作。代码如下：

```c
1 #include <hi_isr.h>
2 #include <hi_early_debug.h>
3 #include <hi_types_base.h>
4 #include <hi_errno.h>
5 #include <hi3861.h>
6 #include <hi_task.h>
7 #include <hi_clock.h>
8 #include "ohos_init.h"
9 #include "cmsis_os2.h"
10 
11 #define UNUSED_PARAM(p) p=p
12 #define TIMER_BASE_ADDRESS (0x40050000)
13 #define TIMER_OFFSET (0x14)
14 #define TIMER_ID (2)
15 #define TIMER_FREQ_24M (24*1)
16 #define TIMER_FREQ_40M (40*1)
17 
18 #define TIMER_REGISTER (0x40010030)
19 /*Timer register*/
20 #define TEST_TIMER_CONTROLREG (0x008)
21 #define TEST_TIMER_LOADCOUNT (0x000)
22 #define TEST_TIMER_EOI (0x00C)
23 #define TEST_TIMER_INTSTATUS (0x010)
24 
25 unsigned int g_timer_cnt_cb = 0;
26 unsigned int tmp = 0;
27 unsigned int uvIntSave;
28 /*Timer count, enter interrupt trigger function after timeout*/
29 void timer2_isr_trigger(unsigned char id, unsigned int period)
30 {
31 unsigned int temp;
32 unsigned short reg_val = 0;
33 /*read timer2 register*/
34 hi_reg_read16(TIMER_REGISTER, reg_val);
35 /*Assign a timer*/
36 reg_val |= 1<<8;
37 /*reg_val write to timer2 register*/
38 hi_reg_write16(TIMER_REGISTER, reg_val);
39 /*disable first*/
40 hi_reg_write32(TIMER_BASE_ADDRESS + id * TIMER_OFFSET + TEST_TIMER_CONTROLREG, 0);
41 /*set init value as period*/
42 hi_reg_write32(TIMER_BASE_ADDRESS + id * TIMER_OFFSET + TEST_TIMER_LOADCOUNT, period);
43 /*
44 * Timing mode: 32bit [bit 1 set as 1]
45 * ticking with 1/1 clock frequency [bit 3 set as 0, bit 2 set as 0]
46 * timing circulary [bit 1 set as 1]
47 */
48 temp = (1U << 0) | (1U << 1);/* 1: circulary, 0: enabled*/
49 hi_reg_write32(TIMER_BASE_ADDRESS + id * TIMER_OFFSET + TEST_TIMER_CONTROLREG, temp);
50 /*Clear counter*/
51 g_timer_cnt_cb = 0;
52 printf("The clock is over\r\n");
53 }
54 /*Clear interrupt*/
55 void timer_clear(unsigned char id)
56 {
57 hi_u32 reg_val = 0;
58 hi_reg_read32(TIMER_BASE_ADDRESS + id * TIMER_OFFSET + TEST_TIMER_EOI, reg_val);
59 if (reg_val != HI_ERR_SUCCESS) {
60 printf("clear timer interrupt failed, reg_val=%d\r\n", reg_val);
61 }
62 }
63 /*Timer time-out into the interrupt, triggering the function to run*/
64 void timer2_irq_handle(unsigned int irqv)
65 {
66 UNUSED_PARAM(irqv);
67 g_timer_cnt_cb++;
68 dprintf("\n into the func timer2_irq_handle\n");
69 
70 /*Clear interrupt*/
71 timer_clear(TIMER_ID);
72 }
73 /**/
74 void TimerIrqTask(void)
75 {
76 unsigned int irq_idx = TIMER_2_IRQ;
77 unsigned int xtal = 0;
78 unsigned int timer_freq = 0;
79 /*Get external crystal frequency*/
80 
81 xtal = hi_get_xtal_clock();
82 switch (xtal) {
83 case HI_XTAL_CLOCK_24M: 
84 timer_freq = TIMER_FREQ_24M;
85 break;
86 case HI_XTAL_CLOCK_40M:
87 timer_freq = TIMER_FREQ_40M;
88 break;
89 case HI_XTAL_CLOCK_MAX:
90 timer_freq = TIMER_FREQ_40M;
91 printf("Crystal frequency invalid\r\n");
92 break;
93 }
94 /*The counter starts*/
95 timer2_isr_trigger(TIMER_ID, timer_freq);//Timing 1s, trigger interrupt after 1s
96 /*Turn off all interrupts*/
97 uvIntSave = hi_int_lock();
98 /*Registration interruption*/
99 unsigned int ret = hi_irq_request(TIMER_2_IRQ, HI_IRQ_FLAG_PRI1, timer2_irq_handle, 0);
100 if (ret != HI_ERR_SUCCESS) {
101 printf("request example irq fail:%x\n", ret);
102 return;
103 }
104 if (g_timer_cnt_cb != 0) {
105 dprintf("\n [hi_int_lock] failed\n");
106 }
107 dprintf("\n [hi_int_lock] success\n");
108 dprintf("\n ----Restore the state before shutting down the interrupt----\n");
109 /*Resume all operations before interruption*/
110 hi_int_restore(uvIntSave);
111 if (g_timer_cnt_cb != 0) {
112 dprintf("\n [hi_int_restore] failed, timer cnt cb = %d\n", g_timer_cnt_cb);
113 } 
114 tmp = g_timer_cnt_cb;
115 /*Enable interrupt*/
116 ret = hi_irq_enable(irq_idx);
117 if (ret != HI_ERR_SUCCESS) {
118 dprintf("failed to hi_irq_enable func ,ret = 0x%x\r\n", ret);
119 }
120 /*Enter interrupt function 3s*/
121 hi_sleep(3000);
122 if (g_timer_cnt_cb > tmp) {
123 dprintf("[timer2_irq_handle]success, timer cnt cb=%d\r\n", g_timer_cnt_cb);
124 } else {
125 dprintf("[timer2_irq_handle]failed, timer cnt cb=%d\r\n", g_timer_cnt_cb);
126 }
127 tmp = g_timer_cnt_cb;
128 /*Interrupt enable off*/
129 hi_irq_disable(irq_idx);
130 if (g_timer_cnt_cb == tmp) {
131 dprintf("[hi_irq_disable]success\r\n");
132 } else {
133 dprintf("[hi_irq_disable]failed, timer cnt cb=%d\r\n", g_timer_cnt_cb);
134 }
135 /*Interrupt release*/
136 hi_irq_free(irq_idx);
137 }
138 
139 void ExampleTimerIrqEntry(void)
140 {
141 osThreadAttr_t attr;
142 
143 IoTWatchDogDisable();
144 
145 attr.name = "TimerIrqTask";
146 attr.attr_bits = 0U;
147 attr.cb_mem = NULL;
148 attr.cb_size = 0U;
149 attr.stack_mem = NULL;
150 attr.stack_size = 1024;
151 attr.priority = osPriorityNormal;
152 
153 if (osThreadNew((osThreadFunc_t)TimerIrqTask, NULL, &attr) == NULL) {
154 printf("[TimerIrqTask] osThreadNew Falied to create TimerIrqTask!\n");
155 }
156 }
157 
158 APP_FEATURE_INIT(ExampleTimerIrqEntry);
```

- 步骤4：编译工程代码
  - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb clean
hb  build  -f
```

- 步骤5：烧录程序到开发板
  - 参考1.3.4节的内容即可

### 3.4.5 实验结果

* 软件烧录成功后，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，可以从串口工具看到。

![](pic/image-20220922214650568.png)

### 3.4.6 扩展实验

* 本实验通过使用软中断的实验，请学生做如下实验：
  * 1、通过软中断实现红灯亮的时候，转而执行黄灯亮。
  
      提示：红灯：GPIO 9 ，黄灯：GPIO 5。

# 4、综合实验

## 4.1 超声波避障小车实验

### 4.1.1 实验目的

* 本实验内容：通过舵机转动使超声波模块可以获取左右两边和中间的距离，判断小车前进方向,实现小车避障。

### 4.1.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.接线方式：J26 GPIO 7 -  TRIG，J6 不要跳线到GPIO 7；硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 4.1.3 流程图参考

![](pic/image-20220923100158164.png)

### 4.1.4 工程参考

* **2.5 GPIO综合实验**
* **2.6 PWM实验-芯片自带PWM实验**

* **2.7 PWM实验-GPIO模拟PWM实验**

### 4.1.5 部分代码参考

* 完整代码参考：ultrasonic_car_demo

```C
1 /*
2 HCSR05 超声波模块的相关API接口
3 */
4 #include <stdio.h>
5 #include <stdlib.h>
6 
7 #include "ohos_init.h"
8 #include "cmsis_os2.h"
9 #include "iot_gpio.h"
10 #include "hi_io.h"
11 #include "iot_gpio_ex.h"
12 
13 #define CAR_TURN_LEFT (0)
14 #define CAR_TURN_RIGHT (1)
15 #define DISTANCE_BETWEEN_CAR_AND_OBSTACLE (15.0)
16 
17 void Hcsr04Init(void)
18 {
19 // 设置超声波Echo为输入模式
20 // 设置GPIO8功能（设置为GPIO功能）
21 IoSetFunc(IOT_IO_NAME_GPIO_8, IOT_IO_FUNC_GPIO_8_GPIO);
22 // 设置GPIO8为输入方向
23 IoTGpioSetDir(IOT_IO_NAME_GPIO_8, IOT_GPIO_DIR_IN);
24 
25 // 设置GPIO7功能（设置为GPIO功能）
26 IoSetFunc(IOT_IO_NAME_GPIO_7, IOT_IO_FUNC_GPIO_7_GPIO);
27 // 设置GPIO7为输出方向
28 IoTGpioSetDir(IOT_IO_NAME_GPIO_7, IOT_GPIO_DIR_OUT);
29 }
30 
31 float GetDistance(void)
32 {
33 // 定义变量
34 static unsigned long start_time = 0, time = 0;
35 float distance = 0.0;
36 static char line[32] = {0};
37 IotGpioValue value = IOT_GPIO_VALUE0;
38 unsigned int flag = 0;
39 
40 // 设置GPIO7输出低电平
41 /* 给trig发送至少10us的高电平脉冲，以触发传感器测距 */
42 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_7, IOT_GPIO_VALUE1);
43 // 延时函数（设置高电平持续时间）
44 hi_udelay(20);
45 // 设置GPIO7输出高电平
46 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_7, IOT_GPIO_VALUE0);
47 /* 计算与障碍物之间的距离 */
48 while (1) {
49 // 获取GPIO8的输入电平状态
50 IoTGpioGetInputVal(IOT_IO_NAME_GPIO_8, &value);
51 //判断GPIO8的输入电平是否为高电平并且flag为0
52 if ( value == IOT_GPIO_VALUE1 && flag == 0) {
53 // 获取系统时间
54 start_time = hi_get_us();
55 // 将flag设置为1
56 flag = 1;
57 }
58 //判断GPIO8的输入电平是否为低电平并且flag为1
59 if (value == IOT_GPIO_VALUE0 && flag == 1) {
60 // 获取高电平持续时间
61 time = hi_get_us() - start_time;
62 break;
63 }
64 }
65 // 计算距离障碍物距离（340米/秒 转换为 0.034厘米/微秒）
66 distance = time * 0.034 / 2;
67 printf("distance is %0.2f cm\r\n", distance);
68 return distance;
69 }
70 
71 /*Judge steering gear*/
72 unsigned int engine_go_where(hi_void)
73 {
74 float left_distance = 0.0;
75 float right_distance = 0.0;
76 /*舵机往左转动测量左边障碍物的距离*/
77 
78 EngineTurnLeft();
79 TaskMsleep(200);
80 left_distance = GetDistance();
81 TaskMsleep(200);
82 /*归中*/
83 RegressMiddle();
84 TaskMsleep(200);
85 
86 /*舵机往右转动测量右边障碍物的距离*/
87 EngineTurnRight();
88 TaskMsleep(200);
89 right_distance = GetDistance();
90 TaskMsleep(200);
91 /*归中*/
92 RegressMiddle();
93 
94 if (left_distance > right_distance) {
95 return CAR_TURN_LEFT;
96 } else {
97 return CAR_TURN_RIGHT;
98 }
99 }
100 
101 /*根据障碍物的距离来判断小车的行走方向
102 1、距离大于等于15cm继续前进
103 2、距离小于15cm，先停止再后退0.1s,继续进行测距,再进行判断
104 */
105 /*Judge the direction of the car*/
106 unsigned int car_where_to_go(float distance)
107 {
108 if (distance < DISTANCE_BETWEEN_CAR_AND_OBSTACLE) {
109 car_stop();
110 car_backward();
111 TaskMsleep(100);
112 car_stop();
113 unsigned int ret = engine_go_where();
114 if (ret == CAR_TURN_LEFT) {
115 car_left();
116 TaskMsleep(500);
117 } else if (ret == CAR_TURN_RIGHT) {
118 car_right();
119 TaskMsleep(500);
120 }
121 car_stop();
122 } else {
123 car_forward();
124 } 
125 }
126 
127 /* 超声波避障 */
128 void ultrasonic_demo()
129 {
130 float m_distance = 0.0;
131 // regress_middle();
132 /*获取前方物体的距离*/
133 m_distance = GetDistance();
134 car_where_to_go(m_distance);
135 TaskMsleep(20);
136 }
137 
138 void UltrasonicDemoTask()
139 {
140 S92RInit();
141 GA12N20Init();
142 Hcsr04Init();
143 while (1) {
144 ultrasonic_demo();
145 }
146 }
147 
148 void UltrasonicSampleEntry(void)
149 {
150 // 初始化超声波传感器
151 osThreadAttr_t attr;
152 IoTWatchDogDisable();
153 attr.name = "UltrasonicDemoTask";
154 attr.attr_bits = 0U;
155 attr.cb_mem = NULL;
156 attr.cb_size = 0U;
157 attr.stack_mem = NULL;
158 attr.stack_size = 1024 * 5; /* 堆栈大小为1024 */
159 attr.priority = osPriorityNormal;
160 
161 if (osThreadNew((osThreadFunc_t)UltrasonicDemoTask, NULL, &attr) == NULL) {
162 printf("[UltrasonicDemoTask] Failed to create UltrasonicDemoTask!\n");
163 }
164 }
165 APP_FEATURE_INIT(UltrasonicSampleEntry);/*
166 HCSR05 超声波模块的相关API接口
167 */
168 #include <stdio.h>
169 #include <stdlib.h>
170 
171 #include "ohos_init.h"
172 #include "cmsis_os2.h"
173 #include "iot_gpio.h"
174 #include "hi_io.h"
175 #include "iot_gpio_ex.h"
176 
177 #define CAR_TURN_LEFT (0)
178 #define CAR_TURN_RIGHT (1)
179 #define DISTANCE_BETWEEN_CAR_AND_OBSTACLE (18.0)
180 
181 void Hcsr04Init(void)
182 {
183 // 设置超声波Echo为输入模式
184 // 设置GPIO8功能（设置为GPIO功能）
185 IoSetFunc(IOT_IO_NAME_GPIO_8, IOT_IO_FUNC_GPIO_8_GPIO);
186 // 设置GPIO8为输入方向
187 IoTGpioSetDir(IOT_IO_NAME_GPIO_8, IOT_GPIO_DIR_IN);
188 
189 // 设置GPIO7功能（设置为GPIO功能）
190 IoSetFunc(IOT_IO_NAME_GPIO_7, IOT_IO_FUNC_GPIO_7_GPIO);
191 // 设置GPIO7为输出方向
192 IoTGpioSetDir(IOT_IO_NAME_GPIO_7, IOT_GPIO_DIR_OUT);
193 }
194 
195 float GetDistance(void)
196 {
197 // 定义变量
198 static unsigned long start_time = 0, time = 0;
199 float distance = 0.0;
200 static char line[32] = {0};
201 IotGpioValue value = IOT_GPIO_VALUE0;
202 unsigned int flag = 0;
203 
204 // 设置GPIO7输出低电平
205 /* 给trig发送至少10us的高电平脉冲，以触发传感器测距 */
206 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_7, IOT_GPIO_VALUE1);
207 // 延时函数（设置高电平持续时间）
208 hi_udelay(20);
209 // 设置GPIO7输出高电平
210 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_7, IOT_GPIO_VALUE0);
211 /* 计算与障碍物之间的距离 */
212 while (1) {
213 // 获取GPIO8的输入电平状态
214 IoTGpioGetInputVal(IOT_IO_NAME_GPIO_8, &value);
215 //判断GPIO8的输入电平是否为高电平并且flag为0
216 if ( value == IOT_GPIO_VALUE1 && flag == 0) {
217 // 获取系统时间
218 start_time = hi_get_us();
219 // 将flag设置为1
220 flag = 1;
221 }
222 //判断GPIO8的输入电平是否为低电平并且flag为1
223 if (value == IOT_GPIO_VALUE0 && flag == 1) {
224 // 获取高电平持续时间
225 time = hi_get_us() - start_time;
226 break;
227 }
228 }
229 // 计算距离障碍物距离（340米/秒 转换为 0.034厘米/微秒）
230 distance = time * 0.034 / 2;
231 printf("distance is %0.2f cm\r\n", distance);
232 return distance;
233 }
234 
235 /*Judge steering gear*/
236 unsigned int engine_go_where(hi_void)
237 {
238 float left_distance = 0.0;
239 float right_distance = 0.0;
240 /*舵机往左转动测量左边障碍物的距离*/
241 
242 EngineTurnLeft();
243 TaskMsleep(200);
244 left_distance = GetDistance();
245 TaskMsleep(200);
246 /*归中*/
247 RegressMiddle();
248 TaskMsleep(200);
249 
250 /*舵机往右转动测量右边障碍物的距离*/
251 EngineTurnRight();
252 TaskMsleep(200);
253 right_distance = GetDistance();
254 TaskMsleep(200);
255 /*归中*/
256 RegressMiddle();
257 
258 if (left_distance > right_distance) {
259 return CAR_TURN_LEFT;
260 } else {
261 return CAR_TURN_RIGHT;
262 }
263 }
264 
265 /*根据障碍物的距离来判断小车的行走方向
266 1、距离大于等于10cm继续前进
267 2、距离小于10cm，先停止再后退0.1s,继续进行测距,再进行判断
268 */
269 /*Judge the direction of the car*/
270 unsigned int car_where_to_go(float distance)
271 {
272 if (distance < DISTANCE_BETWEEN_CAR_AND_OBSTACLE) {
273 car_stop();
274 car_backward();
275 TaskMsleep(100);
276 car_stop();
277 unsigned int ret = engine_go_where();
278 if (ret == CAR_TURN_LEFT) {
279 car_left();
280 TaskMsleep(500);
281 } else if (ret == CAR_TURN_RIGHT) {
282 car_right();
283 TaskMsleep(500);
284 }
285 car_stop();
286 } else {
287 car_forward();
288 } 
289 }
290 
291 /* 超声波避障 */
292 void ultrasonic_demo()
293 {
294 float m_distance = 0.0;
295 // regress_middle();
296 /*获取前方物体的距离*/
297 m_distance = GetDistance();
298 car_where_to_go(m_distance);
299 TaskMsleep(20);
300 }
301 
302 void UltrasonicDemoTask()
303 {
304 S92RInit();
305 GA12N20Init();
306 Hcsr04Init();
307 while (1) {
308 ultrasonic_demo();
309 }
310 }
311 
312 void UltrasonicSampleEntry(void)
313 {
314 // 初始化超声波传感器
315 osThreadAttr_t attr;
316 IoTWatchDogDisable();
317 attr.name = "UltrasonicDemoTask";
318 attr.attr_bits = 0U;
319 attr.cb_mem = NULL;
320 attr.cb_size = 0U;
321 attr.stack_mem = NULL;
322 attr.stack_size = 1024 * 5; /* 堆栈大小为1024 */
323 attr.priority = osPriorityNormal;
324 
325 if (osThreadNew((osThreadFunc_t)UltrasonicDemoTask, NULL, &attr) == NULL) {
326 printf("[UltrasonicDemoTask] Failed to create UltrasonicDemoTask!\n");
327 }
328 }
329 APP_FEATURE_INIT(UltrasonicSampleEntry);
```
## 4.2 循迹小车实验

### 4.2.1 实验目的

实验内容：小车可以调节滑动变阻器RP1实现左右寻迹模块每10ms采集黑白线条不同的模拟值，将模拟信号转换为数字信号，从而实现小车沿着黑色线条行驶。

### 4.2.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：1) 如果使用3861原始IO口左右红外管测距ADC接收，右红外管需要J6跳帽跳至RIN、GPIO7；左红外管测需要J5跳帽跳至LIN、GPIO12，同时J26,J27不要接任何跳线帽;

![](pic/image-20220924163817850.png)

![](pic/image-20220924163850610.png)

2. 如果使用IO扩展板左右红外管测距接收，右红外管需要J6跳帽跳至RIN_IO、RIN;左红外管测需要J5跳帽跳至LIN_IO、LIN;

![](pic/image-20220924163921011.png)

###  4.2.3 流程图参考

![](pic/image-20220924163949896.png)

###  4.2.4  工程参考

* **2.6 PWM实验-芯片自带PWM实验**

* **2.11 ADC实验**

* **3.3 定时器**

###  4.2.5  部分代码参考

* 如果使用3861原始IO口左右红外管测距
* 完整代码参考：

```C

```

* 如果使用扩展IO口左右红外管测距

完整代码参考：trace_ex_demo。

```C
1 #include "pca.h"
2 #include "iot_gpio_ex.h"
3 
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <memory.h>
7 
8 #include "ohos_init.h"
9 #include "cmsis_os2.h"
10 
11 #include "iot_i2c.h"
12 #include "iot_errno.h"
13 #include "hi_errno.h"
14 #include "hi_i2c.h"
15 #include "iot_gpio.h"
16 
17 #define PCA5555_I2C_IDX 0
18 #define IOT_I2C_IDX_BAUDRATE 4 // 400k
19 #define	GET_BIT(x, bit)	((x & (1 << bit)) >> bit)
20 volatile static int g_ext_io_int_valid = 0;
21 //static uint8_t button[255] = { 0 };
22 
23 /**
24 * @berf i2c read
25 * @param hi_u8 reg_high_8bit_cmd:Transmit register value 8 bits high
26 * @param hi_u8 reg_low_8bit_cmd:Transmit register value low 8 bits
27 * @param hi_u8* recv_data:Receive data buff
28 * @param hi_u8 send_len:Sending data length
29 * @param hi_u8 read_len:Length of received data
30 */
31 static uint32_t PCA95555_WriteRead(uint8_t reg_high_8bit_cmd, uint8_t send_len, uint8_t read_len)
32 {
33 uint32_t status =0;
34 uint32_t ret = 0;
35 uint8_t recvData[888] = {0};
36 hi_i2c_data c081nfc_i2c_write_cmd_addr ={0};
37 uint8_t send_user_cmd[1] = {reg_high_8bit_cmd};
38 memset(recvData, 0x0, sizeof(recvData));
39 c081nfc_i2c_write_cmd_addr.send_buf = send_user_cmd;
40 c081nfc_i2c_write_cmd_addr.send_len = send_len;
41 
42 c081nfc_i2c_write_cmd_addr.receive_buf = recvData;
43 c081nfc_i2c_write_cmd_addr.receive_len = read_len;
44 
45 status = hi_i2c_writeread(PCA5555_I2C_IDX, PCA9555_READ_ADDR, &c081nfc_i2c_write_cmd_addr);
46 if (status != HI_ERR_SUCCESS) {
47 return status;
48 }
49 ret = recvData[0];
50 return ret;
51 }
52 
53 static uint32_t PCA95555_Write(uint8_t* buffer, uint32_t buffLen)
54 {
55 uint32_t retval = IoTI2cWrite(PCA5555_I2C_IDX, PCA9555_WRITE_ADDR, buffer, buffLen);
56 if (retval != IOT_SUCCESS) {
57 printf("IoTI2cWrite(%02X) failed, %0X!\n", buffer[0], retval);
58 return retval;
59 }
60 return IOT_SUCCESS;
61 }
62 
63 void PCA_Gpio_Config(uint8_t addr, uint8_t buffer, uint32_t buffLen)
64 {
65 uint8_t write[WRITELEN] = {addr, buffer};
66 PCA95555_Write(write, WRITELEN);
67 }
68 
69 
70 #define LEFT_LAMP_ON() g_ext_io_output |= 0x38; PCA_Gpio_Config(PCA9555_REG_OUT1, g_ext_io_output, 2);
71 #define LEFT_LAMP_OFF() g_ext_io_output &= (~0x38); PCA_Gpio_Config(PCA9555_REG_OUT1, g_ext_io_output, 2);
72 #define RIGHT_LAMP_ON() g_ext_io_output |= 0x07; PCA_Gpio_Config(PCA9555_REG_OUT1, g_ext_io_output, 2);
73 #define RIGHT_LAMP_OFF() g_ext_io_output &= (~0x07); PCA_Gpio_Config(PCA9555_REG_OUT1, g_ext_io_output, 2);
74 
75 extern void car_forward();
76 extern void car_backward();
77 
78 uint8_t g_ext_io_input = 0;
79 uint8_t g_ext_io_input_d = 0;
80 uint8_t g_ext_io_output = 0;
81 int g_intLowFlag = 0;
82 int32_t g_encoderLeftACounter = 0;
83 uint32_t g_StartTick = 0;
84 uint8_t g_car_on_off = 0;
85 
86 
87 
88 void PCA9555_int_proc()
89 {
90 uint8_t diff;
91 
92 if (g_ext_io_int_valid == 1) {
93 g_ext_io_input = PCA95555_WriteRead(PCA9555_REG_IN0, 1, 1);
94 diff = g_ext_io_input ^ g_ext_io_input_d;
95 
96 //printf("ext_io_input = %02x\r\n", ext_io_input);
97 
98 /* ext io 0 - 1: lighting sensor */
99 if (diff & 0x01) {
100 if (g_ext_io_input & 0x01) {
101 printf("left lighten\n");
102 LEFT_LAMP_ON();
103 } else {
104 printf("left darken\n");
105 LEFT_LAMP_OFF();
106 }
107 }
108 if (diff & 0x02) {
109 if (g_ext_io_input & 0x02) {
110 printf("right lighten\n");
111 RIGHT_LAMP_ON();
112 } else {
113 printf("right darken\n");
114 RIGHT_LAMP_OFF();
115 }
116 }
117 
118 /* ext io 2 - 4: user button */
119 if ((diff & 0x04) && ((g_ext_io_input & 0x04) == 0)) {
120 // button1 pressed event proc
121 printf("button 1 pressed\n");
122 car_left();
123 g_car_on_off = 1;
124 } else if ((diff & 0x08) && ((g_ext_io_input & 0x08) == 0)) {
125 // button2 pressed event proc
126 printf("button 2 pressed\n");
127 car_right();
128 g_car_on_off = 1;
129 } else if ((diff & 0x10) && ((g_ext_io_input & 0x10) == 0)) {
130 // button3 pressed event proc
131 printf("button 3 pressed\n");
132 g_car_on_off = !g_car_on_off;
133 if(g_car_on_off)
134 {
135 car_forward();
136 }
137 else
138 {
139 car_stop();
140 }
141 }
142 
143 /* ext io 5 - 6: motor encoder */
144 if ((diff & 0x20) && ((g_ext_io_input & 0x20) == 0)) {
145 g_encoderLeftACounter++;
146 }
147 g_ext_io_int_valid = 0;
148 g_ext_io_input_d = g_ext_io_input;
149 }
150 else 
151 {
152 IotGpioValue value = 0;
153 if (IoTGpioGetInputVal(IOT_IO_NAME_GPIO_11, &value) == IOT_SUCCESS) {
154 if (value == 1) {
155 g_intLowFlag = 0;
156 } else {
157 if (g_intLowFlag == 0) {
158 g_StartTick = hi_get_milli_seconds();
159 g_intLowFlag = 1;
160 } else {
161 if ((hi_get_milli_seconds() - g_StartTick) > 2) {
162 g_ext_io_input = PCA95555_WriteRead(PCA9555_REG_IN0, 1, 1);
163 g_intLowFlag = 0;
164 }
165 }
166 }
167 }
168 }
169 }
170 
171 
172 void PCA95555TestTask()
173 {
174 uint8_t status;
175 // PCA_Gpio_Config(PCA9555_REG_CFG0, 0x7F, 2); /* 输入为1，输出为0，IO0 234输入,0x60代表只用编码器，0x7c代表按键编码器同时使用，0x1c代表只用按键 */
176 // PCA_Gpio_Config(PCA9555_REG_CFG1, 0x00, 2); /*IO1 012345输出 */
177 // PCA_Gpio_Config(PCA9555_REG_OUT1, LED_OFF, 2); /*IO1 012345低电平 */
178 // LSM6DSTask();
179 // car_forward();
180 
181 /* PCA Input
182 /* ext io 0 - 1: lighting sensor
183 ext io 2 - 4: user button
184 ext io 5 - 6: motor encoder 
185 */
186 
187 PCA_Gpio_Config(PCA9555_REG_CFG0, 0x1F, 2); /* */
188 PCA_Gpio_Config(PCA9555_REG_CFG1, 0x00, 2); /*IO1 012345输出 */
189 PCA_Gpio_Config(PCA9555_REG_OUT1, LED_OFF, 2); /*IO1 012345低电平 */
190 while (1) {
191 PCA9555_int_proc();
192 
193 {
194 static int time_stamp = 0;
195 static int encoderLeftACounter_d = 0;
196 if((hi_get_milli_seconds() - time_stamp) > 100)
197 {
198 //printf("rpm: %d\n", (g_encoderLeftACounter - encoderLeftACounter_d) * 60);
199 encoderLeftACounter_d = g_encoderLeftACounter;
200 time_stamp = hi_get_milli_seconds();
201 
202 if((g_ext_io_input & 0x03) == 0x02)
203 {
204 car_left();
205 }
206 else if((g_ext_io_input & 0x03) == 0x01)
207 {
208 car_right();
209 }
210 else if((g_ext_io_input & 0x03) == 0x03)
211 {
212 car_forward();
213 }
214 else
215 {
216 car_stop();
217 }
218 }
219 }
220 }
221 }
222 
223 void OnExtIoTriggered(const char *arg)
224 {
225 (void) arg;
226 g_ext_io_int_valid = 1;
227 }
228 
229 void PCA95555GpioInit()
230 {
231 IoTI2cInit(0, IOT_I2C_IDX_BAUDRATE); /* baudrate: 4 */
232 IoTI2cSetBaudrate(0, IOT_I2C_IDX_BAUDRATE);
233 IoSetFunc(IOT_IO_NAME_GPIO_13, IOT_IO_FUNC_GPIO_13_I2C0_SDA);
234 IoSetFunc(IOT_IO_NAME_GPIO_14, IOT_IO_FUNC_GPIO_14_I2C0_SCL);
235 
236 IoTGpioInit(IOT_IO_NAME_GPIO_11);
237 IoSetFunc(IOT_IO_NAME_GPIO_11, IOT_IO_FUNC_GPIO_11_GPIO);
238 IoTGpioSetDir(IOT_IO_NAME_GPIO_11, IOT_GPIO_DIR_IN);
239 IoSetPull(IOT_IO_NAME_GPIO_11, IOT_IO_PULL_UP);
240 IoTGpioRegisterIsrFunc(IOT_IO_NAME_GPIO_11, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_FALL_LEVEL_LOW, OnExtIoTriggered, NULL);
241 }
242 
243 void TraceDemoTest(void)
244 {
245 osThreadAttr_t attr;
246 PCA95555GpioInit();
247 GA12N20Init();
248 IoTWatchDogDisable();
249 attr.name = "PCA95555Task";
250 attr.attr_bits = 0U;
251 attr.cb_mem = NULL;
252 attr.cb_size = 0U;
253 attr.stack_mem = NULL;
254 attr.stack_size = 5 * 1024;
255 attr.priority = osPriorityNormal;
256 
257 if (osThreadNew(PCA95555TestTask, NULL, &attr) == NULL) {
258 printf("[robot_car_demo] Failed to create Aht20TestTask!\n");
259 }
260 }
261 APP_FEATURE_INIT(TraceDemoTest);

```
## 4.3 IMU小车控制实验
### 4.3.1 实验目的

实验内容：通过IMU实时获取小车的方向角，通过方向角控制小车走一个正方形

### 4.3.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；
* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 4.3.3 流程图参考

![](pic/image-20220923163923345.png)

### 4.3.4 工程参考

* **2.10 PWM实验-GPIO模拟PWM实验**
* **2.10 I2C实验-I2C总线实验**

### 4.3.5 部分代码参考

* 完整代码参考：imu_square_demo

```C
1 /*
2 * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 
16 #include <stdlib.h>
17 #include <string.h>
18 #include <stdio.h>
19 #include <unistd.h>
20 #include <math.h>
21 
22 #include <hi_time.h>
23 #include <hi_timer.h>
24 #include "ssd1306.h"
25 #include "ssd1306_conf.h"
26 #include "ssd1306_fonts.h"
27 
28 #include "gyro.h"
29 #include "iot_gpio_ex.h"
30 
31 #include "ohos_init.h"
32 #include "cmsis_os2.h"
33 
34 #include "iot_i2c.h"
35 #include "iot_errno.h"
36 #include "hi_errno.h"
37 #include "hi_i2c.h"
38 #include "iot_gpio.h"
39 
40 float q0 = 1, q1 = 0, q2 = 0, q3 = 0; // 四元数的元素，代表估计方向
41 float exInt = 0, eyInt = 0, ezInt = 0; // 按比例缩小积分误差
42 float Yaw, Pitch, Roll; // 偏航角，俯仰角，翻滚角
43 static float yaw_conv = 0.0f;
44 
45 #define LSM6DS_I2C_IDX 0
46 #define IOT_I2C_IDX_BAUDRATE 4 // 400k
47 
48 #define Kp 20.0f // 比例增益支配率收敛到加速度计/磁强计
49 #define Ki 0.0004f // 积分增益支配率的陀螺仪偏见的衔接
50 #define halfT 0.005f // 采样周期的一半
51 
52 #define EXEUTION_FREQ 10 //单位ms
53 
54 /**
55 * @berf i2c read
56 * @param hi_u8 reg_high_8bit_cmd:Transmit register value 8 bits high
57 * @param hi_u8 reg_low_8bit_cmd:Transmit register value low 8 bits
58 * @param hi_u8* recv_data:Receive data buff
59 * @param hi_u8 send_len:Sending data length
60 * @param hi_u8 read_len:Length of received data
61 */
62 static uint32_t LSM6DS_WriteRead(uint8_t reg_high_8bit_cmd, uint8_t send_len, uint8_t read_len)
63 {
64 uint32_t status =0;
65 uint8_t recvData[888] = {0};
66 uint32_t ret = 0;
67 hi_i2c_data c081nfc_i2c_write_cmd_addr ={0};
68 uint8_t send_user_cmd[1] = {reg_high_8bit_cmd};
69 
70 memset(recvData, 0x0, sizeof(recvData));
71 c081nfc_i2c_write_cmd_addr.send_buf = send_user_cmd;
72 c081nfc_i2c_write_cmd_addr.send_len = send_len;
73 
74 c081nfc_i2c_write_cmd_addr.receive_buf = recvData;
75 c081nfc_i2c_write_cmd_addr.receive_len = read_len;
76 
77 status = hi_i2c_writeread(LSM6DS_I2C_IDX, LSM6DS_READ_ADDR, &c081nfc_i2c_write_cmd_addr);
78 if (status != IOT_SUCCESS) {
79 printf("I2cRead() failed, %0X!\n", status);
80 return status;
81 }
82 
83 ret = recvData[0];
84 return ret;
85 }
86 
87 static uint32_t LSM6DS_ReadCont(uint8_t reg_addr, uint8_t* buffer, uint16_t read_len)
88 {
89 uint32_t status;
90 hi_i2c_data i2c_attr;
91 
92 i2c_attr.send_buf = &reg_addr;
93 i2c_attr.send_len = 1;
94 i2c_attr.receive_buf = buffer;
95 i2c_attr.receive_len = read_len;
96 
97 status = hi_i2c_writeread(LSM6DS_I2C_IDX, LSM6DS_READ_ADDR, &i2c_attr);
98 return status;
99 }
100 
101 void GyroGpioInit()
102 {
103 IoTI2cInit(0, IOT_I2C_IDX_BAUDRATE); /* baudrate: 4 */
104 IoTI2cSetBaudrate(0, IOT_I2C_IDX_BAUDRATE);
105 IoSetFunc(IOT_IO_NAME_GPIO_13, IOT_IO_FUNC_GPIO_13_I2C0_SDA);
106 IoSetFunc(IOT_IO_NAME_GPIO_14, IOT_IO_FUNC_GPIO_14_I2C0_SCL);
107 ssd1306_Init();
108 ssd1306_Fill(Black);
109 }
110 
111 static uint32_t LSM6DS_Write(uint8_t addr, uint8_t writedata, uint32_t buffLen)
112 {
113 uint8_t buffer[2] = {addr, writedata};
114 uint32_t retval = IoTI2cWrite(LSM6DS_I2C_IDX, LSM6DS_WRITE_ADDR, buffer, buffLen);
115 if (retval != IOT_SUCCESS) {
116 printf("IoTI2cWrite(%02X) failed, %0X!\n", buffer[0], retval);
117 return retval;
118 }
119 printf("IoTI2cWrite(%02X)\r\n", buffer[0]);
120 return IOT_SUCCESS;
121 }
122 
123 void LSM6DS_Init()
124 {
125 LSM6DS_Write(LSM6DSL_CTRL3_C, 0x34, 2);
126 LSM6DS_Write(LSM6DSL_CTRL2_G , 0X4C, 2); // 角速度陀螺仪配置2000dps ,104Hz
127 LSM6DS_Write(LSM6DSL_CTRL10_C, 0x38, 2); // timer en, pedo en, tilt en ??
128 LSM6DS_Write(LSM6DSL_CTRL1_XL, 0x4F, 2); // 加速度配置量程为8g,104Hz, lpf1_bw_sel=1, bw0_xl=1;
129 
130 LSM6DS_Write(LSM6DSL_TAP_CFG, 0x10, 2);
131 LSM6DS_Write(LSM6DSL_WAKE_UP_DUR, 0x00, 2);
132 LSM6DS_Write(LSM6DSL_WAKE_UP_THS, 0x02, 2);
133 LSM6DS_Write(LSM6DSL_TAP_THS_6D, 0x40, 2);
134 LSM6DS_Write(LSM6DSL_CTRL8_XL, 0x01, 2);
135 
136 return IOT_SUCCESS;
137 }
138 
139 static void IMUSquarTask()
140 {
141 uint32_t ret;
142 GyroGpioInit();
143 GA12N20Init();
144 ret = LSM6DS_WriteRead(LSM6DSL_WHO_AM_I, 1, 1);
145 printf("who am i: %X\n", ret);
146 LSM6DS_Init();
147 car_forward();
148 TaskMsleep(3000);
149 while (fabs(yaw_conv) < 90.00) {
150 Lsm_Get_RawAcc();
151 car_left();
152 }
153 car_forward();
154 TaskMsleep(3000);
155 while (fabs(yaw_conv) < 180.00) {
156 Lsm_Get_RawAcc();
157 car_left();
158 }
159 car_forward();
160 TaskMsleep(3000);
161 while (fabs(yaw_conv) < 270.00) {
162 Lsm_Get_RawAcc();
163 car_left();
164 }
165 car_forward();
166 TaskMsleep(3000);
167 while (fabs(yaw_conv) < 360.00) {
168 Lsm_Get_RawAcc();
169 car_left();
170 }
171 car_stop();
172 }
173 
174 void IMU_YAW_CAL(float gyroZ)
175 {
176 static float dt = 0.03; // 间隔8ms
177 static float yaw = 0.0f, temp = 0.0f;
178 static char line[32] = {0};
179 // 除去零偏
180 #if 0
181 static int a = 0;
182 a++;
183 if (hi_get_seconds() <= 5) {
184 printf("---------times-----------:%d\n", a);
185 }
186 #endif
187 
188 if (fabs(gyroZ) < 0.04) {
189 temp = 0;
190 } else {
191 temp = gyroZ * dt;
192 }
193 yaw += temp;
194 yaw_conv = yaw * 57.32;
195 // 360°一个循环
196 if (fabs(yaw_conv) > 360.0f) {
197 if ((yaw_conv) < 0) {
198 yaw_conv += 360.0f;
199 } else {
200 yaw_conv -= 360.0f;
201 }
202 }
203 printf("yaw_conv:%.02f\n", yaw_conv);
204 ssd1306_SetCursor(0, 0);
205 snprintf(line, sizeof(line), "yaw:%.2f", yaw_conv);
206 ssd1306_DrawString(line, Font_7x10, White);
207 ssd1306_UpdateScreen();
208 }
209 
210 void Lsm_Get_RawAcc()
211 {
212 uint8_t buf[12] = {0};
213 int16_t acc_x = 0, acc_y = 0, acc_z = 0;
214 float acc_x_conv = 0, acc_y_conv = 0, acc_z_conv = 0;
215 int16_t ang_rate_x = 0, ang_rate_y = 0, ang_rate_z = 0;
216 float ang_rate_x_conv = 0, ang_rate_y_conv = 0, ang_rate_z_conv = 0;
217 
218 static char line[32] = {0};
219 if ((LSM6DS_WriteRead(LSM6DSL_STATUS_REG, 1, 1) & 0x03)!=0) {
220 
221 if (IOT_SUCCESS != LSM6DS_ReadCont(LSM6DSL_OUTX_L_G, buf, 12)) {
222 printf("i2c read error!\n");
223 } else {
224 ang_rate_x = (buf[1] << 8) + buf[0];
225 ang_rate_y = (buf[3] << 8) + buf[2];
226 ang_rate_z = (buf[5] << 8) + buf[4];
227 acc_x = (buf[7] << 8) + buf[6];
228 acc_y = (buf[9] << 8) + buf[8];
229 acc_z = (buf[11] << 8) + buf[10];
230 
231 ang_rate_x_conv = 3.14 / 180.0 * ang_rate_x / 14.29;
232 ang_rate_y_conv = 3.14 / 180.0 * ang_rate_y / 14.29;
233 ang_rate_z_conv = 3.14 / 180.0 * ang_rate_z / 14.29;
234 
235 acc_x_conv = acc_x / 4098.36;
236 acc_y_conv = acc_y / 4098.36;
237 acc_z_conv = acc_z / 4098.36;
238 IMU_YAW_CAL(ang_rate_z_conv);
239 }
240 }
241 }
242 
243 void IMUSquarSampleEntry(void)
244 {
245 osThreadAttr_t attr;
246 IoTWatchDogDisable();
247 attr.name = "IMUSquarTask";
248 attr.attr_bits = 0U;
249 attr.cb_mem = NULL;
250 attr.cb_size = 0U;
251 attr.stack_mem = NULL;
252 attr.stack_size = 1024 * 5;
253 attr.priority = osPriorityNormal;
254 
255 if (osThreadNew(IMUSquarTask, NULL, &attr) == NULL) {
256 printf("[RobotTask] Failed to create Aht20TestTask!\n");
257 }
258 }
259 APP_FEATURE_INIT(IMUSquarSampleEntry);
```

## 4.4 平衡车实验

### 4.4.1 实验目的

本实验内容：通过直立环、速度环、转向环算法，IMU测量小车的倾角和倾角速度控制小车车轮加速度消除小车倾角实现保持小车两轮平衡直线行驶，增加y轴速度积分求转向叫实现平衡车转弯。

直立环：控制电机的加速度和小车倾角成正比，可以让小车保持平衡，就是小车向倾斜的方向运动，倾斜角越大，小车运动越快。

速度环：小车前倾，直立环使小车加速前进，让小车保持平衡，然后对速度进行闭环控制，将小车速度环目标设置为0，小车就可以长期稳定平衡。

转向环：给予两个电机差速，即左轮最终赋值减去转向输入值，右轮最终赋值加上转向输入值，两值大小相同，符号相反。

### 4.4.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.接线方式：J27 C2B - GPIO 12，J26 C1B - GPIO 7，J13 C2A - GPIO 00， J12 C1A - GPIO 01，J5，j6不要插跳线帽；硬件要求：HiSpark Pegasus T1 IoT开发套件；

![](pic/image-20220924181354971.png)

![](pic/image-20220924181419893.png)

### 4.4.3 流程图参考
```flow
st=>start: 上电运行
op=>operation: IMU模块和其他模块初始化
cond=>condition: 检测LSM6是否正常
op1=>operation: 读取姿态信息
cond1=>condition: 小车是否倒下
op2=>operation: 检测转速
op3=>operation: 计算PID
cond2=>condition: 超出最大转速
op4=>operation: 输出左右轮PWM和转向
op5=>operation: 限幅输出

st->op->cond
cond(yes)->op1->cond1
cond1(no,bottom)->op2->op3->cond2
cond1(yes)->cond
cond2(no,bottom)->op4
cond2(yes)->op5
op5->op4

```

### 4.4.4 部分代码参考

* 完整代码参考：balance_car_demo。

```C
1 // #include <stdio.h>
2 // #include <stdlib.h>
3 // #include <string.h>
4 // #include <memory.h>
5 // #include <math.h>
6 #include <math.h>
7 #include <stdlib.h>
8 #include <string.h> // For memcpy
9 
10 #include <hi_time.h>
11 #include <hi_timer.h>
12 
13 #include <stdio.h>
14 #include <unistd.h>
15 
16 #include "gyro.h"
17 #include "iot_gpio_ex.h"
18 #include "ssd1306.h"
19 #include <ssd1306_fonts.h>
20 
21 #include "ohos_init.h"
22 #include "cmsis_os2.h"
23 
24 #include "iot_i2c.h"
25 #include "iot_errno.h"
26 #include "hi_errno.h"
27 #include "hi_i2c.h"
28 #include "iot_gpio.h"
29 
30 #include "pca9555.h"
31 #include "debug_util.h"
32 #include "wheel_codec.h"
33 #include "ctrl_algo.h"
34 
35 //#include "imu_attitude_cal.h"
36 
37 #define LSM6DS_I2C_IDX 0
38 #define IOT_I2C_IDX_BAUDRATE 4 // 400k
39 
40 //#define gyroKp 100.0f // 比例增益支配率收敛到加速度计/磁强计
41 //#define gyroKi 0.002f // 积分增益支配率的陀螺仪偏见的衔接
42 //#define gyroHalfT 0.001f // 采样周期的一半
43 
44 
45 #define gyroKp 20.0f // 比例增益支配率收敛到加速度计/磁强计
46 #define gyroKi 0.0004f // 积分增益支配率的陀螺仪偏见的衔接
47 #define gyroHalfT 0.005f // 采样周期的一半
48 
49 extern void car_backward(uint32_t pwm_value);
50 extern void car_forward(uint32_t pwm_value);
51 extern void car_drive(int pwm_value);
52 extern void car_drive_diff(int pwm_value, int diff);
53 extern void car_stop(void);
54 extern void GpioPwmControl(void);
55 
56 
57 static int g_TimerFlag = 0;
58 uint32_t g_timer_handle;
59 
60 void timer_svr(hi_u32 data)
61 {
62 data=data;
63 g_TimerFlag = 1;
64 }
65 
66 void init_gyro_timer(void)
67 {
68 uint32_t ret;
69 
70 ret = hi_timer_create(&g_timer_handle);
71 if(ret != HI_ERR_SUCCESS)
72 {
73 printf("hrtimer create fail\n");
74 return;
75 }
76 else
77 {
78 printf("create timer success\n");
79 }
80 
81 ret = hi_timer_start(g_timer_handle, HI_TIMER_TYPE_PERIOD, 10, timer_svr, 188);
82 }
83 
84 
85 float q0 = 1, q1 = 0, q2 = 0, q3 = 0; // 四元数的元素，代表估计方向
86 float exInt = 0, eyInt = 0, ezInt = 0; // 按比例缩小积分误差
87 float Yaw, Pitch, Roll; // 偏航角，俯仰角，翻滚角
88 static float yaw_conv = 0.0f;
89 
90 
91 /**
92 * @berf i2c read
93 * @param hi_u8 reg_high_8bit_cmd:Transmit register value 8 bits high
94 * @param hi_u8 reg_low_8bit_cmd:Transmit register value low 8 bits
95 * @param hi_u8* recv_data:Receive data buff
96 * @param hi_u8 send_len:Sending data length
97 * @param hi_u8 read_len:Length of received data
98 */
99 uint32_t LSM6DS_WriteRead(uint8_t reg_high_8bit_cmd, uint8_t send_len, uint8_t read_len)
100 {
101 uint32_t status =0;
102 uint8_t recvData[888] = {0};
103 uint32_t ret = 0;
104 hi_i2c_data c081nfc_i2c_write_cmd_addr ={0};
105 uint8_t send_user_cmd[1] = {reg_high_8bit_cmd};
106 
107 memset(recvData, 0x0, sizeof(recvData));
108 c081nfc_i2c_write_cmd_addr.send_buf = send_user_cmd;
109 c081nfc_i2c_write_cmd_addr.send_len = send_len;
110 
111 c081nfc_i2c_write_cmd_addr.receive_buf = recvData;
112 c081nfc_i2c_write_cmd_addr.receive_len = read_len;
113 
114 status = hi_i2c_writeread(LSM6DS_I2C_IDX, LSM6DS_READ_ADDR, &c081nfc_i2c_write_cmd_addr);
115 if (status != IOT_SUCCESS) {
116 printf("I2cRead() failed, %0X!\n", status);
117 return status;
118 }
119 // printf("LSM6DS read ndef data\r\n");
120 // for (int i = 0; i < read_len; i++) {
121 // printf("0x%x ", recvData[i]);
122 // }
123 ret = recvData[0];
124 return ret;
125 }
126 
127 uint32_t LSM6DS_ReadCont(uint8_t reg_addr, uint8_t* buffer, uint16_t read_len)
128 {
129 uint32_t status;
130 hi_i2c_data i2c_attr;
131 
132 i2c_attr.send_buf = &reg_addr;
133 i2c_attr.send_len = 1;
134 i2c_attr.receive_buf = buffer;
135 i2c_attr.receive_len = read_len;
136 
137 status = hi_i2c_writeread(LSM6DS_I2C_IDX, LSM6DS_READ_ADDR, &i2c_attr);
138 return status;
139 }
140 
141 
142 static uint32_t LSM6DS_Write(uint8_t addr, uint8_t writedata, uint32_t buffLen)
143 {
144 uint8_t buffer[2] = {addr, writedata};
145 uint32_t retval = IoTI2cWrite(LSM6DS_I2C_IDX, LSM6DS_WRITE_ADDR, buffer, buffLen);
146 if (retval != IOT_SUCCESS) {
147 printf("IoTI2cWrite(%02X) failed, %0X!\n", buffer[0], retval);
148 return retval;
149 }
150 printf("IoTI2cWrite(%02X)\r\n", buffer[0]);
151 return IOT_SUCCESS;
152 }
153 
154 #define EXEUTION_FREQ 10 //单位ms
155 #define DEAD_ZONE 1 // pwm valid range: [-99, -DEAD_ZONE], [DEAD_ZONE, 99]
156 
157 
158 int g_CarStarted = 0;
159 
160 typedef enum {
161 MODE_ON_OFF = 0, 
162 MODE_DEBUG_GYRO,
163 MODE_STAND_KP_ADJ,
164 MODE_STAND_KD_ADJ,
165 MODE_STAND_BASE_ADJ,
166 MODE_VELO_KP_ADJ,
167 MODE_VELO_KI_ADJ,
168 MODE_VELO_TARGET_ADJ,
169 MODE_TURN,
170 MODE_END,
171 MODE_KI_ADJ,
172 } ENUM_MODE;
173 
174 #define MASK_BUTTON1 (0x10)
175 #define MASK_BUTTON2 (0x08)
176 #define MASK_BUTTON3 (0x04)
177 
178 ENUM_MODE g_mode = MODE_ON_OFF;
179 
180 void init_oled_mode(void)
181 {
182 g_mode = MODE_ON_OFF;
183 ssd1306_ClearOLED(); 
184 ssd1306_printf("s kp:%.2f, kd:%.2f", ctrl_pid_stand.kp, ctrl_pid_stand.kd);
185 ssd1306_printf("v kp:%.2f, ki:%.4f", ctrl_pid_velocity.kp, ctrl_pid_velocity.ki);
186 ssd1306_printf("press btn2/3 to start");
187 }
188 
189 
190 void ButtonPressProc(uint8_t ext_io_val)
191 {
192 static uint8_t ext_io_val_d = 0xFF;
193 uint8_t diff;
194 bool button1_pressed, button2_pressed, button3_pressed;
195 
196 diff = ext_io_val ^ ext_io_val_d;
197 button1_pressed = ((diff & MASK_BUTTON1) && ((ext_io_val & MASK_BUTTON1) == 0)) ? true : false;
198 button2_pressed = ((diff & MASK_BUTTON2) && ((ext_io_val & MASK_BUTTON2) == 0)) ? true : false;
199 button3_pressed = ((diff & MASK_BUTTON3) && ((ext_io_val & MASK_BUTTON3) == 0)) ? true : false;
200 
201 ssd1306_ClearOLED(); 
202 if(button1_pressed)
203 {
204 
205 g_mode = (g_mode >= (MODE_END - 1)) ? 0 : (g_mode + 1);
206 switch (g_mode)
207 {
208 case MODE_ON_OFF:
209 ssd1306_printf("stand loop");
210 ssd1306_printf("kp:%.2f, kd:%.2f", ctrl_pid_stand.kp, ctrl_pid_stand.kd);
211 ssd1306_printf("base:%.2f", stand_base);
212 ssd1306_printf("press btn2/3 to start");
213 break;
214 case MODE_STAND_BASE_ADJ:
215 ssd1306_printf("stand base=%.2f", stand_base); 
216 break;
217 case MODE_STAND_KP_ADJ:
218 ssd1306_printf("stand kp=%.2f", ctrl_pid_stand.kp); 
219 break;
220 case MODE_STAND_KD_ADJ:
221 ssd1306_printf("stand kd=%.2f", ctrl_pid_stand.kd); 
222 break;
223 case MODE_VELO_KP_ADJ:
224 ssd1306_printf("velocity kp=%.2f", ctrl_pid_velocity.kp); 
225 break;
226 case MODE_VELO_KI_ADJ:
227 ssd1306_printf("velocity ki=%.4f", ctrl_pid_velocity.ki); 
228 break;
229 case MODE_VELO_TARGET_ADJ:
230 ssd1306_printf("velocity target=%d", target_velo); 
231 break;
232 case MODE_TURN:
233 ssd1306_printf("turn:%d", target_diff);
234 break;
235 case MODE_DEBUG_GYRO:
236 ssd1306_printf("dfx");
237 ssd1306_printf("press 2 record");
238 ssd1306_printf("press 3 report");
239 break;
240 
241 default:
242 init_oled_mode();
243 break;
244 }
245 }
246 else if(button2_pressed || button3_pressed)
247 {
248 switch (g_mode)
249 {
250 case MODE_ON_OFF:
251 g_CarStarted = !g_CarStarted;
252 ssd1306_ClearOLED();
253 ssd1306_printf(g_CarStarted ? "start" : "stop"); 
254 break;
255 case MODE_DEBUG_GYRO:
256 if(button2_pressed)
257 reset_debug_points();
258 if(button3_pressed)
259 print_debug_points();
260 break;
261 case MODE_STAND_KP_ADJ:
262 ctrl_pid_stand.kp += ((button2_pressed) ? -0.1 : 0.1);
263 ssd1306_printf("stand kp=%.2f", ctrl_pid_stand.kp); 
264 break;
265 case MODE_STAND_KD_ADJ:
266 ctrl_pid_stand.kd += (button2_pressed ? -0.1 : 0.1);
267 ssd1306_printf("stand kd=%.2f", ctrl_pid_stand.kd); 
268 break; 
269 case MODE_VELO_KP_ADJ:
270 ctrl_pid_velocity.kp += ((button2_pressed) ? -0.01 : 0.01);
271 ssd1306_printf("velocity kp=%.2f", ctrl_pid_velocity.kp); 
272 break;
273 case MODE_VELO_KI_ADJ:
274 ctrl_pid_velocity.ki += ((button2_pressed) ? -0.001 : 0.001);
275 ssd1306_printf("velocity ki=%.4f", ctrl_pid_velocity.ki); 
276 break;
277 case MODE_VELO_TARGET_ADJ:
278 target_velo += ((button2_pressed) ? -1 : 1); 
279 ssd1306_printf("velo target =%d", target_velo); 
280 break;
281 case MODE_STAND_BASE_ADJ:
282 stand_base += (button2_pressed ? -0.1 : 0.1);
283 ssd1306_printf("stand_base=%.2f", stand_base);
284 break;
285 case MODE_TURN:
286 target_diff += (button2_pressed ? -1 : 1);
287 ssd1306_printf("turn diff=%d", target_diff);
288 break;
289 default:
290 init_oled_mode();
291 }
292 }
293 
294 ext_io_val_d = ext_io_val;
295 }
296 
297 
298 int test_pwm = 99;
299 int test_endur = 5000;
300 int test_dir = 0;
301 int test_cnt = 0;
302 
303 
304 
305 void LSM6DS_Init()
306 {
307 //LSM6DS_Write(LSM6DSL_CTRL3_C, 0x30, 2);
308 LSM6DS_Write(LSM6DSL_CTRL3_C, 0x34, 2);
309 
310 LSM6DS_Write(LSM6DSL_CTRL2_G , 0X4C, 2); // 角速度陀螺仪配置2000dps ,104Hz
311 LSM6DS_Write(LSM6DSL_CTRL10_C, 0x38, 2); // timer en, pedo en, tilt en ??
312 
313 //LSM6DS_Write(LSM6DSL_CTRL1_XL, 0x43, 2); // 加速度配置量程为2g,104Hz, lpf1_bw_sel=1, bw0_xl=1;
314 LSM6DS_Write(LSM6DSL_CTRL1_XL, 0x4F, 2); // 加速度配置量程为8g,104Hz, lpf1_bw_sel=1, bw0_xl=1;
315 
316 LSM6DS_Write(LSM6DSL_TAP_CFG, 0x10, 2);
317 LSM6DS_Write(LSM6DSL_WAKE_UP_DUR, 0x00, 2);
318 LSM6DS_Write(LSM6DSL_WAKE_UP_THS, 0x02, 2);
319 // LSM6DS_Write(LSM6DSL_MD1_CFG, 0x20, 2);
320 LSM6DS_Write(LSM6DSL_TAP_THS_6D, 0x40, 2);
321 LSM6DS_Write(LSM6DSL_CTRL8_XL, 0x01, 2);
322 }
323 
324 void IMU_YAW_CAL(float gyroZ)
325 {
326 static float dt = 0.03;
327 static float yaw = 0.0f, temp = 0.0f;
328 
329 // 除去零偏
330 #if 0
331 static int a = 0;
332 a++;
333 if (hi_get_seconds() <= 5) {
334 printf("---------times-----------:%d\n", a);
335 }
336 #endif
337 
338 if (fabs(gyroZ) < 0.04) {
339 temp = 0;
340 } else {
341 temp = gyroZ * dt;
342 }
343 yaw += temp;
344 yaw_conv = yaw * 57.32;
345 // 360°一个循环
346 if (fabs(yaw_conv) > 360.0f) {
347 if ((yaw_conv) < 0) {
348 yaw_conv += 360.0f;
349 } else {
350 yaw_conv -= 360.0f;
351 }
352 }
353 }
354 
355 void IMU_Attitude_cal(float gx, float gy, float gz, float ax, float ay, float az)
356 {
357 float norm;
358 float vx, vy, vz;
359 float ex, ey, ez;
360 float atan2_x, atan2_y;
361 float atan2_y_pitch;
362 
363 // 把采集到的三轴加速度转化为单位向量，即向量除以模
364 norm = (float)sqrt((float)(ax*ax + ay*ay + az*az));
365 ax = ax / norm;
366 ay = ay / norm;
367 az = az / norm;
368 
369 // 把四元素换算成方向余弦中的第三行的三个元素
370 // vx、vy、vz其实就是上一次的欧拉角(四元数)机体参考坐标系换算出来的重力的单位向量
371 vx = 2*(q1*q3 - q0*q2);
372 vy = 2*(q0*q1 + q2*q3);
373 vz = q0*q0 - q1*q1 - q2*q2 + q3*q3;
374 
375 // 对向量叉乘，求出姿态误差
376 // ex、ey、ez为三轴误差元素
377 ex = (ay*vz - az*vy);
378 ey = (az*vx - ax*vz);
379 ez = (ax*vy - ay*vx);
380 
381 // 叉乘向量仍旧是机体坐标系上的，而陀螺仪积分误差也是机体坐标系
382 // 而且叉积的大小与陀螺仪误差成正比，正好拿来纠正陀螺
383 exInt = exInt + ex*gyroKi;
384 eyInt = eyInt + ey*gyroKi;
385 ezInt = ezInt + ez*gyroKi;
386 
387 // 调整后的陀螺仪测量
388 gx = gx + gyroKp*ex + exInt;
389 gy = gy + gyroKp*ey + eyInt;
390 gz = gz + gyroKp*ez + ezInt;
391 
392 // 使用一阶龙格库塔解四元数微分方程
393 q0 = q0 + (-q1*gx - q2*gy - q3*gz)*gyroHalfT;
394 q1 = q1 + (q0*gx + q2*gz - q3*gy)*gyroHalfT;
395 q2 = q2 + (q0*gy - q1*gz + q3*gx)*gyroHalfT;
396 q3 = q3 + (q0*gz + q1*gy - q2*gx)*gyroHalfT;
397 
398 // 四元数归一化
399 norm = sqrt(q0*q0 + q1*q1 + q2*q2 + q3*q3);
400 q0 = q0 / norm;
401 q1 = q1 / norm;
402 q2 = q2 / norm;
403 q3 = q3 / norm;
404 
405 // 计算姿态角，本文Roll为横滚角，Pitch为俯仰角
406 atan2_x = -2 * q1 * q1 - 2 * q2* q2 + 1;
407 atan2_y = 2 * q2 * q3 + 2 * q0 * q1;
408 if (atan2_x > 0) {
409 Roll = atan(atan2_y / atan2_x) * 180 / 3.14;
410 } else if (atan2_x < 0 && atan2_y >= 0) {
411 Roll = atan(atan2_y / atan2_x) * 180 / 3.14 + 180;
412 } else if (atan2_x < 0 && atan2_y < 0) {
413 Roll = atan(atan2_y / atan2_x) * 180 / 3.14 - 180;
414 } else if (atan2_y > 0 && atan2_x == 0) {
415 Roll = 90;
416 } else if (atan2_y < 0 && atan2_x == 0) {
417 Roll = -90;
418 } else {
419 printf("undefined\n");
420 }
421 
422 // 俯仰角
423 atan2_y_pitch = -2 * q1 * q3 + 2 * q0* q2;
424 if (atan2_x > 0) {
425 Pitch = atan(atan2_y_pitch / atan2_x) * 180 / 3.14;
426 } else if (atan2_x < 0 && atan2_y_pitch >= 0) {
427 Pitch = atan(atan2_y_pitch / atan2_x) * 180 / 3.14 + 180;
428 } else if (atan2_x < 0 && atan2_y_pitch < 0) {
429 Pitch = atan(atan2_y_pitch / atan2_x) * 180 / 3.14 - 180;
430 } else if (atan2_y_pitch > 0 && atan2_x == 0) {
431 Pitch = 90;
432 } else if (atan2_y_pitch < 0 && atan2_x == 0) {
433 Pitch = -90;
434 } else {
435 printf("undefined\n");
436 }
437 }
438 
439 void Lsm_Get_RawAcc()
440 {
441 uint8_t buf[12] = {0};
442 int16_t acc_x = 0, acc_y = 0, acc_z = 0;
443 float acc_x_conv = 0, acc_y_conv = 0, acc_z_conv = 0;
444 int16_t ang_rate_x = 0, ang_rate_y = 0, ang_rate_z = 0;
445 float ang_rate_x_conv = 0, ang_rate_y_conv = 0, ang_rate_z_conv = 0;
446 
447 if ((LSM6DS_WriteRead(LSM6DSL_STATUS_REG, 1, 1) & 0x03)!=0) {
448 
449 if (IOT_SUCCESS != LSM6DS_ReadCont(LSM6DSL_OUTX_L_G, buf, 12)) {
450 printf("i2c read error!\n");
451 }
452 else {
453 ang_rate_x = (buf[1] << 8) + buf[0];
454 ang_rate_y = (buf[3] << 8) + buf[2];
455 ang_rate_z = (buf[5] << 8) + buf[4];
456 acc_x = (buf[7] << 8) + buf[6];
457 acc_y = (buf[9] << 8) + buf[8];
458 acc_z = (buf[11] << 8) + buf[10];
459 
460 // printf("lsm acc: %d, %d, %d \n ang: %d, %d, %d\n ",
461 // acc_x, acc_y, acc_z, ang_rate_x, ang_rate_y, ang_rate_z);
462 ang_rate_x_conv = 3.14 / 180.0 * ang_rate_x / 14.29;
463 ang_rate_y_conv = 3.14 / 180.0 * ang_rate_y / 14.29;
464 ang_rate_z_conv = 3.14 / 180.0 * ang_rate_z / 14.29;
465 
466 acc_x_conv = acc_x / 4098.36;
467 acc_y_conv = acc_y / 4098.36;
468 acc_z_conv = acc_z / 4098.36;
469 // printf("lsm trans acc: %.2f, %.2f, %.2f \n ang: %.2f, %.2f, %.2f\n ",
470 // acc_x_conv, acc_y_conv, acc_z_conv, ang_rate_x_conv, ang_rate_y_conv, ang_rate_z_conv);
471 IMU_Attitude_cal(ang_rate_x_conv, ang_rate_y_conv, ang_rate_z_conv, acc_x_conv, acc_y_conv, acc_z_conv);
472 IMU_YAW_CAL(ang_rate_z_conv);
473 }
474 }
475 }
476 
477 void InitGyro(void)
478 {
479 uint32_t ret;
480 
481 /* init i2c */
482 IoTI2cInit(0, IOT_I2C_IDX_BAUDRATE); /* baudrate: 4 */
483 IoTI2cSetBaudrate(0, IOT_I2C_IDX_BAUDRATE);
484 IoSetFunc(IOT_IO_NAME_GPIO_13, IOT_IO_FUNC_GPIO_13_I2C0_SDA);
485 IoSetFunc(IOT_IO_NAME_GPIO_14, IOT_IO_FUNC_GPIO_14_I2C0_SCL);
486 
487 ret = LSM6DS_WriteRead(LSM6DSL_WHO_AM_I, 1, 1);
488 printf("who am i: %X\n", ret);
489 
490 LSM6DS_Init();
491 }
492 
493 
494 void BalanceTask(int* arg)
495 {
496 (void) arg;
497 int pwm_mid;
498 float bias, exec;
499 int16_t pos_right, pos_left;
500 static int16_t pos_right_d = 0, pos_left_d = 0;
501 
502 //int16_t pos;
503 int16_t velo_left, velo_right;
504 int16_t velo = 0;
505 //static int16_t pos_d = 0;
506 
507 printf("last compile:%s,%s\n",__DATE__,__TIME__);
508 InitGyro(); 
509 ssd1306_Init();
510 GpioPwmControl();
511 car_stop();
512 init_test_pin();
513 init_gyro_timer();
514 
515 init_wheel_codec();
516 init_ctrl_algo();
517 
518 /* button function */
519 init_oled_mode();
520 PCA_RegisterEventProcFunc(ButtonPressProc);
521 
522 while (1) 
523 {
524 usleep(1);
525 
526 if (g_TimerFlag == 1) 
527 {
528 g_TimerFlag = 0;
529 TEST_PIN_HIGH();
530 
531 /* get pitch feedback */
532 Lsm_Get_RawAcc();
533 
534 /* call ctrl algorithm */
535 get_wheel_cnt(&pos_left, &pos_right);
536 velo_left = pos_left - pos_left_d;
537 velo_right = pos_right - pos_right_d;
538 pos_left_d = pos_left;
539 pos_right_d = pos_right;
540 
541 velo = velo_left + velo_right; 
542 bias = ctrl_pid_algo(target_velo, velo, &ctrl_pid_velocity);
543 exec = ctrl_pid_algo(stand_base + bias, Pitch, &ctrl_pid_stand);
544 pwm_mid = (int)(exec);
545 
546 /* dfx */
547 append_debug_point(velo_left);
548 append_debug_point(velo_right);
549 append_debug_point((int16_t)(bias * 100));
550 append_debug_point((int16_t)((stand_base + bias - Pitch)*100));
551 append_debug_point(pwm_mid);
552 
553 /* execute */
554 if(g_CarStarted)
555 {
556 if((pwm_mid > -DEAD_ZONE) && (pwm_mid < DEAD_ZONE))
557 {
558 car_stop();
559 }
560 else
561 {
562 //car_drive(pwm_mid);
563 car_drive_diff(pwm_mid, target_diff);
564 }
565 }
566 else
567 {
568 car_stop();
569 }
570 
571 //printf("velo:%d, bias:%.2f, pwm_mid:%d\n", velo, bias, pwm_mid);
572 
573 TEST_PIN_LOW();
574 }
575 }
576 }
577 
578 
579 void BalanceDemo(void)
580 {
581 osThreadAttr_t attr;
582 
583 /* disable all drive */
584 IoSetFunc(IOT_IO_NAME_GPIO_5, IOT_IO_FUNC_GPIO_5_GPIO); /* 左侧电机 */
585 IoTGpioSetDir(IOT_IO_NAME_GPIO_5, IOT_GPIO_DIR_OUT);
586 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_5, 0);
587 IoSetFunc(IOT_IO_NAME_GPIO_6, IOT_IO_FUNC_GPIO_6_GPIO);
588 IoTGpioSetDir(IOT_IO_NAME_GPIO_6, IOT_GPIO_DIR_OUT);
589 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_6, 0);
590 
591 IoSetFunc(IOT_IO_NAME_GPIO_9, IOT_IO_FUNC_GPIO_9_GPIO); /* 右侧电机 */
592 IoTGpioSetDir(IOT_IO_NAME_GPIO_9, IOT_GPIO_DIR_OUT);
593 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, 0);
594 IoSetFunc(IOT_IO_NAME_GPIO_10, IOT_IO_FUNC_GPIO_10_GPIO);
595 IoTGpioSetDir(IOT_IO_NAME_GPIO_10, IOT_GPIO_DIR_OUT);
596 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_10, 0);
597 
598 
599 //PCA95555GpioInit();
600 IoTWatchDogDisable();
601 // attr.name = "PCA95555Task";
602 attr.attr_bits = 0U;
603 attr.cb_mem = NULL;
604 attr.cb_size = 0U;
605 attr.stack_mem = NULL;
606 attr.stack_size = 5 * 1024;
607 attr.priority = osPriorityNormal;
608 
609 attr.name = "GyroTask";
610 if (osThreadNew(BalanceTask, NULL, &attr) == NULL) {
611 printf("[RobotTask] Failed to create Aht20TestTask!\n");
612 }
613 }
614 
615 
616 
617 
618 
619 APP_FEATURE_INIT(BalanceDemo);

```

## 4.5 WiFi手机互联

### 4.5.1 实验目的

本实验内容：小车当做AP，手机连接小车热点。通过手机控制小车前进后退停止，舵机左右转动。

### 4.5.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.接线：超声波模块-J1，J26：GPIO7 - TRIG；硬件要求：HiSpark Pegasus T1 IoT开发套件；

<img src="pic/image-20220923180948556.png" style="zoom:50%;" /> ![](pic/image-20220923181021411.png)

### 4.5.3 接口说明
### 4.5.4 实验流程

* 步骤1：复制histreaming_control目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：
 
 ```
 .
 └─applications
 └─ sample
 └─ wifi-iot
 └─ app
 ├─ BUILD.gn
 └─histreaming_control
 ├─ BUILD.gn 
 ├─ hal_iot_gpio_ex.c
 ├─ iot_gpio_ex.h
 ├─ hcsr04.c
 ├─ motor_control.c
 ├─ sg92r_control.c
 ├─ wifi_starter.c
 ├─ wifi_starter.h
 └─ histreaming.c
 ```
 
* 步骤2：修改applications/sample/wifi-iot/app/目录下的BUILD.gn，在features字段中添加histreaming_control:histreaming_control。注：第一个histreaming_control指的是需要编译的工程目录，第二个histreaming_control指的是applications/sample/wifi-iot/app/ histreaming_control/BUILD.gn文件中的静态库，名称为histreaming_control。
 
 ```c
 import("//build/lite/config/component/lite_component.gni")
 
 lite_component("app") {
 features = [ "histreaming_control:histreaming_control", ]
 }
 ```
 
* 步骤3：原理：
 
 	Hi3861作为STA模式，手机与板子连接。控制小车前进后退，舵机左转，右转，归中
 
 ```c
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <memory.h>
 4 #include "ohos_init.h"
 5 #include "cmsis_os2.h"
 6 /* Link Header Files */
 7 #include <link_service.h>
 8 #include <link_platform.h>
 9 #include <histreaming.h>
 10 #include <hi_io.h>
 11 #include <hi_gpio.h>
 12 #include <hi_pwm.h>
 13 #include <hi_task.h>
 14 #include <hi_types_base.h>
 15 #include <hi_time.h>
 16 
 17 unsigned char g_car_control_mode = 0;
 18 unsigned char g_car_speed_control = 0;
 19 unsigned char g_car_status = CAR_STOP_STATUS;
 20 unsigned short g_car_modular_control_module = 0;
 21 unsigned short g_car_direction_control_module = 0;
 22 
 23 static void car_direction_control_func()
 24 {
 25 switch (g_car_direction_control_module) {
 26 case CAR_KEEP_GOING_TYPE: //一直往前
 27 car_forward();
 28 break;
 29 case CAR_KEEP_GOING_BACK_TYPE: //一直往后
 30 car_backward();
 31 break;
 32 case CAR_KEEP_TURN_LEFT_TYPE: //一直往左
 33 car_left();
 34 break;
 35 case CAR_KEEP_TURN_RIGHT_TYPE: //一直往右
 36 car_right();
 37 break;
 38 case CAR_STOP_TYPE: //车子停止
 39 car_stop();
 40 default:
 41 break;
 42 }
 43 g_car_direction_control_module = 0;
 44 }
 45 
 46 /*car mode control func*/
 47 void car_mode_control_func()
 48 {
 49 unsigned short current_car_modular_control_module = g_car_modular_control_module;
 50 unsigned short current_car_control_mode = g_car_control_mode;
 51 RegressMiddle();
 52 switch (g_car_modular_control_module) {
 53 case CAR_CONTROL_STEER_ENGINE_TYPE: //有舵机
 54 while (1) {
 55 if ((current_car_modular_control_module != g_car_modular_control_module) 
 56 || (current_car_control_mode != g_car_control_mode)) {
 57 printf("car_mode_control_func 1 module changed\n");
 58 RegressMiddle();
 59 break;
 60 }
 61 /*获取前方物体的距离*/
 62 ultrasonic_demo();
 63 }
 64 break;
 65 default:
 66 break;
 67 }
 68 }
 69 
 70 void car_module_control_func()
 71 {
 72 switch (g_car_modular_control_module) {
 73 case CAR_CONTROL_ENGINE_LEFT_TYPE:
 74 EngineTurnLeft();
 75 break;
 76 case CAR_CONTROL_ENGINE_RIGHT_TYPE:
 77 EngineTurnRight();
 78 break;
 79 case CAR_CONTROL_ENGINE_MIDDLE_TYPE:
 80 RegressMiddle();
 81 break;
 82 case CAR_CONTROL_STEER_ENGINE_TYPE:
 83 car_mode_control_func();
 84 break;
 85 default:
 86 break;
 87 }
 88 g_car_modular_control_module = 0;
 89 }
 90 
 91 /*
 92 modular control func
 93 */
 94 static void car_modular_control(char* value)
 95 {
 96 printf("car_modular_control\n");
 97 if (strcmp(value, "engine_left") == 0) { //舵机向左
 98 g_car_modular_control_module = CAR_CONTROL_ENGINE_LEFT_TYPE;
 99 } else if (strcmp(value, "engine_right") == 0) { //舵机向右
 100 g_car_modular_control_module = CAR_CONTROL_ENGINE_RIGHT_TYPE;
 101 } else if (strcmp(value, "engine_middle") == 0) { //舵机居中
 102 g_car_modular_control_module = CAR_CONTROL_ENGINE_MIDDLE_TYPE;
 103 } else if (strcmp(value, "steer_engine") == 0) { //启动舵机超声波避障模块
 104 g_car_modular_control_module = CAR_CONTROL_STEER_ENGINE_TYPE;
 105 }
 106 }
 107 
 108 /*
 109 car direction control
 110 */
 111 static void car_direction_control(char* value)
 112 {
 113 printf("car_direction_control\n");
 114 if (strcmp(value, "going") == 0) {
 115 g_car_direction_control_module = CAR_KEEP_GOING_TYPE;
 116 } else if(strcmp(value, "backing") == 0) {
 117 g_car_direction_control_module = CAR_KEEP_GOING_BACK_TYPE;
 118 } else if(strcmp(value, "lefting") == 0) {
 119 g_car_direction_control_module = CAR_KEEP_TURN_LEFT_TYPE;
 120 } else if(strcmp(value, "righting") == 0) {
 121 g_car_direction_control_module = CAR_KEEP_TURN_RIGHT_TYPE;
 122 } else if (strcmp(value,"stop") == 0) {
 123 g_car_direction_control_module = CAR_STOP_TYPE;
 124 }
 125 }
 126 
 127 static int GetStatusValue(struct LinkService* ar, const char* property, char* value, int len)
 128 {
 129 (void)(ar);
 130 
 131 printf("Receive property: %s(value=%s[%d])\n", property, value, len);
 132 if (strcmp(property, "Status") == 0) {
 133 }
 134 
 135 /*
 136 * if Ok return 0,
 137 * Otherwise, any error, return StatusFailure
 138 */
 139 return 0;
 140 }
 141 /* recv from app cmd */
 142 static int ModifyStatus(struct LinkService* ar, const char* property, char* value, int len)
 143 {
 144 (void)(ar);
 145 
 146 if (property == NULL || value == NULL) {
 147 return -1;
 148 }
 149 
 150 printf("Receive property: %s(value=%s[%d])\n", property, value,len);
 151 if (strcmp(property,"CarControl") == 0) {
 152 g_car_control_mode = CAR_DIRECTION_CONTROL_MODE;
 153 car_direction_control(value);
 154 } else if (strcmp(property, "ModularControl") == 0) {
 155 g_car_control_mode = CAR_MODULE_CONTROL_MODE;
 156 car_modular_control(value);
 157 }
 158 /*
 159 * if Ok return 0,
 160 * Otherwise, any error, return StatusFailure
 161 */
 162 return 0;
 163 }
 164 
 165 /*
 166 * It is a Wifi IoT device
 167 */
 168 static const char* g_wifista_type = "Light";
 169 static const char* GetDeviceType(struct LinkService* ar)
 170 {
 171 (void)(ar);
 172 
 173 return g_wifista_type;
 174 }
 175 
 176 static void *g_link_platform = NULL;
 177 
 178 void histreaming_open(void)
 179 {
 180 LinkService* wifiIot = 0;
 181 LinkPlatform* link = 0;
 182 
 183 wifiIot = (LinkService*)malloc(sizeof(LinkService));
 184 if (!wifiIot) {
 185 printf("malloc wifiIot failure\n");
 186 return NULL;
 187 }
 188 
 189 wifiIot->get = GetStatusValue;
 190 wifiIot->modify = ModifyStatus;
 191 wifiIot->type = GetDeviceType;
 192 
 193 link = LinkPlatformGet();
 194 if (!link) {
 195 printf("get link failure\n");
 196 return NULL;
 197 }
 198 
 199 if (link->addLinkService(link, wifiIot, 1) != 0) {
 200 histreaming_close(link);
 201 return NULL;
 202 }
 203 
 204 if (link->open(link) != 0) {
 205 histreaming_close(link);
 206 return NULL;
 207 }
 208 
 209 /* cache link ptr*/
 210 g_link_platform = (void*)(link);
 211 #ifdef HISTREAMING_TASK 
 212 hi_task_delete(g_histreaming_demo_task_id);
 213 #endif
 214 return (void*)link;
 215 }
 216 
 217 void histreaming_close(void *link)
 218 {
 219 LinkPlatform *linkPlatform = (LinkPlatform*)(link);
 220 if (!linkPlatform) {
 221 return;
 222 }
 223 
 224 linkPlatform->close(linkPlatform);
 225 
 226 if (linkPlatform != NULL) {
 227 LinkPlatformFree(linkPlatform);
 228 }
 229 }
 230 
 231 void WifiRobotTask()
 232 {
 233 S92RInit();
 234 GA12N20Init();
 235 Hcsr04Init();
 236 StartHotspot();
 237 histreaming_open();
 238 while (1) {
 239 switch (g_car_control_mode) {
 240 case CAR_DIRECTION_CONTROL_MODE:
 241 car_direction_control_func();
 242 break;
 243 case CAR_MODULE_CONTROL_MODE:
 244 car_module_control_func();
 245 break;
 246 default:
 247 break;
 248 }
 249 TaskMsleep(200);
 250 }
 251 }
 252 
 253 static void StartWifiRobotSampleEntry(void)
 254 {
 255 osThreadAttr_t attr;
 256 IoTWatchDogDisable();
 257 attr.name = "WifiRobotTask";
 258 attr.attr_bits = 0U;
 259 attr.cb_mem = NULL;
 260 attr.cb_size = 0U;
 261 attr.stack_mem = NULL;
 262 attr.stack_size = 1024 * 5; /* 堆栈大小为1024 */
 263 attr.priority = osPriorityNormal;
 264 
 265 if (osThreadNew((osThreadFunc_t)WifiRobotTask, NULL, &attr) == NULL) {
 266 printf("[WifiRobotTask] Failed to create WifiRobotTask!\n");
 267 }
 268 }
 269 APP_FEATURE_INIT(StartWifiRobotSampleEntry);
 ```
 
- 步骤5：编译工程代码
 - 在docker的命令行终端，执行下面的命令，进行代码的编译。
 
 ```
 hb build -f
 ```
 
 <img src="./pic/image-20220818102212205.png" alt="image-20220818102212205" style="zoom:67%;" />
 
- 步骤6：在手机端装Histreaming APP（APP可以在IOT/histreaming_control/app下获取），同时可以在https://gitee.com/leo593362220/shistreaming下载获取源码（需要自己学习如何开发APP，并自己编译）。
 
 
- 步骤7：手机端连接Hi3861主板的热点。wifi热点名字格式为HiSpark-AP,可以自己设定。

- 步骤8：点击图标<img src="pic/image-20220923191115996.png" style="zoom: 50%;" /> 打开手机已经安装的app，点击“局域网”，如果打开APP后没有马上出现“已绑定设备”，请往下滑不断刷新，直到出现绑定设备即可。如下图所示。
 
 ![](pic/image-20220923191139300.png)
 
 
 
- 步骤9：点击“局域网”进去后，可以看到“ 小车控制”按键，点击进去之后可以看到“前进”、“后退”等。如下图所示。
 
 ![](pic/image-20220924100706836.png) ![](pic/image-20220924100732450.png)

### 4.5.5 实验结果

* 软件烧录成功后，使用手机控制小车前进，后退，左转，右转，舵机左右转动，超声波避障等。

### 4.5.6 扩展实验

* 通过手机APP控制小车屏幕显示电量，陀螺仪数据，RTC时钟等。

提示：通过手机APP下发对应指令让屏幕显示电量，陀螺仪数据；参考I2C总线实验。

## 4.6 MQTT 云端互联

### 4.6.1 实验目的

本实验内容：小车连接WiFi与华为云建立连接，同时按键S4控制小车红色LED灭，按键S3控制小车红色LED亮，并实时上报亮灭数据，华为下发指令控制小车红色LED亮灭。

### 4.6.2 实验要求

* 1.软件要求：VSCode，hi3861_hdu_iot_application；

* 2.硬件要求：HiSpark Pegasus T1 IoT开发套件；

### 4.6.3 接口说明
### 4.6.4 实验流程

* 步骤1：注册华为云账号;
 
* 步骤2：在搜索栏搜索 ”IoTDA“;
 
 ![](pic/image-20220920151723528.png)
 
* 步骤3：选择 ”免费试用“;
 
 <img src="pic/image-20220920151902522.png" style="zoom: 67%;" />
 
* 步骤4：首先控制台选择 “北京四”，然后点击 “产品”；

![](pic/image-20220920152227956.png)

*  步骤5：选择 “创建产品”，然后弹出对话框，根据提示完善信息，点击 “确定”，出现创建产品成功代表产品创建完成。

![](pic/image-20220920152423918.png)

![](pic/image-20220920152615871.png)

![](pic/image-20220920152721949.png)

* 步骤6：创建成功后，可以在页面处看到产品信息，点击 “查看”,查看产品详细信息，点击 “自定义模型”创建用户自己的模型

![](pic/image-20220920153027665.png)

![](pic/image-20220920153059880.png)
    
* 步骤7：创建自定义模型“添加服务”，根据提示完善信息，点击 “确定”，服务添加完成后可以看到如下界面。

![](pic/image-20220920160111901.png)

* 步骤8：添加成功后，选择 “添加属性”，如：新增属性为属性名称：“ControlModule”，数据类型：“String”，访问权限：“可读，可写”，长度：“255”，点击确定；然后选择 “添加命令”，如：命令名称：“ControlModule”，点击新增输入参数，参数名称：“TrafficLight”，数据类型：“String”，长度：“255”。

![](pic/image-20220920162816193.png)

* 步骤9：模型定义完成后，选择左边栏框 “设备”，选择 “所有设备”，然后在点击右上角 “注册设备”，根据弹窗提示完善信息，点击 “确定”，完成设备注册。

![](pic/image-20220920163023914.png)

![](pic/image-20220920163336853.png)

* 步骤10：设备注册成功后，可以看到设备未激活（这是因为设备已经在云端注册，但是实物还没有连接云端），点击 “查看”，查看设备信息。

![](pic/image-20220920163512778.png)

* 步骤11：复制OC_control/目录下的所有文件到/home/openharmony/hi3861_hdu_iot_application/src的applications/sample/wifi-iot/app/目录下，代码结构如下所示：

* 步骤12：https://iot-tool.obs-website.cn-north-4.myhuaweicloud.com/打开链接，将下图地方设备ID复制到DeviceId，密钥复制到DeviceSecret，点击Generate生Clientld，Username，Password。

![](pic/image-20220924160451960.png)

![](pic/image-20220924160547788.png)

* 步骤12：修改applications/sample/wifi-iot/app/ nfc_control/目录下iot_config.h中CONFIG_AP_SSID，CONFIG_AP_PWD为WiFi名称和WiFi密码以及CONFIG_DEVICE_ID和CONFIG_DEVICE_PWD。CONFIG_DEVICE_ID和CONFIG_DEVICE_PWD为下面图片红色框框内容。

```c
/* Please modify the ssid and pwd for the own */
#define CONFIG_AP_SSID  "x" // WIFI SSID
#define CONFIG_AP_PWD "xxxxxxx" // WIFI PWD

// /<Configure the iot platform
/* Please modify the device id and pwd for your own */
// 设备ID名称，请参考华为物联网云文档获取该设备的ID。例如:60790e01ba4b2702c053ff03_helloMQTT
#define CONFIG_DEVICE_ID "xxxxxxxxxxxxxxxxxxxxxxxxxx" // 生成Username
#define CONFIG_DEVICE_PWD "xxxxxxx" // 生成Password
#define CONFIG_CLIENTID "xxxxxxxxx" // 生成Clientid
```

* 步骤13：./applications/sample/wifi-iot/app/oc_demo/app_demo_iot.c中下列字段参数与自定义创建模型属性及服务保持一致(用户自己定义)，使用参考案例不用修改。

```c
#define TRAFFIC_LIGHT_CMD_CONTROL_MODE      "ControlModule" // 属性名称
#define TRAFFIC_LIGHT_RED_ON_PAYLOAD        "RED_LED_ON"  //  下发参数
#define TRAFFIC_LIGHT_RED_OFF_PAYLOAD        "RED_LED_OFF" // 下发参数
#define TRAFFIC_LIGHT_SERVICE_ID_PAYLOAD    "TrafficLight"
```

* 步骤14：修改源码./applications/sample/wifi-iot/app下的BUILD.gn文件，在features字段中增加索引，使目标模块参与编译。features字段指定业务模块的路径和目标,features字段配置如下:

```c
    import("//build/lite/config/component/lite_component.gni")
    
    lite_component("app") {
        features = [
            "oc_demo:OCDemo",
        ]
    }
    ```

* 步骤15：修改.device/soc/hisilicon/hi3861v100/sdk_liteos/build/config/usr_config.mk文件。在这个配置文件中打开I2C,PWM驱动宏。搜索字段CONFIG_I2C_SUPPORT ，并打开I2C。配置如下：

```
# CONFIG_I2C_SUPPORT is not set
CONFIG_I2C_SUPPORT=y
```

* 步骤16：MQTT云端互联使用的paho.mqtt，目前已提供适配鸿蒙系统的paho.mqtt，在"./device/hisilicon/hispark_pegasus/sdk_liteos/third_party/paho.mqtt.c/include/mqtt"目录下，核心代码实现如下：

```c
1 /*
2 * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 
16 #include <hi_task.h>
17 #include <string.h>
18 #include "iot_config.h"
19 #include "iot_main.h"
20 #include "iot_profile.h"
21 #include "ohos_init.h"
22 #include "cmsis_os2.h"
23 #include "wifi_connecter.h"
24 #include "iot_gpio_ex.h"
25 #include "iot_gpio.h"
26 
27 /* attribute initiative to report */
28 #define TAKE_THE_INITIATIVE_TO_REPORT
29 /* oc request id */
30 #define CN_COMMAND_INDEX "commands/request_id="
31 /* oc report HiSpark attribute */
32 #define TRAFFIC_LIGHT_CMD_CONTROL_MODE "ControlModule"
33 #define TRAFFIC_LIGHT_RED_ON_PAYLOAD "RED_LED_ON"
34 #define TRAFFIC_LIGHT_RED_OFF_PAYLOAD "RED_LED_OFF"
35 
36 #define TASK_SLEEP_1000MS (1000)
37 int g_lightStatus = -1;
38 
39 void RedLedInit()
40 {
41 IoTGpioInit(IOT_IO_NAME_GPIO_9);
42 // 设置GPIO9的管脚复用关系为GPIO
43 IoSetFunc(IOT_IO_NAME_GPIO_9, IOT_IO_FUNC_GPIO_9_GPIO);
44 // GPIO方向设置为输出
45 IoTGpioSetDir(IOT_IO_NAME_GPIO_9, IOT_GPIO_DIR_OUT);
46 }
47 
48 void RedLight()
49 {
50 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE1);
51 g_lightStatus = 0;
52 }
53 
54 void RedOff()
55 {
56 IoTGpioSetOutputVal(IOT_IO_NAME_GPIO_9, IOT_GPIO_VALUE0);
57 g_lightStatus = 1;
58 }
59 
60 static void TrafficLightMsgRcvCallBack(char *payload)
61 {
62 printf("PAYLOAD:%s\r\n", payload);
63 if (strstr(payload, TRAFFIC_LIGHT_CMD_CONTROL_MODE) != NULL) {
64 if (strstr(payload, TRAFFIC_LIGHT_RED_ON_PAYLOAD) != NULL) { // RED LED
65 RedLight();
66 } else if (strstr(payload, TRAFFIC_LIGHT_RED_OFF_PAYLOAD) != NULL) {
67 RedOff();
68 }
69 }
70 }
71 
72 // /< this is the callback function, set to the mqtt, and if any messages come, it will be called
73 // /< The payload here is the json string
74 static void DemoMsgRcvCallBack(int qos, const char *topic, char *payload)
75 {
76 const char *requesID;
77 char *tmp;
78 IoTCmdResp resp;
79 printf("RCVMSG:QOS:%d TOPIC:%s PAYLOAD:%s\r\n", qos, topic, payload);
80 /* app 下发的操作 */
81 TrafficLightMsgRcvCallBack(payload);
82 tmp = strstr(topic, CN_COMMAND_INDEX);
83 if (tmp != NULL) {
84 // /< now you could deal your own works here --THE COMMAND FROM THE PLATFORM
85 // /< now er roport the command execute result to the platform
86 requesID = tmp + strlen(CN_COMMAND_INDEX);
87 resp.requestID = requesID;
88 resp.respName = NULL;
89 resp.retCode = 0; ////< which means 0 success and others failed
90 resp.paras = NULL;
91 (void)IoTProfileCmdResp(CONFIG_DEVICE_PWD, &resp);
92 }
93 }
94 
95 /* traffic light:1.control module */
96 void IotPublishSample()
97 {
98 IoTProfileService service;
99 IoTProfileKV property;
100 unsigned char status = 0;
101 printf("traffic light:control module\r\n");
102 memset_s(&property, sizeof(property), 0, sizeof(property));
103 property.type = EN_IOT_DATATYPE_STRING;
104 property.key = "ControlModule";
105 if (g_lightStatus == 0) {
106 property.value = "RED_LED_ON";
107 } else {
108 property.value = "RED_LED_OFF";
109 }
110 memset_s(&service, sizeof(service), 0, sizeof(service));
111 service.serviceID = "TrafficLight";
112 service.serviceProperty = &property;
113 IoTProfilePropertyReport(CONFIG_DEVICE_ID, &service);
114 }
115 
116 ///< this is the demo main task entry,here we will set the wifi/cjson/mqtt ready ,and
117 ///< wait if any work to do in the while
118 static void *DemoEntry()
119 {
120 ConnectToHotspot();
121 RedLedInit();
122 CJsonInit();
123 IoTMain();
124 IoTSetMsgCallback(DemoMsgRcvCallBack);
125 TaskMsleep(26000);
126 /* 主动上报 */
127 while (1) {
128 // /< here you could add your own works here--we report the data to the IoTplatform
129 TaskMsleep(TASK_SLEEP_1000MS);
130 // /< now we report the data to the iot platform
131 IotPublishSample();
132 }
133 }
134 
135 ///< This is the demo entry, we create a task here, and all the works has been done in the demo_entry
136 #define CN_IOT_TASK_STACKSIZE 0x1000
137 #define CN_IOT_TASK_PRIOR 28
138 #define CN_IOT_TASK_NAME "IOTDEMO"
139 static void AppDemoIot(void)
140 {
141 osThreadAttr_t attr;
142 IoTWatchDogDisable();
143 attr.name = "IOTDEMO";
144 attr.attr_bits = 0U;
145 attr.cb_mem = NULL;
146 attr.cb_size = 0U;
147 attr.stack_mem = NULL;
148 attr.stack_size = CN_IOT_TASK_STACKSIZE;
149 attr.priority = CN_IOT_TASK_PRIOR;
150 
151 if (osThreadNew((osThreadFunc_t)DemoEntry, NULL, &attr) == NULL) {
152 printf("[TrafficLight] Failed to create IOTDEMO!\n");
153 }
154 }
155 
156 SYS_RUN(AppDemoIot);
```

- 步骤17：编译工程代码
    - 在docker的命令行终端，执行下面的命令，进行代码的编译。

```
hb  build  -f
```

- 步骤18：烧录程序到开发板
    - 参考1.3.4节的内容即可
    
- 步骤19 :烧录成功后，等待连接云端成功，串口出现如下打印网页端显示设备在线即可。

![](pic/image-20220924162413633.png)

![](pic/image-20220924162450791.png)

- 步骤20：点击查看，同时按不同按键控制小车红色灯亮灭，可以看到最新数据上报情况。

![](pic/image-20220924162556473.png)

- 步骤21：在命令栏选择同步命令下发，选择创建的命令，然后根据代码设置的下发参数，发送对应指令，可以看到小车红色LED亮灭。

![](pic/image-20220924162736988.png)
### 4.6.5 实验结果

* 1.数据上报云端：打开串口工具，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，根据按不同按键控制红色灯亮灭，实时上报数据，同时可以从串口工具看到：

![](pic/image-20220924161803852.png)

* 2.云端下发指令给小车：打开串口工具，使用串口工具连接好小车的串口，按一下开发板的RESET按键复位开发板，根据下发不同指令实现红色灯亮灭，并将最新数据上报到云端，同时可以从串口工具看到：

![](pic/image-20220924161959432.png)

### 4.6.6 扩展实验

* 1.通过华为云实现小车实时上报电量信息，陀螺仪数据。

提示：参考单I2C轮询实验。

# 附录

## 5.1 T1 IoT一体化开发套件的组装

### 5.1.1 包装盒清单

### 5.1.2 组装步骤

## 5.2 IOT一体化 IO口功能关系表

| pin name | 功能1                                                       | 硬件配置说明                         | 功能2           | 硬件配置说明              | 功能3         | 硬件配置说明       |
| :------: | ----------------------------------------------------------- | :----------------------------------- | --------------- | ------------------------- | ------------- | ------------------ |
|  GPIO 0  | 串口通信UART1_TX                                            | 串口引出J4，需J13跳帽跳至GPIO 0 - TX | 左侧编码器A相   | 需J13跳帽跳至GPIO 0 - C2A | /             | /                  |
|  GPIO 1  | 串口通信UART1_RX                                            | 串口引出J4，需J12跳帽跳至GPIO 0 - RX | 右侧编码器A相   | 需J12跳帽跳至GPIO 0 - C1A | /             | /                  |
|  GPIO 2  | 舵机                                                        | GPIO模拟PWM，调节占空比舵机转动      | /               | /                         | /             | /                  |
|  GPIO 3  | UART0_LOG_TX                                                | 烧录调试串口，空闲为高               | /               | /                         | /             | /                  |
|  GPIO 4  | UART0_LOG_RX                                                | 烧录调试串口，空闲为高               | /               | /                         | /             | /                  |
|  GPIO 5  | 左侧电机调速B相                                             | 置1前进                              | 黄色交通灯      | 置1亮，置0灭              | /             | /                  |
|  GPIO 6  | 左侧电机调速A相                                             | 置1后退                              | /               | /                         | /             | /                  |
|  GPIO 7  | 超声波TRIG                                                  | 置1时输出TRIG高电平，J26跳帽跳至TRIG | 右红外管ADC测距 | 需J6跳线帽跳至GPIO 7-RIN  | 右侧编码器B相 | 需J26跳线帽跳至C1B |
|  GPIO 8  | 超声波ECHO                                                  | 接收超声波发送返回数据               | /               | /                         | /             | /                  |
|  GPIO 9  | 右侧电机调速B相                                             | 置1前进                              | 红色交通灯      | 置1亮，置0灭              | /             | /                  |
| GPIO 10  | 右侧电机调速A相                                             | 置1后退                              | 绿色交通灯      | 置1亮，置0灭              | /             | /                  |
| GPIO 12  | 蜂鸣器鸣响                                                  | 置1响                                | 左红外管ADC测距 | 需J5跳线帽跳至GPIO 12-LIN | 左侧编码器B相 | 需J27跳帽跳至C2B   |
| GPIO 13  | OLED、PCA9555、CW2015CTCC、LSM6DSMTR、FM11NT081DI、INS5699S | I2C0_SDA，I2C数据线                  | /               | /                         | /             | /                  |
| GPIO 14  | OLED、PCA9555、CW2015CTCC、LSM6DSMTR、FM11NT081DI、INS5699S | I2C_SCL，I2C时钟线                   | /               | /                         | /             | /                  |

## 5.3 Hi3861V100 IO口复用关系表

| pin name | F.0          | F.1       | F.2          | F.3  | F.4      | F.5         | F.6         | F.7  | F.8      |
| -------- | ------------ | --------- | ------------ | ---- | -------- | ----------- | ----------- | ---- | -------- |
| GPIO 0   | GPIO 0       | UART1_TXD | SPI1_CLK     | PWM3 | I2C1_SDA | RTC_OSC_32K | RTC32K_XOUT | /    | /        |
| GPIO 1   | GPIO 1       | UART1_RXD | SPI1_RXD     | PWM4 | I2C1_SCL | /           | RTC32K_XINT | /    | /        |
| GPIO 2   | GPIO 2       | UART1_RTS | SPI1_TXD     | PWM2 | /        | SSI_CLK     | /           | /    | /        |
| GPIO 3   | UART0_LOG_TX | UART1_CTS | SPI1_CS1     | PWM5 | I2C1_SDA | SSI_DATA    | GPIO 3      | /    | /        |
| GPIO 4   | UART0_LOG_RX | /         | /            | PWM1 | I2C1_SCL | /           | GPIO 4      | ADC1 | /        |
| GPIO 5   | UART1_RXD    | GPIO 5    | I2S0_MCK     | PWM2 | /        | BT_STATUS   | SPI0_CS1    | ADC2 | /        |
| GPIO 6   | UART1_TXD    | GPIO 6    | I2S0_TX      | PWM3 | /        | COEX_SWITH  | SPI0_CLK    | /    | /        |
| GPIO 7   | UART1_CTS    | GPIO 7    | I2S0_CLK     | PWM0 | /        | BT_ACTIVE   | SPI0_RXD    | ADC3 | /        |
| GPIO 8   | UART1-RTS    | GPIO 8    | I2S0_WS      | PWM1 | /        | WLAN_ACTIVE | SPIO_TXD    | /    | /        |
| GPIO 9   | GPIO 9       | UART2_RTS | SPI0_TXD     | PWM0 | I2C0_SCL | I2S0_MCK    | SDIO_D2     | ADC4 | /        |
| GPIO 10  | GPIO 10      | UATR2_CTS | SPI0_CLK     | PWM1 | I2C0_SDA | I2S0_TX     | SDIO_D3     | /    | /        |
| GPIO 11  | GPIO 11      | UART2_TXD | SPI0_RXD     | PWM2 | /        | I2S0_RX     | SDIO_CMD    | ADC5 | /        |
| GPIO 12  | GPIO 12      | UART2_RXD | SPI0_CS1     | PWM3 | /        | I2S0_CLK    | SDIO_CLK    | ADC0 | /        |
| GPIO 13  | GPIO 13      | UART2_RTS | UART0_LOG_TX | PWM4 | I2C0_SDA | I2S0_WS     | SDIO_D0     | ADC6 | SSI_DATA |
| GPIO 14  | GPIO 14      | UART2_CTS | UART0_LOG_RX | PWM5 | I2C0_SCL | /           | SDIO_D1     | /    | SSI_CLK  |

唯教授/hi3861_hdu_iot_application_cy

简介

发行版

贡献者

近期动态

唯教授/hi3861_hdu_iot_application_cy .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

唯教授/hi3861_hdu_iot_application_cy