EduCoderTeacher0028
/
pke-doc
mirror of https://gitee.com/hustos/pke-doc.git
1
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4ac9e61c9b'
${ noResults }
pke-doc/chapter6_device.md

740 lines
28 KiB
Raw Normal View History Unescape

add chapter6
3 years ago
# 第六章．实验4：设备管理
### 目录
- [6.1 实验4的基础知识](#fundamental)
- [6.1.1 内存映射I/O(MMIO)](#subsec_MMIO)
- [6.1.2 轮询I/O控制方式](#subsec_polling)
- [6.1.3 中断驱动I/O控制方式](#subsec_plic)
- [6.1.4 设备树](#subsec_device_tree)
- [6.2 lab4_1 POLL](#polling)
- [给定应用](#lab4_1_app)
- [实验内容](#lab4_1_content)
- [实验指导](#lab4_1_guide)
- [6.3 lab4_2_PLIC](#PLIC)
- [给定应用](#lab4_2_app)
- [实验内容](#lab4_2_content)
- [实验指导](#lab4_2_guide)
- [6.4 lab4_3_hostdevice](#hostdevice)
- [给定应用](#lab4_3_app)
- [实验内容](#lab4_3_content)
- [实验指导](#lab4_3_guide)
<a name="fundamental"></a>
## 6.1 实验4的基础知识
完成前面所有实验后，PKE内核的整体功能已经得到完善。在实验四的设备实验中，我们将结合fpga-pynq板，在rocket chip上增加uart模块和蓝牙模块，并搭载PKE内核，实现蓝牙通信控制智能小车，设计设备管理的相关实验。
<a name="subsec_MMIO"></a>
### 6.1.1 内存映射I/O(MMIO)
内存映射(Memory-Mapping I/O)是一种用于设备驱动程序和设备通信的方式，它区别于基于I/O端口控制的Port I/O方式。RICSV指令系统的CPU通常只实现一个物理地址空间，这种情况下，外设I/O端口的物理地址就被映射到CPU中单一的物理地址空间，成为内存的一部分，CPU可以像访问一个内存单元那样访问外设I/O端口，而不需要设立专门的外设I/O指令。
在MMIO中，内存和I/O设备共享同一个地址空间。MMIO是应用得最为广泛的一种IO方法，它使用相同的地址总线来处理内存和I/O设备，I/O设备的内存和寄存器被映射到与之相关联的地址。当CPU访问某个内存地址时，它可能是物理内存，也可以是某个I/O设备的内存。此时，用于访问内存的CPU指令就可以用来访问I/O设备。每个I/O设备监视CPU的地址总线，一旦CPU访问分配给它的地址，它就做出响应，将数据总线连接到需要访问的设备硬件寄存器。为了容纳I/O设备，CPU必须预留给I/O一个地址映射区域。
用户空间程序使用mmap系统调用将IO设备的物理内存地址映射到用户空间的虚拟内存地址上，一旦映射完成，用户空间的一段内存就与IO设备的内存关联起来，当用户访问用户空间的这段内存地址范围时，实际上会转化为对IO设备的访问。
<a name="subsec_polling"></a>
### 6.1.2 轮询I/O控制方式
在实验四中，我们设备管理的主要任务是控制设备与内存的数据传递，具体为从蓝牙设备读取到用户输入的指令字符（或传递数据给蓝牙在手机端进行打印），解析为小车前、后、左、右、停止等动作来传输数据给电机实现对小车的控制。在前两个实验中，我们分别需要对轮询控制方式和中断控制方式进行实现。
首先，程序直接控制方式（又称循环测试方式），每次从外部设备读取一个字的数据到存储器，对于读入的每个字，CPU需要对外设状态进行循环检查，直到确定该数据已经传入I/O数据寄存器中。在轮询的控制方式下，由于CPU的高速性和I/O设备的低速性，导致CPU浪费绝大多数时间处于等待I/O设备完成数据传输的循环测试中，会造成大量资源浪费。
轮询I/O控制方式流程如图：
<img src="pictures/fig6_1_polling.png" alt="fig6_1" style="zoom:100%;" />
<a name="subsec_plic"></a>
### 6.1.3 中断驱动I/O控制方式
在前一种轮询的控制方式中，由于没有采用中断机制，CPU需要不断测试I/O设备的状态，造成CPU资源的极大浪费。中断驱动的方式是，允许I/O设备主动打断CPU的运行并请求相应的服务，请求I/O的进程首先会进入阻塞状态，PLIC将字符读取操作转化为s态中断进行处理，向进程传递读取的数据后，唤醒进程继续运行。
采用中断驱动的控制方式，在I/O操作过程中，CPU可以执行其他的进程，CPU与设备之间达到了部分并行的工作状态，从而提升了资源利用率。
中断驱动I/O方式流程如图：
<img src="pictures/fig6_2_plic.png" alt="fig6_2" style="zoom:100%;" />
<a name="subsec_device_tree"></a>
### 6.1.4 设备树
设备树（Device Tree）是描述计算机的特定硬件设备信息的数据结构，以便于操作系统的内核可以管理和使用这些硬件，包括CPU或CPU，内存，总线和其他一些外设。
硬件的相应信息都会写在`.dts`为后缀的文件中，`dtc`是编译`dts`的工具，`dtb(Device Tree Blob)`，`dts`经过`dtc`编译之后会得到`dtb`文件，`dtb`通过`Bootloader`引导程序加载到内核。所以`Bootloader`需要支持设备树才行；Kernel也需要加入设备树的支持。
<img src="pictures/fig6_3.png" alt="fig6_3" style="zoom:130%;" />
在rocketchip中，设备即通过设备树的方式提供给pke使用。
<a name="polling"></a>
## 6.2 lab4_1 POLL
<a name="lab4_1_app"></a>
#### **给定应用**
- user/app_poll.c
```
1 /*
2 * Below is the given application for lab4_1.
3 * The goal of this app is to control the car via Bluetooth.
4 */
5
6 #include "user_lib.h"
7 #include "util/types.h"
8
9 int main(void) {
10 printu("please input the instruction through bluetooth!\n");
11 while(1)
12 {
13 char temp = (char)uartgetchar();
14 uartputchar(temp);
15 switch (temp)
16 {
17 case '1' : gpio_reg_write(0x2e); break; //前进
18 case '2' : gpio_reg_write(0xd1); break; //后退
19 case '3' : gpio_reg_write(0x63); break; //左转
20 case '4' : gpio_reg_write(0x9c); break; //右转
21 case 'q' : exit(0); break;
22 default : gpio_reg_write(0x00); break; //停止
23 }
24 }
25 exit(0);
26 return 0;
27 }
```
应用通过轮询的方式从蓝牙端获取指令，实现对小车的控制功能。
- 切换到lab4_1，继承lab3_3及之前实验所做的修改，并make后的直接运行结果：
```
//切换到lab4_1
$ git checkout lab4_1_poll
//继承lab3_3以及之前的答案
$ git merge lab3_3_rrsched -m "continue to work on lab4_1"
//重新构造
$ make clean; make
//运行构造结果
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_poll
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
please input the instruction through bluetooth!
You need to implement the uart_getchar function in lab4_1 here!
System is shutting down with exit code -1.
```
从结果上来看，蓝牙端端口获取用户输入指令的uartgetchar系统调用未完善，所以无法进行控制小车的后续操作。按照提示，我们需要实现蓝牙uart端口的获取和打印字符系统调用，以及传送驱动数据给小车电机的系统调用，实现对小车的控制。
<a name="lab4_1_content"></a>
#### **实验内容**
如输出提示所表示的那样，需要找到并完成对uartgetchar，uartputchar，gpio_reg_write的调用，并获得以下预期结果：
```
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_poll
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
Ticks 0
please input the instruction through bluetooth!
Ticks 1
going to insert process 0 to ready queue.
going to schedule process 0 to run.
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
<a name="lab4_1_guide"></a>
#### **实验指导**
基于实验lab1_1，你已经了解和掌握操作系统中系统调用机制的实现原理。对于本实验的应用，我们发现user/app_poll.c文件中有三个函数调用：uartgetchar，uartputchar和gpio_reg_write。对代码进行跟踪，我们发现这三个函数都在user/user_lib.c中进行了实现，对应于lab1_1的流程，我们可以在kernel/syscall.h中查看新增的系统调用以及编号：
```
16 #define SYS_user_uart_putchar (SYS_user_base + 6)
17 #define SYS_user_uart_getchar (SYS_user_base + 7)
18 #define SYS_user_gpio_reg_write (SYS_user_base + 8)
```
继续追踪，我们发现在kernel/syscall.c的do_syscall函数中新增了对应系统调用编号的实现函数，对于新增系统调用，分别有如下函数进行处理：
```
133 case SYS_user_uart_putchar:
134 sys_user_uart_putchar(a1);return 1;
135 case SYS_user_uart_getchar:
136 return sys_user_uart_getchar();
137 case SYS_user_gpio_reg_write:
138 return sys_user_gpio_reg_write(a1);
```
读者的任务即为在kernel/syscall.c中追踪并完善对应的函数。对于uart的函数，我们给出uart端口的地址映射如图：
<img src="pictures/fig6_3_address.png" alt="fig6_3" style="zoom:80%;" />
我们可以看到配置uart端口的偏移地址为0x60000000，对应写地址为0x60000000，读地址为0x60000004，同时对0x60000008的状态位进行轮询，检测到信号时进行读写操作。
在kernel/syscall.c中找到函数实现空缺，并根据注释完成uart系统调用：
```
84 //add uart putchar getchar syscall
85 //
86 // implement the SYS_user_uart_putchar syscall
87 //
88 void sys_user_uart_putchar(uint8 ch) {
89 volatile uint32 *status = (void*)(uintptr_t)0x60000008;
90 volatile uint32 *tx = (void*)(uintptr_t)0x60000004;
91 while (*status & 0x00000008);
92 *tx = ch;
93 }
94
95 ssize_t sys_user_uart_getchar() {
96 // TODO (lab4_1): implment the syscall of sys_user_uart_getchar.
97 // hint: the functionality of sys_user_uart_getchar is to get data from UART address. therefore,
98 // we should let a pointer point, insert it in
99 // the rear of ready queue, and finally, schedule a READY process to run.
100 panic( "You have to implement sys_user_uart_getchar to get data from UART using uartgetchar in lab4_1.\n" );
101
102 }
103
104
105
106 //car control
107 ssize_t sys_user_gpio_reg_write(uint8 val) {
108 volatile uint32_t *control_reg = (void*)(uintptr_t)0x60001004;
109 volatile uint32_t *data_reg = (void*)(uintptr_t)0x60001000;
110 //*control_reg = 0;
111 *data_reg = (uint32_t)val;
112 return 1;
113 }
114
```
和uart端口读写过程类似，其中电机连接端口gpio数据地址为0x60001000，根据用户程序app_poll中流程，我们需要将uart端口读到的驱动数据传递给电机。
安卓手机端验证：首先将HC-05蓝牙模块接入pynq板，接口对应关系为：
| pynq接口 | HC-05接口 |
| -------- | --------- |
| VCC | VCC |
| GND | GND |
| JA4 | RXD |
| JA3 | TXD |
接入时注意对应接口错位正确插入，然后在手机端下载BluetoothSerial，连接hc-05蓝牙模块，使用网线连接pynq板和电脑，打开开发板电源。
成功连接蓝牙模块后，启动连接：
```
$ ssh xilinx@192.168.2.99
```
随后使用scp指令将编译后的pke内核和用户app文件导入：
```
$ scp 文件名 xilinx@192.168.2.99:~
```
此时便成功进入pynq板环境，可对结果进行验证。
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定），以便在后续实验中继承lab4_1中所做的工作**：
```
$ git commit -a -m "my work on lab4_1 is done."
```
<a name="PLIC"></a>
## 6.3 lab4_2_PLIC
<a name="lab4_2_app"></a>
#### **给定应用**
- user/app_PLIC.c
```
1 /*
2 * Below is the given application for lab4_2.
3 * The goal of this app is to control the car via Bluetooth.
4 */
5
6 #include "user_lib.h"
7 #include "util/types.h"
8 void delay(unsigned int time){
9 unsigned int a = 0xfffff ,b = time;
10 volatile unsigned int i,j;
11 for(i = 0; i < a; ++i){
12 for(j = 0; j < b; ++j){
13 ;
14 }
15 }
16 }
17 int main(void) {
18 printu("Hello world!\n");
19 int i;
20 int pid = fork();
21 if(pid == 0)
22 {
23 while (1)
24 {
25 delay(3);
26 printu("waiting for you!\n");
27 }
28
29 }
30 else
31 {
32 for (;;) {
33 char temp = (char)uartgetchar();
34 printu("%c\n", temp);
35 switch (temp)
36 {
37 case '1' : gpio_reg_write(0x2e); break; //前进
38 case '2' : gpio_reg_write(0xd1); break; //后退
39 case '3' : gpio_reg_write(0x63); break; //左转
40 case '4' : gpio_reg_write(0x9c); break; //右转
41 case 'q' : exit(0); break;
42 default : gpio_reg_write(0x00); break; //停止
43 }
44 }
45 }
46
47
48 exit(0);
49
50 return 0;
51 }
```
应用通过中断的方式从蓝牙端获取指令，实现对小车的控制功能。
- 切换到lab4_2，继承lab4_1及之前实验所做的修改，并make后的直接运行结果：
```
//切换到lab4_2
$ git checkout lab4_2_PLIC
//继承lab4_1以及之前的答案
$ git merge lab4_1_poll -m "continue to work on lab4_2"
//重新构造
$ make clean; make
//运行构造结果
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_poll
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
please input the instruction through bluetooth!
You need to implement the uart_getchar function in lab4_2 here!
System is shutting down with exit code -1.
```
<a name="lab4_2_content"></a>
#### **实验内容**
如输出提示所表示的那样，需要找到并完成对uartgetchar，do_sleep，getuartvalue的调用，并获得以下预期结果：
```
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_polling
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
Ticks 0
please input the instruction through bluetooth!
Ticks 1
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
<a name="lab4_2_guide"></a>
#### **实验指导**
对于本实验的应用，我们需要在lab4_1基础上实现基于中断的uartgetchar。对代码进行跟踪，我们可以在kernel/syscall.h中查看新增的系统调用以及编号：
```
16 #define SYS_user_uart_putchar (SYS_user_base + 6)
17 #define SYS_user_uart_getchar (SYS_user_base + 7)
18 #define SYS_user_gpio_reg_write (SYS_user_base + 8)
```
继续追踪，我们发现在kernel/syscall.c的do_syscall函数中新增了对应系统调用编号的实现函数，对于新增系统调用，分别有如下函数进行处理：
```
139 case SYS_user_uart_getchar:
140 return sys_user_uart_getchar();
```
你的任务即为在kernel/syscall.c中追踪并完善对应的函数。
在kernel/syscall.c中找到函数实现空缺，并根据注释完成uart系统调用：
```
88 //
89 // implement the uart syscall
90 //
103 ssize_t sys_user_uart_getchar() {
104 panic( "You need to implement the uart_getchar function in lab4_2 here.\n" );
105 //sleep
106
107 //Wait for wake
108
109 //get the value
110
111 //Return the result character
112
113
114 }
```
当蓝牙有数据发送时，pke会收到外部中断，你需要完成接收到外部中断后的处理。
在kernel/strap.c中找到函数空缺，并根据注释完成中断处理函数：
```
100 case CAUSE_MEXTERNEL_S_TRAP:
101 {
102 panic( "You need to complete case CAUSE_MEXTERNEL_S_TRAP function in lab4_2 here.\n"
103 int irq = *(uint32 *)0xc201004L;
104 *(uint32 *)0xc201004L = irq;
105 volatile int *ctrl_reg = (void *)(uintptr_t)0x6000000c;
106 *ctrl_reg = *ctrl_reg | (1 << 4);
107
108 // get the data from MMIO.
109 // send it to the process.
110 // call function to awake process[0]
111
112
113
114 break;
115 }
```
在kernel/process.c中找到函数实现空缺，并根据注释完成do_sleep函数：
```
221 void do_sleep(){
222 panic( "You need to implement do_sleep function in lab4_2 here.\n"
223 // set the process BLOCKED.
224 }
```
在kernel/process.c中找到函数实现空缺，并根据注释完成do_wake函数：
```
226 void do_wake(){
227 panic( "You need to implement do_sleep function in lab4_2 here.\n"
228 //set the process READY.
229 //insert_to_ready_queue
230
231 //schedule
232 }
```
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定），以便在后续实验中继承lab4_2中所做的工作**：
```
$ git commit -a -m "my work on lab4_2 is done."
```
<a name="hostdevice"></a>
## 6.4 lab4_3
<a name="lab4_3_app"></a>
#### **给定应用**
- user/app_host_device.c
```
1 #pragma pack(4)
2 #define _SYS__TIMEVAL_H_
3 struct timeval {
4 unsigned int tv_sec;
5 unsigned int tv_usec;
6 };
7
8 #include "user_lib.h"
9 #include "videodev2.h"
10 #define DARK 64
11 #define RATIO 7 / 10
12
13 int main() {
14 char *info = allocate_share_page();
15 int pid = do_fork();
16 if (pid == 0) {
17 int f = do_open("/dev/video0", O_RDWR), r;
18
19 struct v4l2_format fmt;
20 fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
21 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
22 fmt.fmt.pix.width = 320;
23 fmt.fmt.pix.height = 180;
24 fmt.fmt.pix.field = V4L2_FIELD_NONE;
25 r = do_ioctl(f, VIDIOC_S_FMT, &fmt);
26 printu("Pass format: %d\n", r);
27
28 struct v4l2_requestbuffers req;
29 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
30 req.count = 1; req.memory = V4L2_MEMORY_MMAP;
31 r = do_ioctl(f, VIDIOC_REQBUFS, &req);
32 printu("Pass request: %d\n", r);
33
34 struct v4l2_buffer buf;
35 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
36 buf.memory = V4L2_MEMORY_MMAP; buf.index = 0;
37 r = do_ioctl(f, VIDIOC_QUERYBUF, &buf);
38 printu("Pass buffer: %d\n", r);
39
40 int length = buf.length;
41 char *img = do_mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, f, buf.m.offset);
42 unsigned int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
43 r = do_ioctl(f, VIDIOC_STREAMON, &type);
44 printu("Open stream: %d\n", r);
45
46 char *img_data = allocate_page();
47 for (int i = 0; i < (length + 4095) / 4096 - 1; i++)
48 allocate_page();
49 yield();
50
51 for (;;) {
52 if (*info == '1') {
53 r = do_ioctl(f, VIDIOC_QBUF, &buf);
54 printu("Buffer enqueue: %d\n", r);
55 r = do_ioctl(f, VIDIOC_DQBUF, &buf);
56 printu("Buffer dequeue: %d\n", r);
57 r = read_mmap(img_data, img, length);
58 int num = 0;
59 for (int i = 0; i < length; i += 2)
60 if (img_data[i] < DARK) num++;
61 printu("Dark num: %d > %d\n", num, length / 2 * RATIO);
62 if (num > length / 2 * RATIO) {
63 *info = '0'; gpio_reg_write(0x00);
64 }
65 } else if (*info == 'q') break;
66 }
67
68 for (char *i = img_data; i - img_data < length; i += 4096)
69 free_page(i);
70 r = do_ioctl(f, VIDIOC_STREAMOFF, &type);
71 printu("Close stream: %d\n", r);
72 do_munmap(img, length); do_close(f); exit(0);
73 } else {
74 yield();
75 for (;;) {
76 char temp = (char)uartgetchar();
77 printu("From bluetooth: %c\n", temp);
78 *info = temp;
79 switch (temp) {
80 case '1': gpio_reg_write(0x2e); break; //前进
81 case '2': gpio_reg_write(0xd1); break; //后退
82 case '3': gpio_reg_write(0x63); break; //左转
83 case '4': gpio_reg_write(0x9c); break; //右转
84 case 'q': exit(0); break;
85 default: gpio_reg_write(0x00); break; //停止
86 }
87 }
88 }
89 return 0;
90 }
```
该用户程序包含两个进程，其中主进程和实验4_2类似，负责接收蓝牙发送过来的数据，根据数据控制小车行动（前进、后退、左转、右转、停止）；子进程则负责拍摄和分析，首先初始化摄像头设备，然后是个死循环判断摄像头拍摄的图像数据：如果当前小车处于前进状态，则拍摄，然后检查数据，如果判断前面有障碍物则控制车轮停转（刹车），否则如果主进程退出了，则自己进行释放文件、内存、关闭设备等操作，再退出。在用户程序操控摄像头的过程中，使用了ioctl、mmap、munmap等系统调用，需对其进行完善从而实现小车的障碍识别和停止功能。
- 切换到lab4_3、继承lab4_2中所做修改，并make后的直接运行结果：
```
//切换到lab4_2
$ git checkout lab4_2_PLIC
//继承lab3_3以及之前的答案
$ git merge lab4_2_PLIC -m "continue to work on lab4_2"
//重新构造
$ make clean; make
//运行构造结果
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_PLIC
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
please input the instruction through bluetooth!
You need to implement the uart_getchar function in lab4_3 here!
System is shutting down with exit code -1.
```
<a name="lab4_3_content"></a>
#### 实验内容
如应用提示所表示的那样，读者需要找到并完成对ioctl的调用，使得用户能够设置设备参数，从而控制摄像头实现拍照等功能；获取图片后，检查数据，从而判断前方是否出现障碍物。
跟踪相关系统调用，在kernel/file.c里可以看到需要补充的函数：
```
25 int do_open(char *pathname, int flags) {
26 // TODO (lab4_3): call host open through spike_file_open and then bind fd to spike_file
27 // hint: spike_file_dup function can bind spike_file_t to an int fd.
28 panic( "You need to finish open function in lab4_3.\n" );
29 }
```
```
39 int do_ioctl(int fd, uint64 request, char *data) {
40 // TODO (lab4_3): call host ioctl through frontend_sycall
41 // hint: fronted_syscall ioctl argument:
42 // 1.call number
43 // 2.fd
44 // 3.the order to device
45 // 4.data address
46 panic( "You need to call host's ioctl by frontend_syscall in lab4_3.\n" );
47 return frontend_syscall(HTIFSYS_ioctl, spike_file_get(fd)->kfd,
48 request, (uint64)data, 0, 0, 0, 0);
49 }
```
实验预期结果：小车在前进过程中能够正常识别障碍物后并自动停车。
<a name="lab4_3_guide"></a>
#### 实验指导
##### 摄像头控制
USB摄像头最基础的控制方法是使用读写设备文件的方式。拍摄一张照片包含以下过程：
* 打开设备文件，使用open函数
* 设置设备参数，使用ioctl函数
* 映射内存，由于USB摄像头对应的设备文件不支持直接用read函数进行读写，所以需要用mmap函数将文件映射到一段虚拟地址，通过虚拟地址进行读写
* 拍摄，使用ioctl函数控制
* 结束和清理，包含使用ioctl函数关闭设备，使用munmap函数解映射，使用close函数关闭设备文件
其中ioctl、mmap、munmap三个函数是PKE和riscv-fesvr不支持的，需要在本设计中添加，因此本设计的重点包含以下三个内容：
* 对riscv-fesvr的修改：riscv-fesvr是PS端（Arm）的一个程序，用于控制PL端（Riscv）程序的启动以及和通信。通过riscv-fesvr，PL端上的程序也可以访问PS端的文件，调用一些PS端系统的函数。原版的riscv-fesvr不支持ioctl和mmap等函数，而操控USB摄像头的用户程序必须使用这些函数，所以需要对riscv-fesvr进行修改，使得PL端上运行的PKE和用户程序能够通过riscv-fesvr这个中间层调用宿主机的系统函数从而控制摄像头；
* 对PKE内核代码的修改：需要为riscv-fesvr新增的函数调用提供用户层接口。
* 对用户代码的修改：有了对fesvr和内核的修改，用户程序就可以调用各类系统调用函数操控摄像机了。为了实现避障的功能，程序还需要对获得的图片信息进行解码和分析，根据前方是否为障碍物选择是否刹车。
##### 图片解析
应用第21行可以看到，我们从摄像头获取的数据是YUYV格式，读者可进行查阅，它用灰度、蓝色色度、红色色度三个属性表示颜色，每个像素点都有灰度属性。由于我们分析障碍物只需要灰度图，所以取每个像素点的灰度属性即可。
因此对于获取过来的数据删去奇数索引的数据，就可以得到灰度图。对于障碍物的判断，我们使用了一个比较简单的算法：计算灰度小于64的像素点个数，如果个数大于像素点总数的7/10，即认为前方是障碍物。
**注意：对于灰度阈值的设定可根据环境亮度进行一定的调整，可以先根据摄像头返回的图像进行分析，计算出对应障碍物的灰度值；灰度阈值越精确，小车对于障碍物的识别将越灵敏，并能在合理的距离内识别到障碍物并停车。**
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定），以便在后续实验中继承lab4_3中所做的工作**：
```
$ git commit -a -m "my work on lab4_3 is done."
```