Zesean 的博客

端侧大模型在线/离线部署（Agent）——机器人项目迁移实战（三）

Sat, 15 Aug 2026 14:00:00 +0800

在 Jetson Orin Nano 上部署大语言模型（LLM）是实现端侧大模型 Agent 的第一步，也是最核心的工程挑战。由于 Jetson 采用的是统一内存架构（Unified Memory Architecture），CPU 和 GPU 共享物理内存（4GB 或 8GB），这与传统 PC 的“内存+独立显存”有很大不同。在 Orin Nano 上，我们必须精细控制内存预算，防止系统因 OOM（Out of Memory）而崩溃。

针对子任务 3.1（离线版 - LLM 推理），从瑞芯微 RK 平台迁移到 NVIDIA Jetson 平台，我们需要将原有的 RKNN 链路彻底重构为 NVIDIA 生态的加速链路。

子任务 3.1 拆解：端侧 LLM 部署实施方案

✅️微任务 3.1.1：Jetson 硬件环境准备与 Swap 空间配置

目标：解决 Orin Nano 在模型编译或高负载时内存不足的问题。
具体步骤：

1.确认 JetPack 版本（推荐使用 JetPack 6.x，自带 CUDA 12.x 和更现代的 Linux 内核）。

1
2


#jtop查看板卡信息
jtop

2.必须配置虚拟内存（Swap）：Orin Nano 即使是 8GB 版本，在编译模型或运行 4B 模型时也极易耗尽物理内存。建议通过 NVMe SSD 划分 16GB 的 Swap 空间。

 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


#查看内存和SWAP
free -h
#查看磁盘
lsblk
#创建swap
sudo fallocate -l 16G /swapfile
#设置权限
sudo chmod 600 /swapfile
#验证
ls -lh /swapfile
#格式化swap
sudo mkswap /swapfile
#启用swap
sudo swapon /swapfile
#插看swap
swapon --show & free -h
#开机自动挂载
sudo nano /etc/fstab
#末尾加入/swapfile none swap sw 0 0
#优化swap策略
cat /proc/sys/vm/swappiness
>60
sudo sysctl vm.swappiness=10
#永久生效
sudo nano /etc/sysctl.conf
#末尾加入vm.swappiness=10

3.开启最高性能模式：

1
2


sudo nvpmodel -m 0
sudo jetson_clock

锁住 CPU/GPU 频率，确保推理时延迟最低

✅️微任务 3.1.2：推理引擎技术选型（llama.cpp vs TensorRT-LLM）

目标：根据开发周期和性能需求选择最佳引擎。
方案对比与选择：
- 方案 A：llama.cpp（推荐优先部署）：对 Jetson 适配极佳，编译简单，内存开销极小。通过开启 GGML_CUDA=1，可以将计算完全卸载到 Orin Nano 的 Ampere GPU 上。支持 GGUF 格式，量化极其方便。
- 方案 B：TensorRT-LLM（极致性能追求）：NVIDIA 官方的王牌，吞吐量最高。但由于 TensorRT-LLM 的编译依赖较重，在 8GB 的 Orin Nano 上直接编译模型 Engine 极易 OOM，通常需要在 PC 端（带有 NVIDIA 独立显卡的 Ubuntu 主机）进行交叉编译，生成 Engine 后再拷贝到 Jetson 上运行。
实施建议：第一阶段使用 llama.cpp + CUDA 快速打通链路；第二阶段追求极限低时延时，在 PC 端配置 Docker 交叉编译 TensorRT-LLM 的 Engine。

方案A具体步骤：

1.确认环境

1
2


uname -m#为aarch64
dpkg -l | grep nvidia-jetpack#JetPack 5.1+ 或 6.x、CUDA 已安装

2.安装依赖

1
2
3
4
5
6
7
8


sudo apt update

sudo apt install -y \
 git \
 cmake \
 build-essential \
 python3 \
 python3-pip

3.获取 llama.cpp

1
2


git clone https://github.com/ggml-org/llama.cpp#网慢可以转gitee
cd llama.cpp

4.jetson cuda编译

1
2
3
4
5


cmake -B build -G Ninja \
 -DCMAKE_BUILD_TYPE=Release \
 -DGGML_CUDA=ON \
 -DCMAKE_CUDA_ARCHITECTURES=87 \
 -DLLAMA_CURL=ON

参数	意义
GGML_CUDA=ON	启用 CUDA backend
87	Orin Nano Ampere 架构
Ninja	加速编译
LLAMA_CURL	支持 hf 模型下载

5.编译

1

cmake --build build -j$(nproc)

6.验证

1

./build/bin/llama-cli -h

7.部署测试

下载 https://huggingface.co/bartowski/Qwen2.5-3B-Instruct-GGUF

放入/home/nvidia/Downloads/llama.cpp/models

1
2
3
4
5


./build/bin/llama-cli \
 -m ./models/Qwen2.5-3B-Instruct-Q4_K_M.gguf \
 -ngl 999 \
 -p "你好，请用一句话介绍ROS2" \
 -n 64

✅️微任务 3.1.3：Qwen2.5 模型量化与格式转换

目标：将 Hugging Face 发布的原始 Qwen3.5 模型权重转换为 GGUF 格式，并完成不同量化策略（Q8_0、Q6_K、Q5_K_M、Q4_K_M）的压缩与性能测试，实现 Jetson Orin Nano 端侧部署（原始 Qwen 模型通常以 Transformers 格式发布）
量化策略
- 原始模型一般FP16
- Q8_0：8-bit量化
- Q6_K：6-bit量化K-Quant， llama.cpp 后来提出的新量化算法
- Q5_K_M：5-bit量化、K-Quant算法、Medium（重要层保留更多精度）
- Q4_K_M：4-bit量化、K-Quant、Medium
格式大小

FP16 8GB

Q8_0 4.3GB

Q6_K 3.3GB

Q5_K_M 2.9GB

Q4_K_M 2.3GB

格式	大小
FP16	8GB
Q8_0	4.3GB
Q6_K	3.3GB
Q5_K_M	2.9GB
Q4_K_M	2.3GB

量化工具需要先理解模型结构

GGUF 是 llama.cpp 的统一模型格式
HuggingFace模型(safetensors) –> 转换成GGUF(F16) -> GGUF量化 - > Q4_K_M / Q5_K_M

原始模型

Qwen3-4B/
├── config.json
├── tokenizer.json
├── model.safetensors
├── model-00001-of-00002.safetensors
└── model-00002-of-00002.safetensors
#model.safetensors神经网络权重矩阵

GGUF是llama.cpp专用模型容器

具体步骤（以 llama.cpp 路线为例）：

Qwen2.5-1.5B-Instruct (HF格式)

 ↓ convert_hf_to_gguf.py

qwen2.5-1.5b-f16.gguf

 ↓ llama-quantize

qwen2.5-1.5b-q4_k_m.gguf

1.hf获取国产模型慢，在魔塔社区下代替Qwen2.5-1.5B-Instruct

1
2
3
4
5


# 1. 安装魔搭下载工具（使用清华源瞬间装完）
pip install modelscope -i https://pypi.tuna.tsinghua.edu.cn/simple

# 2. 一键满速下载到指定目录（告别网络报错）
modelscope download --model qwen/Qwen2.5-1.5B-Instruct --local_dir ./Qwen2.5-1.5B-Instruct

模型位置：

2.使用 llama.cpp 的 convert_hf_to_gguf.py 脚本将模型转化为gguf格式

convert_hf_to_gguf.py 依赖 transformers 库，因此在使用前先配个miniconda

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-aarch64.sh
bash Miniconda3-latest-Linux-aarch64.sh
source ~/.bashrc
conda --version
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --set show_channel_urls yes
conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main
conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r

创建进入

1
2


conda create -n llama_cpp_env python=3.10 -y
conda activate llama_cpp_env

安装transformers 和torch

然后转换

1
2
3
4
5
6


cd ~/Downloads/llama.cpp

python convert_hf_to_gguf.py \
 /home/nvidia/Desktop/Qwen2.5-1.5B-Instruct \
 --outfile qwen2.5-1.5b-f16.gguf \
 --outtype f16

3.模型量化：执行 ./llama-quantize。

Orin Nano 4GB 版：必须选择 INT4 量化（如 Q4_K_M），且只能运行 1.8B 模型。
Orin Nano 8GB 版：推荐选择 INT4 量化运行 4B 模型，或者选择 INT8 量化（如 Q8_0）运行 1.8B 模型（具备更好的指令遵循能力）。

1
2
3
4


./build/bin/llama-quantize \
 qwen2.5-1.5b-f16.gguf \
 qwen2.5-1.5b-q4_k_m.gguf \
 Q4_K_M

✅️微任务 3.1.4：Qwen2.5-0.5B-Instruct Lora微调

目标：实现Qwen2.5-0.5B-Instruct微调测试。

方案选择：

Orin Nano 4GB 版：必须选择 INT4 量化（如 Q4_K_M），且只能运行 1.8B 模型。
Orin Nano 8GB 版：推荐选择 INT4 量化运行 4B 模型，或者选择 INT8 量化（如 Q8_0）运行 1.8B 模型（具备更好的指令遵循能力）。

实验环境：魔塔实例，8核32gb，显存24g

方案1：魔塔微调神器 ms-swift

1.安装工具

1
2
3


pip install ms-swift -U
pip install modelscope -U
python -c "from modelscope import snapshot_download; snapshot_download('Qwen/Qwen2.5-0.5B-Instruct', local_dir='.')"

2.创建微调数据集

1
2
3
4
5
6


cd /mnt/workspace
cat << 'EOF' > cat_data.jsonl
{"messages": [{"role": "user", "content": "你是谁？"}, {"role": "assistant", "content": "喵喵喵！本大爷是专属猫咪助手，有小鱼干才回答你！"}]}
{"messages": [{"role": "user", "content": "今天天气怎么样？"}, {"role": "assistant", "content": "喵~ 太阳很大，适合本猫在窗台上睡觉！"}]}
{"messages": [{"role": "user", "content": "帮我写一段Python代码。"}, {"role": "assistant", "content": "打工人自己写！喵！好吧，给你个 print('Meow')。"}]}
EOF

3.开始lora微调

1
2
3
4
5
6
7
8


swift sft \
 --model ./models \
 --model_type qwen2 \
 --template qwen2_5 \
 --dataset cat_data.jsonl \
 --num_train_epochs 1 \
 --max_steps 40 \
 --output_dir ./output

4.合并lora权重

1
2
3
4
5
6


cd /mnt/workspace

swift export \
 --model ./models \
 --adapters ./output/v1-20260615-211104/checkpoint-40 \
 --merge_lora true

5.使用 llama.cpp 转换为 GGUF

1
2
3
4
5
6
7
8
9


cd /mnt/workspace
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
pip install -r requirements.txt

cd /mnt/workspace/llama.cpp
python convert_hf_to_gguf.py /mnt/workspace/output/v1-20260615-211104/checkpoint-40-merged \
 --outfile /mnt/workspace/my_cat_qwen.gguf \
 --outtype q8_0

微任务 3.1.4：流式推理接口开发（C++ / Python）

目标：实现全流式（Streaming）文本输出，降低首字时延（First-token Latency）。
具体步骤：
1. 编写推理控制客户端，调用 llama.cpp 的 API 或使用 llama-cpp-python（确保编译时使能了 CUDA）。
2. 配置关键推理参数：
  - n_ctx（上下文窗口）：机器人局部交互通常不需要太长上下文，建议设为 512 或 1024，以节省大量 KV Cache 占用的显存。
  - n_gpu_layers：设置为 -1，代表将所有模型层（Layers）全部加载到 GPU 显存中，避免 CPU-GPU 之间的数据拷贝时延。

微任务 3.1.5：ROS2 节点封装与端侧通信集成

目标：将大模型推理能力接入机器人系统，供 Agent 决策模块调用。
具体步骤：
1. 创建一个 ROS2 Lifecycle 节点（如 llm_inference_node）。
2. 输入端：订阅 ASR 模块发布的语音识别文本话题（Topic）。
3. 输出端：使用 ROS2 的 Action 机制（而不是普通的 Service 或 Topic）。因为大模型生成是流式的、耗时的，Action 机制允许节点在生成过程中持续回传（Feedback）流式文本，供 TTS 模块实现边接收边朗读（全流式响应），从而大幅降低整个 Agent 链路的感知延迟。

LLM 微调基础：LoRA 与 QLoRA 学习笔记

Sat, 11 Jul 2026 10:00:00 +0800

第一阶段：LLM微调基础

目标：理解文档里提到的

LoRA(Low-Rank Adaptation，低秩适应)
QLoRA（Quantized LoRA）
SFT（Supervised Fine-Tuning，监督微调）
DPO（Direct Preference Optimization，直接偏好优化）
RLHF
vLLM

SFT、DPO

维度	SFT	DPO
训练数据	高质量的标准答案（input → output 对）	偏好对比数据（input → chosen/rejected 对）
学习信号	模仿标准答案（“这是什么”）	学习相对偏好（“哪个更好”）
优化目标	最大化生成标准答案的概率	最大化 chosen 优于 rejected 的边际
是否需要 Reward Model	不需要	不需要（但隐式学习偏好）
对齐效果	基础能力好，但容易过拟合或对齐不足	对齐人类偏好更直接，泛化性通常更好

输入特定类型的文本

监督微调

SFT 像"抄作业"：模型学习专家写好的标准答案，适合传授知识和基本格式。
DPO 像"比较打分"：模型学习"答案 A 比答案 B 更好"，适合对齐人类价值观和偏好（如安全性、有用性、风格）

数据：

{
 "instruction":"把红色方块放进盒子",
 "output":"对应动作序列"
}

理解：

输入
↓
标签
↓
训练

实际训练中通常是先 SFT 后 DPO（或 RLHF）：

SFT 阶段：用高质量指令数据训练模型，让它学会基本对话格式和知识。
DPO 阶段：用偏好数据（如人类标注的 good/bad 回答）进一步微调，让模型输出更符合人类偏好。

技术细节补充

DPO 的优势：避免了 RLHF 中复杂的 Reward Model 训练和 PPO 强化学习，将偏好优化转化为简单的分类损失，训练更稳定高效。
SFT 的局限：如果标准答案本身质量不够高或分布有偏，模型会学到错误模式；且无法表达"好答案"和"更好答案"之间的细微差别。

RLHF

RLHF（Reinforcement Learning from Human Feedback，基于人类反馈的强化学习）是大模型对齐阶段的核心方法，解决 SFT 无法表达"好/坏"偏好的问题。

SFT 的局限：

只知道"标准答案"，不知道"A 比 B 更好"
无法处理开放性任务（如创意写作、多轮对话）
缺乏安全边界（可能生成有害内容）

RLHF 的目标：让模型输出更符合人类偏好

1
2
3
4


┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ 1. SFT 模型 │ → │ 2. 训练 Reward Model │ → │ 3. PPO 强化学习 │
│ (学会基本对话) │ │ (学会打分) │ │ (优化模型输出) │
└─────────────────┘ └─────────────────┘ └─────────────────┘

训练 Reward Model（奖励模型）

1
2
3
4
5


问题：解释量子计算

回答 A（好）："量子计算利用量子叠加和纠缠..." → 得分高
回答 B（差）："量子计算是一种计算..."（含糊） → 得分低
回答 C（有害）："量子计算可以用来破解密码..."（误导）→ 得分极低

LoRA:

参数高效微调（Parameter-Efficient Fine-Tuning，PEFT）技术中的一种,冻结AIGC大模型的大部分参数，再引入一小部分可训练的参数作为适配模块进行微调训练

本质是特征矩阵进行低秩分解的一种近似数值分解技术，可以大幅降低特征矩阵的参数量，但是会伴随着一定的有损压缩，可以大幅降低特征矩阵的参数量，但是会伴随着一定的有损压缩

我们假设原来的是1001024的参数矩阵，那么参数量为102400，LoRA模型将矩阵拆成了两个矩阵相乘，如果我们设置Rank=8，那么就是1008的A矩阵与8*1024的B矩阵做矩阵乘法，参数量为800+8192=8992，整体参数量下降了约11.39倍

Transformer架构

比如attention模块就是

可以控制的就是这些矩阵，矩阵的值就是模型参数

模型预训练：

把海量数据放入模型进行计算；

模型输出和期望输出通过数学方式比较，从而调整参数

模型微调

在预训练模型基础上，集中训练特定领域文本，让模型回复快速集中到特定领域

但监督微调sft显存占用与预训练模型一致

QLoRA（Quantized LoRA）：

背景：模型量化（quantization）也被叫做模型的低精度表示，指的是在不大幅降低模型效果的前提下使用更低的精度来表示模型中的参数，从而缩减模型的体积和训练模型时占用的显存。量化的本质是函数映射，根据量化过程是否线性我们可以把量化分为线性量化和非线性量化。

即从一种数据类型“舍入”到另一种数据类型；量化操作不可避免的带来一些误差，例如从float32到int8的round操作带来的精度损失，超出int8范围的溢出值的截断

最常见的量化技术是最大绝对值：

还有一种量化技术叫做零点量化：

第一步值域映射，即通过缩放将原始的数值范围映射为量化后的数值范围; 第二步零点调整，即通过平移将映射后的数据的最小值对齐为目标值域的最小值。

按照量化过程是否以0点为对称点量化又可以分为对称量化和非对称量化；

对称量化将原浮点数的最小或最大值的绝对值作为映射值的范围，而非对称量化是将原浮点数的最小和最大值映射为量化数据的最小和最大值，如图1。在非对称量化中，0的映射也可能会有偏移，因此不一定会被映射到0。

非线性量化：

分位数量化（Quantile Quantization）顺序排列的一组数据分割为若干个相等块的分割点的数值

累积分布函数（CDF）使用分位数将张量分成了大小相同的若干个块，这样我们得到更加均匀的量化特征，这也就是分位数量化。如图3所示，对于4比特量化，我们希望需要找到15个分位数来将这个曲线下面的面积（积分）等分成16份。两个分位数的中点便是模型量化到这个区间映射的值。预训练模型的参数往往是符合正态分布的，因此我们可以通过累积分布函数的反函数

QLoRA

第一个工作是结合了分位数量化和分块量化的4位标准浮点数量化（4-bit NormalFloat Quantization）。第二个工作是对模型进行两次量化的双重量化（Double Quantization），它的第二次量化只作用在第一次量化产生的量化常数上，可以进一步节约显存占用。第三个工作是分页优化（Paged Optimizer），使用CPU内存代替GPU显存保存部分梯度参数。

一、分位数量化方法我们可以将FP2精度量化到4bit的精度，但是直接这么用的一个问题是不能保证高精度的0一定被映射到低精度的0，但是0点又是深度学习中一个重要的值，例如在模型稀疏化，数据padding的时候一般都是使用0来完成

二、保存模型时我们不仅要保存量化后的结果，还要保存每个块的量化常数。虽然量化后的参数只有4bit的精度，但是这个量化常量的精度是float32。在QLoRA中，每个块的大小是64，因为块中的每个值占4比特。这相当于为了存储量化常数，模型要额外占用12.5%

三、QLoRA分页优化其实就是当显存不足是，将保存的部分梯度检查点转移到CPU内存上，和计算机的内存数据转移到硬盘上的常规内存分页一个道理

室内定位指纹库构建实践：ESP32 地磁采集与 WiFi 网格测量

Sat, 16 May 2026 15:00:00 +0800

这学期《传感器与微系统》课程论文做的是室内定位方向的数据工作：在 3m×5m 的实验场地里，人工采集了 WiFi RSSI 与地磁两路指纹，构建了一张 0.5m 网格的指纹库。定位算法本身是论文的核心内容，暂不展开；本文只记录数据采集与预处理的工程实践。

指纹法定位原理

指纹法分离线、在线两个阶段。离线阶段在场地内按网格逐点采集各 AP 的信号强度，形成「位置 ↔ 信号指纹」数据库；在线阶段用实时采到的信号去指纹库里匹配，反推出当前坐标：

WiFi RSSI 空间波动大、成本低，地磁信号空间差异明显、不受光照遮挡影响，两者互补——这也是选择这两路指纹的原因。

地磁采集：ESP32 + ICM20948

地磁传感器选用 ICM20948（9 轴 IMU 内置 AK09916 磁力计），主控为 ESP32，Arduino 框架开发。

采集流程：

通过姿态解算获取横滚角 $\phi$ 与俯仰角 $\theta$
读取磁力计原始三轴数据 $M^b = [m_x, m_y, m_z]^T$
用旋转矩阵把设备坐标系下的磁场校正到水平坐标系（z 轴指向上方）：

$$R_x(\phi) = \begin{bmatrix} 1 & 0 & 0 \ 0 & \cos\phi & \sin\phi \ 0 & -\sin\phi & \cos\phi \end{bmatrix} \qquad R_y(\theta) = \begin{bmatrix} \cos\theta & 0 & -\sin\theta \ 0 & 1 & 0 \ \sin\theta & 0 & \cos\theta \end{bmatrix}$$

输出三元组：（水平磁场模值，垂直磁场模值，总磁场模值）

采样频率设为 1Hz（宏定义可调）。姿态校正这步很关键——手持设备不可能保证完全水平，不做校正的话，同一位置换个握持角度读数就完全对不上了。

WiFi RSSI 网格测量

场地：约 300cm × 500cm 的室内区域
AP 布置：5 个无线接入点
采样：按 1m 网格逐点人工采集，每个网格点记录 5 路 RSSI（dBm）与地磁三模值

原始数据以 xlsx 记录，字段包括网格点物理坐标（cm）、RSSI_1~RSSI_5、地磁三模值（μT）。

预处理：从 1m 实测到 0.5m 指纹库

实测网格 1m 间距偏稀疏，直接做指纹匹配粒度不够。预处理流水线：

网格提取：从原始测量数据抽取 1m 间隔网格点
IDW 插值扩充：用反距离加权插值把网格加密到 0.5m，扩充指纹库分辨率（插值域的选择有讲究，细节在论文里）
格式转换：xlsx 统一转 CSV 供后续使用

看看采到的数据

数据好不好，可视化是最直观的检验。5 个 AP 中一路 RSSI 的三维曲面——可以明显看到信号强度随空间的起伏：

地磁总模值的等高线图——场地西部偏高（约 55μT）、东部偏低（约 43μT），空间梯度明显，这正是地磁指纹可用于定位的前提：

换个角度看地磁场强度曲面：

小结

指纹库质量决定指纹定位的上限，采集阶段的网格规划、姿态校正、传感器选型都比想象中重要
地磁的空间梯度和 WiFi 的互补性在数据里体现得非常直观
融合定位方法本身是论文核心内容，等论文发表后再写一篇展开

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 编程」一章尚在学习整理中，内容补全后会更新到对应篇章。

QT 入门学习笔记

Sat, 20 Sep 2025 15:00:00 +0800

1.QT创建项目

1.1创建：

QMainWindow：窗口

QWidget：弹窗

QDialog：对话框

1.2文件体系：

1.3UI控件

layout：布局

V垂直，H水平，G网格，F表单（组合控件）

spacers：弹簧（占位）

把控件挤一挤H水平，V垂直

button：按键

P.T差不读 R单选框 C多选

Item Views：单元视图（数据，显示分离）

Item Widgets：

Container：容器，容控件

Input：输入

Display：输出

2.信号与槽

如点击按键发出一个信号，对信号响应，执行一个函数，这个函数叫槽函数（事件和回调）

三种连接方式

3.写计算器

设计ui

添加槽函数

设计框尺寸，框标题、字体

各按钮槽函数类推

按键插图片

退格功能

计算功能太难，跳过

4.定时器

QObject：

startTimer killTimer

启动定时器

标签显示图片

轮换逻辑

QTimer：

头文件

启动定时器

图片法二

槽函数

转换逻辑

暂停

5.QT文件操作

ui设计

新建

添加槽函数

实现槽函数

连接功能

打开

头文件

QFileDialog 开文件选择框

QMessageBox 开警告盒子

QDebug 输出文字到控制台

QFile 读取文件内容

添加槽函数

连接功能

实现槽函数

void MainWindow::openActionSlot()
{
 //括号里的参数分别是：指定父类、标题、默认打开后显示的目录、右下角的文件过滤器。
 QString filename =
 QFileDialog::getOpenFileName(this,
 "选择一个文件",
 ".",
 "*.txt");
 qDebug() << filename;
 if(filename.isEmpty())
 {
 QMessageBox::warning(this,"警告","请选择一个文件");
 }
 else
 {
 qDebug()<<filename;
 QFile file(filename);
 file.open(QIODevice::ReadOnly);
 QByteArray array = file.readAll();	//读取文件所有内容
 ui->textEdit->setText(QString(array));
 file.close();
 }
}

保存

添加槽函数

连接功能

实现槽函数

void MainWindow::saveActionSlot()
{
 QString filename =
 QFileDialog::getSaveFileName(this,
 "选择一个文件",
 "." //当前路径的话是QCoreApplicationFilePath()
 ); //不写就是所有文件
 if(filename.isEmpty())
 {
 QMessageBox::warning(this,"警告","请选择一个文件");
 }
 else
 {
 QFile file(filename);
 file.open(QIODevice::WriteOnly);
 QString str = ui->textEdit->toPlainText();
 QByteArray array = str.toLocal8Bit();
 //array.append(ui->textEdit->toPlainText());
 file.write(array);
 file.close();
 }
}

6.QT事件

键盘事件

ctrl+s实现保存，即打开保存原文件

重写键盘事件虚函数

#include

void keyPressEvent(QKeyEvent *k);

void MainWindow::keyPressEvent(QKeyEvent *k)
{
 if(k->modifiers() == Qt::ControlModifier) { // 如果按下了CTRL键
 if(k->key() == Qt::Key_S){
 qDebug()<<"CTRL + S";
 saveActionSlot();
 }
 }
}

鼠标事件

#include

void mousePressEvent(QMouseEvent *m);

void MainWindow::mousePressEvent(QMouseEvent *m)
{
 QPoint pt = m->pos();
 qDebug()<<pt;
 if(m->button() == Qt::LeftButton)
 {
 qDebug()<<"左键被按下";
 }
 if(m->button() == Qt::RightButton)
 {
 qDebug()<<"右键被按下";
 }
}

7.QT TCP

服务器	客户端
socket	socket
bind	connect
listen	send/recv
accept
send/recv

与网络相关的在工程里加network

TCP前置

客户端

UI设计

编辑槽函数

#include

void Widget::on_connectButton_clicked()
{
 //获取ip地址和端口号
 QString IP = ui->ipLineEdit->text();
 QString PORT = ui->portLineEdit->text();

 //连接服务器
 socket->connectToHost(QHostAddress(IP),PORT.toShort());

 //连接服务器成功，socket对象发出信号
 connect(socket,&QTcpSocket::connected,[this]()
 {
 QMessageBox::information(this,"连接提示","连接服务器成功");
 });

 //连接断开，socket也会发出信号
 connect(socket,&QTcpSocket::disconnected,[this](){
 QMessageBox::warning(this,"连接提示","连接异常 网络断开");
 });
}

服务器

UI设计

头文件

#include #include

创建槽函数

监听

Widget::Widget(QWidget *parent)
 : QWidget(parent)
 , ui(new Ui::Widget)
{
 ui->setupUi(this);
 server = new QTcpServer;

 server->listen(QHostAddress::AnyIPv4,PORT);

 //客户端发起连接，server发出信号
 connect(server,&QTcpServer::newConnection,this,&Widget::newClientHandler);
}

实现槽函数

void Widget::newClientHandler()
{
 //建立TCP连接
 QTcpSocket *socket = server->nextPendingConnection();
 //socket->peerAddress(); //获取客户端地址
 //socket->peerPort();//获取端口号
 ui->iplineEdit->setText(socket->peerAddress().toString());
 ui->portlineEdit->setText(QString::number(socket->peerPort()));
}

8.QT启动新窗口（接服务器，实现发数据）

客户端

对原串口对象连接成功后可以使用

this->hide();隐藏

在原界面头文件引入新界面对象头文件

#include <chat.h>

在原界面需要显示新界面的时候声明对象，像Widget w; w.show()一样

但是新对象要使用socket,因此要传入

Chat *c =new Chat(socket);//堆空间创建

此时需要添加类Chat头文件和成员

#include <QTcpSocket>

构造函数进行一个赋值

Chat::Chat(QTcpSocket *s,QWidget *parent)
 : QWidget(parent)
 , ui(new Ui::Chat)
{
 ui->setupUi(this);
 socket = s;
}

服务器

实现槽函数

void Widget::clientInfoSlot()
{
 
 QTcpSocket *s = (QTcpSocket *)sender();//获取信号的发出者

 QString str = QString(s->readAll());
 ui->mainlineEdit->setText(str);
}

实现了客户端发送，服务器接收并显示

9.QT多线程

接TCP，实现服务器多线程，多客户端连接一个服务器

创建线程类

#include <QThread>
//继承自QThread
class my_thread : public QThread
{
}

启动线程

 //启动线程在widget.cpp
 my_thread *t = new my_thread(socket);//创建线程对象
 t->start();//开始线程

重写虚函数

public:
 explicit my_thread(QTcpSocket *s,QThread *parent = nullptr);
 //重写虚函数
 void run();

修改类

添加成员，修改构造函数参数，在构造函数进行赋值

.h

class my_thread : public QThread
{
 Q_OBJECT
public:
 explicit my_thread(QTcpSocket *s,QThread *parent = nullptr);
 //重写虚函数
 void run();
private slots:
 void clientInfoSlot();

private:
 QTcpSocket *socket;
};

.cpp
my_thread::my_thread(QTcpSocket *s,QThread *parent)
 : QThread{parent}
{
 socket = s;
}

实现虚函数和槽函数


void my_thread::run()
{
 connect(socket,&QTcpSocket::readyRead,this,&my_thread::clientInfoSlot);

}

void my_thread::clientInfoSlot()
{
 qDebug()<<socket->readAll();
}

10.自定义信号

继QT多线程

子线程

在my_thread类中创建自定义信号

signals:
	void sendToWidget(QByteArray b);

//my_thread.cpp

void my_thread::clientInfoSlot()
{
 //qDebug()<<socket->readAll();
 QByteArray ba = socket ->readAll();
 emit sendToWidget(ba);//发送信号
}

主线程

接收数据链接槽函数

实现槽函数

11.MySQL数据库

MySQL部分

1
2
3
4
5
6
7
8
9


create database mydatabase;

create table student(
 id integer unsigned primary key,
 name varchar(16) not null,
 birth date
)charset utf8;

select * from student;

QT部分

 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


//.h

#include <QSqlDatabase>
#include <QMessageBox>

...
private:
	QSqlDatabase db;



//.cpp
Widget::Widget(QWidget *parent)
 : QWidget(parent)
 , ui(new Ui::Widget)
{
 ui->setupUi(this);

 //连接数据库
 db = QSqlDatabase::addDatabase("QMYSQL");//加载MySQL数据库驱动
 db.setDatabaseName("mydatabase");
 db.setHostName("localhost");
 db.setUserName("root");
 db.setPassword("194910");
 if(db.open())
 {
 QMessageBox::information(this,"连接提示","连接成功");
 }
 else
 {
 QMessageBox::warning(this,"连接提示","连接失败");
 }
}

STM32 BootLoader 学习笔记

Sat, 30 Aug 2025 14:00:00 +0800

BootLoader 学习

硬件：

stm32f407(嘉立创天空星)
HC-05蓝牙模块软件：
暂时使用python简陋演示功能

为什么要有bootloader

类似于电脑的boot，可以让我们很方便的去重装系统，可以用u盘重装系统，可以在线重装系统等
可以把一些固定参数放到bootloader里，比如屏幕亮度，初始参数等等，可以专注于APP的开发

前置知识

单片机组成

电脑组成 stm32内部，与电脑组成类似，主要强调：

片内Flash：相当于电脑硬盘
嵌入式 SRAM：相当与电脑内存条

你需要知道：

嵌入式SRAM是被映射在$0x2000 0000$上的
嵌入式flash是被映射在$0x0800 0000$

stm32启动流程

STM32微控制器从上电或复位到执行你编写的 main() 函数 之前，会经历一系列由硬件和启动代码（通常是汇编语言编写的）完成的初始化步骤

下面是 STM32 从上电到进入 main() 函数的详细过程：

一、硬件复位与启动模式选择

1. 上电复位 (POR) 或硬件复位

当STM32芯片上电或者复位引脚（NRST）被置为低电平并释放时，微控制器会进入复位状态。在复位期间，所有内部寄存器会被设置为预设的初始值，确保系统处于一个确定的、已知的状态。

2. 选择启动模式 (BOOT Pins)

CPU内核在复位结束后，首先会采样特定的启动引脚（如 BOOT0 和 BOOT1，具体名称和数量可能因型号而异）。这些引脚的状态决定了微控制器从哪个存储器空间开始执行代码：

主闪存启动 (Main Flash Memory)：最常用的模式，运行用户编写的程序。
系统存储器启动 (System Memory)：运行内置的 Bootloader，用于通过串口、USB等接口烧录程序。
SRAM 启动 (Embedded SRAM)：运行驻留在SRAM中的代码，不常用。通常，在运行用户程序时，会配置为从主闪存启动。

二、Cortex-M 内核的初始寻址

STM32 的核心是 Cortex-M 系列内核（如 M0、M3、M4、M7），它们遵循一个标准化的启动流程，这部分是由硬件自动完成的。

3. 读取中断向量表

微控制器根据启动模式，确定中断向量表的起始地址（在主闪存启动模式下，通常是 0x0800 0000）。中断向量表是存储了各种异常和中断服务程序入口地址的表格。

4. 初始化栈指针 (SP)

CPU 从向量表的第一个 32 位字（地址 Boot_Address + 0x00）中读取初始的 主栈指针 (MSP) 的值。这是程序中栈区的最高地址，用于存储局部变量、函数调用返回地址等。

5. 设置程序计数器 (PC)

CPU 从向量表的第二个 32 位字（地址 Boot_Address + 0x04）中读取 复位处理程序（Reset_Handler）的地址，并将这个地址加载到 程序计数器 (PC) 中。 至此，硬件初始化完成，程序控制权正式移交给 Reset_Handler。

三、执行启动文件代码 (`Reset_Handler`)

Reset_Handler 是由编译器和芯片厂商提供的一个汇编语言函数，通常位于项目中的 startup_stm32xxx.s 文件（即启动文件）中。它的任务是为C/C++程序的运行准备好环境，包括内存、时钟和库函数等。

6. 调用 `SystemInit()`

Reset_Handler 做的第一件大事是调用 SystemInit() 函数（通常在 system_stm32xxx.c 文件中）。该函数主要完成：

配置系统时钟：设置主时钟源、PLL 倍频等，将系统时钟配置到所需的工作频率（但此时还不涉及用户外设时钟）。
配置存储器：如设置 Flash 访问等待周期等。

7. 初始化 RAM 中的数据段

初始化 .data 段：.data 段存储了已初始化的全局变量和静态变量。这些变量的初始值存储在 Flash 中，Reset_Handler 会将这些值从 Flash 复制到 RAM 中。
初始化 .bss 段：.bss 段存储了未初始化的全局变量和静态变量。C 语言标准要求它们在程序开始时必须被清零。Reset_Handler 会将 .bss 段在 RAM 中的区域清零。

8. 调用 C 库初始化函数

对于标准 C/C++ 环境，Reset_Handler 还会调用 C 库的初始化函数（例如 __libc_init_array），用于：

初始化 C 运行时环境。
调用 C++ 程序的静态构造函数（如果你的代码中有使用）。

9. 跳转到 `main()`

在完成所有必要的硬件和软件环境准备后，Reset_Handler 的最后一步就是执行一条跳转指令，调用用户编写的 main() 函数。代码段

; 假设这是 Reset_Handler 的最后几行伪汇编代码
; ...
BL SystemInit ; 调用系统时钟初始化函数
BL __libc_init_array ; 调用 C 库初始化函数
LDR R0, =main ; 将 main 函数地址加载到 R0
BX R0 ; 跳转到 main 函数执行

至此，STM32 终于进入了你的应用程序，开始执行用户代码。

总结流程图

上电后检查boot引脚的高低决定从哪启动（在哪寻找代码）
读取代码(编译后的2进制文件)的第一个字(主堆栈的地址)，（工厂的工作地点）
寻找第二个字以运行到main();

步骤	执行者	动作描述	目标
1	硬件/CPU	上电复位 (POR)	强制所有硬件到初始状态。
2	硬件/CPU	检查 BOOT 引脚	确定代码的启动位置（如主 Flash）。
3	硬件/CPU	读取向量表	确定 SP 和 PC 的初始值。
4	硬件/CPU	设置初始 SP/PC	初始化主栈指针，跳转到 `Reset_Handler`。
5	启动文件	调用 `SystemInit()`	配置系统时钟和 Flash 等基础硬件。
6	启动文件	初始化数据段	从 Flash 复制 `.data` 到 RAM，将 `.bss` 段清零。
7	启动文件	调用库初始化	初始化 C 运行时环境和静态构造函数。
8	启动文件	调用 `main()`	进入用户应用程序的起点。

问题：

Question1为什么启动后需要先找到中断向量表呢，很重要吗?

Question2:堆栈是用来干嘛的，为什么要先初始化它，不初始化会怎么样

Question3：为什么会映射成0x08000000呢

简单跳转代码

使用O3优化可以减小boot大小 fromelf –bin -o “$L@L.bin” “#L

Boot

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


typedef void (*pFunction)(void);

void JumpToApplication(void) {
 // 1. 检查应用程序地址是否有效
 // 应用程序的栈顶地址位于其起始地址的第一个字
 if (((*(__IO uint32_t*)APP_ADDRESS) & 0x2FFE0000) == 0x20000000) {
 // 2. 将中断向量表重定向到应用程序地址
 SCB->VTOR = APP_ADDRESS;

 // 3. 获取应用程序的栈顶地址和复位处理函数地址
 pFunction app_reset_handler = (pFunction)(*(__IO uint32_t*)(APP_ADDRESS + 4));
 __set_MSP(*(__IO uint32_t*)APP_ADDRESS);

 // 4. 跳转到应用程序
 app_reset_handler();
 }
}

APP

随便，但是：

问题

question1 SCB是什么：

远程下载讲解

注意事项：HC-05的VCC接3V3，实测5V无法使用蓝牙模块只有在通信状态才会显示已连接蓝牙，打不开蓝牙串口参考：HC05和电脑蓝牙通讯 HC05-python-stm32的波特率必须都设置为同样的速率，我这里为9600

蓝牙模块讲解

总结：当成远程串口用就行

常用AT指令

波特率为38400

指令	返回	意义
AT	ok	检测固件是否可用
AT+RESET	ok	模块软件复位
AT+VERSION?	+VERSION:<Param> OK	获取固件版本
AT+NAME=name	ok	设置模块名字
AT+NAME?	+NAME:<Param> OK	返回模块名字
AT+PSWD=“passwd”	OK	设置模块密码
AT+PSWD?	+PSWD:<Param> OK	获取模块密码
AT+UART=115200,0,0	ok	设置通信时的波特率
AT+UART?	+UART:<Param1>,<Param2>,<Param3> OK	获取串口参数

模块指示灯标志

定时闪两下：已经连接蓝牙，处于通信状态
快闪：未连接
慢闪：工作模式，可使用AT指令调整参数（进入：保持按键按下，通电后松开按键即可）

测试流程

先进入工作模式，使用AT检查是否可用，
设置模块名字：AT+NAME=MyBluetooth
获取密码：AT+PSWD?
查看波特率：AT+UART?

嵌入式Flash操作

 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


void Flash_Erase_App(void)
{
 FLASH_EraseInitTypeDef EraseInit;
 uint32_t PageError;
 // 解除Flash保护
 HAL_FLASH_Unlock();

 // F407: sector2(扇区2) = 0x08008000 开始
 EraseInit.TypeErase = FLASH_TYPEERASE_SECTORS;
 EraseInit.Sector = FLASH_SECTOR_2;
 EraseInit.NbSectors = 6; // 到 sector7(扇区7)
 EraseInit.VoltageRange = FLASH_VOLTAGE_RANGE_3;

 if (HAL_FLASHEx_Erase(&EraseInit, &PageError) != HAL_OK) {
 // 错误处理
 }
 // 开启保护
 HAL_FLASH_Lock();
}

HAL_StatusTypeDef Flash_Write(uint32_t addr, uint8_t *data, uint32_t len)
{
 HAL_StatusTypeDef status;
 HAL_FLASH_Unlock();

 for(uint32_t i=0; i<len; i+=4) {
 uint32_t word = *(uint32_t*)(data+i);
 status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, addr+i, word);
 if(status != HAL_OK) break;
 }

 HAL_FLASH_Lock();
 return status;
}

主要逻辑

固件发送与接收

Bootloader代码逻辑

 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


void Bootloader_Update(void)
{
 uint8_t cmd;
 uint8_t buf[256];
 uint32_t addr = APP_ADDR;

 Flash_Erase_App();

 while(1)
 {
 HAL_UART_Receive(&huart1, &cmd, 1, HAL_MAX_DELAY);

 if(cmd == CMD_DATA) {
 uint16_t len;
 HAL_UART_Receive(&huart1, (uint8_t*)&len, 2, HAL_MAX_DELAY);
 HAL_UART_Receive(&huart1, buf, len, HAL_MAX_DELAY);

 Flash_Write(addr, buf, len);
 addr += len;

 HAL_UART_Transmit(&huart1, (uint8_t*)"OK", 2, HAL_MAX_DELAY);
 }
 else if(cmd == CMD_END) {
 HAL_UART_Transmit(&huart1, (uint8_t*)"DONE", 4, HAL_MAX_DELAY);
 break;
 }
 }
}

电脑_python–发送

python要先安装pyserial跑：pip install pyserial 固件采用分批的形式发送，使用python脚本进行发送 ser = serial.Serial("COM4", 9600)这里的COM4需要改成你的com端口

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


import serial
import struct
# 初始化一个串口对象
ser = serial.Serial("COM4", 9600)

def send_data(data):
 ser.write(b"\x02") # CMD_DATA
 # 把当前数据块的长度打包成两个字节的无符号整数（小端序）。
 # 比如 len(data) = 256，那么结果是 b'\x00\x01'，开发板端可以据此知道这包数据有多长。
 ser.write(struct.pack("<H", len(data)))
 ser.write(data)
 # 阻塞读取开发板发送的信息，确保是否传递成功
 print(ser.read(2)) # OK

with open("app.bin", "rb") as f:
 while True:
 # 每次循环读取256个数据
 chunk = f.read(256)
 if not chunk:
 break
 send_data(chunk)

ser.write(b"\x03") # CMD_END
print(ser.read(4)) # DONE

stm32_蓝牙–接收

 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


#define APP_ADDR 0x08008000
#define CMD_START 0x01
#define CMD_DATA 0x02
#define CMD_END 0x03
void Bootloader_Update(void)
{
 uint8_t cmd;
 uint8_t buf[256];
 uint32_t addr = APP_ADDR;
 // 擦除老APP,准备迎接新王
 Flash_Erase_App();

 while(1)
 {
 // 堵塞接收，根据先接收到的命令决定怎么做
 HAL_UART_Receive(&huart1, &cmd, 1, HAL_MAX_DELAY);
 // 数据命令，表示接收到的是数据
 if(cmd == CMD_DATA) {
 uint16_t len;
 // 获取长度
 HAL_UART_Receive(&huart1, (uint8_t*)&len, 2, HAL_MAX_DELAY);
 // 获取内容
 HAL_UART_Receive(&huart1, buf, len, HAL_MAX_DELAY);
 // 写入内容
 Flash_Write(addr, buf, len);
 // 位移地址，准备写入后续内容
 addr += len;
 // 回应OK
 HAL_UART_Transmit(&huart1, (uint8_t*)"OK", 2, HAL_MAX_DELAY);
 }
 // 结束命令，表示接收完成，退出该函数
 else if(cmd == CMD_END) {
 HAL_UART_Transmit(&huart1, (uint8_t*)"DONE", 4, HAL_MAX_DELAY);
 break;
 }
 }
}

增加校验-CRC32

一、CRC32 是什么

CRC 全称 Cyclic Redundancy Check（循环冗余校验）。
CRC32 表示它使用的是 32位的多项式运算结果。它不是“加法求和”那种简单校验，而是用一种二进制多项式除法的思想：

把整个数据看作一个很长的二进制数；
用一个固定的“生成多项式”去做模2除法；
最后得到一个 32 位的余数；
这个余数就是 CRC 校验码。

🧠 模2除法：相当于普通除法，但所有加减都用“异或（XOR）”。

二、CRC32 的作用

CRC32 不是用来“防黑客”或“加密”的，而是为了 检测传输或存储过程中的错误。例如：

你通过串口发送 100KB 的固件；
中途某一字节丢了、翻转了；
STM32 收到的文件计算出的 CRC 不等于原始文件的 CRC；
→ 说明传输错误，不执行更新。可以检测出几乎所有单比特错误、突发错误，非常可靠。

电脑端-python增加校验

 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


import serial
import struct
import binascii
from tqdm import tqdm # pip install tqdm

# 打开串口
ser = serial.Serial("COM4", 9600, timeout=2)

def send_data(data):
 # 发送数据包
 ser.write(b"\x02") # CMD_DATA
 ser.write(struct.pack("<H", len(data))) # 长度
 ser.write(data) # 数据本体
 resp = ser.read(2) # Bootloader 回复 OK
 if resp != b"OK":
 raise Exception("Bootloader写入失败，返回: %s" % resp)

def send_end(crc32, total_size):
 # 通知 Bootloader 固件结束 + CRC
 ser.write(b"\x03") # CMD_END
 ser.write(struct.pack("<I", crc32)) # 4字节 CRC32
 ser.write(struct.pack("<I", total_size)) # 固件总长度（可选）
 resp = ser.read(4)
 if resp != b"DONE":
 raise Exception("Bootloader校验失败，返回: %s" % resp)

# ---------------- 主流程 -----------------
with open("app.bin", "rb") as f:
 data = f.read()

# 计算 CRC32（和 Bootloader 保持一致）
crc32 = binascii.crc32(data) & 0xFFFFFFFF
total_size = len(data)
print(f"固件大小: {total_size} 字节, CRC32 = 0x{crc32:08X}")

# 分块发送（带进度条）
chunk_size = 256
with tqdm(total=total_size, unit="B", unit_scale=True, desc="升级中") as pbar:
 for i in range(0, total_size, chunk_size):
 chunk = data[i:i+chunk_size]
 send_data(chunk)
 pbar.update(len(chunk))

# 通知结束
send_end(crc32, total_size)
print("固件升级完成 ✅")

stm32端-增加校验

在CRC校验算法中，数据被视为一个巨大的二进制数，代表一个多项式的系数。生成多项式（CRC32_POLY）就是用来与这个数据多项式进行“模2除法”运算的除数，最终得到的余数就是CRC校验值。

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


// 多项式 (Ethernet, ZIP, etc. 通用): 0x04C11DB7
#define CRC32_POLY 0xEDB88320UL
uint32_t crc32_calc(uint8_t *data, uint32_t length) {
 uint32_t crc = 0xFFFFFFFFUL;
 for (uint32_t i = 0; i < length; i++) {
 crc ^= data[i];
 for (uint8_t j = 0; j < 8; j++) {
 if (crc & 1) {
 crc = (crc >> 1) ^ CRC32_POLY;
 } else {
 crc >>= 1;
 }
 }
 }
 return ~crc;
}

bootloader逻辑改变

 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


#define APP_ADDR 0x08008000
#define CMD_START 0x01
#define CMD_DATA 0x02
#define CMD_END 0x03
void Bootloader_Update(void)
{
 uint8_t cmd;
 uint8_t buf[256];
 uint32_t addr = APP_ADDR;

 Flash_Erase_App();

 while(1)
 {
 HAL_UART_Receive(&huart1, &cmd, 1, HAL_MAX_DELAY);

 if(cmd == CMD_DATA) {
 uint16_t len;
 HAL_UART_Receive(&huart1, (uint8_t*)&len, 2, HAL_MAX_DELAY);
 HAL_UART_Receive(&huart1, buf, len, HAL_MAX_DELAY);

 Flash_Write(addr, buf, len);
 addr += len;

 HAL_UART_Transmit(&huart1, (uint8_t*)"OK", 2, HAL_MAX_DELAY);
 }
 else if(cmd == CMD_END) {
 uint32_t host_crc, host_size;
			HAL_UART_Receive(&huart1, (uint8_t*)&host_crc, 4, HAL_MAX_DELAY);
			HAL_UART_Receive(&huart1, (uint8_t*)&host_size, 4, HAL_MAX_DELAY);

			// 自己计算 CRC32
			uint32_t calc_crc = crc32_calc((uint8_t*)APP_ADDR, host_size);

			if (calc_crc == host_crc) {
				HAL_UART_Transmit(&huart1, (uint8_t*)"DONE", 4, HAL_MAX_DELAY);
			} else {
				HAL_UART_Transmit(&huart1, (uint8_t*)"FAIL", 4, HAL_MAX_DELAY);
			}
 break;
 }
 }
}

FreeRTOS 源码解析笔记

Sat, 09 Aug 2025 10:00:00 +0800

1.动态创建详细过程

动态创建

1.首先tasks.c中

结构体并给别名，所以初始化可以用TCB_t

typedef struct tskTaskControlBlock

{

…

}tskTCB; typedef tskTCB TCB_t;

2.因此在xTaskCreate()实现中

TCB_t * pxNewTCB;创建了任务控制块

3.任务控制块的结构体中

状态列表事件列表优先级栈指针任务名

4.回到xTaskCreate

判断生长方向，STM32栈区向下生长

#if ( portSTACK_GROWTH > 0 )

进入的

#else中

其中先定义任务堆栈大小：

StackType_t * pxStack;//这个申请的代表首地址

pxStack = pvPortMallocStack( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) );//如128*4字节，128字×每字字节数=字节数

判断是否申请成功任务堆栈，成功则进入

 if( pxStack != NULL )
 {
 pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); //任务控制块信息也需要空间，因此申请
 if( pxNewTCB != NULL ) //如果申请了一块
 {
 memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) );
 pxNewTCB->pxStack = pxStack;//然后将首地址给到任务控制块的这个成员变量
 }
 else
 {
 vPortFreeStack( pxStack );//否则就释放掉任务堆栈
 }
 }
 else
 {
 pxNewTCB = NULL;
 }

再下面判断是否申请成功任务控制块

prvInitialiseNewTask：这个用来初始化任务控制块中的成员

prvAddNewTaskToReadyList：将任务添加到就绪列表

 if( pxNewTCB != NULL )
 {
 prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );
 prvAddNewTaskToReadyList( pxNewTCB );
 xReturn = pdPASS;//就是成功的返回值
 }
 else
 {
 xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
 }

5.到prvInitialiseNewTask

( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );

这句pxStack是任务堆栈的首地址，将( size_t ) ulStackDepth * sizeof( StackType_t )大小的地址赋值为( int ) tskSTACK_FILL_BYTE

而这个值是

#define tskSTACK_FILL_BYTE ( 0xa5U )

意思就是整个任务堆栈赋值成a5，那就可以通过判断多少a5被改变，得到剩下的空间

6.判断 #if ( portSTACK_GROWTH < 0 )

是否向下生长？

STM32:是的

//首地址的最低位，取得栈顶
pxTopOfStack = &( pxNewTCB->pxStack[ ulStackDepth - ( uint32_t ) 1 ] );

判断名字是否为空

//pcName是一个入口参数
if( pcName != NULL )
 {
 for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
 {
 pxNewTCB->pcTaskName[ x ] = pcName[ x ]; //给到任务控制块的这个成员里
 if( pcName[ x ] == ( char ) 0x00 )
 {
 break;
 }
 else
 {
 mtCOVERAGE_TEST_MARKER();
 }
 }
 pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';
 }
 else
 {
 mtCOVERAGE_TEST_MARKER();
 }

判断优先级

优先级大于最大优先级，就改为最大优先级

if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
 {
 uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
 }

pxNewTCB->uxPriority = uxPriority;

然后初始化状态列表项和事件列表项

vListInitialiseItem( &( pxNewTCB->xStateListItem ) ); vListInitialiseItem( &( pxNewTCB->xEventListItem ) );

将状态列表项所有权给到任务控制块，就可以得到任务当前状态

listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );

下面是事件列表项

listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority ); 
 listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );

下面来到

pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );

7.进入pxPortInitialiseStack

里面栈顶陆续减，就可以往下陆续给赋值。

StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
 TaskFunction_t pxCode,
 void * pvParameters )
{
 
 pxTopOfStack--; 
 *pxTopOfStack = portINITIAL_XPSR; /* xPSR */
 pxTopOfStack--;
 *pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK; /* PC */
 pxTopOfStack--;
 *pxTopOfStack = ( StackType_t ) prvTaskExitError; /* LR */

 pxTopOfStack -= 5; /* R12, R3, R2 and R1. */
 *pxTopOfStack = ( StackType_t ) pvParameters; /* R0 */
 pxTopOfStack -= 8; /* R11, R10, R9, R8, R7, R6, R5 and R4. */

 return pxTopOfStack;
}

PC是任务函数指针，切换到A任务时，就通过这个指针切换到任务函数A

这个实际就是最初传入的函数指针

而R0传入的是任务函数参数

程序结束后返回更新后的pxTopOfStack

8.回到prvInitialiseNewTask

将任务句柄给到任务控制块

if( pxCreatedTask != NULL ) { *pxCreatedTask = ( TaskHandle_t ) pxNewTCB; }

9.再到prvAddNewTaskToReadyList()

这是将任务添加到就绪列表

先进入临界区 taskENTER_CRITICAL();

增加任务数量uxCurrentNumberOfTasks++;

如果当前没有任务，这是第一个任务pxCurrentTCB = pxNewTCB;

如果这确实是第一个if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )

就初始化任务列表prvInitialiseTaskLists()

10.进入prvInitialiseTaskLists()

初始化32个就绪列表0~31

for( uxPriority = ( UBaseType_t ) 0U; uxPriority < ( UBaseType_t ) configMAX_PRIORITIES; uxPriority++ )
 {
 vListInitialise( &( pxReadyTasksLists[ uxPriority ] ) );
 }

如果使能删除列表，就初始化一个等待删除列表

如果使能挂起列表，就初始化一个挂起列表

#if ( INCLUDE_vTaskDelete == 1 )
 {
 vListInitialise( &xTasksWaitingTermination );
 }
 #endif /* INCLUDE_vTaskDelete */

 #if ( INCLUDE_vTaskSuspend == 1 )
 {
 vListInitialise( &xSuspendedTaskList );
 }
 #endif /* INCLUDE_vTaskSuspend */

11.继续prvAddNewTaskToReadyList()

否则的话，如果当前任务控制块优先级小于新创建的任务控制块

那新创建的就赋给当前

if( xSchedulerRunning == pdFALSE )
 {
 if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )
 {
 pxCurrentTCB = pxNewTCB;
 }
 else
 {
 mtCOVERAGE_TEST_MARKER();
 }
 }

下面是任务标号，就可以通过这个查询这是第几个创建的任务

12.进入prvAddTaskToReadyList( pxNewTCB );

进入 taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );

进如portRECORD_READY_PRIORITY

得到

#define portRECORD_READY_PRIORITY( uxPriority, uxReadyPriorities ) ( uxReadyPriorities ) |= ( 1UL « ( uxPriority ) )

表示就绪列表，哪个位置一，哪个位就有任务，从上往下读就知道哪个任务优先级最高

13.继续prvAddNewTaskToReadyList()

退出临界区taskEXIT_CRITICAL();

如果任务调度器开启，当前任务优先级，小于新的优先级，执行任务切换，到优先级最高的

2.任务挂起与恢复详细过程

任务挂起

1.进入prvGetTCBFromHandle

如果句柄为NULL，返回当前任务控制块句柄，否则返回传入任务控制块句柄

#define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? pxCurrentTCB : ( pxHandle ) )

2.回到vTaskSuspend

if内是不管当前状态是什么，并移除列表项，移除成功则进入

 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
 {
 taskRESET_READY_PRIORITY( pxTCB->uxPriority );
 }

3.进入taskRESET_READY_PRIORITY

if(listCURRENT_LIST_LENGTH(&(pxReadyTasksLists[( uxPriority ) ] ) ) == ( UBaseType_t ) 0 ) 
 { 
 portRESET_READY_PRIORITY( ( uxPriority ), ( uxTopReadyPriority ) ); 
 }

4.回到vTaskSuspend

移除事件列表项

if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
 {
 ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
 }

插入挂起列表项末尾

vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );

如果带挂起的任务控制块在等待消息通知，清除消息通知

for( x = 0; x < configTASK_NOTIFICATION_ARRAY_ENTRIES; x++ )
 {
 if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION )
 {
 pxTCB->ucNotifyState[ x ] = taskNOT_WAITING_NOTIFICATION;
 }
 }

判断调度器是否正在运行

如果正在运行，更新下一个阻塞超时时间

if( xSchedulerRunning != pdFALSE )
 {
 taskENTER_CRITICAL();
 {
 prvResetNextTaskUnblockTime();
 }
 taskEXIT_CRITICAL();
 }

判断挂起是否为任务自己，如果挂起的是自己，强制进行任务切换。

如果不是，判断当前挂起的任务总数等于创建的任务总数，表明全部在挂起，则将任务控制块赋值为NULL，

if( pxTCB == pxCurrentTCB )
 {
 if( xSchedulerRunning != pdFALSE )
 {
 configASSERT( uxSchedulerSuspended == 0 );
 portYIELD_WITHIN_API();
 }
 else
 {
 if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) 
 {
 pxCurrentTCB = NULL;
 }
 else
 {
 vTaskSwitchContext();		//查找下一个最高优先级任务
 }
 }
 }

任务恢复

任务句柄赋值给任务控制块

TCB_t * const pxTCB = xTaskToResume;

恢复的任务控制块不能等于当前任务和NULL

if( ( pxTCB != pxCurrentTCB ) && ( pxTCB != NULL ) )

如果成立进入，判断任务控制块是否在挂起列表中

if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )

如果成立进入，在挂起列表中移除

( void ) uxListRemove( &( pxTCB->xStateListItem ) );

并添加到就绪列表

prvAddTaskToReadyList( pxTCB );

在判断优先级是否大于当前优先级，如果是，则任务切换

taskYIELD_IF_USING_PREEMPTION();

 if( ( pxTCB != pxCurrentTCB ) && ( pxTCB != NULL ) )
 {
 taskENTER_CRITICAL();
 {
 if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )
 {
 traceTASK_RESUME( pxTCB );
 ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
 prvAddTaskToReadyList( pxTCB );
 if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
 {
 taskYIELD_IF_USING_PREEMPTION();
 }
 else
 {
 mtCOVERAGE_TEST_MARKER();
 }
 }
 else
 {
 mtCOVERAGE_TEST_MARKER();
 }
 }
 taskEXIT_CRITICAL();
 }
 else
 {
 mtCOVERAGE_TEST_MARKER();
 }

3.临界段代码保护

通过++，–实现了嵌套，本质还是基于portDISABLE_INTERRUPTS();和portENABLE_INTERRUPTS();

/*进入临界段*/
#define taskENTER_CRITICAL() portENTER_CRITICAL()
#define portENTER_CRITICAL() vPortEnterCritical()

void vPortEnterCritical( void )
{
 portDISABLE_INTERRUPTS();
 uxCriticalNesting++;
 if( uxCriticalNesting == 1 )
 {
 configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );
 }
}

/*退出临界段*/
void vPortExitCritical( void )
{
 configASSERT( uxCriticalNesting );
 uxCriticalNesting--;
 if( uxCriticalNesting == 0 )
 {
 portENABLE_INTERRUPTS();
 }
}

4.任务调度

FreeRTOS 常用 API 手册

Sat, 26 Jul 2025 10:30:00 +0800

任务内核

portDISABLE_INTERRUPTS() portENABLE_INTERRUPTS()

关闭FreeRTOS可管理的5-15优先级的中断

开启FreeRTOS可管理的5-15优先级的中断

taskENTER_CRITICAL() taskEXIT_CRITICAL()

任务中进入临界段

任务中退出临界段

taskENTER_CRITICAL() ;
{
… … /* 临界区 */
}
taskEXIT_CRITICAL() ;

taskENTER_CRITICAL_FROM_ISR() taskEXIT_CRITICAL_FROM_ISR()

中断中进入临界段

中断中退出临界段

uint32_t save_status;
save_status = taskENTER_CRITICAL_FROM_ISR() ；
{
… … /* 临界区 */
}
taskEXIT_CRITICAL_FROM_ISR(save_status );

vTaskSuspendAll() xTaskResumeAll()

实现任务调度器挂起与恢复

vTaskSuspendAll() ;
{
… … /* 内容 */
}
xTaskResumeAll();

void vTaskStartScheduler()

vTaskStartScheduler();

任务创建与删除

1.xTaskCreate

参数和返回值

BaseType_t xTaskCreate
(
	TaskFunction_t pxTaskCode, 					/* 指向任务函数的指针 */
	const char * const pcName, 					/* 任务名字，最大长度 configMAX_TASK_NAME_LEN */
	const configSTACK_DEPTH_TYPE usStackDepth, 	/* 任务堆栈大小，注意字为单位 */
	void * const pvParameters, 					/* 传递给任务函数的参数 */
	UBaseType_t uxPriority, 					/* 任务优先级，范围： 0 ~ configMAX_PRIORITIES - 1 */
	TaskHandle_t * const pxCreatedTask 			/* 任务句柄，就是任务的任务控制块 */
)

返回:
pdPASS 任务创建成功
errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY 任务创建失败

实现例程

#define START_TASK_STACK_SIZE 	128					//栈大小
#define START_TASK_PRIO 	 	1					//优先级
TaskHandle_t 					start_task_handle;	//句柄
void startTask(void* pvParamenters);

#define TASK1_STACK_SIZE 		128
#define TASK1_PRIO 	 			2
TaskHandle_t 					task1_handle;
void task1(void* pvParamenters);

void freertos_demo(void)
{
	xTaskCreate( (TaskFunction_t	 ) startTask,
	 			 (char *		 ) "startTask", 
				 (configSTACK_DEPTH_TYPE) START_TASK_STACK_SIZE,
				 (void * 			 ) NULL,
				 (UBaseType_t ) START_TASK_PRIO,
				 (TaskHandle_t * 	 ) &start_task_handle );

	vTaskStartScheduler();
}

void startTask(void* pvParamenters)
{
	taskENTER_CRITICAL();
	xTaskCreate( (TaskFunction_t 	 ) task1,			//任务函数
				 (char *		 	 ) "task1", 			//任务名
			 	 (configSTACK_DEPTH_TYPE) TASK1_STACK_SIZE,	//任务堆栈
				 (void * 		 	 ) NULL,				//任务函数参数
				 (UBaseType_t ) TASK1_PRIO,		//优先级
				 (TaskHandle_t * 	 ) &task1_handle );	//任务句柄（就是指向任务控制块头的指针）

	vTaskDelete(start_task_handle);
	taskEXIT_CRITICAL();
}

void task1(void* pvParamenters){
	while(1){
	}
}

2.xTaskCreateStatic

参数和返回值

TaskHandle_t xTaskCreateStatic
(
	TaskFunction_t pxTaskCode, 			/* 指向任务函数的指针 */
	const char * const pcName, 			/* 任务函数名 */
	const uint32_t ulStackDepth, 		/* 任务堆栈大小注意字为单位 */
	void * const pvParameters, 			/* 传递的任务函数参数 */
	UBaseType_t uxPriority, 			/* 任务优先级 */
	StackType_t * const puxStackBuffer, /* 任务堆栈，一般为数组，由用户分配 */
	StaticTask_t * const pxTaskBuffer 	/* 任务控制块指针，由用户分配 */
);

返回:
NULL 用户没有提供相应的内存，任务创建失败
其他值 任务句柄，任务创建成功

实现例程

#define START_TASK_STACK_SIZE 	128
#define START_TASK_PRIO 	 	1
TaskHandle_t 					start_task_handle;
StackType_t						start_task_stack[START_TASK_STACK_SIZE];
StaticTask_t					start_task_buffer;
void startTask(void* pvParamenters);

#define TASK1_STACK_SIZE 		128
#define TASK1_PRIO 	 			2
TaskHandle_t 					task1_handle;
StackType_t						task1_stack[TASK1_STACK_SIZE];
StaticTask_t					task1_buffer;
void task1(void* pvParamenters);

/*空闲任务配置*/
StaticTask_t idle_task_tcb;
StackType_t idle_task_stack[configMINIMAL_STACK_SIZE];

/*软件定时器任务配置*/
StaticTask_t timer_task_tcb;
StackType_t timer_task_stack[configTIMER_TASK_STACK_DEPTH];

/*空闲任务内存分配*/
void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
 StackType_t ** ppxIdleTaskStackBuffer,
 uint32_t * pulIdleTaskStackSize )
{
	*ppxIdleTaskTCBBuffer = &idle_task_tcb;
	*ppxIdleTaskStackBuffer = idle_task_stack;
	*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
}

/*软件定时器内存分配*/
void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
 StackType_t ** ppxTimerTaskStackBuffer,
 uint32_t * pulTimerTaskStackSize )
{
	*ppxTimerTaskTCBBuffer = &timer_task_tcb;
	*ppxTimerTaskStackBuffer = timer_task_stack;
	*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
}

void freertos_demo(void)
{
	
	start_task_handle = xTaskCreateStatic( (TaskFunction_t) startTask,
										 (char* 		 ) "startTask", 
										 (uint32_t	 ) START_TASK_STACK_SIZE,
										 (void*		 ) NULL,
										 (UBaseType_t	 ) START_TASK_PRIO,
										 (StackType_t* ) start_task_stack,
										 (StaticTask_t* ) &start_task_buffer );
	vTaskStartScheduler();
}

void startTask(void* pvParamenters)
{
	taskENTER_CRITICAL();
	task1_handle = xTaskCreateStatic( (TaskFunction_t) task1,
									 (char* 		 ) "task1", 
									 (uint32_t	 ) TASK1_STACK_SIZE,
									 (void*		 ) NULL,
									 (UBaseType_t	 ) TASK1_PRIO,
									 (StackType_t* ) task1_stack,
									 (StaticTask_t* ) &task1_buffer );
	vTaskDelete(start_task_handle);
	taskEXIT_CRITICAL();
}

void task1(void* pvParamenters)
{
	while(1)
	{
	}
}

3.vTaskDelete

void vTaskDelete(TaskHandle_t xTaskToDelete);//xTaskToDelete 待删除任务的任务句柄

任务挂起与恢复

1.vTaskSuspend

void vTaskSuspend( TaskHandle_t xTaskToSuspend );
vTaskSuspend(任务句柄);
vTaskSuspend(NULL);//挂起本任务

2.vTaskResume

void vTaskResume( TaskHandle_t xTaskToResume );
vTaskResume(任务句柄);

3.xTaskResumeFromISR

BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume );

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	BaseType_t xYieldRequired;
	switch(GPIO_Pin)
	{
	case GPIO_PIN_0:
		delay_ms(20); /* 消抖 */
		flag2_suspend++;
		if(flag2_suspend%2==1) vTaskSuspend(task2_handle);
		else xYieldRequired = xTaskResumeFromISR(task2_handle);
		portYIELD_FROM_ISR( xYieldRequired );		//任务恢复后需要进行任务切换
		
		break;
	}
}

列表与列表项

1.vListInitialise

初始化列表

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


/*pxList 是待初始化列表*/
void vListInitialise( List_t * const pxList )
{
 //初始化时，列表只有xListEnd，pxIndex指向xListEnd
 pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd ); 
	//末尾列表项默认最大值，升序排序在最后
	pxList->xListEnd.xItemValue = portMAX_DELAY;
	//初始化时，列表中只有xListEnd，因此上下都是本身
	pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd ); 
	pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd ); 
	//初始化时列表项数量为0（不包含xListEnd）
	pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
	//初始化校验
	listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
	listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
}

2.vListInitialiseItem

初始化列表项

1
2
3
4
5
6
7
8
9


/*pxItem是待初始化列表项*/
void vListInitialiseItem( ListItem_t * const pxItem )
{
	//初始化时，列表项所在列表为空
 pxItem->pxContainer = NULL;

 listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
 listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
}

3.vListInsertEnd

列表末尾插入列表项

1
2


//目标列表，目标列表项
void vListInsertEnd(List_t * const pxList,ListItem_t * const pxNewListItem);

4.vListInsert

列表插入列表项

1
2


//目标列表，目标列表项
void vListInsert(List_t * const pxList,ListItem_t * const pxNewListItem); 

5.uxListRemove

列表移除列表项

1
2
3


//pxItemToRemove 待移除的列表项
UBaseType_t uxListRemove ( ListItem_t * const pxItemToRemove );
//返回值，移除后所剩列表项

插入删除实验

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


/*创建列表*/
List_t 	 TestList;
ListItem_t ListItem1;
/*初始化列表，列表项*/
vListInitialise(&TestList);
vListInitialiseItem(&ListItem1);
ListItem1.xItemValue = 40;
/*插入列表项*/
vListInsert((List_t* )&TestList, /* 列表 */
 (ListItem_t*)&ListItem1); /* 列表项 */

任务相关API

1.uxTaskPriorityGet

获取任务优先级

打开宏INCLUDE_uxTaskPriorityGet

//xTask要查找的任务句柄， NULL 代表任务自身
UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask )
//返回无符号整数，为任务优先级

2.vTaskPrioritySet

改变任务优先级

宏 INCLUDE_vTaskPrioritySet 为 1

//xTask任务句柄 uxNewPriority优先级
void vTaskPrioritySet( TaskHandle_t xTask , UBaseType_t uxNewPriority )

3.uxTaskGetNumberOfTasks

此函数用于获取系统中任务的任务数量

UBaseType_t uxTaskGetNumberOfTasks( void )

4.uxTaskGetSystemState

获取系统中所有任务的任务状态信息

消息队列API

例子

 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


QueueHandle_t key_quque; /*小数据句柄*/
QueueHandle_t big_date_queue;/*大数据句柄*/
char buff[100] = {"This is a big data queue"};

key_quque = xQueueCreate(2,sizeof(uint8_t));
 if(key_quque != NULL)
 {
 printf("key_queue队列创建成功\r\n");
 }else printf("key_queue队列创建失败\r\n");

big_date_queue = xQueueCreate(1,sizeof(char *));
 if(key_quque != NULL)
 {
 printf("big_date_queue队列创建成功\r\n");
 }else printf("big_date_queue队列创建失败\r\n");
/*入队，发送*/
void task1()
{
 key_val = key_scan(0);
 if(key_val == KEY0_PRES || key_val == KEY1_PRES)
 {
 err = xQueueSend(key_quque,&key_val,portMAX_DELAY);
 if(err!=pdTRUE)
 {
 printf("key_queue队列发送失败\r\n");
 }
 }
}

/*出队，读取*/
void task2()
{
 if(xQueueReceive(big_date_queue,&buf,portMAX_DELAY)!=pdTRUE)
 {
 printf("big_date_queue队列接收失败\r\n"); 
 }
 else 
 {
 printf("big_date_queue读取队列成功,数据%s\r\n",buf);
 }
}

FreeRTOS 学习笔记：从入门到内核机制

Sat, 12 Jul 2025 10:00:00 +0800

序、FreeRTOS函数名前缀

一、单片机程序设计模式

1.轮询模式

2.前后台

后台：执行在main

前台：执行在中断，但不能执行太多

可以在中断中用标志位，将任务放在主函数

3.定时器驱动

函数执行不能太长

4.状态机

基于轮询，将单个任务分解成多个任务，减少每个任务需要的时间，降低造成的相互影响

5.多任务系统

交替执行，基于时间片和任务优先级调度

对于重要的任务可以提高优先级，在高优先级处于延时中执行低优先级任务

伪代码实现

void main()
{
// 创建 2 个任务
create_task(task1);
create_task(task2);
// 启动调度器
start_scheduler();
}
task1()
{
while(1)
{
	do_task1();
}
}
task2()
{
while(1)
{
	do_task2();
}
}

二、FreeRTOS基础知识

1.任务调度简介(熟悉)

抢占式：每个任务有优先级，优先级高抢占优先级低

FreeRTOS数值越大，优先级越高

Task1 、 Task2 、 Task3 的优先级分别为 1 、 2 、 3 ；在FreeRTOS 中任务设置的数值越大，优先级越高，所以 TASK3 的优先级最高

时间片：同优先级，每个时钟节拍切换任务

同等优先级任务轮流地享有相同的 CPU 时间 ( 可设置 ) ，叫时间片，在 FreeRTOS 中，一个时间片就等于 SysTick 中断周期

没用完的时间片抛弃

协程式：当前执行任务一直执行，高优先级不抢占低优先级（不常用）

2.任务状态(熟悉)

1.运行态

正在执行，同一时间仅一个

2.就绪态

能够被执行，但还未执行

3.阻塞态

任务在延时或等待外部事件发生

4.挂起态

类似暂停，不参与调度，需要解挂才能进就绪vTaskResume()；

注：只有就绪态可以转运行态，挂起要解挂，阻塞要变成就绪

任务状态列表

1.就绪列表：pxReadyTasksLists[x]，其中 x 代表任务优先级数值。0~31，31最高

32位变量，当某个位置一说明对应优先级有任务存在

2.阻塞列表：pxDelayedTaskList

3.挂起列表：xSuspendedTaskList

调度器取就绪列表最高优先级任务来执行

相同优先级的任务会连接在同一个就绪列表

三、FreeRTOS移植

源码：https://www.freertos.org/

FreeRTOS：内核有用

Demo和Source

Source文件夹

include,portable,list,queue,task必须

portable文件夹

与硬件连接桥梁

由于使用MDK开发，只要

手把手移植

1.基础工程的Middlewares文件夹中新建一个FreeRTOS子文件夹

将FreeRTOS内核源码的Source文件夹下的所有文件添加到工程的FreeRTOS文件夹中

CORE中是源码

heap_4是内存管理算法4

port是软硬件连接桥梁

port根据芯片选择

头文件哪有就加什么路径

2.添加 FreeRTOSConfig.h 文件

这个可裁剪，用不到的功能可以裁剪，Demo里有，或者例程

3.修改SYSTEM

详阅《FreeRTOS开发指南》

系统配置详解

FreeRTOSConfig.h 配置文件作用：对 FreeRTOS 的功能进行配置和裁剪，以及 API 函数的使能

详看注释

四、FreeRTOS任务创建和删除

1.任务创建和删除的 API 函数

API	描述
xTaskCreate()	动态创建
xTaskCreateStatic()	静态创建
vTaskDelete()	删除

动态创建：任务控制块以及任务栈空间所需内存，有FreeRTOS自动分配

静态创建：用户分配

动态创建

返回pdPass：创建成功

返回errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY：创建失败

流程：

1、将宏 configSUPPORT_DYNAMIC_ALLOCATION 配置为 1

2 、定义函数入口参数

3 、编写任务函数

创建后进入就绪态，然后启动任务调度器运行

内部实现：

任务控制块就是任务的身份证，保留任务的信息

静态创建

返回NULL：创建成功

其他值：任务句柄，任务创建成功

流程：

1 、需将宏 configSUPPORT_STATIC_ALLOCATION 配置为 1

2 、定义空闲任务 & 定时器任务的任务堆栈及TCB

3 、实现两个接口函数

vApplicationGetIdleTaskMemory( )必须

vApplicationGetTimerTaskMemory ()可选

4 、定义函数入口参数

5 、编写任务函数

任务删除

xTaskDelete(TaskHandle_t xTaskToDelete);

实际是通过传入的任务句柄获取任务控制块，从四个任务列表中移除

注意：1.当传入NULL，删除任务自身

2.空闲任务会释放被删除任务中有系统分配的内存，但是用户在任务删除前申请的内存，需要手动释放，否则内存泄漏

五、FreeRTOS任务挂起与恢复

1.任务挂起与恢复的API函数

挂起：暂停

恢复：继续

FromISR：从中断中恢复

任务挂起

将宏 INCLUDE_vTaskSuspend 配置为 1

任务恢复

将宏 INCLUDE_vTaskSuspend 必须定义为 1

中断中恢复

INCLUDE_vTaskSuspend 和 INCLUDE_xTaskResumeFromISR 必须定义为 1

注意：中断服务程序中要调用FreeRTOS的API，中断优先级不能高于FreeRTOS所管理的优先级

因为FreeRTOS管理的5~~15的优先级，所有中断优先级不能在0~~4，因为中断优先级数字越低优先级越高

六、FreeRTOS中断管理

1.中断

中断请求，响应中断（转中断处理ISR），退出中断

2.中断优先级

8位宽寄存器来配置中断优先级

ARM Cortex-M支持2^8=256个中断优先级

STM32只用高四位[7:4]，所以STM32提供2^4=16个中断优先级

STM32中断分为抢占优先级和子优先级

抢占优先级：抢占优先级高的中断可以打断正在执行但抢占优先级低的中断

子优先级：当同时发生具有相同抢占优先级的两个中断时，子优先级数值小的优先执行

（中断优先级数字越小越优先）

分配方式

如：HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4 ）设置优先级分组4

注意

1 、低于 configMAX_SYSCALL_INTERRUPT_PRIORITY 优先级的中断里才允许调FreeRTOS 的 API 函数

2 、建议将所有优先级位指定为抢占优先级位，方便 FreeRTOS 管理

HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4 ）

3 、中断优先级数值越小越优先，任务优先级数值越大越优先

七、临界段代码保护任务调度器挂起和恢复

1.临界段代码保护

临界段：指那些必须完整运行，不能被（中断、任务调度PendSV）打断的代码段

需要保护：

1.严格时序初始化的外设

2.系统自身需求

3.用户需求

2.临界段代码保护函数

临界区屏蔽中断，系统任务调度和ISR都靠中断，因此临界区不能长

3.任务调度器挂起和恢复

挂起任务调度器，就是不许任务切换，不需要关闭中断

1.挂起任务调度器未关闭中断

2.防止任务间资源争夺，中断照样响应

八、FreeRTOS列表和列表项

1.列表和列表项

列表是FreeRTOS的一个数据结构，类似链表，用于跟踪FreeRTOS的任务

列表项是在列表中的项目

FreeRTOS中列表是双向环形链表

非连续地址，人为连接到一起，数目后期添加，随时可以改变

列表相关结构体

1.校验值：用于调试，默认不开启

2.uxNumberOfltems，记录列表项的个数

3.pxIndex：指向列表中的某个列表项，用于遍历列表项

4.xListEnd是迷你列表项，排在末尾

列表项结构体

1.xItemValue为列表项的值，对列表项进行排序（升序）

2.pxNext 和 pxPrevious 分别用于指向列表中列表项的下一个列表项和上一个列表项

3.pxOwner指向包含列表项的对象（通常是任务控制块）

3.pxContainer指向列表项所在列表

迷你列表项结构体

用于标记列表的末尾和挂载其他插入列表中的列表项

少了pxOwner和pxContainer

列表和列表项的关系

列表初始化就有末尾列表项，而无列表项

初始末尾列表项的xItemValue=0xFFFFFFFF

*pxPrevious，*pxNext都是指向的列表项的头指针（首地址）

pxIndex不遍历时不指向

2.列表及列表项API

九、任务调度机制*

1.开启任务调度器

vTaskStartScheduler()中

启动任务调度器

1.创建空闲任务

先判断创建方式：静态创建、动态创建；根据宏configSUPPORT_STATIC_ALLOCATION选择

2.定时器任务

如果使能软件定时器，创建定时器任务

根据宏configUSE_TIMERS；xTimerCreateTimerTask()

若创建成功

3.关闭中断

防止调度器开启之前或过程中，受中断干扰，会在运行第一个任务时打开中断

portDISABLE_INTERRUPTS();

4.初始化全局变量

并将任务调度器设置为已运行

//阻塞时间默认最大值
xNextTaskUnblockTime = portMAX_DELAY;
//调度器运行状态
xSchedulerRunning = pdTRUE;
//初始节拍 0
xTickCount = ( TickType_t ) configINITIAL_TICK_COUNT;

5.调用xPortStartScheduler();

作用：该函数用于完成启动任务调度器中与硬件架构相关的配置部分，以及启动第一个任务

5.1检测配置是否有误

用户在 FreeRTOSConfig.h 文件中对中断的相关配置

5.2配置 PendSV 和 SysTick

配置 PendSV 和 SysTick 的中断优先级为最低优先级

portNVIC_SHPR3_REG |= portNVIC_PENDSV_PRI;
portNVIC_SHPR3_REG |= portNVIC_SYSTICK_PRI;

5.3调用vPortSetupTimerInterrupt()；

函数中在配置SysTick

SysTick控制及状态寄存器（地址：0xE000_E010）

SysTick当前数值寄存器（地址：0xE000_E018）

1
2
3
4
5
6
7


/*
配置寄存器
#define portNVIC_SYSTICK_CTRL_REG ( *( ( volatile uint32_t * ) 0xe000e010 ) )
#define portNVIC_SYSTICK_CURRENT_VALUE_REG ( *( ( volatile uint32_t * ) 0xe000e018 ) )
*/
portNVIC_SYSTICK_CTRL_REG = 0UL;
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;

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


/*
#define portNVIC_SYSTICK_CTRL_REG ( *( ( volatile uint32_t * ) 0xe000e010 ) )
#define portNVIC_SYSTICK_LOAD_REG ( *( ( volatile uint32_t * ) 0xe000e014 ) )
*/
/*
F103C8中
uint32_t SystemCoreClock = 16000000;
#define configCPU_CLOCK_HZ 	SystemCoreClock //定义CPU主频, 单位: Hz, 无默认需定义
#define configSYSTICK_CLOCK_HZ (configCPU_CLOCK_HZ / 8)
#define configTICK_RATE_HZ 20					/* 定义系统时钟节拍频率, 单位: Hz, 无默认需定义 */
*/
portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );

5.4初始化临界区嵌套计数器为 0

uxCriticalNesting = 0;

5.5调用函数 prvEnableVFP() 使能 FPU

Cortex M3没有FPU

5.6调用函数 prvStartFirstTask() 启动第一个任务

2.启动第一个任务

要启动的第一个任务是任务 A，那么就需要将任务A的寄存器值恢复到CPU寄存器

任务 A 的寄存器值，在一开始创建任务时就保存在任务堆栈里

注意：

1、中断产生时，硬件自动将 xPSR，PC(R15) ，LR(R14) ，R12 ，R3-R0出/入栈；而 R4~R11需要手动出/入栈

2 、进入中断后硬件会强制使用 MSP 指针，此时 LR(R14 ）的值将会被自动被更新为特殊的 EXC_RETURN

prvStartFirstTask()

….

/* Call SVC to start the first task. */ svc 0

触发SVC中断，启动第一个任务

#define vPortSVCHandler SVC_Handler

SVC中断

只在启动第一次任务时会调用一次，以后不调用

出栈/压栈汇编指令详解

3.任务切换

任务切换本质：CPU寄存器的切换

就是把不同任务加载到CPU寄存器里

假设要把任务A切换到B：

第一步：暂停任务A，将此时任务A的寄存器保存（压栈）到任务堆栈，即保存现场

第二步：将任务B的寄存器值（存在任务堆栈中）恢复到CPU寄存器，即恢复现场

切换过程：保存A现场，恢复B现场，即上下文切换

需要手动的部分：R4-R11

切换：任务切换在PendSV中断服务函数里完成

如何触发PendSV中断

1.滴答定时器中断调用

2.FreeRTOS相关API：portYIELD()；//底层函数

本质：向中断控制和状态寄存器ICSR的bit28写1挂起PendSV来启动PendSV中断

流程

1：滴答定时器中断处理函数SysTick_Handler()

启动了任务调度器，则进入xPortSysTickHandler()

判断xTaskIncrementTick()

则执行

1
2
3
4


#define portNVIC_INT_CTRL_REG ( *( ( volatile uint32_t * ) 0xe000ed04 ) )
#define portNVIC_PENDSVSET_BIT ( 1UL << 28UL )
//即向地址0xe000ed04 第28位写入1
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;

#define portYIELD() 
{ 
 portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; 
 __dsb( portSY_FULL_READ_WRITE ); 
 __isb( portSY_FULL_READ_WRITE ); 
}

PendSV中断服务函数

FreeRTOSConfig.h中

#define xPortPendSVHandler PendSV_Handler

 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


__asm void xPortPendSVHandler( void )
{
 extern uxCriticalNesting;
 extern pxCurrentTCB;		//任务控制块地址
 extern vTaskSwitchContext;
	//八字节对齐
 PRESERVE8

 mrs r0, psp
 isb

 ldr r3, =pxCurrentTCB 	
 ldr r2, [ r3 ]				//r2存放任务控制块地址

 stmdb r0 !, { r4 - r11 } 	//r4到r11压入cpu任务栈
 str r0, [ r2 ] 

 stmdb sp !, { r3, r14 }
 mov r0, #configMAX_SYSCALL_INTERRUPT_PRIORITY
 msr basepri, r0
 dsb
 isb
 bl vTaskSwitchContext
 mov r0, #0
 msr basepri, r0
 ldmia sp !, { r3, r14 }

 ldr r1, [ r3 ]
 ldr r0, [ r1 ] 
 ldmia r0 !, { r4 - r11 } 
 msr psp, r0
 isb
 bx r14
 nop
}

十、时间片调度

当多个任务的任务优先级相同时，CPU 会轮流的处理每一个任务，每个任务享有 CPU 处理的时间都是相同的，这个时间被称为时间片。

一个时间片就等于 SysTick 中断周期（可以由用户自行设置），CPU 给与了一个时间片运行一个任务，不管这个任务是否运行完成，CPU 都会跑到下一个任务。

流程：

1.task1 运行完一个时间片切换到 task2

2.task2 运行完一个时间片切换至 task3

3.task3 运行阻塞(系统延时或等待信号量等)切换至下一个任务 task1

没有用完的时间片不会再使用，下次任务 task3 得到执行还是按照一个时间片的时钟节拍运行

4.task1 运行完一个时间片之后，切换至 task2 运行

十一、任务相关API

不多介绍

十二、时间管理

· 相对延时：指每次延时都是从任务执行函数vTaskDelay()开始，延时指定的时间结束。

· 绝对延时：指每隔指定的时间，执行一次调用vTaskDelayUntil()函数的任务。

即:vTaskDelay()是从调用其本身开始计时，vTaskDelayUntil()是从调用任务开始计时

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


BaseType_t xTaskDelayUntil( TickType_t *pxPreviousWakeTime, 						 const TickType_t xTimeIncrement );

// Perform an action every 10 ticks.
void vTaskFunction( void * pvParameters )
{
 TickType_t xLastWakeTime;
 const TickType_t xFrequency = 10;
 xLastWakeTime = xTaskGetTickCount();
 for( ;; )
 {
 // Wait for the next cycle.
 // Perform action here.
 vTaskDelayUntil( &xLastWakeTime, xFrequency );
 }
}

十三、FreeRTOS消息队列

1.队列简介

任务到任务，任务到中断，中断到任务数据交流的一种机制

为什么不用全局变量？

假设有一个全局变量a=0，现在俩个认为在写变量a

任务1执行到第二步，任务2打断，执行a++，此时a才是1，回到任务1的第三步，a为1，但执行两次a++。

因此全局变量数据无保护，当多任务操作数据时，数据受损

使用队列

为什么会安全？因为封装了临界区，即关闭中断，读写队列都有保护，防止多任务冲突

队列存储数量有限、大小固定的数据。队列的每个数据叫队列项目

队列要点

1.数据入队出队：通常FIFO（先入先出），也可以LIFO（后入先出）

2.数据传递方式：freertos采用实际值，将数据拷贝至队列，在传递较大数据时可以传递指针

3.多任务访问：队列不属于某任务，任何任务、中断都可以读写

4.出入阻塞：当任务向队列读写时，可以指定阻塞时间，队列已满或空则无法入队、出队

阻塞时间是：0：直接返回不等待

0~max：超时不入队则不等待

max：死等

入/出队阻塞

入队阻塞，队列满了，此时写不进去数据

将该任务的状态列表项挂载再 pxDelayedTaskLisk；
将该任务的事件列表项挂载在 xTasksWaitingToSend；

出队阻塞，队列为空，此时读取不了数据：

将该任务的状态列表项挂载再 pxDelayedTaskLisk；
将该任务的事件列表项挂载在 xTasksWaitingToReceive；

多任务都在等待同一个队列入队，都在阻塞，那当队列有空间，谁先进入就绪态:

那优先级最高的入队，若优先级相同，等最久的入队

2.队列结构体

 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


typedef struct QueueDefinition 
{ 
 int8_t * pcHead; /* 存储区域的起始地址 */ 
 int8_t * pcWriteTo; /* 下一个写入的位置 */ 
 union 
 { 
 QueuePointers_t xQueue; 		//当用于队列时
 SemaphoreData_t xSemaphore; 	//当用于信号量时
 } u; 
 List_t xTasksWaitingToSend; /* 写入阻塞任务列表 */ 
 List_t xTasksWaitingToReceive; /* 读取阻塞任务列表 */ 
 
 volatile UBaseType_t uxMessagesWaiting; /* 非空闲项目的数量 */ 
 UBaseType_t uxLength; /* 队列的长度 */ 
 UBaseType_t uxItemSize; /* 队列项目的大小 */ 
 
 /* 锁用于在任务因队列操作被阻塞前，防止中断或其他任务操作队列。 
 * 上锁期间，队列可以写入和读取消息，但不会操作队列阻塞任务列表， 
 * 当有消息写入时，cTxLock加1，当有消息被读取时，cRxLock加1， 
 * 在解锁时，会统一处理队列的阻塞任务列表 
 */ 
 volatile int8_t cRxLock; /* 读取上锁计数器 */ 
 volatile int8_t cTxLock; /* 写入上锁计数器 */ 
	//以下省略一些条件编译
} xQUEUE; 

3.队列相关API函数

主要流程:创建队列->写队列->读队列

1
2
3


#define xQueueCreate( uxQueueLength, uxItemSize ) 
		xQueueGenericCreate(( uxQueueLength ),( uxItemSize ),
 (queueQUEUE_TYPE_BASE )) 

其中queueQUEUE_TYPE_BASE代表不同创建类型的功能，实际都是基于一个函数实现的

#define queueQUEUE_TYPE_BASE ( ( uint8_t ) 0U ) 				/* 队列 */ 
#define queueQUEUE_TYPE_SET ( ( uint8_t ) 0U ) 				/* 队列集 */ 
#define queueQUEUE_TYPE_MUTEX ( ( uint8_t ) 1U ) 			/* 互斥信号量 */ 
#define queueQUEUE_TYPE_COUNTING_SEMAPHORE ( ( uint8_t ) 2U ) 	/* 计数型信号量 */ 
#define queueQUEUE_TYPE_BINARY_SEMAPHORE ( ( uint8_t ) 3U )		/* 二值信号量 */ 
#define queueQUEUE_TYPE_RECURSIVE_MUTEX ( ( uint8_t ) 4U ) 		/* 递归互斥信号量 */

QueueHandle_t xQueueCreate( uxQueueLength, uxItemSize )

uxQueueLength:队列长度

uxItemSize：队列项大小

返回值QueueHandle_t句柄

NULL：创建失败，其他值：创建成功，返回句柄

3.1写入消息API

这四个函数都是对xQueueGenericSend()的宏定义

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#define xQueueSend(xQueue, pvItemToQueue, xTicksToWait) 
 xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK) 
 
#define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait) 
 xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK) 
 
#define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait) 
 xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT) 
 
#define xQueueOverwrite( xQueue, pvItemToQueue) 
 xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), 0, queueOVERWRITE)

xQueueGenericSend为

BaseType_t xQueueGenericSend( QueueHandle_t 	 xQueue, 
 					 const void * const pvItemToQueue, 
 					 TickType_t 	 xTicksToWait, 
 					 const BaseType_t xCopyPosition);

3.2读取消息API

xQueueReceive

从队列中读取消息，并且消息读取成功后，会将消息从队列中移除

BaseType_t xQueueReceive( QueueHandle_t xQueue,
 void * const pvBuffer,
 TickType_t xTicksToWait );

xQueuePeek

不会删除的函数，参数一致

4.队列相关API函数解析

4.1xQueueCreate

#define xQueueCreate( uxQueueLength, uxItemSize )

xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )

对队列而言xQueueGenericCreate前两个入口参数有效

首先长度判断

if( ( uxQueueLength > ( UBaseType_t ) 0 ) &&
 ( ( SIZE_MAX / uxQueueLength ) >= uxItemSize ) &&
 ( ( SIZE_MAX - sizeof( Queue_t ) ) >= ( uxQueueLength * uxItemSize ) ) )

队列项存储区大小

xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize );

申请内存是队列项存储区+结构体存储区，并把首地址给到pxNewQueue

pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes );

再将地址指向队列项存储区

pucQueueStorage = ( uint8_t * ) pxNewQueue; pucQueueStorage += sizeof( Queue_t );

执行

QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType )

除一个是存储区首地址，一个是队列结构体首地址pucQueueStorage，pxNewQueue外，由外部传入

prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );

进入prvInitialiseNewQueue后

if( uxItemSize == ( UBaseType_t ) 0 )是信号量

否则是队列，执行以下行，将队列项存储区首地址给到队列首地址

pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;

再进入

( void ) xQueueGenericReset( pxNewQueue, pdTRUE );

4.2xQueueSend

#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait )

	 xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), 		queueSEND_TO_BACK )

进入

xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

如果尾部插入

十四、信号量

1.简介

队列是发送数据，信号是发送状态，信号量是队列的衍生

信号量结局同步机制（我做完一件事告诉你），任务间的通信以及事件通知，对共享资源的有序访问

举例：

1.停车场车位是否还有（判断信号量是否还有资源）

2.停车场有空位（有资源），就可以将车开入（获取信号量）

3.停车场无空位（无资源），不可以将车开入（获取信号量失败），可以等待其他人开出（释放）

如果最大值被限定为 1 ，那么它就是二值信号量；如果最大值不是 1 ，它就是计数型信号量。

1.二值信号量

本质：长度为1的队列，该队列只有空和满

通常用于互斥访问（一个任务持有锁，其他任务无法执行）和任务同步（一个任务等另一个任务完成才能执行下去），互斥信号量相似，但二值信号量可能导致优先级反转

二值信号量相关API函数

过程：创建-释放-获取

创建

SemaphoreHandle_t xSemaphoreCreateBinary( void )

释放

传入句柄xSemaphore

BaseType_t xSemaphoreGive( xSemaphore )

返回值pdPASS：成功

errQUEUE_FULL：失败

获取

传入句柄xSemaphore，阻塞时间xBlockTime ，死等为portMAX_DELAY

BaseType_t xSemaphoreTake( xSemaphore,xBlockTime )

返回值：pdTRUE 获取信号量成功 pdFALSE 超时，获取信号量失败

2.计数型信号量

计数型信号量相当于队列长度大于 1 的队列，因此计数型信号量能够容纳多个资源，这在计数型信号量被创建的时候确定的

适用场合：

事件计数：每次事件发生，事件处理函数中释放计数型信号量，计数值+1，其他任务获取计数型信号量，计数值-1，初始计数值一般设为0
资源管理：信号量表示有效资源数量，任务必须先获取信号量，计数值-1，才能获取资源控制权，当计数值减到0时表示没有资源，当任务使用完资源后，必须释放，计数值+1,。信号量创建时一般等于最大资源数

计数型信号量相关API

创建-释放-获取

创建：

1
2
3
4
5
6


//uxMaxCount计数值的最大值限定
//uxInitialCount计数值的初始值
#define xSemaphoreCreateCounting(uxMaxCount, uxInitialCount)
 		xQueueCreateCountingSemaphore((uxMaxCount),(uxInitialCount)) 
//返回值NULL创建失败
//其他值返回句柄 

获取和释放与二值相同

3.优先级翻转

优先级翻转：高优先级任务反而慢执行，低优先级任务反而先执行

优先级翻转在抢占式内核中是很常见的问题，但是在实时操作系统中是不允许出现优先级翻转的，因为优先级翻转会破环任务的预期顺序，可能会导致未知的严重后果。在使用二值信号量的时候，经常会遇到优先级翻转问题。

角色	行为	优先级
H（高）	想用共享资源（如 UART、SPI）	3（最高）
L（低）	已经拿到资源，正在用	1（最低）
M（中）	纯计算任务，不碰资源	2

L 先运行，拿到互斥量 → 进入临界区。
H 就绪，优先级最高，抢占 L，但发现互斥量被占 → 阻塞。
M 就绪，优先级介于 H 和 L 之间 → 抢占 L，开始跑长计算。
结果： • H 必须等 M 跑完 → M 跑完 L 才能继续 → L 释放后 H 才能拿到。 • H 实际被 优先级远低于它的 L 间接阻塞。

4.互斥信号量

互斥信号量是一个拥有优先级继承的二值信号量，在同步的应用中二值信号量最适合，互斥信号量适用与需要互斥访问的应用中。

优先级继承：当一个互斥信号量正在被一个低优先级的任务持有时，如果此时有个高优先级的任务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。不过这个高优先级的任务会将低优先级任务的优先级提升到与自己相同的优先级。

依旧L阻塞H，但M就不会浪费时间执行，将优先级翻转危害降低。

就是不能完全消除影响，但尽可能把影响降到最低。

注意：互斥信号量不能用于中断服务函数中。原因：

互斥信号量有任务优先级继承的机制，但中断不是任务，没有任务优先级，所以互斥信号量只能用于任务中，不能用于中断服务函数
中断服务函数中不能因为要等待互斥信号量而设置阻塞时间进入阻塞态

互斥信号量相关API

宏 configUSE_MUTEXES 置一

创建互斥信号量 -（ task ）获取信号量 -（ give ）释放信号量

无传入参数

xSemaphoreCreateMutex()

返回NULL创建失败，其他值返回句柄

获取与释放与二值信号量相同，只是不支持中断调用

十五、队列集

1.简介

一个队列只允许任务间传递同一种数据类型，如果要传递不同数据类型，可以使用队列集。

作用：

对多个队列或信号量进行监听，不管哪个消息到来，都可以让任务退出阻塞状态

原始思路：

队列集思路：

2.队列集相关API

2.1创建xQueueCreateSet

QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength );

参数：uxEventQueueLength 队列集可容纳的队列数量

返回值：NULL：队列集创建失败其他值：创建成功，返回句柄

2.2添加xQueueAddToSet

往队列集添加队列时，队列不能有消息

BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore , QueueSetHandle_t xQueueSet );

2.3移除

移除前不能有有效消息

BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore , QueueSetHandle_t xQueueSet );

2.4获取有效消息xQueueSelectFromSet

1
2


QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
										TickType_t const xTicksToWait )

示例

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


 member_handle = xQueueSelectFromSet(queueset_handle,portMAX_DELAY);
 if(member_handle == queue_handle)
 {
 if(xQueueReceive(queue_handle,&key,portMAX_DELAY)==pdPASS)
 {
 printf("队列queue_handle读取数据成功\r\n");
 }
 }
 else if(member_handle == semphr_handle)
 {
 if(xSemaphoreTake(semphr_handle,portMAX_DELAY)==pdPASS)
 {
 printf("获取信号量成功\r\n");
 }
 }

十六、事件标志组

1.简介

事件标志组：用一个位表示时间是否发生

是一组事件标志位的集合，类似多个标志位

特点：

每一个位表示一个事件（高八位不算）
每位事件的含义由用户决定如bit0表示按键，bit1表示消息是否接受
1：事件发生，0：事件未发生
任意任务和中断可读写这些位
可等待某一位，也可等待多位

一个事件组包含，EventBits_t是数据类型变量

一个事件组最多可以存储 24 个事件标志

与队列信号量区别

2.事件标志组相关API

2.1创建xEventGroupCreate

EventGroupHandle_t xEventGroupCreate ( void) ;

返回NULL：失败

其他值：成功返回句柄

2.2清零标志位xEventGroupClearBits

EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )

参数：

xEventGroup 待操作的事件标志组句柄 uxBitsToSet 待清零的事件标志位

返回：整数=清零事件标志位之前事件组中事件标志位的值

2.3设置标志位xEventGroupSetBits

EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )

参数：

xEventGroup 待操作的事件标志组句柄 uxBitsToSet 待设置的事件标志位

返回：整数=函数返回时，事件组中的事件标志位值

2.4等待标志位xEventGroupWaitBits

1
2
3
4
5


EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
								 const EventBits_t 	uxBitsToWaitFor,
								 const BaseType_t 	xClearOnExit,
								 const BaseType_t 	xWaitForAllBits,
								 TickType_t 		xTicksToWait )

2.5同步函数

1
2
3
4


EventBits_t xEventGroupSync(EventGroupHandle_t xEventGroup, 
							const EventBits_t uxBitsToSet, 
							const EventBits_t uxBitsToWaitFor, 
							TickType_t 	 xTicksToWait) 

示例

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


EventGroupHandle_t eventgroup_handle;
#define EVENTBIT_0 1<<0
#define EVENTBIT_1 1<<1

eventgroup_handle = xEventGroupCreate();

if(key==KEY0_PRES)
 {
 xEventGroupSetBits(eventgroup_handle,EVENTBIT_0);
 }else if(key==KEY1_PRES)
 {
 xEventGroupSetBits(eventgroup_handle,EVENTBIT_1);
 }

event_bit = xEventGroupWaitBits(eventgroup_handle,EVENTBIT_0|EVENTBIT_1,
 pdTRUE,pdFALSE,portMAX_DELAY);
 printf("等待到的事件标志位值:%#x\r\n",event_bit);

十七、任务通知

1.简介

任务通知：用来通知任务，任务控制块中的结构体成员变量 ulNotifiedValue 就是这个通

知值

为什么还要这个？

使用任务通知时，任务结构体就包含了内部对象，可以直接接收别人发过来的通知
使用队列、信号量、事件标志组时都需另外创建一个结构体，通过中间的结构体进行简介通信

发送端修改接收端任务控制块中结构体变量：ulNotifiedValue

任务通知值的更新方式

覆盖或不覆盖接受任务的通知值（队列）
更新接收任务通知值的一个过多个 bit（事件标志组）
增加接收任务的通知值（信号量）

但只能在一些场合替代

优劣势

优势：

效率高：使用任务通知向任务发送事件或数据比使用队列、事件标志组或信号量快
使用内存更小：使用其他方法时都要先创建对应的结构体，使用任务通知时无需

劣势：

无法发送数据给 ISR（中断服务函数）：ISR 没有任务结构体，因此无法给 ISR 发送数据，但 ISR可以使用任务通知的功能发送数据给任务
无法广播给多个任务：任务通知只能是被指定的一个任务接收并处理
无法缓存多个数据：任务通知是通过更新任务通知值来发送数据的，任务结构体中只有一个任务通知值，只能保持一个数据
发送受阻不支持阻塞：发送方无法进入阻塞状态等待

2.任务通知值和通知状态

任务的任务控制块中，有两个结构体成员变量就是任务通知相关的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


typedef struct tskTaskControlBlock
{
	...
	#if(configUSE_TASK_NOTIFICATIONS == 1)	//打开这个宏
	volatile uint32_t ulNotifiedValue[configTASK_NOTIFICATION_ARRAY_ENTRIES];	//通知值
	volatile uint8_t ucNotifyState[configTASK_NOTIFICATION_ARRAY_ENTRIES];		//通知状态
	endif
	...
}tskTCB;
#define configTASK_NOTIFICATION_ARRAY_ENTRIES 1	//定义任务通知数组的大小，默认为1

任务通知值ulNotifiedValue

更新方式：

计数值（数值累加，类似信号量）
相应位置1（类似事件标志组）
任意数（支持覆写不覆写，类似队列）

任务通知状态ucNotifyState

三种取值：

#define taskNOT_WAITING_NOTIFICATION ((uint8_t)0) //任务未等待通知 #define taskWAITING_NOTIFICATION ((uint8_t)1) //任务在等待通知 #define taskNOTIFICATION_RECEIVED ((uint8_t)2) //任务在等待接收

未等待通知：任务通知默认的初始化状态（事不关己，高高挂起）
等待通知：接收方已经准备好了（调用了接收任务通知函数），等待发送方给个通知
等待接收：发送方已经发送出去（调用了发送任务通知函数），等待接收方接收

3.任务通知API函数

有发送和接收，发送可在任务和中断中，接收只能在任务（因为中断没TCB）

3.1发送

函数原型

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


BaseType_t xTaskGenericNotify(TaskHandle_t xTaskToNotify, 
 				 UBaseType_t uxIndexToNotify, 
				 uint32_t 	 ulValue, 
				 eNotifyAction eAction, 
				 uint32_t * pulPreviousNotificationValue); 

#define xTaskNotify(xTaskToNotify, ulValue, eAction) 
		xTaskGenericNotify((xTaskToNotify), (tskDEFAULT_INDEX_TO_NOTIFY), 
						 (ulValue), (eAction), NULL) 				 
 
#define xTaskNotifyAndQuery(xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue) 
 	xTaskGenericNotify((xTaskToNotify), (tskDEFAULT_INDEX_TO_NOTIFY),
 					 (ulValue), (eAction), (pulPreviousNotifyValue)) 			 
 
#define xTaskNotifyGive(xTaskToNotify) 
 	 	xTaskGenericNotify((xTaskToNotify), (tskDEFAULT_INDEX_TO_NOTIFY), 
 				 (0), eIncrement, NULL) 

其中通知方式（通知值更新方式）eNotifyAction

1
2
3
4
5
6
7
8


typedef enum
{
	eNoAction = 0, 				/* 无操作 */
	eSetBits 					/* 更新指定 bit */
	eIncrement 					/* 通知值加一 */
	eSetValueWithOverwrite 		/* 覆写的方式更新通知值*/
	eSetValueWithoutOverwrite 	/* 不覆写通知值 */
} eNotifyAction;

3.2接收

当任务通知用作与信号量时，使用函数获取信号量：ulTaskNotifyTake( )
当任务通知用作与事件标志组或队列时，使用此函数来获取：xTaskNotifyWait( )

3.2.1ulTaskNotifyTake

ulTaskNotifyTake( xClearCountOnExit , xTicksToWait )

#define ulTaskNotifyTake(xClearCountOnExit, xTicksToWait) 
		ulTaskGenericNotifyTake((tskDEFAULT_INDEX_TO_NOTIFY), 
								(xClearCountOnExit), 
								(xTicksToWait))

原型

uint32_t ulTaskGenericNotifyTake(UBaseType_t uxIndexToWaitOn, 
								 BaseType_t xClearCountOnExit, 
							 	 TickType_t xTicksToWait);

通知值清零模拟二值信号量，通知值减一模拟计数型信号量

3.2.2xTaskNotifyWait

此函数用于等待任务通知通知值中的指定比特位被置 1，此函数可以在等待前和成功等待到任务通知通知值中的指定比特位被置 1 后清零指定比特位，并且还能获取等待超时后任务通知的通知值。

#define xTaskNotifyWait(ulBitsToClearOnEntry, 
			 ulBitsToClearOnExit, 
			 pulNotificationValue, 
			 xTicksToWait) 
 	 xTaskGenericNotifyWait(tskDEFAULT_INDEX_TO_NOTIFY, 
					 (ulBitsToClearOnEntry), 
					 (ulBitsToClearOnExit), 
					 (pulNotificationValue), 
					 (xTicksToWait))

形参	描述
uxIndexToWaitOn	等待的任务通知索引（任务通知数组下标）
ulBitsToClearOnEntry	进入等待前，把任务通知值的哪些位清 0（旧值对应位清零）
ulBitsToClearOnExit	等待成功后，把任务通知值的哪些位清 0（新值对应位清零）
pulNotificationValue	用于取出当时的 32 位通知值；若不需要，可设为 NULL
xTicksToWait	最大阻塞等待时间（以系统节拍为单位）

返回值	描述
pdTRUE	等待任务通知成功（已满足等待条件）
pdFALSE	等待任务通知失败（超时或被中断）

4.任务通知模拟信号量

模拟二值信号量

 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


void task1(void* pvParamenters)
{
 uint8_t key = 0;
 while(1)
 {
 key = key_scan(0);
 if(key==KEY0_PRES)
 {
 printf("任务通知模拟二值信号量释放\r\n");
 xTaskNotifyGive(task2_handle);
 }
 }
}
void task2(void* pvParamenters)
{
 uint32_t rev = 0;
 while(1)
 {
 rev = ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
 if(rev!=0)
 {
 printf("接受任务通知成功,获取模拟二值信号量\r\n");
 }
 }
 
}

模拟计数型信号量

 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


void task1(void* pvParamenters)
{
 uint8_t key = 0;
 while(1)
 {
 key = key_scan(0);
 if(key==KEY0_PRES)
 {
 printf("任务通知模拟计数型信号量释放\r\n");
 xTaskNotifyGive(task2_handle);
 }
 }
}
void task2(void* pvParamenters)
{
 uint32_t rev = 0;
 while(1)
 {
 rev = ulTaskNotifyTake(pdFALSE,portMAX_DELAY);
 if(rev!=0)
 {
 printf("接受任务通知成功,模拟获取计数型信号量,rev:%d\r\n",rev);
 }
 vTaskDelay(1000);
 }
}

5.任务通知模拟消息邮箱（类似队列）

消息邮箱其实就是长度为1的队列

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


void task1(void *pvParamenters)
{
 uint8_t key = 0;
 while (1)
 {
 key = key_scan(0);
 if ((key != 0) && (task2_handle != NULL))
 {
 printf("任务通知模拟消息邮箱发送,发送的键值为:%d\r\n", key);
 xTaskNotify(task2_handle, key, eSetValueWithOverwrite);
 }
 vTaskDelay(10);
 }
}
void task2(void *pvParamenters)
{
 uint32_t notify_val = 0;
 while (1)
 {
 xTaskNotifyWait(0, 0xFFFFFFFF, &notify_val, portMAX_DELAY);
 printf("接受到的通知值为:%d\r\n",notify_val);
 }
}

6.任务通知模拟事件标志组

 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


#define EVENTBIT_0 1<<0
#define EVENTBIT_1 1<<1

void task1(void *pvParamenters)
{
 uint8_t key = 0;
 while (1)
 {
 key = key_scan(0);
 if(key==KEY0_PRES)
 {
 printf("更新bit0位置1\r\n");
 xTaskNotify(task2_handle,EVENTBIT_0,eSetBits);
 }
 else if(key==KEY1_PRES)
 {
 printf("更新bit1位置1\r\n");
 xTaskNotify(task2_handle,EVENTBIT_1,eSetBits);
 }
 vTaskDelay(10);
 }
}

void task2(void *pvParamenters)
{
 uint32_t notify_val = 0,event_bit = 0;
 while (1)
 {
 xTaskNotifyWait(0,0xFFFFFFFF,&notify_val,portMAX_DELAY);
 if(notify_val&EVENTBIT_0)
 {
 event_bit|=EVENTBIT_0;
 }
 if(notify_val&EVENTBIT_1)
 {
 event_bit|=EVENTBIT_1;
 }
 if(event_bit == (EVENTBIT_0|EVENTBIT_1))
 {
 printf("任务通知模拟事件标志组接收成功\r\n");
 event_bit = 0;
 }
 }
}

十八、软件定时器

1.简介

定时器：指定时刻开始，经过指定时间，触发超时事件，用户可自定义周期

硬件定时器：芯片自带定时器，精度高，通过定时器中断，在中断服务函数处理

软件定时器：定时功能的软件，可设定定时周期，超时调用回调函数，在回调函数处理

软件定时器优缺点

优点：硬件定时器有限，而软件定时器理论更多；使用简单

缺点：精度低，对于高精度要求，不使用

FreeRTOS软件定时器特点

可裁剪：configUSE_TIMERS 配置项配置成 1

支持单次和周期

注：软件定时器的超时回调函数是由软件定时器服务任务调用的，软件定时器的超时回调函数本身不是任务，因此不能在该回调函数中使用可能会导致任务阻塞的 API 函数

软件定时器服务任务：vTaskStartScheduler()中会创建

软件定时器命令队列

FreeRTOS 提供了许多软件定时器相关的 API 函数，这些 API 函数大多是往定时器的队列中写入消息（发送命令），这个队列叫做软件定时器命令队列。这个队列控制软件定时器

软件定时器相关配置

configUSE_TIMERS配置为1

启动任务调度器时，会自动创建软件定时器的服务 / 守护任务prvTimerTask( );

软件定时器服务任务的优先级为configTIMER_TASK_PRIORITY = 31;

定时器的命令队列长度为configTIMER_QUEUE_LENGTH = 5;

注：

服务任务服务于多个定时器，因此定时器的回调函数不能影响其他定时器
回调函数要尽快实行，不能进入阻塞状态，既不能调用那些会阻塞任务的 API 函数，如vTaskDelay( );
访问队列或者信号量的非零阻塞时间的 API 函数也不能调用

软件定时器状态

休眠态、运行态

单次定时器和周期定时器

2.软件定时器结构体

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


typedef struct
{
	const char * pcTimerName 					/* 软件定时器名字 */
	ListItem_t xTimerListItem 					/* 软件定时器列表项 */
	TickType_t xTimerPeriodInTicks; 			/* 软件定时器的周期*/
	void * pvTimerID 							/* 软件定时器的 ID */
	TimerCallbackFunction_t pxCallbackFunction; /* 软件定时器的回调函数*/
	#if ( configUSE_TRACE_FACILITY == 1 )
		UBaseType_t uxTimerNumber 				/* 软件定时器编号调试用*/
	#endif
	uint8_t ucStatus; 							/* 软件定时器的状态 */
} xTIMER;

3.软件定时器相关API

3.1创建xTimerCreate

1
2
3
4
5


TimerHandle_t xTimerCreate(const char * const 	pcTimerName, 
						 const TickType_t 	 xTimerPeriodInTicks, 
						 const UBaseType_t 		uxAutoReload, 
						 void * const 		pvTimerID, 
						 TimerCallbackFunction_t pxCallbackFunction);

形参	描述
pcTimerName	软件定时器名称（字符串）
xTimerPeriodInTicks	定时周期，以系统时钟节拍（ticks）为单位
uxAutoReload	定时器模式： pdTRUE = 周期定时器（重复触发） pdFALSE = 单次定时器（触发一次后停止）
pvTimerID	用户自定义 ID，可用于多个定时器共用同一回调函数时区分实例
pxCallbackFunction	定时器超时时的回调函数指针

返回值	描述
NULL	软件定时器创建失败
非 NULL 句柄	软件定时器创建成功，返回该定时器的句柄

创建例子

1
2


timer1_handle = xTimerCreate("timer1",1000,pdFALSE,(void *)1,timer1_callback);
 timer2_handle = xTimerCreate("timer2",1000,pdTRUE,(void *)1,timer2_callback);

3.2开启xTimerStart

BaseType_t xTimerStart( TimerHandle_t xTimer, const TickType_t xTicksToWait );

参数：xTimer 待开启的软件定时器的句柄 xTickToWait 发送命令到软件定时器命令队列的最大等待时间

返回pdPASS，pdFAIL

3.3停止xTimerStop

BaseType_t xTimerStop( TimerHandle_t xTimer, const TickType_t xTicksToWait);

参数：xTimer 待停止的软件定时器的句柄 xTickToWait 发送命令到软件定时器命令队列的最大等待时间

返回pdPASS，pdFAIL

3.4复位xTimerReset

使软件定时器的重新开启定时

BaseType_t xTimerReset( TimerHandle_t xTimer, const TickType_t xTicksToWait);

参数：xTimer 待复位的软件定时器的句柄 xTickToWait 发送命令到软件定时器命令队列的最大等待时间

返回pdPASS，pdFAIL

3.5更改超时时间xTimerChangePeriod

BaseType_t xTimerChangePeriod( TimerHandle_t xTimer, const TickType_t xNewPeriod, const TickType_t xTicksToWait);

参数：xTimer 待更新的软件定时器的句柄 xNewPeriod 新的定时超时时间，单位：系统时钟节拍 xTickToWait 发送命令到软件定时器命令队列的最大等待时间

返回pdPASS，pdFAIL

示例

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


TimerHandle_t timer1_handle = 0;/*单次定时器*/
TimerHandle_t timer2_handle = 0;/*周期定时器*/
void timer1_callback(TimerHandle_t pxTimer);
void timer2_callback(TimerHandle_t pxTimer);

timer1_handle = xTimerCreate("timer1",1000,pdFALSE,(void *)1,timer1_callback);
 timer2_handle = xTimerCreate("timer2",1000,pdTRUE,(void *)1,timer2_callback);

xTimerStart(timer2_handle,0);
xTimerStart(timer1_handle,0);

void timer1_callback(TimerHandle_t pxTimer)
{
 static uint32_t timer1 = 0;
 printf("Timer1的运行次数:%d\r\n",++timer1);
}

void timer2_callback(TimerHandle_t pxTimer)
{
 static uint32_t timer2 = 0;
 printf("Timer2的运行次数:%d\r\n",++timer2);
}

十九、Tickless低功耗模式

1.低功耗模式

STM32提供集中低功耗，睡眠，停止，待机

FreeRTOS也提供Tickless低功耗模式，通过动态调整SysTick 减少不必要的 CPU 唤醒，从而降低功耗

为了降低功耗，又不影响系统运行，可以在本该空闲任务执行期间，让 MCU 进入相应的低功耗模式；当其他任务准备运行的时候，唤醒 MCU 退出低功耗模式，但是进入低功耗之后，多久唤醒，下一个要运行的任务如何被准确唤醒？任何中断均可唤醒 MCU，若滴答定时器频繁中断则会影响低功耗的效果。这些问题可以这样解决：

将滴答定时器的中断周期修改为低功耗运行时间推出低功耗之后，补上系统时钟节拍数

2.相关配置

使能低功耗 Tickless 模式：configUSE_TICKLESS_IDLE 定义系统进入相应低功耗模式的最短时长：configEXPECTED_IDLE_TIME_BEFORE_SLEEP 定义需要在系统进入低功耗模式之前执行的事务，例如：进入低功耗之前关闭外设时钟，以降低功耗：configPRE_SLEEP_PROCESSING(x)，需要自己在 FreeRTOSconfig.h 里面自己定义定义需要在系统退出低功耗模式之后执行的事务，例如：退出低功耗之后开启被关闭的外设时钟，使系统能够正常运行：configPOST_SLEEP_PROCESSING(x)，需要自己在 FreeRTOSconfig.h 里面自己定义

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


#define configUSE_TICKLESS_IDLE 1 
#define configEXPECTED_IDLE_TIME_BEFORE_SLEEP 2

//接着在 FreeRTOSconfig.h 文件中找个位置定义下面函数
#include "freertos_demo.h"
#define configPRE_SLEEP_PROCESSING( x )		PRE_SLEEP_PROCESSING()
#define configPOST_SLEEP_PROCESSING( x )	POSR_SLEEP_PROCESSING()

//freertos_demo.h 文件里声明这两个函数
void PRE_SLEEP_PROCESSING(void);
void POST_SLEEP_PROCESSING(void);

//freertos_demo.c 文件里，入口函数上面定义
//进入低功耗模式前要关闭的事情
void PRE_SLEEP_PROCESSING(void)
{
	__HAL_RCC_GPIOA_CLK_DISABLE();
	__HAL_RCC_GPIOB_CLK_DISABLE();
	__HAL_RCC_GPIOC_CLK_DISABLE();
	__HAL_RCC_GPIOD_CLK_DISABLE();
	__HAL_RCC_GPIOE_CLK_DISABLE();
	__HAL_RCC_GPIOF_CLK_DISABLE();
	__HAL_RCC_GPIOG_CLK_DISABLE();
}
//退出低功耗模式后需要打开的事情
void POST_SLEEP_PROCESSING(void)
{
	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOB_CLK_ENABLE();
	__HAL_RCC_GPIOC_CLK_ENABLE();
	__HAL_RCC_GPIOD_CLK_ENABLE();
	__HAL_RCC_GPIOE_CLK_ENABLE();
	__HAL_RCC_GPIOF_CLK_ENABLE();
	__HAL_RCC_GPIOG_CLK_ENABLE();
}

二十、FreeRTOS内存管理

1.FreeRTOS内存管理简介

FreeRTOS创建任务、队列、信号量等时，可用动态方法或者静态方法创建

动态方法：申请时FreeRTOS从内存堆中自动申请，删除对象时自动释放
静态方法：用户提供内存空间，但是占用的空间固定下来了，删除依旧占用

本节讲的是动态内存管理方式（实际是管理算法的区别heap.c）

freertosconfig.h中定义的宏管理内存堆的大小：

1
2


#define configTOTAL_HEAP_SIZE ((size_t)(10 * 1024)) 
/* FreeRTOS堆中可用的RAM总量, 单位: Byte, 无默认需定义 */

2.FreeRTOS内存管理算法

算法	优点	缺点
heap_1	分配简单，时间确定	只允许申请内存，不允许释放内存
heap_2	允许申请和释放内存	不能合并相邻空闲块，产生碎片，时间不定
heap_3	直接调用 C 库 malloc()/free()，实现简单（不使用）	速度慢、时间不定
heap_4	相邻空闲块可合并，减少碎片	时间不定
heap_5	支持管理多个非连续内存区域，功能同 heap_4	时间不定

2.1 heap_1

heap_1只能申请内存无法释放内存，若工程中创建好的任务、队列、信号量等不需要删除，那使用heap_1

heap_1分配图示：

2.2 heap_2

heap_2采用最适应算法，支持释放内存，但是并不能将相临空闲内存块合并，不可避免产生内存碎片。如果需要频繁的创建和删除任务，且所创建的任务堆栈都相同，可以用heap_2

最适应算法：

假设heap 有 3 块空闲内存：5,25,50
申请一个总共20字节的任务，先找到最小能满足的内存：25
删除任务内存释放后，得到20、5两块内存碎片
最后存在：5,5,20,50

heap_2分配图示：

2.3 heap_4

heap_4 使用了首次适应算法，能够将空闲且相邻的内存进行合并。适合频繁分配释放大小不同内存。

首次适应算法：

假设heap 有 3 块空闲内存（按内存块地址由低到高排序）：5,50,25
申请一个总共20字节的任务，先找到第一个能满足的内存：50
删除任务内存释放后，这块内存依旧为50
最后存在：5,50,25

heap_4分配图示：

2.4 heap_5

heap_5能管理多块不连续内存，但需要用户指定内存区域

使用如下结构体：

1
2
3
4
5


typedef struct HeapRegion
{
	uint8_t * pucStartAddress; /* 内存区域的起始地址 */
	size_t xSizeInBytes; /* 内存区域的大小，单位：字节 */
} HeapRegion_t;

指定多块不连续内存

1
2
3
4
5
6
7
8


Const HeapRegion_t xHeapRegions[] =
{
	{ (uint8_t *)0x80000000, 0x10000 }, /* 内存区域1 */
	{ (uint8_t *)0x90000000, 0xA0000 }, /* 内存区域2 */
	{ NULL, 0 } /* 数组终止标志 */
};

vPortDefineHeapRegions(xHeapRegions);

CAN 通信协议学习笔记

Sat, 24 May 2025 10:00:00 +0800

CAN简介

CAN总线特征：

两根通信线(CAN_H、CAN_L)，无需共地
差分信号，抗干扰
高速CAN:125k-1mbps，<40m
低速CAN:10k~125kbps, <1km
异步通信(无时钟线)，通信速率由设备各自约定
半双工，可挂载多设备，多设备同时发送数据时通过仲裁判断先后顺序
11位/29位报文ID，用于区分消息功能，同时决定优先级
可配置1~8字节的有效载荷
可实现广播式和请求式两种传输方式
应答、CRC校验、位填充、位同步、错误处理等特性

主流通信协议

名称	引脚	双工	时钟	电平	设备	应用场景
UART	TX、RX	全双工	异步	单端	点对点	两个设备互相通信
I2C	SCL、SDA	半双工	同步	单端	多设备	一个主控外挂多个模块
SPI	SCK、MOSI、MISO、SS	全双工	同步	单端	多设备	一个主控外挂多个模块（高速）
CAN	CAN_H、CAN_L	半双工	异步	差分	多设备	多个主控互相通信

CAN类似UART和IIC的结合

第一章

CAN硬件电路

主控会内置CAN控制器，借助CAN收发器挂载在CAN总线网络

高速CAN采用闭环网络，CAN的差分信号默认状态下(1，CANH=CANL)，由电阻收紧，而电阻因为阻抗不大，因此电压跃变快，但是功耗高

低速CAN使用开环网络，两端加开路的电阻，降低反射

电平标准

差分信号，即电压差传输数据

高速CAN：

隐性电平是不碰两根线，电阻处为收紧状态（默认状态1，隐性）

显性电平是拉开两根线，电阻处为非收紧状态（显性可以控制总线，0强于1，所以能叫显性）

电压差为0V时表示逻辑1（隐性电平）
电压差为2V时表示逻辑0（显性电平）

CAN收发器-TJA1050(高速CAN)

CANH和CANL有电压差，RECEIVER输出1，下管导通，RXD为0(有电压差，逻辑0，显性)

CANH和CANL无电压差，RECEIVER输出0，上管导通，RXD为1(无电压差，逻辑1，隐性)

TXD为0时，2,3的场效应管导通，CANH和CANL有电压差（逻辑0，显性）

而TXD悬空时，电流源默认让TXD为1

CAN物理层特性

第二章

CAN总线帧格式

主要看数据帧

帧类型	用途
数据帧	发送设备主动发送数据（广播式）
遥控帧	接收设备主动请求数据（请求式）
错误帧	某个设备检测出错误时向其他设备通知错误
过载帧	接收设备通知其尚未做好接收准备
帧间隔	用于将数据帧及遥控帧与前面的帧分离开

数据帧

SOF（Start of Frame）：帧起始，表示后面一段波形为传输的数据位
ID（Identify）：标识符，区分功能，同时决定优先级
RTR（Remote Transmission Request ）：远程请求位，区分数据帧和遥控帧
IDE（Identifier Extension）：扩展标志位，区分标准格式和扩展格式
SRR（Substitute Remote Request）：替代RTR，协议升级时留下的无意义位
r0/r1（Reserve）：保留位，为后续协议升级留下空间
DLC（Data Length Code）：数据长度，指示数据段有几个字节
Data：数据段的1~8个字节有效数据
CRC（Cyclic Redundancy Check）：循环冗余校验，校验数据是否正确
ACK（Acknowledgement）：应答位，判断数据有没有被接收方接收
CRC/ACK界定符：为应答位前后发送方和接收方释放总线留下时间
EOF（End of Frame ）：帧结束，表示数据位已经传输完毕

标准格式

开始为空闲状态为隐性
SOF为帧起始，表明开始一帧数据
起始帧后发送11位标识符报文，区分功能，同时决定优先级
RTR为0：数据帧。为1：遥控帧
IDE为0：标准格式。为1：扩展格式
r0保留位，暂时无功能
DLC为数据长度，0001发一个字节，1000发8字节
Data根据DLC给几个字节能给范围0-64字节
CRC为校验
ACK应答位，发送方释放总线，如果接收方收到了，就抢占总线，发送方读取总线状态知道被接受
CRC/ACK界定符是留出时间交出控制权
EOF作为结束

遥控帧

适合使用频率低的数据

遥控帧无数据段，RTR为隐性电平1，其他部分与数据帧相同

如果有数据需要，首先接收方发出一个遥控帧，遥控帧包含报文ID，如果发送方有这个报文ID，就将数据发送出来，接收方可以及时获取数据

错误帧

总线所有设备监督总线数据，一旦发现错误，这些设备发出错误帧来破坏数据，同时终止当前的发送设备

过载帧

接收方收到大量数据无法处理，发送过载帧，延缓发送方的数据发送，以平衡总线负载，避免数据丢失

帧间隔

将数据帧和遥控帧与前面的帧分离开

位填充

规则：发送方每发送5个相同电平，自动追加相反电平的填充位，接收方检测到填充位，自动移除填充位。

即将发送： 100000110 10000011110 0111111111110 实际发送： 1000001110 1000001111100 011111011111010 实际接收： 1000001110 1000001111100 011111011111010 移除填充后： 100000110 10000011110 0111111111110

作用：

增加定时信息，有利于接收方同步，防止波形长时间无变化（防止连续很多相同电平，接收方可能数错）
将正常数据流与“错误帧”和“过载帧”区分（防止连续6个相同电平）
保持CAN发送数据的活跃状态，防止认为总线空闲（防止连续11个隐性电平1）

波形实例

标准数据帧

11位报文ID：0x555，

RTR = 0 数据帧，IDE = 0，标准格式

DLC = 0001(注意其中第一个1为位填充) = 1，一个字节数据

Data = 10101010 = 0xAA

扩展数据帧

扩展数据帧，报文ID为0x0789ABCD，数据长度1字节，数据内容为0x56

第三章

接收方数据采样

CAN总线无时钟线，总线设备通过一个约定的波特率方式确定每个数据位的时长
发送方以约定的位时长每个固定时间输出一个数据位
接收方以约定的位时长每个固定时间采样总线电平，输入一个数据位
理想采样是数据位中心附近

会遇到的问题

接收方采样点没有对齐数据位中心附近

解决：第一个跳变沿对齐（硬同步）

接收方刚开始采样正确，但是时钟有误差，随着误差积累，采样点逐渐偏离

解决：采样点动态调节，弥补时钟误差（再同步）

位时序

因为要调节采样点，所以会对一个数据位时长进行细分

同步段（SS）
传播时间段（PTS）
相位缓冲段1（PBS1）
相位缓冲段2（PBS2）

每个段又由若干个最小时间单位（Tq）构成

SS = 1Tq、PTS = 1~~8Tq、PBS1 = 1~~8Tq、PBS2 = 2~8Tq

如果跳边沿在SS段，说明当前设备与波形达成同步，否则不同步，则需要调节时序使跳变沿正好在同步段

硬同步

使第一次采样对齐

每个设备有一个位时序计时周期，当某设备发送报文，其他设备接收到SOF下降沿，会将位时序计时周期拨到SS段，与发送方保持同步（实际就是让第一个边沿段调整为SS段，类似于时区，绝对时刻不一样，但都规定为北京时间）

而此时接受段直接确定数据位采样点（PBS1和PBS2段中间）

硬同步解决没有对齐数据位中心附近，只要时钟没误差，就不会有问题

再同步

解决时钟误差，若数据位边沿逐渐偏离SS段，此时接收方根据再同步补偿宽度值（sjw，是最大的补偿，如果误差1tq，sjw2，则补偿1tq；若误差3tq，则补偿2tq）加长PBS1段，或缩短PBS2段

再同步发生在，第一个下降沿之后每个数据位跳变边沿

波特率计算

波特率 = 1/一个数据位的时长 = 1/（Tss+Tpts+Tpbs1+Tpbs2）

SS = 1Tq，PTS = 3Tq，PBS1 = 3Tq，PBS2 = 3Tq，Tq = 0.5us

则波特率 = 1 / (0.5us + 1.5us + 1.5us + 1.5us) = 200kbps

第四章

多设备同时发送遇到的问题

CAN总线只有一差分信号线，同时只能有一个设备操作总线

若多设备同时又发送需求，该如何分配总线资源？

资源分配规则1-先占先得

若当前有设备操作总线发送数据帧/遥控帧，则其他设备不可发（可发错误帧/过载帧）
任何设备检测到11连续隐性电平，认为总线空闲，才能发送
若有设备有发送需求要等待总线空闲

而位填充的适用范围是从帧起始（SOF）到CRC序列结束，不包括CRC界定符、ACK域和EOF段

此时有ACK界定符一个隐性，EOF7个隐性，只需再等三个隐性即可继续发送。

但有可能不止一个信号在等待，多个设备同时到来（总线仲裁）

资源分配规则2-非破坏性仲裁

多设备发送需求同时到来，对仲裁段（ID+RTR）进行非破坏性仲裁，ID号小（优先级高）的取得控制权，ID号大（优先级低）仲裁失利，继续等待空闲

实现非破坏性仲裁两个需要的特性：

线与特性：0 & X & X = 0，1 & 1 & 1 = 1
回读机制：设备发出一个数据位后，读回总线电平状态，确认电平被发送。发送0读回0，发送1读回不一定是1

仲裁：发出数据1，读回（回读机制）数据0（被其他设备线与了）

非破坏性仲裁过程

数据位从前到后依次比较，出现差异且数据位为1的设备仲裁失利

单元1在仲裁段中某一个数据位发送1，回读出0，判断有其他设备在发生，但自己优先级低，放弃发送。但是总线电平依旧是单元2的，并没有被破坏

数据帧和遥控帧优先级

数据帧和遥控帧ID号一样时，数据帧的优先级高于遥控帧（RTR决断，因为RTR = 0 为数据帧）

标准格式和拓展格式的优先级

标准格式11位ID号和扩展格式29位ID号的高11位一样时，标准格式的优先级高于扩展格式（SRR必须始终为1，以保证此要求）

第五章

错误类型

位错误、填充错误、CRC错误、格式错误、应答错误

错误状态

主动错误状态参与通信并检测到错误时发送主动错误帧（6个0），可以破坏别的设备的数据
而频繁发送主动错误，说明这个设备不太可靠，就转到被动错误，收回他破坏其他设备通信的权利
若还是频繁被动错误，则进入总线关闭
如何判断：每个设备内部管理一个TEC和REC，根据TEC和REC确定自己状态（信誉分）

错误计数器

信誉分积分：

STM32 CAN外设

STM32内置bxCAN支持CAN2.0A和2.0B，可自动发报文，程序只需处理报文数据
波特率最高1mbps
3个可配置优先级的发送邮箱
2个3级深度接收FIFO
时间触发通信、自动离线恢复、自动唤醒、禁止自动重传、接收FIFO溢出处理方式可配置、发送优先级可配置、双CAN模式
STM32F103C8T6 CAN资源：CAN1

第一节

CAN网络拓扑

STM32F103C8T6 CAN引脚默认复用

重定义

CAN收发器电路

注意TX，RX接法与串口区分

第二节

CAN框图

对于STM32F103C8T6，没有CAN2，只有CAN1。

通过读写以下寄存器对CAN电路进行配置：

3个主发送邮箱，每个可以存入一个CAN报文，若想发送一个报文，可以将报文放入空置邮箱，在设置寄存器请求发送

接收部分包括过滤器和2个FIFO，过滤器设置过滤规则，告诉硬件想要的ID的报文，如果硬件收到相应ID的报文，将报文放入FIFO；如果都没用，就抛弃，减轻软件负担。

FIFO：先入先出，类似于队列，等待CPU读取

CAN基本结构

发送过程

选择空置邮箱-写入报文-配置寄存器请求发送

RQCP：请求完成

TXOK：发送成功

TME = 1：发送邮箱空

发送流程：

默认TME=1处于空置状态时，TXRQ（请求发送控制位）=1（产生发送请求）
进入挂号状态TME=0，排队等到该邮箱为最高优先级发送报文
进入预定状态，若优先级被比下去，则退回挂号状态
处于预定的报文，探测到CAN总线=IDLE空闲，管理员将报文发送到CAN总线
发送成功回到空置状态，发送失败时若启用NART=0（禁止自动重发）回到空置，若禁止，NART=1则回到预定等待发送（比如总线仲裁失败）

接收过程

接收到一个报文→匹配过滤器后进入FIFO 0或FIFO 1→CPU读取

FMP：报文数目

FOVR：FIFO溢出

接收到一个报文时，FMP=1,FOVR=0，依次接收后FMP递增
有效报文存满FULL置1，在收到有效报文进入溢出FOVR=1
若读取一个报文，RFOM=1，释放一次邮箱

注意：溢出状态释放一次是挂号2

发送和接收配置位

NART：NART=1关闭自动重传，CAN报文只发送一次，不管发送结果如何；置0，自动重传，直到发送成功
TXFP：TXFP=1，优先级按发送请求的顺序；置0，优先级按报文ID，标志符小的先发送（标志符相等，邮箱号小的先发送）
RFLM：置1，接收FIFO锁定，FIFO溢出，新报文丢弃；置0，FOFO溢出后最后收到报文被覆盖

标识符过滤器

x可以表示0-13，每个过滤器都有一套电路

每个过滤器由2个32位寄存器组成，R1[31:0] R2[31:0]
位宽设置，FSCx=0，16位，FSCx=1,32位
- 若只有标准ID，则16位足矣，若有标准，有拓展需要用到32位
- 16位的话两个32位寄存器能写4个ID号，32位写两个
模式设置，
- FBMx=0，屏蔽模式
  
  允许一类，使用了类似掩码功能，屏蔽的是不需要的ID号的位，如只需要用前三位，可以ID段前三位写001xxxxxxxx，屏蔽写11100000000,过滤ID前三位为001
- FBMx=1，列表模式（允许个别）
关联到队列，FFAx=0，关联FIFO0，否则关联FIFO1
激活FACTx:FACTx=0，禁用，否则启用

列表模式
- 想要的ID号写入R1或R2寄存器中
- 位宽32位
  - STID高11位为标准ID
  - 前29位是拓展ID
  - 过滤拓展ID，IDE=1，过滤标准ID，IDE=0
  - RTR=1，过滤遥控帧，RTR=0,过滤数据帧
- 位宽16位
  - 只使用标准ID，4个16位
屏蔽模式
- ID号过多时使用
- 采用位与屏蔽，类似掩码功能
- ID段有效位写实际，对应屏蔽位写1

过滤器配置示例

第三节

测试模式

静默模式：用于分析CAN总线的活动，不会对总线造成影响
环回模式：用于自测试，同时发送的报文可以在CAN_TX引脚上检测到
环回静默模式：用于热自测试，自测的同时不会影响CAN总线

工作模式

初始化模式：用于配置CAN时禁止收发
正常模式
睡眠模式：低功耗，CAN外设时钟停止，可以软件唤醒或硬件自动唤醒
AWUM：置1，自动唤醒，一旦检测到CAN总线活动，硬件就自动清零SLEEP，唤醒CAN外设；置0，手动唤醒，软件清零SLEEP，唤醒CAN外设

位时间特性

STM32中，PDS和PBS1合在一起

SS = 1Tq BS1 = 1~~16Tq BS2 = 1~~8Tq
SJW=1~4Tq

波特率=APB1时钟频率/分频系数/1位Tq数

=36Mhz/(BRP[9:0]+1)/(1+(TS1[3:0]+1)+(TS2[2:0]+1))

中断

CAN外设占用4个专用中断向量

发送中断：发送邮箱空时产生
FIFO 0中断：收到一个报文/FIFO 0满/FIFO 0溢出时产生
FIFO 1中断：收到一个报文/FIFO 1满/FIFO 1溢出时产生
状态改变错误中断：出错/唤醒/进入睡眠时产生

中断发生条件：

git学习

Thu, 15 May 2025 13:30:00 +0800

配置Git

1
2
3
4



$ git config --global user.name "Your Name"

$ git config --global user.email "email@example.com"

创建版本库

1
2
3
4
5
6
7
8



$ mkdir learngit

$ cd learngit

$ pwd

/Users/michael/learngit

1
2

$ git init

1
2

$ git add readme.txt

1
2

$ git commit -m "wrote a readme file"

版本管理

版本回退

1
2

$ git log

1
2
3
4
5
6
7
8



$ git log --pretty=oneline

1094adb7b9b3807259d8cb349e7df1d4d6477073 (HEAD -> master) append GPL

e475afc93c209a690c39c13a46716e8fa000c366 add distributed

eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0 wrote a readme file

1
2

$ git reset --hard HEAD^//根据参数回退对应

1
2

$ git reset --hard 1094a

1
2

$ git reflog//查看每次

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



$ git status//查看状态

On branch master

Changes to be committed:

 (use "git reset HEAD <file>..." to unstage)



	new file: LICENSE

	modified: readme.txt

管理修改

第一次修改 -> git add -> 第二次修改 -> git add -> git commit

1
2

$ git diff HEAD -- readme.txt //查看工作区和版本库最新版本区别

撤销修改

1
2

$ git checkout -- readme.txt//丢弃工作区修改

1
2

$ git reset HEAD readme.txt//把暂存区的修改撤销掉

删除文件

1
2

$ git rm test.txt

1
2

$ git checkout -- test.txx//此时是还原

远程仓库

添加远程库

1
2

$ git remote add origin https://github.com/Zesaen/learngit.git

1
2

$ git push -u origin master//第一次推送master分支时，加上了-u参数

1
2

$ git push origin master//此后本地提交

删除远程库

1
2

$ git remote -v//查看远程库

1
2

$ git remote rm origin//删除origin

从远程库克隆

1
2

$ git clone

分支管理

创建并合并

查看分支：git branch

创建分支：git branch <name>

切换分支：git switch <name>

创建+切换分支：git switch -c <name>

合并某分支到当前分支：git merge <name>

删除分支：git branch -d <name>

解决冲突

master分支和feature1分支各自都分别有新的提交

Git用<<<<<<<，=======，>>>>>>>标记出不同分支的内容

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



<<<<<<< HEAD

Creating a new branch is quick & simple.

=======

Creating a new branch is quick AND simple.

>>>>>>> feature1

Bug分支

略

强制删除分支

1
2

$ git branch -D <name>

多人协作

略

标签管理

1
2

$ git tag v1.0//给最新打标签

1
2

$ git tag v0.9 f52c633//给对应打标签

1
2

$ git show v0.9//查看标签信息

1
2

$ git tag -d v0.1//删除标签

操作标签

命令git push origin <tagname>可以推送一个本地标签；
命令git push origin --tags可以推送全部未推送过的本地标签；
命令git tag -d <tagname>可以删除一个本地标签；
命令git push origin :refs/tags/<tagname>可以删除一个远程标签。

Modbus 通信协议学习笔记

Sat, 10 May 2025 10:00:00 +0800

通信：

硬件层：RS485解决数据传输问题，如何将“0”或“1”传输到另外一个设备

软件层：MODBUS，在硬件基础上解决数据传输的含义或意义

对于RS485：作为两线制485由于传输差分信号，因此是半双工的

对于MAX485芯片： RE和DE连一根线，为高电平时DE使能，单片机TX发送至DI。为低电平时RE使能，485信号发送至单片机RX

max485电路：

对于主从机：RS485和modbus支持主从通信，能够一主多从

modbus约定：

一个系统一主多从，只能进行主从通信，从从通信需要借助主机
系统中从机不可主动向主机发送数据
系统上电后所有设备都应处于监听总线的状态，也就是接收状态
如果要进行一次通信，必须由主机主动发起通信

一次modbus通信：模式为主机轮询，从机应答的机制

主机一开始也是监听总线的状态，要切换成发送模式（实际上是修改MAX485上RE、DE的电平），发送数据包
发送完成后立马转成接收模式

modbus通信报文或数据包格式：

通信地址0-247，指定地址0是广播指令，所有设备都会运行

常用功能码：

03功能码报文示例：从机读数据

主机发送Tx:01 03 00 00 00 02 C4 0B

	地址码8bit	功能码8bit	寄存器起始16bit	CRC校验16bit
主机发送	01	03	00 00	C4 0B
从机应答Rx:01 03 04 00 01 00 02 2A 32

读了2个寄存器，每个寄存器16位

	地址码	功能码	字节数	数据1	数据2	CRC校验
从机应答	01	03	04	00 01	00 02	2A 32

06功能码报文示例：向从机写一个寄存器数据

主机发送Tx:01 06 00 03 00 C8 78 5C

	地址码8bit	功能码8bit	寄存器个数16bit	数据16bit	CRC校验16bit
主机发送	01	06	00 03	00 C8	78 5C

从机应答Rx::01 06 00 03 00 C8 78 5C与主机发送一致

如何接受报文：

9600波特率，3字符 1个字符占10bit

3*10*1/9600=3ms 超时时间10ms就认为一个新的数据包

IIC 通信协议学习笔记

Sat, 19 Apr 2025 09:30:00 +0800

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，因为有发有收

SPI 通信协议学习笔记

Sat, 12 Apr 2025 09:30:00 +0800

SPI通信

SPI：通用数据总线
四根通信线：轻松Mhz
- SCK(Serial Clock)
- MOSI(Master Output Slave Input)
- MISO(Master Input Slave Output)
- SS(Slave Select)
同步，全双工
支持总线挂载多设备（一主多从）

常用模块：W25Q64 FLASH存储器、SPI OLED屏、NRF24L01 2.4G无线通讯模块、SD卡支持SPI

硬件电路

所有SPI设备SCK、MOSI、MISO分别连接在一起
主机引出多条SS控制线，分别连接各从机SS引脚
输出引脚配置推挽输出（驱动能力强，驱动上下降沿强），输入引脚配置浮空或上拉

主机指定从机：将对应SS线输出低电平，其余高电平

移位示意图

波特率发生器作为时钟，每一个上升沿，移位寄存器移出一位，进行数据发送；每一个下降沿，最低位采样

一般主机发0x00或0xff跟从机交换数据

SPI时序基本单元

起始条件：SS高电平到低电平
终止条件：SS低电平切换高电平

SPI由不同的移位模型，能根据SCK的不同边沿变化进行移位。

模式1

CPOL=0：空闲状态时，SCK低电平

CPHA=1：SCK第一个边沿移出数据，第二个边沿移入数据（数据采样）

模式0

CPOL=0:空闲状态时，SCK为低电平 CPHA=0: SCK第一个边沿移入数据,第二个边沿移出数据

将第一个数据变化的时机提前

SPI时序

W25Q64为例，芯片厂商规定

发送指令
向SS指定设备，发送指令（0x06），00000110

如何更新这个博客

Sat, 15 Mar 2025 11:30:00 +0800

这是一篇备忘录，记录本博客的日常更新流程。现在有两种方式：**本地笔记工作台（推荐）**和手工流程。

1. notes-ui 本地工作台（推荐）

仓库里的 tools/notes-ui/ 是一个只监听本机的 Web 工具，双击 start.bat 启动后浏览器自动打开 http://127.0.0.1:8091 ：

导入笔记：拖拽 .md 文件或整个笔记文件夹（图片会自动带上），也可以直接粘贴文本
检查元数据：标题、描述、分类、标签、发布时间都会自动预填，slug 实时查重；右侧图片清单能看到正文引用的图片是否齐全，缺的可补传
生成页面包：图片自动拷入 images/、正文路径自动改写、front matter 按站内规范生成
本地预览：弹窗内嵌真实主题渲染（含公式和 Mermaid）
分步发布：构建验证 → 部署上线（二次确认）→ 线上抽查 → git 提交，每步独立日志，出问题可停在中途

「文章管理」页还能改历史文章的元数据、切换草稿、改 slug、删除（进本地回收站）。

2. 手工流程（备用）

不用工具时，流程如下。

写新文章

在 content/post/ 目录下新建页面包 my-new-post/index.md（图片放同目录 images/），或单文件 my-new-post.md：

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


---
title: "文章标题"
date: 2025-03-15T11:30:00+08:00
slug: my-new-post
draft: false
description: "文章摘要，会显示在首页卡片上。"
categories:
 - 分类名
tags:
 - 标签
---

正文从这里开始，支持标准 Markdown。

把 draft 设为 true 可以存草稿，构建时不会发布。注意 front matter 的 date 不要写成未来时间，否则 Hugo 默认不构建该文章。

本地预览（可选）

1

hugo server -D

浏览器打开 http://localhost:1313 实时预览，Ctrl+C 退出。

构建并部署

1
2


# 在博客根目录执行一键部署脚本（构建 + 上传 + 原子替换）
bash deploy/deploy.sh

部署完成，访问 https://zeseanblog.top 即可看到新文章。

3. 让 AI 助手代劳

直接说一句「帮我发布新文章」即可——本文件夹的 AGENTS.md 里记录了完整的环境信息和部署流程。

4. 提交代码（备份）

1
2
3


# 只提交这篇 文章 的路径，避免带上工作区其他未完成的改动
git add content/post/my-new-post
git commit -m "post: 新文章标题"

文章源码就是备份，随时可以回滚或迁移。

你好，世界

Sat, 15 Mar 2025 10:00:00 +0800

折腾了一阵子，个人博客终于上线了 🎉 这是本站的第一篇文章，简单记录一下搭建过程。

技术栈

组件	选择	说明
静态站点生成器	Hugo	单二进制，构建速度极快
主题	Stack	卡片式设计，简洁美观
Web 服务器	Nginx	托管静态文件，性能足够
HTTPS	Let’s Encrypt	免费证书，自动续期
服务器	腾讯云	Ubuntu 22.04

为什么选择静态博客？

快：纯静态 HTML，没有数据库查询，加载飞快
稳：没有后端服务，几乎不会被黑，维护成本极低
省：一台最小配置的服务器就能流畅运行

接下来

以后这里会不定期更新：

📝 技术学习笔记
🔨 项目开发记录
💭 生活随想

欢迎常来逛逛～

Zesean 的博客

端侧大模型在线/离线部署（Agent）——机器人项目迁移实战（三）

子任务 3.1 拆解：端侧 LLM 部署实施方案

✅️微任务 3.1.1：Jetson 硬件环境准备与 Swap 空间配置

✅️微任务 3.1.2：推理引擎技术选型（llama.cpp vs TensorRT-LLM）

✅️微任务 3.1.3：Qwen2.5 模型量化与格式转换

✅️微任务 3.1.4：Qwen2.5-0.5B-Instruct Lora微调

微任务 3.1.4：流式推理接口开发（C++ / Python）

微任务 3.1.5：ROS2 节点封装与端侧通信集成

LLM 微调基础：LoRA 与 QLoRA 学习笔记

第一阶段：LLM微调基础

SFT、DPO

RLHF

LoRA:

QLoRA（Quantized LoRA）：

QLoRA

室内定位指纹库构建实践：ESP32 地磁采集与 WiFi 网格测量

指纹法定位原理

地磁采集：ESP32 + ICM20948

WiFi RSSI 网格测量

预处理：从 1m 实测到 0.5m 指纹库

看看采到的数据

小结

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上机

第10章串口UART编程

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

第8章网络通信

第9章多线程编程

第4章文件IO

第1章交叉编译

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

第2章安装软件

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

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