# 第六章.实验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)
## 6.1 实验4的基础知识
完成前面所有实验后,PKE内核的整体功能已经得到完善。在实验四的设备实验中,我们将结合fpga-pynq板,在rocket chip上增加uart模块和蓝牙模块,并搭载PKE内核,实现蓝牙通信控制智能小车,设计设备管理的相关实验。
### 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设备的访问。
### 6.1.2 轮询I/O控制方式
在实验四中,我们设备管理的主要任务是控制设备与内存的数据传递,具体为从蓝牙设备读取到用户输入的指令字符(或传递数据给蓝牙在手机端进行打印),解析为小车前、后、左、右、停止等动作来传输数据给电机实现对小车的控制。在前两个实验中,我们分别需要对轮询控制方式和中断控制方式进行实现。
首先,程序直接控制方式(又称循环测试方式),每次从外部设备读取一个字的数据到存储器,对于读入的每个字,CPU需要对外设状态进行循环检查,直到确定该数据已经传入I/O数据寄存器中。在轮询的控制方式下,由于CPU的高速性和I/O设备的低速性,导致CPU浪费绝大多数时间处于等待I/O设备完成数据传输的循环测试中,会造成大量资源浪费。
轮询I/O控制方式流程如图:
### 6.1.3 中断驱动I/O控制方式
在前一种轮询的控制方式中,由于没有采用中断机制,CPU需要不断测试I/O设备的状态,造成CPU资源的极大浪费。中断驱动的方式是,允许I/O设备主动打断CPU的运行并请求相应的服务,请求I/O的进程首先会进入阻塞状态,PLIC将字符读取操作转化为s态中断进行处理,向进程传递读取的数据后,唤醒进程继续运行。
采用中断驱动的控制方式,在I/O操作过程中,CPU可以执行其他的进程,CPU与设备之间达到了部分并行的工作状态,从而提升了资源利用率。
中断驱动I/O方式流程如图:
### 6.1.4 设备树
设备树(Device Tree)是描述计算机的特定硬件设备信息的数据结构,以便于操作系统的内核可以管理和使用这些硬件,包括CPU或CPU,内存,总线和其他一些外设。
硬件的相应信息都会写在`.dts`为后缀的文件中,`dtc`是编译`dts`的工具,`dtb(Device Tree Blob)`,`dts`经过`dtc`编译之后会得到`dtb`文件,`dtb`通过`Bootloader`引导程序加载到内核。所以`Bootloader`需要支持设备树才行;Kernel也需要加入设备树的支持。
在rocketchip中,设备即通过设备树的方式提供给pke使用。
## 6.2 lab4_1 POLL
#### **给定应用**
- 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端口的获取和打印字符系统调用,以及传送驱动数据给小车电机的系统调用,实现对小车的控制。
#### **实验内容**
如输出提示所表示的那样,需要找到并完成对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.
```
#### **实验指导**
基于实验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端口的地址映射如图:
我们可以看到配置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."
```
## 6.3 lab4_2_PLIC
#### **给定应用**
- 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.
```
#### **实验内容**
如输出提示所表示的那样,需要找到并完成对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.
```
#### **实验指导**
对于本实验的应用,我们需要在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."
```
## 6.4 lab4_3
#### **给定应用**
- 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.
```
#### 实验内容
如应用提示所表示的那样,读者需要找到并完成对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 }
```
实验预期结果:小车在前进过程中能够正常识别障碍物后并自动停车。
#### 实验指导
##### 摄像头控制
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."
```