嵌入式系统移植环境搭建

嵌入式系统移植环境搭建

开发板硬件

嵌入式系统的核心是定制，是根据市场需求对软硬件进行定制,实现性能的最大化

无OS嵌入式系统

单片机，直接操作硬件，结构简单，实现的功能单一。

有OS嵌入式系统

系统中的各个层之间地址是相互独立的，跨层操作需要通过系统调用、地址映射经过地址转换。

如果不是处理器，芯片没有运算器等，其它的芯片本质是通过访问它的寄存器（地址）来操作或者获取数据。

linux交叉编译环境硬件基本组成

  • 准备开发主机、目标机(开发板)以及二者的连接介质
  • 准备目标机代码
  • 安装交叉工具链
  • 开发主机上安装的软件(为方便调试)
  • 终端软件(putty, minicom)
  • tftp服务，文件传输
  • nfs服务，目录同步
  • 目标机安装(u-boot烧写调试)

1.SD卡方式
2.Fastboot方式 (成功后,板子有串口信息输出)

  • 主机和目标机能联通
    网络自动tftp加载内核,并挂载nfs rootfs启动

开发板启动流程

主机Ubuntu环境搭建

  • 将GCC.G+编器版本从4.6降至4.4

  • 安装了Android编译所需要的工具和(source.android.com)

  • 安装SUN JAVA JDK 6

  • 安装内核编译所依赖的工具包

  • 解决了libncurses 32位和64位不能同时安装导致编Android和配置内核软件冲突的问题

  • 安装制作安卓文件系统yaffi2格式mkyaffs工具

  • 添加了常用的am-linux交叉工具链,版本号为4.3.2、 4.4.6、4.5.1

  • 安装Vim.Ctags

  • 安装Vim常用插件

  • 安装配置TFTP

  • 安装配置NFS网络文件系统服务

  • 安装SSH工具网络服务程序

  • 安装Kernit串口调试工具

  • 安装Sogou输入法

  • 关闭Ubuntu更新提示

    TFTP服务

-使用条件是:
需要网络连接
主机端需要安装tftp服务器软件
目标机需要实现tftp客户端
-优点：
传输速度快
可以将编译好的内核下载到目标机,提高开发效率
-ftp 是用来下载远程文件的最简单网络协议,它基于udp协议而实现。嵌入式linux的tftp开发环境包括两个方面:
一是linux开发主机端的tftp-server支持,
二是嵌入式目标系统的tftp-client支持。

主机端thtp服务器配置

开发板的bootloader自带有thtp客户端

主机端NFS服务器配置

目标机开发环境搭建

  • 下载bootloader到开发板

制作SD卡，并ASD卡启动(使用的是2010版本u-boot，支持fastboot烧写的)将sdfuse_q拷贝到inux下将SD卡插入电脑并识别，当SD卡识别不到时,用下面方法进入sdfuse_q执行如下操作：

1
sudo ./mkuboot. sh /dev/sdb /s

关闭开发板电源，将拨码开ESE(100) (SD启动模式)，刚才做好的SD启动盘插入SD卡槽打开电源。

  • 设置ip地址
1
2
3
4
5
6
# print打印系统环境变量，查看当前ip地址
setenv ipaddr 192.168.xx.xx
setenv serverip 192.168.xx.xx
 
# 保存环境变量
savenenv
  • 设置nfs服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 设置tftp方式加载内核，上电依次执行这三个命令，设置在bootloader环境变了里面的
setenv bootcmd tftp 41000000 ulmage\:tftp 42000000 exynos4412-fs4412. dtb\:bootm 41000000-42000000  
# tftp：下载文件
# bootm: 启动内核
# 41000000: 地址
# ulmage：文件名

# 设置启动参数，bootloader在启动的时候会把这个参数传给内核
# 内核解析参数，从而直到从哪里去挂载跟文件系统（根文件系统放在tftp服务器里面）
setenv bootargs root=/dev/nfs nfsroot-192.168.9.120:/nfs/rootfs rw console=ttySAC2, 115200 init=/linuxrc ip=192.168.9.9 #挂载nfs rootfs
# ttySAC2串口2的意思

# 保存环境变量
savenenv

展开全文 >>

Linux内核分析

Linux内核分析

  • 基本概念

1.从技术上说linux是一个内核。
2.“内核”指的是一个提供硬件抽象层、磁盘及文件系统控制、多任务等功能的系统软件，一个内核不是一套完整的操作系统。
3.通常我们使用的linux系统是一个集linux内核、工具集、各种库、桌面管理器、应用程序等一体的一个发布包(发行版)。

  • 内核版本

目前linux系统采用A. B.C.D的版本号管理方式
-A表示linux的主版本号

-B表示linux的次版本号, B为偶数表示稳定版本,奇数表示开发中的版本

-C表示linux的发行版本号
-D表示更新版本号
主版本(X.Y)
1.0 2.0 2.2 2.4 2.6 3. x

偶数版本代表稳定版本，奇数代表开发中的版本

  • 内核子系统

进程管理
内存管理
文件系统
网络协议
设备管理

子系统难点：内核调度算法和中断处理，linux不是实时的操作系统（本质是时间片方式），实时操作系统Vxwork（进程优先级调度或中断）。

  • 内核结构框图

linux系统分成三层：硬件层–>内核层–>应用层

  • 编译内核

所有需要用到符号文件的都要先拷到linux独有文件夹编译，windows和linux共有的共享文件夹编译因为windows不支持符号文件的原因，不会有符号文件。

1
2
make uImage # 编译内核
make dtbs # 编译设备树

添加临时环境变量示例：export PATH=/home/linux/gcc-4.6.4/bin/:$PATH

编译成功内核存放目录：arch/arm/boot/uImage

设备树：3.14之前内核没有设备树，描述外部设备的，例如：连接管脚

  • 内核目录

目录1：…/linux -3.14 -fs412/arch/arm/boot

uImage：正对u-boot的内核，增加了识别u-boot的头信息。

zImge：内核压缩的一种格式。

Image：未压缩的内核。

dts：设备树文件夹

目录2：…/linux -3.14 -fs412/drivers

watchdog、net、input、media等设备驱动文件夹。

目录3：…/linux -3.14 -fs412/kernel

内核调度等内核相关

目录4：…/linux -3.14 -fs412/net

网络相关的协议，例如：TCP/IP

通过将与驱动硬件相关的配置剥离出去，用一个设备树文件描述硬件信息：连接管脚等与硬件相关的，drivers里面只实现具体的驱动硬件的逻辑.。

推想drivers层功能: app层定义一个设备句柄，open一个设备得到一个设备实体（open是drivers提供给app层的api），设备句柄指向这个实体，以后操作设备就是操作这个设备句柄。

  • 启动分析

    系统启动信息分析：

u-boot启动过程：间前面章节

内核启动流程：

a. 自解压内核decompess(arch/arm/boot/compressed/head. s)代码位置。
b. 运行内核汇编部分head. s入口stext (arch/arm/kernel/head. S)，检测合法性(CPU类型, 机器类型，通过读cpu寄存器信息)。
c. 运行内核c部分start_kernel (init/main.c)
1.CPU,机器参数的安装 setup_arch。
2.中断,定时,终端,内存等最基本的初始化（之前bootloader也有一样的初始化，因为bootloader和内核不再同一个地址空间）。
3.创建核心进程kernel_init运行,启动多任务调度。
d. 挂载rootfs。
e. 运行第一个应用程序init (一般是linbxrc)。

  • 调试方法

1.点灯法
1dr r0 =0x11000c40 @GPK2 7 1ed2
Idr r1, [r0]
bic r1, rl, #0xo000
orr rl, r1, #0x100000000
str rl, [r0]
1dr ro,=0x11000c44
mov r1, #Oxff
str r1, [r0]

2.printk打印输出信息

puts (内核解压前)
printascii (console初始化前)
printk (内核解压后,信息输出显示是在console初始化之后)
通过proc在运行时查看和修改日志级别
cat／proc/sys/kernel/printk 显示 4417

echo “7417” >/proc/sys/kernel/printk后

cat /proc/sys/krnel/printk 显示7417
打印级别：

3.制造错误：

展开全文 >>

TCP编程基础

TCP编程

  • 函数调用流程图：

  • Socket创建函数：

1
2
3
4
5
6
7
8
9
10
11
#include <sys/types,h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
//参数:
//1. domain: AF_INET（ipv4） / AF_INETE6（ipv6） / AF_PACKET（原始套接字）
//2. type:
//SOCKSTREAM:流式套接字唯一对应于TCP
//SOCK-DGRAM: 数据报套接字,唯一对应着UDP
//SOCK_RAW: 原始套接字
//3. protocol:一般填0,前面参数AF_PACKET和SOCK_RAW需填网络协议
//4. 返回值：文件描述符，出错-1
  • 绑定函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr,
socklen t addrlen);
//参数:
//sockfd:通过socket()函数拿到的fd
//addr: struct sockaddr的结构体变量的地址
//addrlen:地址长度

//第二个参数需传入类型：
struct sockaddr
{
    sa_family_t sa_family; // 2字节
	char sa data [14]; // 14字节
}；
//第二个参数实际传入类型，填充好后需强制转换成struct sockadd：
 struct sockaddr_in 
 {
     sa_family_t    sin_family; /* 网络族ipv4/ipv6 ,  AF_INET（ipv4） / AF_INETE6（ipv6） / AF_PACKET（原始套接字）*/
     in_port_t      sin_port;   /* 端口号网络（字节序） */
     struct in_addr sin_addr;   /* 32位ip（网络字节序）， 通过int inet_pton(int af, const char *src, void *dst);得到*/
 };
//32位网络字节序ip结构体
struct in_addr 
{
    uint32_t s_addr;     /* address in network byte order */
};
  • 监听函数：
1
2
3
4
5
6
7
8
9
10
#include <sys/types.h>
#include <sys/socket.h>
int listen(int sockfd, int backlog);
//参数:
//sockfd:通过socket()函数拿到的fd
//backlog: 同时允许几路客户端和服务器进行正在连接的过程(正在三次握手)一般填5, 测试得知, ARM最大为8,

//内核中服务器的套接字fd会维护2个链表:
//1·正在三次握手的的客户端链表(数量=2*backlog+1)，正在建立连接的客户端会消耗内存用于后面创建连接，因为每建立一个连接会消耗内存所以backlog个数有限制
//2,已经建立好连接的客户端链表(已经完成3次握手分配好了newfd)
  • 阻塞等待连接函数：
1
2
3
4
5
6
7
#include <sys/types.h>
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
//参数:
//sockfd:经过前面socket ()创建并通过bind(), listen ()设置过的。
//fdaddr和addrlen：成功是返回的新连接的客户端的信息，ip地址、端口号、网络族
//返回值：成功返回新连接客户端的文件描述符fd，错误返回-1
  • TCP Sevser创建示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

#define SERV_IP_ADDR "192.168.1.100"
#define SERV_PORT 9999

int main (int argv, char **argc)
{
    int fd;
    struct sockaddr_in sin = {0};

    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(SERV_PORT); // 端口号转成网络字节序
#if 1
    sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR); // 将点斜式ip转成整形ip，内部自动转成网络字节序
#else
    if (inet_pton(AF_INET, SERV_IP_ADDR, (void *)&sin.sin_addr.s_addr) != 1) // 支持ipv4/ipv6
    {
        perror("inet_pton");
        exit(-1);
    }
#endif

    /* 绑定套接字 */
    if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)  
    {
        perror("bind");
        exit(-1);
    }

    /* 把主动套接字变成被动套接字 */
    if (listen(fd, 5) < 0)
    {
        perror("listen");
        exit(-1);
    }

    /* 阻塞等待客户端链接请求 */
    int cfd;
    struct sockaddr_in cin;
    socklen_t clen = sizeof(cin);
    
    cfd = accept(fd, (struct sockaddr *)&cin, &clen); // 得到新连接的客户端信息
    if (cfd < 0) 
    {
        perror("accept");
        exit(-1);
    }
    char ipv4_addr[16];
	if (!inet_ntop(AF_INET, (void *)&cin.sin_addr, ipv4_addr, clen))
	{
		perror("inet_ntop");
		exit(-1);
	}
	printf("new client is connectde : %s:%d\n", ipv4_addr, htons(sin.sin_port));
    
    /* 读写套接字 */
    #define BUF_SIZE 1024
    int ret = -1;
    char buf[BUF_SIZE];

    while (1) 
    {
        bzero (buf, BUF_SIZE); // 数组清零
        do 
        {
            ret = read (cfd, buf, BUF_SIZE-1);
        } while (ret < 0 && EINTR == errno); // EINTR读文件被中断，继续读文件

        if (ret < 0) 
        {
            perror ("read");
            exit (-1);
        }

        if (0 == ret) //对方已经关闭，文件读完了到文件末尾了
        { 
            break;
        }
        printf ("Receive data : %s\n", buf);
        
        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
  			printf("Client is exiting!\n");
            break;
        }

        if (write(cfd, buf, strlen(buf) + 1) < 0) //发送数据到客户端
        {
            perror ("write");
            exit (-1);
        }
    }
    
    close (cfd);
    close (fd);
 
    return 0;
}
  • 连接服务器函数
1
2
3
4
5
6
7
8
#include <sys/types.h>
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr,
socklen t addrlen);
//参数:参数、返回值和bind()函数一模一样
//sockfd:通过socket()函数拿到的fd
//addr: struct sockaddr的结构体变量的地址
//addrlen:地址长度
  • TCP Client创建示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

#define SERV_IP_ADDR "192.168.1.100"
#define SERV_PORT 9999

int main (int argv, char **argc)
{
    int fd;
    struct sockaddr_in sin = {0};

    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(SERV_PORT); // 端口号转成网络字节序
#if 1
    sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR); // 将点斜式ip转成整形ip，内部自动转成网络字节序
#else
    if (inet_pton(AF_INET, SERV_IP_ADDR, (void *)&sin.sin_addr.s_addr) != 1) // 支持ipv4/ipv6
    {
        perror("inet_pton");
        exit(-1);
    }
#endif

    /* 连接服务器 */
    if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(-1);
 	}
    printf("conect sever success\n");

    /* 读写套接字 */
    #define BUF_SIZE 1024
    int ret = -1;
    char buf[BUF_SIZE];

    while (1)
    {
        bzero (buf, BUF_SIZE); // 数组清零
        if (fgets(buf, BUF_SIZE, stdin) < 0)
        {
                continue;
        }
        write(fd, buf, strlen(buf));

        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
                printf("Client is exiting!\n");
                break;
        }
    }

    close (fd);

    return 0;
}

从上面的示例可以看出，服务器和客户端通信的时候读写的都是客户端创建的socket文件，服务器自己创建的socket文件只是由来等待被连接，连接后就用accept()返回的的客户端的socket文件通信。

运行结果：

小结：

上面的示例存在一个问题就是服务器只能连接一个客户端，连接到一个客户端后服务器就没有再阻塞等待新的客户端连接了，如果要实现一个服务端同时服务多个客户端的并发访问，需要用到io多路复用或者每个客户端服务器都创建一个线程或进程为新连接的客户端服务。

补充知识

使用ifconfig可以虚拟一个网卡并指定网卡ip地址：

  • 服务器监听任意ip加端口号

指定地址为0.0.0.0的地址，这样服务器程序的运行就不受机器网卡ip的限制。

1
sin.sin addr.s addr = htonl(INADDR_ANY); //INADDR_ANY代表任意ip地址，进程对所有网卡凡是从监听的端口号过来的数据都会收到

  • 服务器获取新连接的客户端ip地址
1
2
3
4
5
6
7
8
9
10
#include <arpa/inet. h>
const char *inet_ntop(int af, const void *src,
char *dst, socklen t size):
//特点: 1.适应于IPV4和IPV6
//参数：
//2、能正确的处理-1的转换问题
//1, af:地址协议族(AF-INET或AF INET6)
//2. src:是一个指针(32位网络字节序的IP地址)
//3. dst:输出结果为点分形式的IP地址[主要指IPV4]
//4. 成功：非空指针，失败：NULL

补充知识：

  • UDP网络编程不同于文件io单独封装的函数

发送数据函数

1
2
3
4
5
6
7
8
9
10
11
12
#include <sys/types.h>
#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, sizet len, int flag);

#include <unistd.h>
ssize t write(int fd, const void *buf, size_t count);

// send()比write多一个参数flags:
// flags:
// 一般填写0,此时和write()作用一样
// 填MSG_DONTWAIT: 非阻塞版本
// 填MSG_00B: 用于发送TCP类型的带外数据(out-of-band)，异常数据

接收数据函数

1
2
3
4
5
6
7
8
9
10
11
12
#include <sys/types.h>
#include <sys/socket.h>
ssize _t recv(int sockfd, void *buf, size t len, int flags);

#include <unistd.h>
ssize t read(int fd, void *buf, size t count);

// flags:
// 般填写0,此时和read()
// SG_DONTWAIT: 非阻塞版本
// SG_00B: 于发送TCP类型的带外数据(out-of-band)，异常数据
// MSG_PEEK: 可以成功读数据，但流的偏移量不会改变

MSG_PEEK方式读数据：常用在对一包数据进行协议长度检查，看是否已经接收到一包完整的数据，下次再调用recv（）读数据还是会读到和上次一样的数据，因为上次以MSG_PEEK方式读数据，文件描述符（流）的偏移量并没有改变。

展开全文 >>

设备LED驱动开发

设备介绍

设备驱动图示：

设备名字就是设备的名字，设备的id就是身份证的id，应用层通过名字open（）一个设备，驱动层会找到这个名字的人（设备）可以有很多同名的人（设备），然后通过身份证id（设备id）找到具体是哪个人（设备）。

假如应用层open（）一个按键文件，驱动层就open（）按键相关的函数，

应用层open（）-个串口，驱动层就open（）串口相关的函数。关键点在于我们如何给一个东西代表按键、串口在应用层（linux是通过一个文件），然后还要对按键和串口在驱动层做多态处理。

  • 字符设备驱动框架：

  • 申请设备号：

proc/devices描述所有已经注册的设备（可自定义）：

示例代码：

  • 创建设备节点


创建设备节点主要让内核创建两个结构体：struct class 和 struct device ，创建函数会返回创建好的地址，我们只需要在代码中定义指针就行。

代码中的创建就是自动创建设备文件会，在/dev/chr_cls（类）

1
2
3
4
rt_err_t rt_device_register(rt_device_t dev,    // rt_thread直接将linux里面的主设备号变成了一个具体的对象，
//因为rtos不一定有文件系统，所以省略了主设备号，open拿到设备对象的步骤
                            const char *name,
                            rt_uint16_t flags)

文件io对象

应用层通过设备文件找到具体的设备（对象），然后对它进行read、write，就是调用驱动层写好的设备对象里定义好的read、wirte

rt里面应用层open，先要通过名字找到设备对象，linux是通过设备文件找到设备对象

1
2
3
4
5
6
7
8
/**
 * This function finds a device driver by specified name.
 *
 * @param name the device driver's name
 *
 * @return the registered device driver on successful, or RT_NULL on failure.
 */
rt_device_t rt_device_find(const char *name)  // 通过设备名字找到设备对象

makefile修改

gcc最终效果

1
/home/george/Linux 4412/toolchain/qcc-4.6.4/bin/arm-none-linux-gnueabi-gcc chr test.c -o chr test

应用程序运行效果（执行了驱动程序的open、write）

驱动中要实现的read内核空间到应用空间、write用户空间到内核空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//buffer可以是malloc的全局数组和变量
//内核空间的数据可以是设备产生的，通过read给到应用空间

int copy to user(void user * to, const void * from, unsigned long n)
//将数据从丙核空间拷贝到用户空间,一般是在驱动中chr_drv-read()用
//参数1:应用驱动中的一个buffer
//参数2:内核空间到一个buffer
//参数3:个数
//返回值：大于0，出错（大于0的值表示还有多少个每个拷贝成功），等于0，正确，
    
int copy from user (void * to, const void user * from, unsigned long n)
//将数据从用卢空间拷贝到内核空间,一般是在驱动中chr_drv-write()用
//参数1:内核驱动中的一个buffer
//参数2:应用空间到一个buffer
//参数3:个数

copy_to_user()是对memcpy函数的封装，会对从用户空间传过来的buf指针进行判断，如果指针是NULL就会报错。使用copy_to_user()更安全。

返回值大于0代表还有多少个数据没有拷贝

内核控制外设的方法

MMU地址映射：通过ioremap（物理地址）返回一个内存中的虚拟地址

展开全文 >>

Linux驱动并发环境搭建

Linux驱动并发环境搭建

1.ubuntu中配置编译环境搭建

设置交叉工具链:
tar -xvf gcc-4.6.4.tar.xz-c ~/Linux 4412/toolchain
设置环境变量:
vim ~/.bashrc 最后面添加
更新脚本:
export PATH-$PATH:/home/george/Linux 4412/toolchain/qcc-4.6.4/bin
source ~/.bashrc
arm-none-linux-gnueabi-qcc -v
Using built-in specs.
COLLECT GCC=arm-none-linux-gnueabi-gco
COLLECT LTO WRAPPER=/home/george/Linux 4412/toolchain/gcc-4.6.4/bin/../libexec/qcc/arm-arm1176jzfssf-1inux-qnueabi/4.6.4/1to-wrapper

linux本地系统：通过读取emmc加载u-boot、内核、dtb、rootfs到内存

linux网络下载系统：通过网络加载u-boot、内核、dtb、rootfs到内存

tftp：tinyftp小型ftp ，下载是通过u-boot去下载，自带tftp客户端

2.运行开发

a.通过tftp去启动内核

1.将uImage和dtb文件放入到ubuntu中/tftpboot

2.在开发板中设置uboot参数,使其能够去加载内核

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 设置开发板自己的地址
set ipaddr 192.168.7.22

# 设置tftp服务器地址
set serverip 192.168.7.21

# bootcmd 是一个变量：将后面的变量内容赋值给bootcmd
# tftp：将文件下载到内存相应地址位置（动作）
# bootm：启动内核（动作）
# 0x41000000 - 0x42000000：-不是到的意思，-表示预留位置，是给ramdisk预留的
# \：连接的意思
set bootcmd tftp 0x41000000 uImage \; tftp 0x42000000 exynos4412-fs4412.dtb \; bootm 0x41000000 - 0x42000000

# 保存上面设置
save

# 查看上面设置的环境变量
pri

# 重启

重启显示的信息

b.通过nfs挂载根文件系统

1.需要一个跟文件系统目录 rootfs.tar.xz，需要解压到ubuntu

1
2
# 根文件系统解压到一个文件
sudo tar -xvf rootfs.tar.xz -C /opt/4412

2.配置nfs服务器（需要安装），让/opt/4412/rootfs可以被别的主机挂载

1
2
3
4
5
6
7
8
9
# 添加nfs共享目录
vim /etc/exports  

# 重启nfs服务器
sudo service nfs-kernel-server restart

# 自挂载nfs共享目录（测试）
sudo mount -t nfs localhost:/opt/4412/rootfs /mnt

*表示所有用户

3.在开发板中去指定要挂载 /opt/4412/rootfs，切换到开发板操作

1
2
3
4
5
6
7
8
# bootargs是uboot传递给内核到启动参数,是一个字符串
# console=xxx: 告诉内核启动时候到调试信息是从哪个设备输出
# init=xxx: 告诉内核linux到第一个用户进程是什么
# root=xxx :告诉内核根文件系统在哪里
# 	root=/dev/nfs表示根文件系统在网路远端
# 	nfsroot=ip:pathl
# ip=xxx: 告诉内核开机的时候内核的ip地址是多少（静态分配ip）
set bootargs console=ttysAC2, 115200 init=/linuxrc root=/dev/nfs rw nfsroot=192.168.7.21:/opt/4412/rootfs ip=192.168.7.22

改变文件的所有者：chown george:george drv_module/

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发