Linux on Zesean 的博客

Samba 共享：把开发板目录变成 Windows 本地磁盘

Sat, 14 Mar 2026 20:45:00 +0800

Samba 共享（⭐ 最原生的 Windows 挂载方案）

如果你希望把板子上的目录变成 Windows 电脑里的一个"本地磁盘"（比如 Z: 盘），随时可以拖拽文件，那么 Samba 是最佳选择。

1. 在 RK3588 上安装 Samba 服务：

Bash

sudo apt update
sudo apt install samba

2. 配置共享目录： 打开 Samba 配置文件：

Bash

sudo nano /etc/samba/smb.conf

在文件最末尾，添加以下内容（将你的 /home/cat 目录共享出去）：

Ini, TOML

[lubancat_home]
 path = /home/cat
 available = yes
 browseable = yes
 public = yes
 writable = yes

保存并退出（Ctrl+O 回车，Ctrl+X）。

3. 为你的用户设置 Samba 密码：

Bash

sudo smbpasswd -a cat

(输入两次你想要的密码，建议就用你板子的登录密码方便记)

4. 重启 Samba 服务：

Bash

sudo systemctl restart smbd

5. 在 Windows 上挂载：

打开 Windows 的"此电脑"（文件资源管理器）。
在顶部地址栏输入：\\192.168.137.200 并回车。
此时会弹出一个窗口让你输入账号密码，输入账号 cat 和你刚才设置的密码。
你会看到 lubancat_home 文件夹，右键点击它，选择"映射网络驱动器"，分配一个盘符（比如 Z: 盘）。搞定！

嵌入式 Linux 学习笔记（07）：I2C 应用编程

Sat, 28 Feb 2026 10:30:00 +0800

📚 本文是《嵌入式 Linux 应用开发学习笔记》系列第 07 / 7 篇：I2C 应用编程。返回系列目录。

第10章串口UART编程

第11章 I2C应用编程

11.1 I2C硬件

SCL,SDA，一条I2C总线可接很多设备，SCL,SDA放上拉电阻

11.2 传输数据类比

如何通过IIC传数据，

主设备：一主多从，可把数据从主设备发到从设备，也可从设备发到主设备

发送

主设备：开始(start)

主设备：A，我把数据发你(地址/方向)

A：收到(回应)

主设备：发送数据(传输)

A：收到后，告诉主设备(回应)

主设备：结束(停止)

接收

主设备：开始(start)

主设备：B，把数据发我(地址/方向)

B：收到(回应)

B：把数据发给主设备(传输)

主设备：收到数据后，告诉A(回应)

主设备：结束(停止)

11.3 IIC传输数据格式

11.3.1写操作

主设备发出start信号
发出设备地址，方向(读1/写0)
从设备发出应答信号
主设备发送一字节数据，等待回应
每传输一字节，接收方回应一次，在传输下一个数据
数据发送完成，主设备发送stop信号

11.3.2读操作

11.3.3 IIC信号

IIC协议栈数据传输单位是字节，但是要用到9个时钟，前面8个时钟用来传输8数据，第9个始终用来传输回应信号，先传输最高位

开始信号(S)：SCL为高时，SDA由高跳低，开始传输数据
结束信号(P)：SCL为高时，SDA由低跳高，结束传输数据
响应信号(ACK)：接收到8位数据，第九个时钟周期，拉低SDA
SDA数据必须在SCL高时稳定，只能在SCL为低时变化

11.3.4 协议细节

1.SDA引脚必须双向IO，因为有发有收

11.4 SMBus协议

11.4.1 SMBus是IIC协议子集

SMBus: System Management Bus，系统管理总线

11.5无需编写驱动直接访问设备(I2C-Tools)

通过I2Ctool的程序，使用自带的驱动程序，来操作内核的i2c操作程序来访问硬件

首先确定：使用哪个IIC控制器，使用哪个IIC设备，读还是写数据

11.5.1用法

i2cdetect：I2C检测

// 列出当前的I2C Adapter(或称为I2C Bus、I2C Controller)
i2cdetect -l

// 打印某个I2C Adapter的Functionalities, I2CBUS为0、1、2等整数
i2cdetect -F I2CBUS

// 看看有哪些I2C设备, I2CBUS为0、1、2等整数
i2cdetect -y -a I2CBUS

11.5.2操作传感器AP3216C

AP3216C是红外、光强、距离三合一的传感器，以读出光强、距离值为例

复位：往寄存器0写入0x4
使能：往寄存器0写入0x3
读光强：读寄存器0xC、0xD得到2字节的光强
读距离：读寄存器0xE、0xF得到2字节的距离值

使用SMBus协议

//i2cset查看用法
i2cset
//写数据
i2cset -f -y 0（0号线） 0x1e（芯片地址） 0（写入地址） 0x4
i2cset -f -y 0 0x1e 0 0x3
//读数据
i2cget -f -y 0 0x1e 0xc w 	//0xc光照
i2cget -f -y 0 0x1e 0xe w	//0xe距离

使用I2C协议

i2ctransfer -f -y 0 w2@0x1e 0 0x4
i2ctransfer -f -y 0 w2@0x1e 0 0x3
i2ctransfer -f -y 0 w1@0x1e 0xc r2
i2ctransfer -f -y 0 w1@0x1e 0xe r2

11.5.3 I2CTools访问I2C设备的方式

APP通过I2C Controller与I2C Device传输数据

指定i2c控制器：

i2c-dev.c提供为每个I2C控制器(I2C Bus、I2C Adapter)都生成一个设备节点：/dev/i2c-0、/dev/i2c-1等待
open某个/dev/i2c-X节点，就是去访问该I2C控制器下的设备

指定i2c设备：

ioctl(file, I2C_SLAVE, address)
- 如果该设备已经有了对应的设备驱动程序，则返回失败
ioctl(file, I2C_SLAVE_FORCE, address)
- 如果该设备已经有了对应的设备驱动程序
- 但是还是想通过i2c-dev驱动来访问它
- 则使用这个ioctl来指定I2C设备地址

传输方式：I2C或SMBus

11.6编写APP直接访问EEPRPM

I2C控制器地址0x50

I2C设备地址0x50

从芯片手册上可以知道，AT24C02的设备地址跟它的A2、A1、A0引脚有关：

高4位为1010，A2A1A0都是0，所以AT24C02的设备地址是：0b1010000，即0x50

11.6.1写数据

11.6.2读数据

嵌入式 Linux 学习笔记（06）：输入系统、网络编程与多线程

Sat, 07 Feb 2026 10:30:00 +0800

📚 本文是《嵌入式 Linux 应用开发学习笔记》系列第 06 / 7 篇：输入系统、网络编程与多线程。返回系列目录。

第7章输入系统应用编程（未完成）

7.1输入设备

键盘、鼠标、遥控杆、书写板、触摸屏等与linux完成数据交换

输入设备种类繁多，能否统一它们的接口？

Linux 为了统一管理输入设备，实现了一套能兼容所有输入设备的框架：输入系统

7.2输入系统框架及调试

输入系统框架

示例：

在开发板上执行，可以看到触摸屏数据

hexdump /dev/input/event1

hexdump: 是一个命令行工具，它将文件或数据流的内容以十六进制和 ASCII 格式输出

/dev/input/event1: 是一个特殊的设备文件，代表一个输入设备，比如键盘、鼠标或触摸板。Linux 内核会把来自这些设备的原始输入事件（例如按键、鼠标移动或点击）写入这些文件

7.2.2编写APP需要掌握的知识

驱动程序上报的数据含义三项重要内容：

1.type：哪类，如EV_KEY为按键类

2.code：哪个，比如KEY_A

3.value：值，比如0按下，1松开

此外APP 读取数据时，可以得到一个或多个数据，比如一个触摸屏的一个触点会上报 X、Y 位置信息，也可能会上报压力值
驱动程序上报完一系列的数据后，会上报一个“同步事件”，表示数据上报完毕。APP 读到“同步事件”时，就知道已经读完了当前的数据
同步事件也是一个 input_event 结构体，它的 type、code、value 三项都是 0

7.2.3调试技巧

确定设备信息

ls /dev/input/* -l

可以看到设备

确定设备对应的硬件

cat /proc/bus/input/devices

7.3不用库的应用编程

APP访问硬件有4种方式：查询方式、休眠-唤醒、poll方式、异步通知

通过 ioctl 获取设备信息：

int ioctl(int fd, unsigned long request, ...);

比如要读取输入设备的 evbit 时，ioctl 的 request 要写为“EVIOCGBIT(0, size)

7.3.1查询、休眠唤醒方式

if (argc < 2)
	{
		printf("Usage: %s <dev> [noblock]\n", argv[0]);
		return -1;
	}

	if (argc == 3 && !strcmp(argv[2], "noblock"))
	{
		fd = open(argv[1], O_RDWR | O_NONBLOCK);
	}
	else
	{
		fd = open(argv[1], O_RDWR);
	}
while (1)
	{
		len = read(fd, &event, sizeof(event));
		if (len == sizeof(event))
		{
			printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
		}
		else
		{
			printf("read err %d\n", len);
		}
	}

7.3.2poll/select方式

POLL 机制、SELECT 机制是完全一样的，只是 APP 接口函数不一样

第8章网络通信

8.1网络通信概述

实际还是数据传输

数据传输三要素：源、目的、长度。

现在假设A、B两台计算机通讯，一台为服务器，一台为客户端。

访问网站的话，设计网站服务器、浏览器，网站服务器平时安静地呆着，浏览器主动发起数据请求

服务器：被动地响应请求

客户端：主动地发起请求

数据传输两种方式：TCP、UDP。

TCP：可靠的、有重传机制（确保数据真到达）、适合控制命令

UDP：不可靠的（适合视频、语音等），视频通话时，使用 UDP，偶尔的丢包、偶尔的花屏时可以忍受的

怎么写程序？

仿照文件读写

将fd=open(”文件名“);

read(fd,buf,len);//源、目的、长度

8.1.1IP和端口

数据传输：源、目的、长度

源端口区分不同浏览器，目的端口区分想要服务

8.1.3两种传输方式TCP/UDP

网络协议5层：物理层、数据链路层、网络层、传输层、应用层

应用层：直接为用户进程提供服务，如支持www的HTTP协议、电子邮箱SMTP协议、文件传输FTP协议，DNS、POP3、FNMP、Telnet

传输层：负责向两个主机中进程之间的通信提供服务，主要TCP、UDP

8.2TCP网络编程

服务端

socket函数

int socket(int domain, int type,int protocol);

用于创建套接字，根本不涉及什么源、目的、长度，

bind函数

fd = socket(.....);
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

从函数用于将地址绑定到一个套接字（自己的IP端口）

把fd和ip端口绑定，以后就检测这个ip端口看看数据有没有

listen函数

int listen(int sockfd,int backlog);

启动检测数据

accept函数

int accept(int sockfd, struct sockaddr *addr,int *addrlen);

建立一条连接，接收连接

send函数

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

发数据

recv函数

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

收数据

客户端

socket函数

fd=socket(......)

connect函数

int connect(int sockfd, struct sockaddr * serv_addr,int addrlen);

建立连接

recv
send

8.3UDP网络编程

服务端

socket函数

int socket(int domain, int type,int protocol);

用于创建套接字，根本不涉及什么源、目的、长度，

bind函数

fd = socket(.....);
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

从函数用于将地址绑定到一个套接字（自己的IP端口）

recvfrom

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
				 struct sockaddr *src_addr, socklen_t *addrlen);

recvfrom 通常用于无连接套接字，因为此函数可以获得发送者的地址。

src_addr 是一个 struct sockaddr 类型的变量，该变量保存源机的 IP 地

址及端口号。

addrlen 常置为 sizeof （struct sockaddr）。

sendto

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
 			 const struct sockaddr *dest_addr, socklen_t addrlen);

客户端

socket函数

fd=socket(......)

connect函数

int connect(int sockfd, struct sockaddr * serv_addr,int addrlen);

建立连接

recvfrom,recv
sendto,send

第9章多线程编程

9.1线程的使用

9.1.1为什么使用多线程

编写代码时有时候要做2件事，如一边屏幕播放视频，一边等待用户按键操作

如果使用多线程，线程1单独处理按键，线程2单独处理播放

9.1.2线程概念

操作系统所能调度的最小单位，普通的进程，只有一个线程执行逻辑。

我们可以通过多线程编程，使一个进程可以去执行多个不同的任务

相比多进程编程，线程享有共享资源，在进程中出现的全局变量，每个线程都可以访问

9.1.3线程的标识pthread_t

对进程：每个进程有唯一PID

对线程：有tid，本质是pthread_t类型的变量

测试例程

#include <pthread.h>
#include <stdio.h>
int main()
{
	pthread_t tid = pthread_self();//获取主线程的 tid 号
	printf("tid = %lu\n",(unsigned long)tid);
	return 0;
}

gcc xxx.c -lpthread 方可编译多线程程序

9.1.4线程的创建

pthread_create

int pthread_create( pthread_t *thread, 
					const pthread_attr_t *attr,
					void *(*start_routine) (void *), 
					void *arg);

例程

 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


#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
static void *my_thread_func(void *data)
{
 while (1)
 {
 sleep(1);
 }
 
}
int main(int argc, char const *argv[])
{
 pthread_t tid;
 int ret;
 /*1.创建接收线程*/
 ret = pthread_create(&tid,NULL,my_thread_func,NULL);
 if(ret)
 {
 printf("pthread_create err\n");
 return -1;
 }
 /*2.主线程读取标准输入，发送给接受线程*/
 while(1)
 {
 sleep(1);
 }
 return 0;
}

9.1.5同步操作-向线程传数据(等待)

 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


#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

static char g_buf[1000];
static int g_hasData = 0;

static void *my_thread_func(void *data)
{
 while (1)
 {
 /*等待通知*/
 while(g_hasData == 0);
 /*打印*/
 printf("recv: %s",g_buf);
 g_hasData = 0;
 }
 
}

int main(int argc, char const *argv[])
{
 pthread_t tid;
 int ret;
 /*1.创建接收线程*/
 ret = pthread_create(&tid,NULL,my_thread_func,NULL);
 if(ret)
 {
 printf("pthread_create err\n");
 return -1;
 }
 /*2.主线程读取标准输入，发送给接受线程*/
 while(1)
 {
 fgets(g_buf,1000,stdin);
 /*通知接受线程*/
 g_hasData = 1;
 }
 return 0;
}

9.1.6同步操作(信号量)

// 初始化
#include <semaphore.h>
static sem_t sem;
int sem_init(sem_t *sem,int pshared,unsigned int value);
等待/释放：
#include <pthread.h>
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);

 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


#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>

static char g_buf[1000];
static sem_t g_sem;

static void *my_thread_func(void *data)
{
 while (1)
 {
 /*等待通知*/
 sem_wait(&g_sem);
 /*打印*/
 printf("recv: %s",g_buf);
 }
}
int main(int argc, char const *argv[])
{
 
 pthread_t tid;
 int ret;
 /*初始化信号量*/
 sem_init(&g_sem,0,0);
 /*1.创建接收线程*/
 ret = pthread_create(&tid,NULL,my_thread_func,NULL);
 if(ret)
 {
 printf("pthread_create err\n");
 return -1;
 }
 /*2.主线程读取标准输入，发送给接受线程*/
 while(1)
 {
 fgets(g_buf,1000,stdin);
 /*通知接受线程*/
 sem_post(&g_sem);
 }
 return 0;
}

9.1.7同步操作(互斥量)

static pthread_mutex_t g_tMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&g_tMutex);
pthread_mutex_unlock(&g_tMutex);

给不希望打断的内容加锁

 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


#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>

static char g_buf[1000];
static sem_t g_sem;
static pthread_mutex_t g_tMutex = PTHREAD_MUTEX_INITIALIZER;

static void *my_thread_func(void *data)
{
 while (1)
 {
 /*等待通知*/
 sem_wait(&g_sem);
 /*打印*/
 pthread_mutex_lock(&g_tMutex);
 printf("recv: %s",g_buf);
 pthread_mutex_unlock(&g_tMutex);
 }
}

int main(int argc, char const *argv[])
{
 
 pthread_t tid;
 int ret;
 char buf[1000];
 /*初始化信号量*/
 sem_init(&g_sem,0,0);
 /*1.创建接收线程*/
 ret = pthread_create(&tid,NULL,my_thread_func,NULL);
 if(ret)
 {
 printf("pthread_create err\n");
 return -1;
 }
 /*2.主线程读取标准输入，发送给接受线程*/
 while(1)
 {
 fgets(buf,1000,stdin);
 pthread_mutex_lock(&g_tMutex);
 memcpy(g_buf,buf,1000);
 pthread_mutex_unlock(&g_tMutex);
 /*通知接受线程*/
 sem_post(&g_sem);
 }
 return 0;
}

嵌入式 Linux 学习笔记（05）：Framebuffer 与文字显示

Sat, 24 Jan 2026 10:30:00 +0800

📚 本文是《嵌入式 Linux 应用开发学习笔记》系列第 05 / 7 篇：Framebuffer 与文字显示。返回系列目录。

第5章、Framebuffer应用编程

5.1LCD操作原理

Framebuffer是Linux/Unix 下“最直接”的图形输出接口，可以通过Framebuffer驱动程序来控制LCD，Frame是帧，buffer是缓冲，意思是Framebuffer是一块内存，里面保存一帧图像的每一个像素值。

假设LCD分辨率1024*768，颜色32位，那

Framebuffer大小1024*768*32/8=3145728 字节

LCD操作原理：

驱动程序设置好 LCD 控制器

根据 LCD 的参数设置 LCD 控制器的时序、信号极性；

根据 LCD 分辨率、BPP 分配 Framebuffer
APP 使用 ioctl 获得 LCD 分辨率、BPP
APP 通过 mmap 映射 Framebuffer，在 Framebuffer 中写入数据

每一块数据与LCD每一个像素一一对应
bpp：bits per pixel 每个像素用多少位表示颜色

假设需要设置 LCD 中坐标(x,y)处像素的颜色

(x，y)像素起始地址=fb_base+(xres*bpp/8)*y + x*bpp/8

怎么显示颜色？

5.2 涉及的API函数

流程：打开 LCD 设备节点，获取分辨率等参数，映射Framebuffer，最后实现描点函数

5.2.2 ioctl函数

ioctl 是 Unix/Linux 里最“万能”的系统调用——“I/O 控制” 万金油，几乎任何驱动都能通过它暴露“命令 + 数据”接口

#include <sys/ioctl.h>

int ioctl(int fd, unsigned long request, …);

fd 表示文件描述符
request 表示与驱动程序交互的命令，用不同的命令控制驱动程序输出我们需要的数据
… 表示可变参数 arg，根据 request 命令，设备驱动程序返回输出的数据
返回值，成功返回文件描述符，失败返回-1

5.2.3 mmap 函数

头文件：

#include <sys/mman.h>

函数原型：

void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);

参数：

addr 表示指定映射的內存起始地址，通常设为 NULL 表示让系统自动选定地址，并在成功映射后返回该地址
length 表示将文件中多大的内容映射到内存中
prot 表示映射区域的保护方式，可以为以下 4 种方式的组合

◼ PROT_EXEC 映射区域可被执行

◼ PROT_READ 映射区域可被读出

◼ PROT_WRITE 映射区域可被写入

◼ PROT_NONE 映射区域不能存取
Flags 表示影响映射区域的不同特性，常用的有以下两种

◼ MAP_SHARED 表示对映射区域写入的数据会复制回文件内，原来的文

件会改变。

◼ MAP_PRIVATE 表示对映射区域的操作会产生一个映射文件的复制，对此区域的任何修改都不会写回原来的文件内容中。

返回值：若成功映射，将返回指向映射的区域的指针，失败将返回-1。

5.3程序

 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


#include <sys/types.h>			//open()
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>				//close()

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

#include <sys/ioctl.h>			//ioctl()

#include <sys/mman.h>			//mmap()

#include <linux/fb.h>			

static int fd_fb;
static struct fb_var_screeninfo var;	/* Current var */
static int screen_size;
static unsigned char *fb_base;
static unsigned int line_width;
static unsigned int pixel_width;

void lcd_put_pixel(int x, int y, unsigned int color);

int main(int argc, char **argv)
{
	int i;
	fd_fb = open("/dev/fb0",O_RDWR);
	
	if(fd_fb < 0)
	{
		printf("can't open /dev/fb0\n");
		return -1;
	}

	if(ioctl(fd_fb, FBIOGET_VSCREENINFO, &var)<0)
	{
		printf("can't get var\n");
		close(fd_fb);
		return -1;
	}
	
	line_width	= var.xres * var.bits_per_pixel / 8;
	pixel_width = var.bits_per_pixel / 8;
	screen_size = var.xres * var.yres * var.bits_per_pixel / 8;
	fb_base = (unsigned char *)mmap(NULL , screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_fb, 0);

	if(fb_base == (unsigned char *)-1)
	{
		printf("can't mmap\n");
		return -1;
	}

	/* 清屏: 全部设为白色 */
	memset(fb_base, 0xff, screen_size);

	for (i = 0; i < 100; i++)
		lcd_put_pixel(var.xres/2+i, var.yres/2, 0xFF0000);

	munmap(fb_base , screen_size);

	close(fd_fb);

	return 0;
	
}

void lcd_put_pixel(int x, int y, unsigned int color)
{
	unsigned char *pen_8 = fb_base+y*line_width+x*pixel_width;
	unsigned short *pen_16;	
	unsigned int *pen_32;	

	unsigned int red, green, blue;	

	pen_16 = (unsigned short *)pen_8;
	pen_32 = (unsigned int *)pen_8;

	switch (var.bits_per_pixel)
	{
		case 8:
		{
			*pen_8 = color;
			break;
		}
		case 16:
		{
			/* 565 */
			red = (color >> 16) & 0xff;
			green = (color >> 8) & 0xff;
			blue = (color >> 0) & 0xff;
			color = ((red >> 3) << 11) | ((green >> 2) << 5) | (blue >> 3);
			*pen_16 = color;
			break;
		}
		case 32:
		{
			*pen_32 = color;
			break;
		}
		default:
		{
			printf("can't surport %dbpp\n", var.bits_per_pixel);
			break;
		}
	}
}

5.4上机

arm-buildroot-linux-gnueabihf-gcc -o show_pixel show_pixel.c

adb上传后执行

第6章文字显示

6.1字符编码方式

6.1.1编码与字体

1.ASCII

常用字母就 26 个，区分大小写、加上标点符号也没超过 127 个，每个字符用一个字节来表示就足够了。一个字节的 7 位就可以表示 128 个数值，在 ASCII 码中最高位永远是 0

2.ANSI

强烈建议阅读：https://www.cnblogs.com/malecrab/p/5300486.html

如在中国大陆地区，ANSI 的默认编码是 GB2312；在港澳台地区默认编码是 BIG5

不同文字系统ANSI表示不同编码

3.UniCode

UNICODE 中的数值范围是 0x0000 至 0x10FFFF，有 1,114,111 即 100 多万个数值，可以表示 100 多万个字符，足够地球人使用了。

向下兼容ascii

6.1.2UniCode编码实现

“中” UNICODE 值是 0x4e2d，在 TXT 文件中怎么表示 0x4e2d？直接写入 0x4e2d？

不行！

比如在 TXT 文件中写入 2 字节数据“0x2d 0x4e”，它可以用来表示“中”字吗？

不能！它们对应 ASCII 字符“-N”。

问题的关键在于：怎么断字

那怎么表示一个unicode

1.使用3个字节

太浪费，比如字符 A 的 UNICOCDE 值是0x41，难道也用“0x41 0x00 0x00”这 3 个字节来表示？

2.UCS-2 Little endian/UTF-16 LE

能表示2^16=65536 个字符

Little endian 表示小字节序，数值中权重低的字节放在前面，比如字符“A 中”在 TXT 文件中的数值如下，其中的“A”使用“0x41 0x00”两字节表示；“中”使用“0x2d 0x4e”两字节表示。文件开头的“0xff 0xfe”表示“UTF-16 LE”。

3.UCS-2 Big endian/UTF-16 BE

与2相反

4.UTF8

上面两种方法：表示字符数量有限、对于ASCII字符浪费空间、如果某字节丢失后面字符都因为错位无法显示

使用UTF8可以解决上述所有问题。UTF8 是变长的编码方法，有 2 种 UTF8格式的文件：带有头部、不带头部。

对ascii字符在 UTF8 文件中直接用其 ASCII 码来表示，0x61 表示字符 a、0x62 表示字符 b

而3 个字节“0xe4 0xb8 0xad”表示的数值是 0x4e2d，对应“中”的 UNICODE 码

0xe4 的二进制是“11100100”，高位有 3 个 1，表示从当前字节起有3字节参与表示UNICODE；
0xb8 的二进制是“10111000”，高位有 1 个 1，表示从当前字节起有1字节参与表示UNICODE；
0xad 的二进制是“10101101”，高位有 1 个 1，表示从当前字节起有1字节参与表示 UNICODE
除去高位的“1110”、“10”、“10”后，剩下的二进制数组合起来得到“01001110001101”，它就是 0x4e2d，即“中”的 UNICODE 值

6.2 ASCII点阵显示

LCD中显示ASCII字符，首先要找到字符对应的点阵，在linux内核源码有这个文件

lib\fonts\font_8x16.c以数组形式保存字符点阵。

储存形式：

要显示某个字符时，根据它的 ASCII 码在 fontdata_8x16 数组中找到它的点阵，然后取出这 16 个字节去描画 16 行像素.

比如字符 A 的 ASCII 值是 0x41，那么从 fontdata_8x16[0x41*16]开始取其点阵数据

6.2.1获取点阵

对于字符c

unsigned char *dots = (unsigned char *)&fontdata_8x16[c*16];

6.2.2描点

因为有十六行，所以首先要有一个循环 16 次的大循环，然后每一行里有 8位，那么在每一个大循环里也需要一个循环 8 次的小循环。小循环里的判断单行的描点情况，如果是 1，就填充白色，如果是 0 就填充黑色。

 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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145


#include <sys/types.h>			//open()
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>				//close()

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

#include <sys/ioctl.h>			//ioctl()

#include <sys/mman.h>			//mmap()

#include <linux/fb.h>

#define FONTDATAMAX 4096

static const unsigned char fontdata_8x16[FONTDATAMAX] = {
	//...略
};

int fd_fb;
struct fb_var_screeninfo var;	/* Current var */
int screen_size;
unsigned char *fbmem;
unsigned int line_width;
unsigned int pixel_width;
/**********************************************************************
 * 函数名称： lcd_put_pixel
 * 功能描述： 在LCD指定位置上输出指定颜色（描点）
 * 输入参数： x坐标，y坐标，颜色
 * 输出参数： 无
 * 返 回 值： 会
 * 修改日期 版本号 修改人	 修改内容
 * -----------------------------------------------
 * 2020/05/12	 V1.0	 zh(angenao)	 创建
 ***********************************************************************/ 
void lcd_put_pixel(int x, int y, unsigned int color)
{
	unsigned char *pen_8 = fbmem+y*line_width+x*pixel_width;
	unsigned short *pen_16;	
	unsigned int *pen_32;	

	unsigned int red, green, blue;	

	pen_16 = (unsigned short *)pen_8;
	pen_32 = (unsigned int *)pen_8;

	switch (var.bits_per_pixel)
	{
		case 8:
		{
			*pen_8 = color;
			break;
		}
		case 16:
		{
			/* 565 */
			red = (color >> 16) & 0xff;
			green = (color >> 8) & 0xff;
			blue = (color >> 0) & 0xff;
			color = ((red >> 3) << 11) | ((green >> 2) << 5) | (blue >> 3);
			*pen_16 = color;
			break;
		}
		case 32:
		{
			*pen_32 = color;
			break;
		}
		default:
		{
			printf("can't surport %dbpp\n", var.bits_per_pixel);
			break;
		}
	}
}
/**********************************************************************
 * 函数名称： lcd_put_ascii
 * 功能描述： 在LCD指定位置上显示一个8*16的字符
 * 输入参数： x坐标，y坐标，ascii码
 * 输出参数： 无
 * 返 回 值： 无
 * 修改日期 版本号 修改人	 修改内容
 * -----------------------------------------------
 * 2020/05/12	 V1.0	 zh(angenao)	 创建
 ***********************************************************************/ 
void lcd_put_ascii(int x, int y, unsigned char c)
{
	unsigned char *dots = (unsigned char *)&fontdata_8x16[c*16];
	int i, b;
	unsigned char byte;

	for (i = 0; i < 16; i++)
	{
		byte = dots[i];
		for (b = 7; b >= 0; b--)
		{
			if (byte & (1<<b))
			{
				/* show */
				lcd_put_pixel(x+7-b, y+i, 0xffffff); /* 白 */
			}
			else
			{
				/* hide */
				lcd_put_pixel(x+7-b, y+i, 0); /* 黑 */
			}
		}
	}
}

int main(int argc, char **argv)
{
	fd_fb = open("/dev/fb0", O_RDWR);
	if (fd_fb < 0)
	{
		printf("can't open /dev/fb0\n");
		return -1;
	}
	if (ioctl(fd_fb, FBIOGET_VSCREENINFO, &var))
	{
		printf("can't get var\n");
		return -1;
	}

	line_width = var.xres * var.bits_per_pixel / 8;
	pixel_width = var.bits_per_pixel / 8;
	screen_size = var.xres * var.yres * var.bits_per_pixel / 8;
	fbmem = (unsigned char *)mmap(NULL , screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_fb, 0);
	if (fbmem == (unsigned char *)-1)
	{
		printf("can't mmap\n");
		return -1;
	}

	/* 清屏: 全部设为黑色 */
	memset(fbmem, 0, screen_size);

	lcd_put_ascii(var.xres/2, var.yres/2, 'A'); /*在屏幕中间显示8*16的字母A*/
	
	munmap(fbmem , screen_size);
	close(fd_fb);
	
	return 0;	
}

6.2.3show_string

1
2
3
4
5
6
7
8


void lcd_put_string(int x, int y, unsigned char * str)
{
	while (*str) {
 lcd_put_ascii(x, y, *str); /* 每字符宽 8 像素 */
 x += 8; /* 横排前进 8 像素 */
 ++str;
 }
}

6.3中文字符的点阵显示

6.3.1指定编码格式

test_charset_ansi.c

test_charset_utf8.c

可以对test_charset_ansi.c将原文件的GB2312格式，输出为可执行文件时以UTF8格式编码

gcc -finput-charset=GB2312 -fexec-charset=UTF-8 -o test_charset_ansi test_charset_ansi.c

如果不指定“-finput-charset”，GCC 就会默认 C 程序的编码方式为 UTF-8，即使你是以 ANSI 格式保存，也会被当作 UTF-8 来对待

如果不指定“-fexec-charset”，GCC 就会默认编译出的可执行程序中字符的编码方式为 UTF-8

如果“-finput-charset”与“-fexec-charset”不一样，编译器会进行格式转换

6.3.3汉字区位码

HZK16 这个文件，它是常用汉字的 16*16 点阵字库

每个汉字用32字节描述

HZK16 中是以 GB2312 编码值来查找点阵以“中”字为例，它的编码值是“0xd6 0xd0”，其中的 0xd6 表示“区码”，表示在哪一个区：第“0xd6 - 0xa1”区；其中的 0xd0 表示“位码”，表示它是这个区里的哪一个字符：第“0xd0 -0xa1”个。每一个区有 94 个汉字。区位码从 0xa1 而不是从 0 开始，是为了兼容 ASCII 码

中字：第(0xd6-0xa1)*94+(0xd0-0xa1)个字符

6.4交叉编译程序：以freetype为例

使用 buildroot 来给 ARM 板编译程序、编译库会很简单，以后系统讲解buildroot 时再使用 buildroot

现在我们还是手工交叉编译 freetype

6.4.1程序运行的基本知识

1.编译程序时去哪找头文件

系统目录：交叉编译工具链的某include目录

自己指定：编译时-I dir

2.链接时去哪找库文件

系统目录：就是交叉编译工具链里的某个 lib 目录

自己指定：链接时用 “ -L dir ”

3.运行时去哪找库文件

系统目录：就是板子上的/lib、/usr/lib 目录

自己指定：运行程序用环境变量 LD_LIBRARY_PATH 指定

4.运行时不需要头文件，因此头文件不需要放板子上

6.4.2常见错误

1.头文件

编译时找不到头文件。在程序中这样包含头文件：#include <xxx.h>

怎么找到头文件

系统目录：交叉编译工具链的某个include目录

怎么找到系统目录？

echo 'main(){}'| arm-buildroot-linux-gnueabihf-gcc -E -v -

2.库文件

链接程序时如果有这样的提示：undefined reference to `xxx’，它表示 xxx 函数未定义

解决方法：写出这个函数，或使用库函数，即在链接时指定库

怎么指定：

想链接 libabc.so，那链接时加上：-labc

库在哪：

系统目录：就是交叉编译工具链里的某个 lib 目录
以自己指定：链接时用 “ -L dir ”选项指定

3.运行问题

运行时找不到库，库在哪？

系统目录：就是板子上的/lib、/usr/lib 目录

自己指定：

export LD_LIBRARY_PATH=/xxx_dir; ./test

或

LD_LIBRARY_PATH=/xxx_dir ./test

6.4.3交叉编译万能命令

如果交叉编辑工具链的前缀是arm-buildroot-linux-gnueabihf-

交叉编译开源软件时，如果有configure文件

万能命令如下：

./configure --host=arm-buildroot-linux-gnueabihf --prefix=$PWD/tmp
make
make install

就可以在当前目录的 tmp 目录下看见 bin, lib, include 等目录，里面存有可执行程序、库、头文件

cp include/freetype2/* -rfd /home/book/100ask_imx6ull-sdk/ToolChain/arm-buildroot-linux-gnueabihf_sdk-buildroot/bin/../lib/gcc/arm-buildroot-linux-gnueabihf/7.5.0/include

cp lib/* -rfd /home/book/100ask_imx6ull-sdk/ToolChain/arm-buildroot-linux-gnueabihf_sdk-buildroot/bin/../lib/gcc/arm-buildroot-linux-gnueabihf/7.5.0/../../../../arm-buildroot-linux-gnueabihf/lib

6.5使用freetype显示单个文字

6.5.1矢量字体引入

使用点阵字库显示放大缩小会模糊甚至锯齿，为解决引入矢量字体

矢量字体分三步：

确定关键点
使用数学曲线连接头键点
填充闭合曲线内部空间

6.5.2在 LCD 上显示一个矢量字体

开源字体引擎库，统一接口访问多种字体格式文件，实现矢量字体显示。

一个文字的显示过程可以概括如下：

给定一个字符可以确定它的编码值(ASCII、UNICODE、GB2312)；
设置字体大小；
根据编码值，从文件头部中通过 charmap 找到对应的关键点(glyph)，它会根据字体大小调整关键点；
把关键点转换为位图点阵；
在 LCD 上显示出来

freetype初始化步骤如下：

初始化：FT_InitFreetype
加载(打开)字体 Face：FT_New_Face
设置字体大小：FT_Set_Char_Sizes 或 FT_Set_Pixel_Sizes
选择 charmap：FT_Select_Charmap
根据编码值 charcode 找到 glyph_index：glyph_index = FT_Get_Char_Index（face，charcode）
根据 glyph_index 取出 glyph：FT_Load_Glyph（face，glyph_index）
转为位图：FT_Render_Glyph
移动或旋转:FT_Set_Transform
最后显示出来

上面的5、6、7可以使用一个函数代替：FT_Load_Char(face, charcode, FT_LOAD_RENDER)，它就可以得到位图

 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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159


#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <linux/fb.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <wchar.h>
#include <sys/ioctl.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H

int fd_fb;
struct fb_var_screeninfo var;	/* Current var */
int screen_size;
unsigned char *fbmem;
unsigned int line_width;
unsigned int pixel_width;

void lcd_put_pixel(int x, int y, unsigned int color)
{
	unsigned char *pen_8 = fbmem+y*line_width+x*pixel_width;
	unsigned short *pen_16;	
	unsigned int *pen_32;	

	unsigned int red, green, blue;	

	pen_16 = (unsigned short *)pen_8;
	pen_32 = (unsigned int *)pen_8;

	switch (var.bits_per_pixel)
	{
		case 8:
		{
			*pen_8 = color;
			break;
		}
		case 16:
		{
			/* 565 */
			red = (color >> 16) & 0xff;
			green = (color >> 8) & 0xff;
			blue = (color >> 0) & 0xff;
			color = ((red >> 3) << 11) | ((green >> 2) << 5) | (blue >> 3);
			*pen_16 = color;
			break;
		}
		case 32:
		{
			*pen_32 = color;
			break;
		}
		default:
		{
			printf("can't surport %dbpp\n", var.bits_per_pixel);
			break;
		}
	}
}

void draw_bitmap(FT_Bitmap* bitmap,FT_Int x,FT_Int y)
{
	FT_Int i, j, p, q;
	FT_Int x_max = x + bitmap->width;
	FT_Int y_max = y + bitmap->rows;

	//printf("x = %d, y = %d\n", x, y);

	for ( j = y, q = 0; j < y_max; j++, q++ )
	{
		for ( i = x, p = 0; i < x_max; i++, p++ )
		{
			if ( i < 0 || j < 0 ||i >= var.xres || j >= var.yres )
			continue;
			lcd_put_pixel(i, j, bitmap->buffer[q * bitmap->width + p]);
		}
	}
}


int main(int argc, char **argv)
{
	wchar_t *chinese_str = L"繁";

	FT_Library	 library;
	FT_Face 	 face;
	int error;
 FT_Vector pen;
	FT_GlyphSlot slot;
	int font_size = 24;

	if (argc < 2)
	{
		printf("Usage : %s <font_file> [font_size]\n", argv[0]);
		return -1;
	}

	if (argc == 3)
		font_size = strtoul(argv[2], NULL, 0);
		
	fd_fb = open("/dev/fb0", O_RDWR);
	if (fd_fb < 0)
	{
		printf("can't open /dev/fb0\n");
		return -1;
	}

	if (ioctl(fd_fb, FBIOGET_VSCREENINFO, &var))
	{
		printf("can't get var\n");
		return -1;
	}

	line_width = var.xres * var.bits_per_pixel / 8;
	pixel_width = var.bits_per_pixel / 8;
	screen_size = var.xres * var.yres * var.bits_per_pixel / 8;
	fbmem = (unsigned char *)mmap(NULL , screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_fb, 0);
	if (fbmem == (unsigned char *)-1)
	{
		printf("can't mmap\n");
		return -1;
	}

	/* 清屏: 全部设为黑色 */
	memset(fbmem, 0, screen_size);

	/* 显示矢量字体 */
	error = FT_Init_FreeType( &library );			 /* initialize library */
	/* error handling omitted */
	
	error = FT_New_Face( library, argv[1], 0, &face ); /* create face object */
	/* error handling omitted */	
	slot = face->glyph;

	FT_Set_Pixel_Sizes(face, font_size, 0);

	/* 确定座标:
	 */
	//pen.x = 0;
	//pen.y = 0;

 /* set transformation */
 //FT_Set_Transform( face, 0, &pen);

 /* load glyph image into the slot (erase previous one) */
 error = FT_Load_Char( face, chinese_str[0], FT_LOAD_RENDER );
	if (error)
	{
		printf("FT_Load_Char error\n");
		return -1;
	}
	
 draw_bitmap( &slot->bitmap,var.xres/2,var.yres/2);

	return 0;	
}

上机：

./freetype_show_font ./simsun.ttc

6.5.3在 LCD 上令矢量字体旋转某个角度

定义 2 个变量：角度、矩阵

设置角度值

设置矩阵、变形、加载位图

上机：

./freetype_show_font_angle ./simsun.ttc 90 200

6.6使用freetype显示一行文字

在 LCD 上指定一个左上角坐标(x, y)，把一行文字显示出来。下图中，文字的外框用虚线表示，外框的左上角坐标就是(x, y)

6.6.1笛卡尔坐标系

在 LCD 的坐标系中，原点在屏幕的左上角。对于笛卡尔坐标系，原点在左下角。freetype 使用笛卡尔坐标系，在显示时需要转换为 LCD 坐标系

在笛卡尔坐标系中坐标是(x, y)，那么它在 LCD 坐标系中坐标值为(x, V-y)

6.6.2每个字符大小不同

所以在显示一行文字时，后面文字的位置会受到前面文字的影响

在显示一行文字时，这些文字会基于同一个基线来绘制位图：baseline

每一个字符都有它的原点(origin)，比如上图中 baseline左边的黑色圆点就是字母“g”的原点。当前 origin 加上 advance 就可以得到下一个字符的 origin

嵌入式 Linux 学习笔记（04）：文件 IO 与系统调用

Sat, 10 Jan 2026 10:30:00 +0800

📚 本文是《嵌入式 Linux 应用开发学习笔记》系列第 04 / 7 篇：文件 IO 与系统调用。返回系列目录。

第4章文件IO

Linux一切皆文件，因此文件IO非常重要

Linux查看函数指令man

4.1文件IO分类

Linux上有两套函数：标准IO、系统调用IO

标准 IO 的相关函数是：fopen/fread/fwrite/fseek/fflush/fclose
系统调用 IO的相关函数是：open/read/write/lseek/fsync/close

两套接口来源：

系统调用IO是用户程序利用posix接口兼容访问Linux、Unix、Unix-like操作系统的功能，用于直接访问内核。

标准IO是C库的，但是为了兼容Windows用系统调用IO重新封装了。

标准IO引入了一个用户buffer。

读数据的话就读一个大数据在buffer，后续对其读取就在buffer里读，但是系统调用IO就必须多次向内核申请

4.2函数原型

4.2.1open()

1
2
3
4
5
6


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t 
mode);

打开或创建一个文件

pathname：文件路径名或文件名

flags：打开方式和状态标志，通过位或操作

mode：仅当flags包含O_CREAT或 O_TMPFILE 时才需要提供，指定文件权限，指定方式同chmod

宏	含义
访问模式（三选一）
`O_RDONLY`	只读
`O_WRONLY`	只写
`O_RDWR`	读写
创建与控制
`O_CREAT`	若文件不存在则创建，需提供 `mode`
`O_EXCL`	与 `O_CREAT` 合用，文件已存在时报错
`O_TRUNC`	打开时把文件截断为 0
追加/非阻塞/同步
`O_APPEND`	每次写都追加到文件尾
`O_NONBLOCK` / `O_NDELAY`	非阻塞模式
`O_SYNC`	每次写都等待物理 I/O 完成
`O_DSYNC`	仅同步数据，不含元数据
`O_DIRECT`	绕过页缓存，直接用户缓冲到磁盘
`O_CLOEXEC`	在执行 `execve` 时自动关闭 fd（防泄漏）

 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


//open
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <stdio.h>
#include <string.h>
#include <errno.h>
//close
#include <unistd.h>

/*
 * ./open 1.txt
 * argc = 2
 * argv[0] = "./open"
 * argv[1] = "1.txt"
 */

int main(int argc, char **argv)
{
 int fd;
 
 if (argc != 2)
 {
 printf("Usage: %s <file>\n", argv[0]);
 return -1;
 }
	//打开文件,若不存在则创建，且创建时截断，权限设为0777
 fd = open(argv[1],O_RDWR|O_CREAT|TRUNC,0777);
 if (fd < 0)
 {
 printf("can not open file %s\n", argv[1]);
 printf("errno = %d\n", errno);
 printf("err: %s\n", strerror(errno));
 perror("open");
 }
 else
 {
 printf("fd = %d\n", fd);
 }

 while (1)
 {
 sleep(10);
 }

 close(fd);
 return 0;
}

4.2.2write()

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

fd：指定要写入的文件描述符

buf：缓冲区，一般是一个数组，该数组的内容写入文件

count：要写入的实际字符数

 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


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
int main(int argc,char *argv[])
{
 int fd;
 int i;
 int len;
 fd = open(argv[1],O_RDWR | O_CREAT | O_TRUNC,0777);
 if (fd < 0)
 {
 printf("can not open file %s\n", argv[1]);
 printf("errno = %d\n", errno);
 printf("err: %s\n", strerror(errno));
 perror("open");
 }
 else
 {
 printf("fd = %d\n", fd);
 }
 for (i = 2; i < argc; i++) {
 len = write(fd,argv[i],strlen(argv[i]));
 if (len != strlen(argv[i]))
 {
 perror("write");
 break;
 }
 write(fd,"\r\n",2);
 }
 close(fd);
 return 0;
}

4.2.3read()

1
2


#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);

作用：从给定的文件描述符指定的文件中，读取 count 个字节的数据，存放至 buf 中。

fd：指定要读写的文件描述符

buf：缓冲区，一般是一个数组，用于存放读取的内容

count：一次要读取的最大字节数

4.2.4lseek()

#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);

fd：指定要偏移的文件描述符

offset：文件偏移量

whence：开始添加偏移 offset 的位置

SEEK_SET，offset 相对于文件开头进行偏移

SEEK_CUR，offset 相对文件当前位置进行偏移

SEEK_END，offset 相对于文件末尾进行偏移

4.2.5read()

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);

作用：从给定的文件描述符指定的文件中，读取 count 个字节的数

据，存放至 buf 中。

fd：指定要读写的文件描述符

buf：缓冲区，一般是一个数组，用于存放读取的内容

count：一次要读取的最大字节数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

int main(int argc,char **argv)
{
 int len;
 int i;
 unsigned char buf[100];
 int fd = open(argv[1],O_RDONLY,0777);
 while(1)
 {
 len = read(fd,buf,sizeof(buf)-1);
 if(len==0) break; //表示读到结尾了
 buf[len] = '\0';
 printf("%s",buf);
 }
 close(fd);
}

4.4内部机制

用户空间应用层调用glibc给出的系统调用接口

这些系统调用接口会触发异常引入内核
比如触发异常：swi/svc，并异常原因事先记录在某处
cpu发现异常后会调用内核提供的异常处理函数

他会进行分辨原因/处理异常
然后继续做自己的事

如SYSCALL_DEFINE为系统调用定义，3为参数个数

这个宏定义出这个函数

int sys_open(const char __user * filename,int flags,umode_t mode)

整体流程

即用户调用glibc的接口函数，接口函数触发异常，同时把异常原因记录在某些寄存器里面，cpu捕获到异常，根据异常的原因来调用对应的函数

每个进程有自己的文件句柄空间

fd=3，是xx进程里fd=3的文件

嵌入式 Linux 学习笔记（03）：交叉编译、GCC 与 Makefile

Sat, 27 Dec 2025 10:30:00 +0800

📚 本文是《嵌入式 Linux 应用开发学习笔记》系列第 03 / 7 篇：交叉编译、GCC 与 Makefile。返回系列目录。

第1章交叉编译

获取源码后，想要给ARM板编译出hello程序

arm-buildroot-linux-gnueabihf-gcc -o hello hello.c

若hello程序如下

01 #include <stdio.h>
02
03 /* 执行命令: ./hello weidongshan
04 * argc = 2
05 * argv[0] = ./hello
06 * argv[1] = weidongshan
07 */
08
09 int main(int argc, char **argv)
10 {
11 		if (argc >= 2)
12 			printf("Hello, %s!\n", argv[1]);
13 		else
14 			printf("Hello, world!\n");
15 		return 0;
16 }

头文件在哪

进入交叉编译器的目录里，执行：find -name “stdio.h”，它位于一个“include”目录下的根目录里。这个“include”目录，就是要找的路径（系统目录）

或者自己指定
怎么指定头文件目录

编译时，加上“-I <头文件目录>”这样的选项。
怎么确定交叉编译时库文件

进入交叉编译器的目录里，执行：find -name lib，可以得到 xxxx/lib、

xxxx/usr/lib，一般来说这 2 个目录就是要找的路径。如果有很多类似的 lib，

进去看看，有很多 so 文件的目录一般就是要找的路径
怎么指定自己的库文件目录、库文件

编译时，加上“-L <库文件目录>”这样的选项，用来指定库目录；

编译时，加上“-labc”这样的选项，用来指定库文件 libabc.so。

第2章 GCC编译器使用

2.1GCC编译过程

通过不同的编译选项可以控制这些过程

2.1.2编译多个文件

一起编译、链接

gcc -o test main.c sub.c
分开编译，统一链接

gcc -c -o main.o main.c

gcc -c -o sub.o sub.c

gcc -o test main.o sub.o

2.1.3制作使用动态库

step1：制作、编译

gcc -c -o main.o main.c
gcc -c -o sub.o sub.c
gcc -shared -o libsub.so sub.o sub2.o sub3.o(可以使用多个.o 生成动态库)
gcc -o test main.o -lsub -L /libsub.so/所在目录/

step2：运行

先把 libsub.so 放到 Ubuntu 的/lib 目录，然后就可以运行 test 程序
如果不想把 libsub.so 放到/lib，也可以放在某个目录比如/a，然后执行

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/a 
./test

2.1.4制作使用静态库

gcc -c -o main.o main.c
gcc -c -o sub.o sub.c
ar crs libsub.a sub.o sub2.o sub3.o(可以使用多个.o 生成静态库)
gcc -o test main.o libsub.a (如果.a 不在当前目录下，需要指定它的绝对或相对路径)

执行 arm-buildroot-linux-gnueabihf-gcc -c -o sub.o sub.c 交叉编译需要在最后面加上-fPIC 参数

第3章 Makefile的使用

3.1Makefile大纲

3.1.1为什么需要Makefile

修改源文件或头文件，只需要重新编译牵涉到的文件就可以重新生成APP

3.1.2Makefile基本规则

目标文件(target)…: 依赖文件(prerequiries)…
<tab>命令(command)

3.1.3一步步完善Makefile

1.如果没有makefile

使用gcc -o test a.c b.c

前三步统称为编译，最后一步链接

很简单，但是对所有文件都再处理一次，即使b.c没有修改，a.c修改了

优化上一步可以a.c和b.c分开编译，最后链接

gcc -c -o a.o a.c

gcc -c -o b.o b.c

gcc -o test a.o b.o

如何判断哪些文件被修改了？通过比较时间

目标文件(target)…: 依赖文件(prerequiries)…
<tab>命令(command)

当依赖文件比目标文件信，就执行命令

2.最简单的Makefile

test:a.o b.o
 gcc -o test a.o b.o 
a.o : a.c
 gcc -c -o a.o a.c
b.o : b.c
 gcc -c -o b.o b.c

执行make命令，此时修改a.c，只执行两条gcc命令

3.引入通配符

相似规则太多，可以使用通配符

test:a.o b.o c.o
	gcc -o test $^
	//$^表示所有依赖
%.o:%.c
	gcc -c -o $@ $<
	//$@表示目标文件 $<表示依赖文件

%.o：通配符
$@：表示目标
$<：表示第一个依赖文件
$^：表示所有依赖文件

4.引入clean、.PHONY

垃圾文件太多

test: a.o b.o c.o
	gcc -o test $^
%.o : %.c
	gcc -c -o $@ $<
clean:
	rm *.o test
.PHONY: clean

make：执行第一个目标

make [目标]：执行指定目标

假想目标.PHONY

5.即时变量、延时变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


A := $(C)				#A的值即时确定，在定义时即确定，赋值						 #为C，C现在为空
B = $(C)				#B的值使用到才确定
C = abc					#C赋值字符串abc

#D = 100ask
# 若 D 未定义则设为 weidongshan，已定义则保持原值
D ?= weidongshan		

# 默认目标 all：打印各变量最终值
all:
	@echo A = $(A) # A 为空（在第 1 行已固定）
	@echo B = $(B) # B 为 abc123（C 后面被追加 123）
	@echo D = $(D) # D 为 weidongshan（未被覆盖）

# C += 123 # 将 123 追加到 C 末尾，使 C 变成 abc123
C += 123

6.Makefile函数

 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


#A赋值 a b b
A = a b c 
#对A中每一个元素，取出来赋值给f，把f改为这种形式
B = $(foreach f, $(A), $(f).o)

#C赋值
C = a b c d/

#对C中符合%/格式的内容，过滤留下来
D = $(filter %/, $(C))

#对C中符合%/格式的内容，过滤出去
E = $(filter-out %/, $(C))

#*.c格式的文件是否存在，把存在的列出来
files = $(wildcard *.c)

files2 = a.c b.c c.c d.c e.c abc

#找到file2中存在的文件列出来
files3 = $(wildcard $(files2))

#找到file2中符合%.c的文件，将其改为%.d
dep_files = $(patsubst %.c,%.d,$(files2))

all:
	@echo B = $(B)
	@echo D = $(D)
	@echo E = $(E)
	@echo files = $(files)
	@echo files3 = $(files3)
	@echo dep_files = $(dep_files)

3.2Makefile实例

 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


objs = a.o b.o c.o
#把objs所有文件加前缀.加后缀.d
dep_files := $(patsubst %,.%.d, $(objs))
#找到dep_files中存在的文件列出来
dep_files := $(wildcard $(dep_files))

#编译参数
CFLAGS = -Werror -Iinclude

test: $(objs)
	gcc -o test $^

#如果dep_files不为空，就把这个文件包含
ifneq ($(dep_files),)
include $(dep_files)
endif

%.o : %.c
	gcc $(CFLAGS) -c -o $@ $< -MD -MF .$@.d

clean:
	rm *.o test

distclean:
	rm $(dep_files)
	
.PHONY: clean	

嵌入式 Linux 学习笔记（02）：环境搭建与开发板操作

Sat, 13 Dec 2025 10:30:00 +0800

📚 本文是《嵌入式 Linux 应用开发学习笔记》系列第 02 / 7 篇：环境搭建与开发板操作。返回系列目录。

第三篇环境搭建与开发板操作

windows：

filezilla：传文件到ubuntu
mobaxterm：远程操作ubuntu，操作开发板串口

ubuntu：

vmware运行ubuntu当做服务器

开发板：编辑编译运行

第2章安装软件

2.3MobaXterm 远程登录 Ubuntu

ubuntu命令ifconfig

ens33：为NAT网卡ip

2.4使用FileZilla

在Windows和ubuntu之间传文件

2.5Ubuntu上执行程序

touch hello.c

gedit hello.c

1
2
3
4
5
6
7


#include <studio.h>

int main(int argc, char **argv)
{
	printf("hello, world!\n");
	return 0;
}

gcc -o hello hello.c：编译

./hello：执行可执行文件

第3章 IMX6ULL开发板基本操作

3.1开发板资源

3.4串口连接

启动拨码EMMC启动
电源
Windows安装串口驱动

3.4.1使用Mobaxterm打开串口

登录名：root

100ask login: root

3.6ADB替代NFS传输文件

3.6.1使用adb

就可以在ubuntu上使用adb操作开发板

可以上传、下载开发板文件、目录

adb devices
adb push 1.txt /root # 把Ubuntu的文件放到开发板的/root目录
adb pull /root/1.txt 2.tx # 把开发板的/root/1.txt下载并改名为2.txt
adb shell # 登录开发板

第4章开发板的第一个APP实验

4.1源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
/* 执行命令: ./hello weidongshan 
 * argc = 2
 * argv[0] = ./hello
 * argv[1] = weidongshan
 */

int main(int argc, char **argv)
{
	if (argc >= 2)
		printf("Hello, %s!\n", argv[1]);
	else
		printf("Hello, world!\n");
	return 0;
}

4.2编译

给ARM板的程序要使用交叉编译工具链编译

执行

arm-buildroot-linux-gnueabihf-gcc -o hello hello.c

4.3上传开发板运行

adb push hello /root
adb shell
./root/hello

第5章开发板第一个驱动实验

5.1前提

为什么编译驱动程序前先编译内核？

驱动程序要用到内核文件

比如驱动程序包含#include <asm/io.h>，其中asm是链接文件，指向asm-arm或asm-mips，需要先配置、编译内核才会生成asm的链接文件

编译驱动时用的内核、开发板上运行到内核，要一致
更换板子上的内核后，板子上的其他驱动也要更换

流程：

配置编译内核、设备树、驱动
放到板子上
编译测试第一个驱动

5.2 编译内核

cd /home/book/100ask_imx6ull-sdk/Linux-4.9.88
make mrproper
make 100ask_imx6ull_defconfig
make zImage -j4
make dtbs
cp arch/arm/boot/zImage ~/nfs_rootfs
cp arch/arm/boot/dts/100ask_imx6ull-14x14.dtb ~/nfs_rootfs/

5.3编译内核模块

make modules
make ARCH=arm INSTALL_MOD_PATH=/home/book/nfs_rootfs modules_install

5.4安装内核和模块到开发板

cd /home/book/nfs_rootfs
adb push zImage /boot
adb push 100ask_imx6ull-14x14.dtb /boot
adb push lib/modules /lib

最后，在开发板上执行“sync”命令，再重启开发板，它就使用新的 zImage、dtb、模块了。

5.5编译led驱动

01_all_series_quickstart\05_嵌入式Linux驱动开发基础知识\source\01_hello_drv

上传到/home/book/nfs_rootfs

修改Makefile指定内核源码/home/book/100ask_imx6ull-sdk/Linux-4.9.88

编译make，将这两个上传到开发板目录

adb push hello_drv.ko /root
adb push hello_drv_test /root

5.6安装驱动模块

insmod hello_drv.ko

lsmod：查看安装的模块

5.7执行测试模块

先看看有没有设备ls /dev

嵌入式 Linux 学习笔记（01）：学习路线、资料下载与 Ubuntu 入门

Sat, 06 Dec 2025 11:00:00 +0800

📚 本文是《嵌入式 Linux 应用开发学习笔记》系列第 01 / 7 篇：学习路线、资料下载与 Ubuntu 入门。返回系列目录。

c第一篇学习路线、资料下载

000_课程链接

https://linux.100ask.net/

第1章 Linux路线

与windows对标：

第2章资料下载

🎫100ASK_IMX6ULL_PRO开发板 — 百问网资料下载中心 3.0 文档

开发板配套资料：
- 百度云网盘：链接：https://pan.baidu.com/s/1NsAIRkQj0bOaPDWdSkBuXw 密码： root
实验班配套资料：
- 实验班的虚拟机里装好了vscode、下载好了Linux源码
- 百度云网盘下载地址： https://pan.baidu.com/s/1SjpWb0K-dL2C06DjUEuA_A?pwd=qjke 密码： qjke

配套资料：全系列Linux教程的配套资料(应用基础、驱动基础等)

1 git clone https://e.coding.net/weidongshan/01_all_series_quickstart.git

第二篇 Ubuntu入门

打开终端快捷键：Ctrl+Alt+T

文件树：

第2章Ubuntu操作入门

2.3Linux常用命令

命令格式

linux路径

根目录：/

家目录：~

当前路径：.

上一级路径：..

查看函数指令：man

2.3.1目录文件相关

pwd：打印当前路径

cd：改变路径

mkdir：创建目录

mkdir dir0 ：创建dir0
mkdir -p dir1/dir2：创建目录dir1有子目录dir2

ls：列出目录内容

ls
ls -l：显示完整信息
ls -a：显示隐藏文件
ls -la：所有文件、完整信息
ls -lh：h表示–human-readable

cp：复制文件夹

cp -r dir1 dir2：复制dir1文件夹
cp -rfd dir_a dir_b：-r为复制所有，-f强制覆盖，-d如果源文件为链接，也只复制链接

rm：删除文件或目录

rm -rf dir_a：-r删除所有，-f强制删除

cat：打印文件内容

cat file.txt

touch：修改文件时间，如文件不存在则创建

touch file

2.3.2文件权限属性

chgrp：改变文件所属用户组

chgrp [-r] dirname/filename：-r递归更改，更新成为用户组
chgrp hy install.log：install.log更改为hy用户组

chowm：改变文件所有者

chmod：改变文件权限

权限对应数字r：4、0 w:2、0 x：1、0
权限对象：owner、group、others
权限值：owner=rwx=4+2+1=7，group=rwx=4+2+1=7，other=—=0+0+0=0
chmod [-r] 777 文件或目录：数字改法
chmod [-r] u=rwx,go=rx 文件或目录：字母改法用 u、g、o 三个字母代表 user、group、others
chmod a+w .bashrc：a代表all，对.bashrc文件ugo增加w权限

2.3.3查找搜索命令

find：搜索文件

find 目录名 [选项] 查找条件
find /home -name “test1.txt”：/home中以名字查找text1.txt
find /home -name " *.txt “：/home中以名字查找所有.txt文件

grep：查找文件中符合条件的字符串

grep [选项] [查找模式] [文件名]
grep -rn “字符串” 文件名

2.3.4压缩解压命令

gzip：

常用选项：-l列出压缩文件内容，-k在压缩和解压时保留输入文件，-d将压缩文件进行解压
gzip -l pwd.1.gz：查看压缩文件
gzip -kd pwd.1.gz：解压文件
gzip -k mypwd.1：得到一个.gz结尾的压缩文件

bizp2：

常用选项：-k在压缩解压时保留文件，-d将压缩文件解压
bzip2 -k mypwd.1：得到一个.bz2后缀的压缩文件
bzip2 -kd mypwd.1.bz2：解压

tar：

tar czvf dira.tar.gz dira：把目录dira压缩、打包为dira.tar.gz文件
tar tvf dira.tar.gz：查看压缩文件
tar xzvf dira.tar.gz：解压到当前目录
tar xzvf dira.tar.gz -c /home：解压到指定目录

2.3.5vi编辑器

vi 1.txt：vim打开1.txt，不存在则新建
输入i开启编辑
：wq保存并退出
：q！不保存退出

vi快捷键

1.新建、移动、取消、保存

2.移动

上下左右箭头移动光标
ctrl+f：向前翻页，ctrl+b：向后翻页
：输入行号：跳到某行
：set number 显示行号
：set nonumber 隐藏行号
G：跳到文件结尾
0：跳到行首
$：跳到行尾

3.编辑

x：删除一个字母
dd：删除一行
ndd：删除当前行及后n-1行（n是数字）
o：当前行后新增行
u：撤销上一步

4.复制粘贴

yy：复制当前行
nyy：同理
p：粘贴

嵌入式 Linux 应用开发学习笔记（系列目录）

Sat, 06 Dec 2025 10:00:00 +0800

本系列整理自嵌入式 Linux 应用开发的学习过程（基于 IMX6ULL 开发板），原文较长，现按主题拆分为 7 篇：

学习路线、资料下载与 Ubuntu 入门 — 学习路线对比、开发板资料获取、Linux 常用命令与 vi 编辑器
环境搭建与开发板操作 — MobaXterm / FileZilla / ADB，交叉编译第一个 APP 与 LED 驱动实验
交叉编译、GCC 与 Makefile — GCC 编译过程、动态/静态库制作、Makefile 从基本规则到工程实例
文件 IO 与系统调用 — open/read/write/lseek 函数详解及内核系统调用机制
Framebuffer 与文字显示 — LCD 操作原理、字符编码、点阵字库与 freetype 矢量字体
输入系统、网络编程与多线程 — input 子系统、TCP/UDP socket 编程、线程创建与信号量/互斥量同步
I2C 应用编程 — I2C 协议要点、I2C-Tools 操作 AP3216C 传感器、编写 APP 直接访问 EEPROM

注：原笔记中「串口 UART 编程」一章尚在学习整理中，内容补全后会更新到对应篇章。

Linux on Zesean 的博客

Samba 共享：把开发板目录变成 Windows 本地磁盘

Samba 共享（⭐ 最原生的 Windows 挂载方案）

嵌入式 Linux 学习笔记（07）：I2C 应用编程

第10章 串口UART编程

第11章 I2C应用编程

11.1 I2C硬件

11.2 传输数据类比

11.3 IIC传输数据格式

11.3.1写操作

11.3.2读操作

11.3.3 IIC信号

11.3.4 协议细节

11.4 SMBus协议

11.4.1 SMBus是IIC协议子集

11.5无需编写驱动直接访问设备(I2C-Tools)

11.5.1用法

11.5.2操作传感器AP3216C

11.5.3 I2CTools访问I2C设备的方式

11.6编写APP直接访问EEPRPM

11.6.1写数据

11.6.2读数据

嵌入式 Linux 学习笔记（06）：输入系统、网络编程与多线程

第7章 输入系统应用编程（未完成）

7.1输入设备

7.2输入系统框架及调试

7.2.2编写APP需要掌握的知识

7.2.3调试技巧

7.3不用库的应用编程

7.3.1查询、休眠唤醒方式

7.3.2poll/select方式

第8章 网络通信

8.1网络通信概述

8.1.1IP和端口

8.1.3两种传输方式TCP/UDP

8.2TCP网络编程

服务端

客户端

8.3UDP网络编程

服务端

客户端

第9章 多线程编程

9.1线程的使用

9.1.1为什么使用多线程

9.1.2线程概念

9.1.3线程的标识pthread_t

9.1.4线程的创建

9.1.5同步操作-向线程传数据(等待)

9.1.6同步操作(信号量)

9.1.7同步操作(互斥量)

嵌入式 Linux 学习笔记（05）：Framebuffer 与文字显示

第5章、Framebuffer应用编程

5.1LCD操作原理

5.2 涉及的API函数

5.2.2 ioctl函数

5.2.3 mmap 函数

5.3程序

5.4上机

第6章文字显示

6.1字符编码方式

6.1.1编码与字体

6.1.2UniCode编码实现

6.2 ASCII点阵显示

6.2.1获取点阵

6.2.2描点

6.2.3show_string

6.3中文字符的点阵显示

6.3.1指定编码格式

6.3.3汉字区位码

6.4交叉编译程序：以freetype为例

6.4.1程序运行的基本知识

6.4.2常见错误

6.4.3交叉编译万能命令

6.5使用freetype显示单个文字

6.5.1矢量字体引入

6.5.2在 LCD 上显示一个矢量字体

6.5.3在 LCD 上令矢量字体旋转某个角度

6.6使用freetype显示一行文字

6.6.1笛卡尔坐标系

6.6.2每个字符大小不同

第10章串口UART编程

第7章输入系统应用编程（未完成）

第8章网络通信

第9章多线程编程

第4章文件IO

第1章交叉编译

第三篇环境搭建与开发板操作

第2章安装软件

第4章开发板的第一个APP实验

第5章开发板第一个驱动实验

c第一篇学习路线、资料下载

第2章资料下载