LsWorld Hexo https://lsworl.github.io/ All rights reserved 2026, LsWorld 机器学习与代码笔记 LsWorld 2026-05-23T02:18:10.000Z LsWorld 线性回归（Linear Regression）是机器学习中最基础、也最常用的监督学习算法之一。它主要用于解决回归问题，也就是预测一个连续数值。

例如：

  • 根据房屋面积预测房价。
  • 根据学习时长预测考试分数。
  • 根据广告投入预测销售额。

线性回归的核心思想很朴素：如果两个变量之间存在近似线性的关系，就可以用一条直线或者一个线性函数去描述这种关系，并用它来预测未知样本。

线性回归拟合直线示意图

图中的蓝色点是训练数据，红色直线是拟合出的线性模型，灰色虚线表示预测值和真实值之间的误差。线性回归训练时，本质上就是在寻找一条让整体误差尽可能小的直线。

1. 线性回归的直觉

假设我们想根据学习时长预测考试分数，已有数据如下：

学习时长/小时考试分数
150
255
365
470
580

把这些点画到坐标系中，可以发现：学习时间越长，考试分数通常越高。虽然这些点不一定完全落在同一条直线上，但整体趋势接近一条向上倾斜的直线。

线性回归要做的事情，就是找到一条尽可能贴近这些数据点的直线：

$$
\hat{y} = wx + b
$$

其中：

  • $x$ 表示输入特征，比如学习时长。
  • $\hat{y}$ 表示模型预测值，比如预测分数。
  • $w$ 表示权重，也可以理解为直线的斜率。
  • $b$ 表示偏置，也可以理解为直线在 $y$ 轴上的截距。

如果最终学到的模型是：

$$
\hat{y} = 7x + 43
$$

那么当一个学生学习 6 小时时，模型会预测：

$$
\hat{y} = 7 \times 6 + 43 = 85
$$

也就是说，预测考试分数为 85 分。

2. 一元线性回归

只有一个输入特征时，称为一元线性回归。模型形式为：

$$
\hat{y}^{(i)} = wx^{(i)} + b
$$

其中 $i$ 表示第 $i$ 个样本。

对于训练集：

$$
(x^{(1)}, y^{(1)}), (x^{(2)}, y^{(2)}), \dots, (x^{(m)}, y^{(m)})
$$

线性回归希望找到合适的 $w$ 和 $b$，让所有样本的预测值 $\hat{y}$ 尽可能接近真实值 $y$。

这里的“接近”需要一个明确的衡量标准，于是就引出了损失函数。

3. 损失函数

线性回归中最常用的损失函数是均方误差（Mean Squared Error，MSE）：

$$
J(w, b) = \frac{1}{m}\sum_{i=1}^{m}(\hat{y}^{(i)} - y^{(i)})^2
$$

因为：

$$
\hat{y}^{(i)} = wx^{(i)} + b
$$

所以也可以写成：

$$
J(w, b) = \frac{1}{m}\sum_{i=1}^{m}(wx^{(i)} + b - y^{(i)})^2
$$

这个公式的含义是：

  1. 对每个样本计算预测值和真实值之间的误差。
  2. 将误差平方，避免正负误差相互抵消。
  3. 对所有平方误差求平均。

线性回归的训练目标就是让这个损失函数尽可能小：

$$
\min_{w,b} J(w,b)
$$

固定截距时斜率和均方误差的关系

上图固定截距 $b=41.5$，只观察斜率 $w$ 变化时均方误差的变化。曲线最低的位置对应更合适的参数，这也解释了为什么训练模型可以理解为“寻找损失函数的最低点”。

4. 最小二乘法

对于一元线性回归，可以直接使用最小二乘法求出最优的 $w$ 和 $b$。

最优斜率 $w$ 的计算公式为：

$$
w = \frac{\sum_{i=1}^{m}(x^{(i)} - \bar{x})(y^{(i)} - \bar{y})}{\sum_{i=1}^{m}(x^{(i)} - \bar{x})^2}
$$

最优截距 $b$ 的计算公式为：

$$
b = \bar{y} - w\bar{x}
$$

其中：

  • $\bar{x}$ 表示所有 $x$ 的平均值。
  • $\bar{y}$ 表示所有 $y$ 的平均值。

从直觉上看，$w$ 描述的是 $x$ 增加时 $y$ 大约会增加多少；$b$ 则负责调整整条直线的上下位置。

5. 手工计算例子

仍然使用学习时长和考试分数的数据：

编号$x$$y$
1150
2255
3365
4470
5580

先计算平均值：

$$
\bar{x} = \frac{1+2+3+4+5}{5} = 3
$$

$$
\bar{y} = \frac{50+55+65+70+80}{5} = 64
$$

接着计算 $w$：

$x$$y$$x-\bar{x}$$y-\bar{y}$$(x-\bar{x})(y-\bar{y})$$(x-\bar{x})^2$
150-2-14284
255-1-991
3650100
4701661
580216324

因此：

$$
w = \frac{28+9+0+6+32}{4+1+0+1+4} = \frac{75}{10} = 7.5
$$

再计算 $b$：

$$
b = 64 - 7.5 \times 3 = 41.5
$$

所以拟合出来的直线为：

$$
\hat{y} = 7.5x + 41.5
$$

当学习时间为 6 小时时：

$$
\hat{y} = 7.5 \times 6 + 41.5 = 86.5
$$

模型预测考试分数约为 86.5 分。

6. 多元线性回归

实际问题中，预测目标往往不只受一个因素影响。

例如房价可能同时受到这些因素影响：

  • 房屋面积
  • 房间数量
  • 地理位置
  • 房龄
  • 楼层

如果有多个输入特征，就称为多元线性回归。模型形式为：

$$
\hat{y} = w_1x_1 + w_2x_2 + \dots + w_nx_n + b
$$

也可以写成向量形式：

$$
\hat{y} = \mathbf{w}^T\mathbf{x} + b
$$

其中：

  • $\mathbf{x}$ 是特征向量。
  • $\mathbf{w}$ 是权重向量。
  • $b$ 是偏置。

多元线性回归的本质没有变化，仍然是在寻找一组参数，让预测值和真实值之间的误差尽可能小。

7. 梯度下降求解

当数据量较大、特征较多时，可以使用梯度下降来优化参数。

梯度下降的核心思想是：先随机给 $w$ 和 $b$ 一个初始值，然后不断沿着损失函数下降最快的方向更新参数，直到损失足够小。

参数更新公式为：

$$
w := w - \alpha \frac{\partial J(w,b)}{\partial w}
$$

$$
b := b - \alpha \frac{\partial J(w,b)}{\partial b}
$$

其中 $\alpha$ 是学习率，用来控制每次更新参数的步长。

对于一元线性回归：

$$
\frac{\partial J(w,b)}{\partial w}
= \frac{2}{m}\sum_{i=1}^{m}(\hat{y}^{(i)} - y^{(i)})x^{(i)}
$$

$$
\frac{\partial J(w,b)}{\partial b}
= \frac{2}{m}\sum_{i=1}^{m}(\hat{y}^{(i)} - y^{(i)})
$$

学习率不能太大，也不能太小：

  • 如果学习率太大，可能会越过最优点，导致损失震荡甚至发散。
  • 如果学习率太小，收敛速度会很慢，需要训练很多轮。

8. Python 实现

8.1 使用最小二乘法手写实现

import numpy as npx = np.array([1, 2, 3, 4, 5], dtype=float)y = np.array([50, 55, 65, 70, 80], dtype=float)x_mean = np.mean(x)y_mean = np.mean(y)w = np.sum((x - x_mean) * (y - y_mean)) / np.sum((x - x_mean) ** 2)b = y_mean - w * x_meanprint("w =", w)print("b =", b)new_x = 6prediction = w * new_x + bprint("预测分数 =", prediction)

输出结果大致为：

w = 7.5b = 41.5预测分数 = 86.5

8.2 使用 scikit-learn 实现

import numpy as npfrom sklearn.linear_model import LinearRegressionX = np.array([[1], [2], [3], [4], [5]], dtype=float)y = np.array([50, 55, 65, 70, 80], dtype=float)model = LinearRegression()model.fit(X, y)print("w =", model.coef_[0])print("b =", model.intercept_)prediction = model.predict([[6]])print("预测分数 =", prediction[0])

在 scikit-learn 中，输入特征 $X$ 通常需要是二维数组，即使只有一个特征，也要写成 [[1], [2], [3]] 这样的形式。

9. 模型评估指标

线性回归属于回归模型，常用评估指标包括 MAE、MSE、RMSE 和 $R^2$。

9.1 MAE

MAE（Mean Absolute Error，平均绝对误差）：

$$
MAE = \frac{1}{m}\sum_{i=1}^{m}|\hat{y}^{(i)} - y^{(i)}|
$$

MAE 表示预测值和真实值平均相差多少，单位和原始标签一致，因此比较容易理解。

9.2 MSE

MSE（Mean Squared Error，均方误差）：

$$
MSE = \frac{1}{m}\sum_{i=1}^{m}(\hat{y}^{(i)} - y^{(i)})^2
$$

MSE 会放大较大的误差，因此对异常值更敏感。

9.3 RMSE

RMSE（Root Mean Squared Error，均方根误差）：

$$
RMSE = \sqrt{\frac{1}{m}\sum_{i=1}^{m}(\hat{y}^{(i)} - y^{(i)})^2}
$$

RMSE 对 MSE 开平方后，单位重新回到原始标签的单位。

9.4 $R^2$

$R^2$ 又叫决定系数，用来衡量模型对数据变化的解释能力：

$$
R^2 = 1 - \frac{\sum_{i=1}^{m}(y^{(i)} - \hat{y}^{(i)})^2}{\sum_{i=1}^{m}(y^{(i)} - \bar{y})^2}
$$

$R^2$ 越接近 1，说明模型拟合效果越好；如果 $R^2$ 接近 0，说明模型效果可能和直接预测平均值差不多。

10. 线性回归的优缺点

10.1 优点

  • 模型简单，容易理解和实现。
  • 训练速度快，适合作为回归任务的 baseline。
  • 参数具有一定可解释性，可以观察每个特征对预测结果的影响。
  • 对线性关系明显的数据效果很好。

10.2 缺点

  • 表达能力有限，难以拟合复杂的非线性关系。
  • 对异常值比较敏感，极端样本可能明显影响拟合结果。
  • 特征之间存在强相关性时，参数解释可能变得不稳定。
  • 假设特征和目标值之间近似线性，如果这个假设不成立，效果会比较差。

11. 实际使用时的注意点

11.1 观察数据是否接近线性关系

线性回归适合处理接近线性关系的数据。如果特征和目标之间明显是曲线关系，可以考虑加入多项式特征，或者使用决策树、随机森林、梯度提升树等非线性模型。

11.2 注意异常值

由于线性回归通常使用平方误差作为损失函数，异常值会被放大。训练前可以先画散点图、箱线图，或者使用统计方法检查异常样本。

11.3 做好特征处理

对于多元线性回归，特征尺度差异过大时，虽然普通最小二乘法仍然能求解，但在使用梯度下降时会影响收敛速度。因此常见做法是对特征进行标准化：

$$
z = \frac{x - \mu}{\sigma}
$$

其中 $\mu$ 是均值，$\sigma$ 是标准差。

11.4 避免只看训练集误差

如果模型只在训练集上表现好，但在测试集上表现差，说明模型泛化能力不足。更合理的做法是将数据划分为训练集和测试集，再使用测试集评估模型效果。

12. 总结

线性回归的核心可以概括为一句话：用一个线性函数去拟合输入特征和连续目标值之间的关系。

它的关键步骤是：

  1. 假设模型形式，例如 $\hat{y} = wx + b$。
  2. 定义损失函数，例如均方误差。
  3. 通过最小二乘法或梯度下降求出最优参数。
  4. 使用 MAE、MSE、RMSE、$R^2$ 等指标评估模型。

虽然线性回归看起来简单，但它包含了机器学习中很多重要思想：模型假设、损失函数、参数优化、泛化能力和特征处理。理解线性回归之后，再学习逻辑回归、神经网络、支持向量机等模型时，会更容易抓住其中的共同脉络。

]]> https://lsworl.github.io/2026/05/23/machine-learning-linear-regression/ 2026-05-22T16:00:00.000Z 从直觉、数学公式、手工计算、Python 实现和优缺点几个角度理解线性回归。 线性回归：从直觉到最小二乘法 2026-05-23T02:18:10.000Z LsWorld KNN（K-Nearest Neighbors，K 近邻）是一种非常直观的监督学习算法：一个样本属于什么类别，可以参考它在特征空间中最近的 $K$ 个邻居。

在分类任务中，KNN 通常采用“多数投票”：最近的 $K$ 个样本里哪个类别最多，就预测为哪个类别；在回归任务中，KNN 通常取最近 $K$ 个样本标签值的平均值或加权平均值。

1. KNN 的直觉

可以把 KNN 想象成“向邻居打听答案”。

假设小区里新搬来一户人家，你想判断他们更像“高收入家庭”还是“普通收入家庭”。最直接的方式，是观察离他们最近的几户邻居：如果最近的 5 户里有 3 户都是高收入家庭，那么你可能会猜测这户新邻居也更接近高收入家庭。

机器学习里的 KNN 做的是类似的事情：

  • 输入：一个尚未标记类别的新样本。
  • 过程：在训练集中找到距离它最近的 $K$ 个已知样本。
  • 输出：分类时进行多数投票，回归时进行平均或加权平均。

KNN 本质上没有显式的训练过程，它把训练数据保存下来，预测时再计算新样本与训练样本之间的距离。因此它也被称为惰性学习（Lazy Learning）。

2. 数学原理

KNN 要解决两个核心问题：

  1. 如何定义“近”？也就是距离度量。
  2. 找到邻居后如何做决策？也就是分类或回归规则。

2.1 距离度量

假设两个 $n$ 维样本分别为：

$$
\mathbf{x} = (x_1, x_2, \dots, x_n)
$$

$$
\mathbf{y} = (y_1, y_2, \dots, y_n)
$$

不同的距离函数会影响 KNN 对“相似”的判断。

欧氏距离

欧氏距离是最常见的距离度量，可以理解为多维空间中的直线距离：

$$
d(\mathbf{x}, \mathbf{y}) = \sqrt{\sum_{i=1}^{n}(x_i - y_i)^2}
$$

二维空间中，它就是两点之间的几何距离。

曼哈顿距离

曼哈顿距离可以理解为在网格道路中行走时的距离，只能横向或纵向移动：

$$
d(\mathbf{x}, \mathbf{y}) = \sum_{i=1}^{n}|x_i - y_i|
$$

闵可夫斯基距离

闵可夫斯基距离是欧氏距离和曼哈顿距离的推广：

$$
d(\mathbf{x}, \mathbf{y}) =
\left(\sum_{i=1}^{n}|x_i - y_i|^p\right)^{\frac{1}{p}}
$$

当 $p=1$ 时，它等价于曼哈顿距离；当 $p=2$ 时，它等价于欧氏距离。

2.2 为什么要做特征缩放

KNN 对特征尺度非常敏感。

假设一个样本有两个特征：年收入和年龄。年收入的范围可能是 $0 \sim 100000$，年龄的范围可能是 $0 \sim 100$。如果直接计算欧氏距离，年收入会主导距离结果，年龄的影响几乎被淹没。

因此，在使用 KNN 前通常要先进行标准化或归一化：

$$
z = \frac{x - \mu}{\sigma}
$$

其中 $\mu$ 是均值，$\sigma$ 是标准差。标准化后，不同特征会处于更可比较的尺度上。

3. 手工计算例子：水果分类

假设我们用两个特征判断水果类别：

  • 甜度 $x_1$
  • 脆度 $x_2$

已有训练数据如下：

编号类别甜度 $x_1$脆度 $x_2$坐标
A苹果87$(8, 7)$
B苹果78$(7, 8)$
C梨24$(2, 4)$
D梨33$(3, 3)$

现在有一个未知水果 $X=(4,5)$，设 $K=3$，判断它是苹果还是梨。

KNN 水果分类示意图

图中的星形点表示未知水果，虚线连接的是它最近的 3 个邻居。通过这张图可以更直观地看到：KNN 并不是提前学出一个公式，而是在预测时临时寻找附近样本，再根据邻居类别做判断。

3.1 计算距离

使用欧氏距离：

$$
d(X,A)=\sqrt{(4-8)^2+(5-7)^2}=\sqrt{20}\approx4.47
$$

$$
d(X,B)=\sqrt{(4-7)^2+(5-8)^2}=\sqrt{18}\approx4.24
$$

$$
d(X,C)=\sqrt{(4-2)^2+(5-4)^2}=\sqrt{5}\approx2.24
$$

$$
d(X,D)=\sqrt{(4-3)^2+(5-3)^2}=\sqrt{5}\approx2.24
$$

按距离从小到大排序：

排名邻居类别距离
1C梨$2.24$
2D梨$2.24$
3B苹果$4.24$
4A苹果$4.47$

因为 $K=3$，最近的 3 个邻居是 C、D、B。其中梨有 2 票，苹果有 1 票，所以 KNN 会预测：

$$
\hat{y}=\text{梨}
$$

4. 决策规则

4.1 分类任务

分类任务中最常见的是多数投票：

$$
\hat{y}=\arg\max_{c}\sum_{i \in N_K(x)} I(y_i=c)
$$

其中 $N_K(x)$ 表示样本 $x$ 的 $K$ 个最近邻，$I(\cdot)$ 是指示函数。

如果希望离得更近的邻居拥有更高权重，可以使用距离加权投票：

$$
w_i=\frac{1}{d(x,x_i)+\epsilon}
$$

这里 $\epsilon$ 是一个很小的正数，用来避免距离为 0 时分母出错。

4.2 回归任务

回归任务中，KNN 可以取最近邻标签的平均值：

$$
\hat{y}=\frac{1}{K}\sum_{i \in N_K(x)}y_i
$$

也可以使用距离加权平均：

$$
\hat{y}=\frac{\sum_{i \in N_K(x)} w_i y_i}{\sum_{i \in N_K(x)}w_i}
$$

5. 如何选择 K 值

$K$ 是 KNN 中最重要的超参数之一。

  • $K$ 太小：模型会过于敏感，容易受到噪声点影响，训练集表现很好但泛化能力较差，这通常对应过拟合。
  • $K$ 太大：模型会参考太多远处样本，决策边界过于平滑，难以捕捉局部结构，这通常对应欠拟合。

在二分类任务中，通常会优先尝试奇数 $K$，例如 $K=3,5,7$，这样可以减少平票情况。但在多分类任务中，即使 $K$ 是奇数也可能平票，此时可以使用距离加权、降低 $K$ 或制定固定的平票处理规则。

实践中常用交叉验证选择合适的 $K$：

$$
K^* = \arg\min_K \text{CVError}(K)
$$

6. Python 实战：观察不同 K 值的决策边界

下面代码使用 scikit-learn 构造一个二维数据集，并对比 $K=1$、$K=5$、$K=15$ 时的决策边界。

安装依赖：

pip install scikit-learn numpy matplotlib

示例代码：

import numpy as npimport matplotlib.pyplot as pltfrom matplotlib.colors import ListedColormapfrom sklearn.datasets import make_moonsfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.preprocessing import StandardScalerX, y = make_moons(n_samples=200, noise=0.3, random_state=42)scaler = StandardScaler()X_scaled = scaler.fit_transform(X)h = 0.02x_min, x_max = X_scaled[:, 0].min() - 0.5, X_scaled[:, 0].max() + 0.5y_min, y_max = X_scaled[:, 1].min() - 0.5, X_scaled[:, 1].max() + 0.5xx, yy = np.meshgrid(    np.arange(x_min, x_max, h),    np.arange(y_min, y_max, h),)k_values = [1, 5, 15]cmap_light = ListedColormap(["#FEE2E2", "#DBEAFE"])cmap_bold = ListedColormap(["#DC2626", "#2563EB"])plt.figure(figsize=(15, 4.5))for i, k in enumerate(k_values, start=1):    clf = KNeighborsClassifier(n_neighbors=k)    clf.fit(X_scaled, y)    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])    Z = Z.reshape(xx.shape)    plt.subplot(1, 3, i)    plt.pcolormesh(xx, yy, Z, cmap=cmap_light, shading="auto")    plt.scatter(        X_scaled[:, 0],        X_scaled[:, 1],        c=y,        cmap=cmap_bold,        edgecolors="k",        s=36,    )    plt.title(f"KNN Decision Boundary (K={k})")    plt.xlabel("Feature 1")    plt.ylabel("Feature 2")plt.tight_layout()plt.show()
不同 K 值下的决策边界示意

从图中可以看到：

  • $K=1$ 时，决策边界非常曲折，模型对局部噪声非常敏感。
  • $K=5$ 时，边界相对平滑，同时还能保留数据的局部结构。
  • $K=15$ 时，边界进一步变平滑，如果继续增大 $K$，模型可能出现欠拟合。

7. KNN 的优缺点

优点

  • 简单直观，容易理解和实现。
  • 不需要显式训练过程，适合做快速基线模型。
  • 天然支持多分类任务。
  • 对非线性边界有一定表达能力，因为决策边界由局部邻居决定。

缺点

  • 预测阶段计算成本高，每次预测都需要计算新样本与大量训练样本的距离。
  • 内存消耗较大，需要保存训练集。
  • 对特征尺度敏感，通常必须先做特征缩放。
  • 对高维数据不友好，容易受到维度灾难影响。
  • 对类别不平衡较敏感，多数类样本可能在邻域中占优势。

8. 实践建议

使用 KNN 时，可以按下面的顺序思考：

  1. 先进行数据清洗，处理缺失值和异常值。
  2. 对连续特征做标准化或归一化。
  3. 用交叉验证选择 $K$。
  4. 视情况选择距离度量，例如欧氏距离、曼哈顿距离或余弦距离。
  5. 如果数据规模较大，可以考虑 KD-Tree、Ball Tree 或近似最近邻搜索。
  6. 如果类别不平衡，可以尝试距离加权或重采样方法。

9. 总结

KNN 的思想非常朴素：相似的样本往往拥有相似的标签。它没有复杂的训练过程，却能在许多小规模、低维、结构清晰的数据集上取得不错效果。

要用好 KNN，最重要的是记住三点：

  • 特征缩放几乎是必需的。
  • $K$ 值需要通过验证集或交叉验证选择。
  • 数据维度和数据规模会直接影响 KNN 的效果与速度。

因此，KNN 很适合作为入门算法和基线模型；但在大规模、高维度或实时预测场景中，需要谨慎使用。

]]> https://lsworl.github.io/2026/05/19/machine-learning-knn/ 2026-05-19T11:43:23.000Z 从直觉、数学公式、手工例子、代码实现和优缺点几个角度理解 K 近邻算法。 K 近邻算法：KNN（K-Nearest Neighbors） 2026-05-23T02:17:58.000Z LsWorld

1. 任务管理 (Task Management)

  • xTaskCreate(): 创建任务。

    • 功能: 动态创建一个新的任务，并将其加入到 FreeRTOS 的任务调度器中。

    • 常用场景: 在系统初始化阶段或运行时动态创建任务，用于执行不同的功能模块。

    • 关键参数

      :

      • pvTaskCode: 指向任务函数的指针，任务代码的入口。
      • pcName: 任务名称，字符串形式，方便调试和追踪。
      • usStackDepth: 任务堆栈大小，以字 (word) 为单位，需要根据任务需求合理配置。
      • pvParameters: 传递给任务函数的参数，void 指针类型，可以传递任意类型数据。
      • uxPriority: 任务优先级，数值越大优先级越高，FreeRTOS 会根据优先级进行任务调度。
      • pxCreatedTask: 任务句柄指针，用于存储创建的任务句柄，后续操作任务时需要使用该句柄。

  • vTaskDelete(): 删除任务。

    • 功能: 删除指定的任务。可以删除自身任务或其它任务。

    • 常用场景: 任务执行完成后不再需要，或者需要动态管理任务生命周期时。

    • 关键参数

      :

      • xTaskToDelete: 要删除的任务句柄。如果为 NULL，则删除自身任务。

  • vTaskDelay(): 任务延时。

    • 功能: 使当前任务进入阻塞态，延时指定的时间。

    • 常用场景: 周期性任务的延时，或在不需要立即执行的任务中加入延时以降低 CPU 占用率。

    • 关键参数

      :

      • xTicksToDelay: 延时的时间，以 tick 为单位。tick 的时间长度由 configTICK_RATE_HZ 配置宏定义，例如 configTICK_RATE_HZ 为 1000，则 1 tick 为 1ms。

  • vTaskSuspend(): 挂起任务。

    • 功能: 将指定的任务挂起，使其进入挂起态，不再参与任务调度。

    • 常用场景: 暂时停止某个任务的执行，例如调试时暂停某个功能模块。

    • 关键参数

      :

      • xTaskToSuspend: 要挂起的任务句柄。如果为 NULL，则挂起自身任务。

  • vTaskResume(): 恢复任务。

    • 功能: 恢复被挂起的任务，使其进入就绪态，重新参与任务调度。

    • 常用场景: 与 vTaskSuspend() 配对使用，在需要时恢复被挂起的任务。

    • 关键参数

      :

      • xTaskToResume: 要恢复的任务句柄。

  • uxTaskGetStackHighWaterMark(): 获取任务堆栈剩余空间。

    • 功能: 获取任务堆栈当前剩余空间的大小，用于评估堆栈使用情况，避免堆栈溢出。

    • 常用场景: 调试阶段或性能优化时，检查任务堆栈是否足够，预防潜在的堆栈溢出问题。

    • 关键参数

      :

      • xTask: 要查询的任务句柄。如果为 NULL，则查询自身任务。

  • pcTaskGetName(): 获取任务名称。

    • 功能: 获取指定任务的任务名称字符串。

    • 常用场景: 调试信息输出，日志记录等，方便识别任务。

    • 关键参数

      :

      • xTaskToQuery: 要查询的任务句柄。如果为 NULL，则查询自身任务。

2. 队列管理 (Queue Management)

  • xQueueCreate(): 创建队列。

    • 功能: 创建一个新的队列，用于任务间或 ISR 与任务间的数据传递。

    • 常用场景: 任务间通信，数据缓冲，消息传递。

    • 关键参数

      :

      • uxQueueLength: 队列的长度，即队列可以存储的最大消息数量。
      • uxItemSize: 队列中每个消息的长度，以字节为单位。如果消息是结构体，则为结构体的大小。

  • xQueueSend() / xQueueSendToBack(): 发送消息到队列尾部 (前者是宏定义，后者是函数)。

    • 功能: 向队列的尾部发送一条消息。

    • 常用场景: 任务向队列发送数据。

    • 关键参数

      :

      • xQueue: 要发送消息的队列句柄。
      • pvItemToQueue: 指向要发送的消息数据的指针。
      • xTicksToWait: 阻塞等待时间，如果队列已满，任务将阻塞等待，直到队列有空间或超时。设置为 0 表示非阻塞发送，队列满则立即返回错误。portMAX_DELAY 表示永久阻塞等待。

  • xQueueSendToFront(): 发送消息到队列头部。

    • 功能: 向队列的头部发送一条消息。
    • 常用场景: 发送高优先级消息，需要优先处理的消息。
    • 参数: 与 xQueueSend() 类似。

  • xQueueReceive(): 接收队列消息。

    • 功能: 从队列中接收一条消息。

    • 常用场景: 任务从队列接收数据。

    • 关键参数

      :

      • xQueue: 要接收消息的队列句柄。
      • pvBuffer: 指向接收消息数据缓冲区的指针。
      • xTicksToWait: 阻塞等待时间，如果队列为空，任务将阻塞等待，直到队列有消息或超时。设置为 0 表示非阻塞接收，队列空则立即返回错误。portMAX_DELAY 表示永久阻塞等待。

  • uxQueueMessagesWaiting(): 获取队列中消息数量。

    • 功能: 获取当前队列中已有的消息数量。

    • 常用场景: 查询队列状态，判断队列是否为空或已满。

    • 关键参数

      :

      • xQueue: 要查询的队列句柄。

  • vQueueDelete(): 删除队列。

    • 功能: 删除指定的队列，释放队列占用的内存。

    • 常用场景: 队列不再需要时，释放资源。

    • 关键参数

      :

      • xQueueToDelete: 要删除的队列句柄。

3. 信号量管理 (Semaphore Management)

  • xSemaphoreCreateBinary(): 创建二值信号量。

    • 功能: 创建一个二值信号量，初始状态可以为可用或不可用。二值信号量只能取 0 和 1 两个值。
    • 常用场景: 互斥访问共享资源，任务同步 (例如事件触发)。
    • 返回: 信号量句柄，创建失败返回 NULL。

  • xSemaphoreCreateCounting(): 创建计数信号量。

    • 功能: 创建一个计数信号量，可以设定最大计数值和初始计数值。计数信号量可以允许多个任务访问资源 (但访问数量有限制)。

    • 常用场景: 资源计数，例如控制访问具有多个槽位的资源池 (例如缓冲区管理)。

    • 关键参数

      :

      • uxMaxCount: 信号量的最大计数值。
      • uxInitialCount: 信号量的初始计数值。

    • 返回: 信号量句柄，创建失败返回 NULL。

  • xSemaphoreCreateMutex(): **创建互斥信号量 (互斥锁)**。

    • 功能: 创建一个互斥信号量，用于保护共享资源，防止多个任务同时访问造成数据竞争。互斥信号量具有优先级继承机制，可以避免优先级反转问题。
    • 常用场景: 保护临界区，例如访问共享外设、全局变量等。
    • 返回: 互斥信号量句柄，创建失败返回 NULL。

  • xSemaphoreTake(): 获取信号量。

    • 功能: 尝试获取信号量，如果信号量不可用，则任务进入阻塞态等待信号量可用。

    • 常用场景: 任务访问共享资源前，先获取信号量。

    • 关键参数

      :

      • xSemaphore: 要获取的信号量句柄。
      • xTicksToWait: 阻塞等待时间，如果信号量不可用，任务将阻塞等待，直到信号量可用或超时。portMAX_DELAY 表示永久阻塞等待。

  • xSemaphoreGive(): 释放信号量。

    • 功能: 释放信号量，使信号量可用。

    • 常用场景: 任务访问完共享资源后，释放信号量，允许其他任务访问。

    • 关键参数

      :

      • xSemaphore: 要释放的信号量句柄。

  • vSemaphoreDelete(): 删除信号量。

    • 功能: 删除指定的信号量，释放信号量占用的内存。

    • 常用场景: 信号量不再需要时，释放资源。

    • 关键参数

      :

      • xSemaphoreToDelete: 要删除的信号量句柄。

4. 互斥量 (Mutex) 管理

  • 互斥信号量 xSemaphoreCreateMutex() 实际上就是互斥量，因此互斥量管理 API 与信号量管理 API 在互斥量部分是重合的。 常用的互斥量操作 API 实际上就是 xSemaphoreTake() 和 xSemaphoreGive()。

5. 事件组管理 (Event Group Management)

  • xEventGroupCreate(): 创建事件组。

    • 功能: 创建一个事件组，用于任务间的事件同步。一个事件组可以包含多个事件标志位。
    • 常用场景: 多事件同步，一个任务需要等待多个事件发生后才能执行。
    • 返回: 事件组句柄，创建失败返回 NULL。

  • xEventGroupSetBits(): 设置事件位。

    • 功能: 设置事件组中指定的事件位。

    • 常用场景: 事件发生时，设置对应的事件位。

    • 关键参数

      :

      • xEventGroup: 要设置事件位的事件组句柄。
      • uxBitsToSet: 要设置的事件位掩码。可以使用位操作来设置多个事件位。

  • xEventGroupWaitBits(): 等待事件位。

    • 功能: 等待事件组中指定的事件位被设置。

    • 常用场景: 任务等待指定的事件发生。

    • 关键参数

      :

      • xEventGroup: 要等待事件位的事件组句柄。
      • uxBitsToWaitFor: 要等待的事件位掩码。
      • xClearOnExit: 退出时是否清除等待的事件位。
      • xWaitForAllBits: 是否等待所有指定的事件位都被设置。
      • xTicksToWait: 阻塞等待时间。

    • 返回: 实际触发的事件位掩码。

  • xEventGroupClearBits(): 清除事件位。

    • 功能: 清除事件组中指定的事件位。

    • 常用场景: 事件处理完成后，清除事件位，准备下一次事件触发。

    • 关键参数

      :

      • xEventGroup: 要清除事件位的事件组句柄。
      • uxBitsToClear: 要清除的事件位掩码。

  • vEventGroupDelete(): 删除事件组。

    • 功能: 删除指定的事件组，释放事件组占用的内存。

    • 常用场景: 事件组不再需要时，释放资源。

    • 关键参数

      :

      • xEventGroupToDelete: 要删除的事件组句柄。

6. 软件定时器管理 (Software Timer Management)

  • xTimerCreate(): 创建软件定时器。

    • 功能: 创建一个软件定时器，可以设置定时器周期和回调函数。

    • 常用场景: 周期性任务触发，延时操作，事件触发等。

    • 关键参数

      :

      • pcTimerName: 定时器名称，字符串形式。
      • xTimerPeriodInTicks: 定时器周期，以 tick 为单位。
      • uxAutoReload: 自动重载标志，pdTRUE 为自动重载 (周期定时器)，pdFALSE 为单次触发定时器。
      • pvTimerID: 定时器 ID，用户自定义数据，可以传递给定时器回调函数。
      • pxCallbackFunction: 定时器回调函数指针，定时器超时后执行的函数。

    • 返回: 定时器句柄，创建失败返回 NULL。

  • xTimerStart(): 启动定时器。

    • 功能: 启动指定的定时器。

    • 常用场景: 在需要开始定时时启动定时器。

    • 关键参数

      :

      • xTimer: 要启动的定时器句柄。
      • xTicksToWait: 阻塞等待时间 (通常设置为 0 或 portMAX_DELAY，在定时器服务任务上下文中可以阻塞等待，在其他任务上下文中不应该阻塞等待)。

  • xTimerStop(): 停止定时器。

    • 功能: 停止指定的定时器。

    • 常用场景: 在不需要定时器触发时停止定时器。

    • 关键参数

      :

      • xTimer: 要停止的定时器句柄。
      • xTicksToWait: 阻塞等待时间 (同 xTimerStart() )。

  • xTimerChangePeriod(): 修改定时器周期。

    • 功能: 动态修改定时器的周期。

    • 常用场景: 在运行时根据需要调整定时器周期。

    • 关键参数

      :

      • xTimer: 要修改周期的定时器句柄。
      • xNewPeriodInTicks: 新的定时器周期，以 tick 为单位。
      • xTicksToWait: 阻塞等待时间 (同 xTimerStart() )。

  • xTimerIsTimerActive(): 判断定时器是否激活。

    • 功能: 判断指定的定时器是否处于激活状态。

    • 常用场景: 查询定时器状态。

    • 关键参数

      :

      • xTimer: 要查询的定时器句柄。

    • 返回: pdTRUE 表示激活，pdFALSE 表示未激活。

  • xTimerDelete(): 删除定时器。

    • 功能: 删除指定的定时器，释放定时器占用的内存。

    • 常用场景: 定时器不再需要时，释放资源。

    • 关键参数

      :

      • xTimerToDelete: 要删除的定时器句柄。
      • xTicksToWait: 阻塞等待时间 (同 xTimerStart() )。

7. 内存管理 (Memory Management)

  • pvPortMalloc(): 动态内存分配 (FreeRTOS 的内存分配函数)。

    • 功能: 从 FreeRTOS 的堆内存中分配指定大小的内存块。

    • 常用场景: 动态创建 FreeRTOS 对象 (例如队列、信号量、任务等) 或应用程序需要动态内存分配时。

    • 关键参数

      :

      • xWantedSize: 要分配的内存块大小，以字节为单位。

    • 返回: 指向分配的内存块的指针，分配失败返回 NULL。

  • vPortFree(): 动态内存释放 (FreeRTOS 的内存释放函数)。

    • 功能: 释放由 pvPortMalloc() 分配的内存块。

    • 常用场景: 释放不再使用的动态分配内存，避免内存泄漏。

    • 关键参数

      :

      • pvBlockToFree: 指向要释放的内存块的指针，必须是由 pvPortMalloc() 分配的内存块。

8. 中断管理 (Interrupt Management)

  • xSemaphoreGiveFromISR(): 在中断服务例程 (ISR) 中释放信号量。

    • 功能: 在 ISR 中释放信号量，用于通知任务发生了某个事件。

    • 常用场景: ISR 中检测到硬件事件，需要通知任务进行处理时。

    • 关键参数

      :

      • xSemaphore: 要释放的信号量句柄。
      • pxHigherPriorityTaskWoken: 输出参数，用于指示是否有更高优先级的任务因为释放信号量而进入就绪态，需要进行上下文切换。通常需要根据该参数判断是否需要手动触发上下文切换 (portYIELD_FROM_ISR() 或 taskYIELD_FROM_ISR() )。

  • xQueueSendFromISR() / xQueueSendToBackFromISR(): 在 ISR 中发送消息到队列尾部。

    • 功能: 在 ISR 中向队列发送消息，用于 ISR 与任务间的数据传递。

    • 常用场景: ISR 中接收到数据，需要传递给任务进行处理时。

    • 关键参数

      :

      • xQueue: 要发送消息的队列句柄。
      • pvItemToQueue: 指向要发送的消息数据的指针。
      • pxHigherPriorityTaskWoken: 输出参数，同 xSemaphoreGiveFromISR()。

  • xQueueSendToFrontFromISR(): 在 ISR 中发送消息到队列头部。

    • 功能: 在 ISR 中向队列头部发送消息。
    • 参数: 与 xQueueSendFromISR() 类似。

  • portYIELD_FROM_ISR() / taskYIELD_FROM_ISR(): 在 ISR 中触发上下文切换 (与具体的 FreeRTOS 移植有关)。

    • 功能: 在 ISR 中手动触发上下文切换，将 CPU 使用权交给更高优先级的就绪态任务。

    • 常用场景: 当 ISR 中释放信号量或发送消息到队列，导致更高优先级的任务进入就绪态时，需要触发上下文切换，立即执行高优先级任务，提高系统实时性。

    • 参数

      :

      • 无参数，根据 xSemaphoreGiveFromISR() 或 xQueueSendFromISR() 的 pxHigherPriorityTaskWoken 参数判断是否需要调用。

二、CMSIS-V2 RTOS API (在 STM32CubeMX 中常用)

CMSIS-V2 RTOS API 提供了一套标准化的 RTOS 接口，在 STM32CubeMX 中，如果您选择了 CMSIS_RTOS_V2，则可以使用 CMSIS-V2 标准接口来操作 FreeRTOS 内核对象。CMSIS-V2 RTOS API 实际上是对原生 FreeRTOS API 的一层封装，其底层实现仍然是调用原生 FreeRTOS API。

使用 CMSIS-V2 RTOS API 的好处是可以提高代码的可移植性，如果将来需要更换 RTOS，只需要修改 RTOS 适配层即可，应用程序代码可以基本保持不变。

以下是一些常用的 CMSIS-V2 RTOS API 接口，对应于原生 FreeRTOS API 的功能模块：

1. 任务管理 (Thread Management) (CMSIS-V2 中任务称为线程)

  • osThreadNew(): 创建线程 (对应 xTaskCreate() )。

    • 功能: 创建并启动一个新的线程。

    • 关键参数

      :

      • thread_def: 线程定义结构体指针，包含线程入口函数、名称、优先级、堆栈大小等信息。
      • thread_attr: 线程属性结构体指针，可以配置线程属性，例如堆栈、优先级等，可以设置为 NULL 使用默认属性。

    • 返回: 线程 ID (osThreadId_t)，创建失败返回 NULL。

  • osThreadTerminate(): 终止线程 (对应 vTaskDelete() )。

    • 功能: 终止指定的线程。

    • 关键参数

      :

      • thread_id: 要终止的线程 ID。

  • osDelay(): 线程延时 (对应 vTaskDelay() )。

    • 功能: 使当前线程进入延时状态。

    • 关键参数

      :

      • ticks: 延时的时间，以 tick 为单位。

  • osThreadSuspend(): 挂起线程 (对应 vTaskSuspend() )。

    • 功能: 挂起指定的线程。

    • 关键参数

      :

      • thread_id: 要挂起的线程 ID。

  • osThreadResume(): 恢复线程 (对应 vTaskResume() )。

    • 功能: 恢复被挂起的线程。

    • 关键参数

      :

      • thread_id: 要恢复的线程 ID。

  • osThreadGetStackSpace(): 获取线程堆栈剩余空间 (对应 uxTaskGetStackHighWaterMark() )。

    • 功能: 获取线程堆栈当前剩余空间的大小。

    • 关键参数

      :

      • thread_id: 要查询的线程 ID。

  • osThreadGetName(): 获取线程名称 (对应 pcTaskGetName() )。

    • 功能: 获取指定线程的线程名称字符串。

    • 关键参数

      :

      • thread_id: 要查询的线程 ID。

2. 队列管理 (Message Queue Management) (CMSIS-V2 中队列称为消息队列)

  • osMessageQueueNew(): 创建消息队列 (对应 xQueueCreate() )。

    • 功能: 创建一个新的消息队列。

    • 关键参数

      :

      • msg_count: 消息队列的长度，即队列可以存储的最大消息数量。
      • msg_size: 队列中每个消息的长度，以字节为单位。
      • queue_attr: 队列属性结构体指针，可以配置队列属性，可以设置为 NULL 使用默认属性。

    • 返回: 消息队列 ID (osMessageQueueId_t)，创建失败返回 NULL。

  • osMessageQueuePut(): 发送消息到消息队列尾部 (对应 xQueueSend() / xQueueSendToBack() )。

    • 功能: 向消息队列的尾部发送一条消息。

    • 关键参数

      :

      • mq_id: 要发送消息的消息队列 ID。
      • msg_ptr: 指向要发送的消息数据的指针。
      • timeout: 阻塞等待时间，以 tick 为单位。

  • osMessageQueueGet(): 接收消息队列消息 (对应 xQueueReceive() )。

    • 功能: 从消息队列中接收一条消息。

    • 关键参数

      :

      • mq_id: 要接收消息的消息队列 ID。
      • msg_ptr: 指向接收消息数据缓冲区的指针。
      • timeout: 阻塞等待时间，以 tick 为单位。

  • osMessageQueueGetCount(): 获取消息队列中消息数量 (对应 uxQueueMessagesWaiting() )。

    • 功能: 获取当前消息队列中已有的消息数量。

    • 关键参数

      :

      • mq_id: 要查询的消息队列 ID。

  • osMessageQueueDelete(): 删除消息队列 (对应 vQueueDelete() )。

    • 功能: 删除指定的消息队列。

    • 关键参数

      :

      • mq_id: 要删除的消息队列 ID。

3. 信号量管理 (Semaphore Management)

  • osSemaphoreNew(): 创建信号量 (对应 xSemaphoreCreateBinary() 和 xSemaphoreCreateCounting() )。

    • 功能

      : 创建一个信号量，可以创建二值信号量或计数信号量，根据 

      max_signals

      参数决定。

      • 如果 max_signals 为 1，则创建二值信号量。
      • 如果 max_signals 大于 1，则创建计数信号量。

    • 关键参数

      :

      • max_signals: 信号量的最大计数数量 (二值信号量为 1，计数信号量大于 1)。
      • initial_signals: 信号量的初始计数数量。
      • semaphore_attr: 信号量属性结构体指针，可以配置信号量属性，可以设置为 NULL 使用默认属性。

    • 返回: 信号量 ID (osSemaphoreId_t)，创建失败返回 NULL。

  • osSemaphoreAcquire(): 获取信号量 (对应 xSemaphoreTake() )。

    • 功能: 尝试获取信号量。

    • 关键参数

      :

      • semaphore_id: 要获取的信号量 ID。
      • timeout: 阻塞等待时间，以 tick 为单位。

  • osSemaphoreRelease(): 释放信号量 (对应 xSemaphoreGive() )。

    • 功能: 释放信号量。

    • 关键参数

      :

      • semaphore_id: 要释放的信号量 ID。

  • osSemaphoreDelete(): 删除信号量 (对应 vSemaphoreDelete() )。

    • 功能: 删除指定的信号量。

    • 关键参数

      :

      • semaphore_id: 要删除的信号量 ID。

4. 互斥锁 (Mutex) 管理

  • osMutexNew(): 创建互斥锁 (对应 xSemaphoreCreateMutex() )。

    • 功能: 创建一个互斥锁。

    • 关键参数

      :

      • mutex_attr: 互斥锁属性结构体指针，可以配置互斥锁属性，可以设置为 NULL 使用默认属性。

    • 返回: 互斥锁 ID (osMutexId_t)，创建失败返回 NULL。

  • osMutexAcquire(): 获取互斥锁 (对应 xSemaphoreTake() )。

    • 功能: 尝试获取互斥锁。

    • 关键参数

      :

      • mutex_id: 要获取的互斥锁 ID。
      • timeout: 阻塞等待时间，以 tick 为单位。

  • osMutexRelease(): 释放互斥锁 (对应 xSemaphoreGive() )。

    • 功能: 释放互斥锁。

    • 关键参数

      :

      • mutex_id: 要释放的互斥锁 ID。

  • osMutexDelete(): 删除互斥锁 (对应 vSemaphoreDelete() )。

    • 功能: 删除指定的互斥锁。

    • 关键参数

      :

      • mutex_id: 要删除的互斥锁 ID。

5. 事件标志 (Event Flags) 管理 (CMSIS-V2 中事件组称为事件标志)

  • osEventFlagsNew(): 创建事件标志 (对应 xEventGroupCreate() )。

    • 功能: 创建一个事件标志组。

    • 关键参数

      :

      • ef_attr: 事件标志属性结构体指针，可以配置事件标志属性，可以设置为 NULL 使用默认属性。

    • 返回: 事件标志 ID (osEventFlagsId_t)，创建失败返回 NULL。

  • osEventFlagsSet(): 设置事件标志位 (对应 xEventGroupSetBits() )。

    • 功能: 设置事件标志组中指定的事件位。

    • 关键参数

      :

      • ef_id: 要设置事件位的事件标志 ID。
      • flags: 要设置的事件位掩码。

  • osEventFlagsWait(): 等待事件标志位 (对应 xEventGroupWaitBits() )。

    • 功能: 等待事件标志组中指定的事件位被设置。

    • 关键参数

      :

      • ef_id: 要等待事件位的事件标志 ID。
      • flags: 要等待的事件位掩码。
      • options: 等待选项，例如 osFlagsWaitAny (等待任意一个事件位被设置) 或 osFlagsWaitAll (等待所有指定的事件位都被设置)。
      • timeout: 阻塞等待时间，以 tick 为单位。

    • 返回: 实际触发的事件位掩码。

  • osEventFlagsClear(): 清除事件标志位 (对应 xEventGroupClearBits() )。

    • 功能: 清除事件标志组中指定的事件位。

    • 关键参数

      :

      • ef_id: 要清除事件位的事件标志 ID。
      • flags: 要清除的事件位掩码。

  • osEventFlagsDelete(): 删除事件标志 (对应 vEventGroupDelete() )。

    • 功能: 删除指定的事件标志组。

    • 关键参数

      :

      • ef_id: 要删除的事件标志 ID。

6. 定时器 (Timer) 管理 (CMSIS-V2 中软件定时器称为定时器)

  • osTimerNew(): 创建定时器 (对应 xTimerCreate() )。

    • 功能: 创建一个定时器。

    • 关键参数

      :

      • callback: 定时器回调函数指针。
      • type: 定时器类型，osTimerOnce (单次触发) 或 osTimerPeriodic (周期触发)。
      • timer_attr: 定时器属性结构体指针，可以配置定时器属性，可以设置为 NULL 使用默认属性。

    • 返回: 定时器 ID (osTimerId_t)，创建失败返回 NULL。

  • osTimerStart(): 启动定时器 (对应 xTimerStart() )。

    • 功能: 启动指定的定时器。

    • 关键参数

      :

      • timer_id: 要启动的定时器 ID。
      • period: 定时器周期，以 tick 为单位。

  • osTimerStop(): 停止定时器 (对应 xTimerStop() )。

    • 功能: 停止指定的定时器。

    • 关键参数

      :

      • timer_id: 要停止的定时器 ID。

  • osTimerIsRunning(): 判断定时器是否运行 (对应 xTimerIsTimerActive() )。

    • 功能: 判断指定的定时器是否处于运行状态。

    • 关键参数

      :

      • timer_id: 要查询的定时器 ID。

    • 返回: true 表示运行，false 表示停止。

  • osTimerDelete(): 删除定时器 (对应 xTimerDelete() )。

    • 功能: 删除指定的定时器。

    • 关键参数

      :

      • timer_id: 要删除的定时器 ID。

7. 内存管理 (Memory Pool Management) (CMSIS-V2 中没有直接对应 pvPortMalloc() 和 vPortFree() 的标准 API，CMSIS-V2 提供了内存池管理，用于管理固定大小的内存块，如果需要动态内存分配，仍然需要使用原生 FreeRTOS 的 pvPortMalloc() 和 vPortFree() 或者 C 标准库的 malloc() 和 free() )

  • osMemoryPoolNew(): 创建内存池。

    • 功能: 创建一个内存池，用于管理固定大小的内存块。

    • 关键参数

      :

      • block_count: 内存池中内存块的数量。
      • block_size: 每个内存块的大小，以字节为单位。
      • mp_attr: 内存池属性结构体指针，可以配置内存池属性，可以设置为 NULL 使用默认属性。

    • 返回: 内存池 ID (osMemoryPoolId_t)，创建失败返回 NULL。

  • osMemoryPoolAlloc(): 从内存池分配内存块。

    • 功能: 从内存池中分配一个内存块。

    • 关键参数

      :

      • mp_id: 要分配内存的内存池 ID。
      • timeout: 阻塞等待时间，以 tick 为单位。

    • 返回: 指向分配的内存块的指针，分配失败返回 NULL。

  • osMemoryPoolFree(): 释放内存块到内存池。

    • 功能: 将从内存池分配的内存块释放回内存池。

    • 关键参数

      :

      • mp_id: 要释放内存的内存池 ID。
      • block: 指向要释放的内存块的指针。

  • osMemoryPoolDelete(): 删除内存池。

    • 功能: 删除指定的内存池。

    • 关键参数

      :

      • mp_id: 要删除的内存池 ID。
]]> https://lsworl.github.io/2025/02/12/freertos-zhong-chang-yong-api-zong-jie/ 2025-02-12T06:43:35.000Z 汇总 FreeRTOS 任务管理、队列、信号量、软件定时器等常用 API 的作用、参数和典型使用场景。 freertos中常用api总结 2026-05-23T07:33:06.000Z LsWorld

所使用的模块与工具：

  • STM32F103C8T6
  • DHT11温湿度传感器
  • ESP32WROOM(采用ESP-IDF)
  • EMQX Serverless（MQTT Broker）
  • TiDB Cloud（云数据库）
  • 腾讯位置服务API
  • 和风天气API

硬件层

STM32

Stm32Cubemx配置

使用引脚:

  • PA10->D17(USART1_RX连到ESP32的D17)
  • P9->D16(USART1_TX连到ESP32的D16)
  • PB10->LED（用于测试系统是否正常运作，设置为GPIO_Output，推挽输出）
  • PA0->DHT11 Do口（芯片左边标S的口，最右边有-的标志连GND，中间连VCC）

Pinout&Configuration

由于硬件层面比较简单，就不采用DMA来传输了

SystemCore配置

  • GPIO

    • PA0

      • GPIO output level: low（默认输出低电平）
      • GPIO mode : Output Push Pull（推挽输出）
      • GPIO Pull-up/Pull-down：No pull-up and pull-down（无上下拉）
      • Maximum output speed:Low（这里任意）

    • PA10

      • GPIO output level: low（默认输出低电平）
      • GPIO mode : Output Push Pull（推挽输出）
      • GPIO Pull-up/Pull-down：No pull-up and pull-down（无上下拉）
      • Maximum output speed:Low（这里任意）

      USART配置采用默认。

  • NVIC（USART1 global interrupt 使能，开启USART中断）

  • RCC

    • 高速，低速都配置外部晶振时钟

  • SYS

    • Debug：Serial Wire
    • Timebase Source：SysTick，时基源选系统滴答。
Connectivity配置

USART1

  • Mode：Asynchronous（异步）
  • Hardware Flow Control：Disable（不采用硬件流控制）
  • Parameter Settings：
    • Baud Rate：115200 Bits/s
    • Word Length: 8Bits
    • Parity: None
    • Stop Bits:1

Clock Configuration

采用系统时钟为72MHz。

Project Manager

输入项目名已经存放路径，还有IDE配置。

选择只复制必要的库以及分开生成对应的c和h文件。

然后点GENERATE CODE生成代码。

代码编写获取DHT11数据

由于DHT11A通信中需要用到微妙延迟，而HAL库没有自带的微妙延迟函数，需要自己编写，这里就借助DWT来实现微妙延迟。

void Enable_DWT(void) {//Enable_DWT在main.c初始化中调用    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; //enable DWT    DWT->CYCCNT = 0; // reset period counter    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk; // enable period counter}void delay_us(uint32_t us){  uint32_t ticks = us * (SystemCoreClock / 1000000); // compute ticks  uint32_t start = DWT->CYCCNT;                      // get current period counter value  while ((DWT->CYCCNT - start) < ticks)    ; // wait for specified period}

初始化

上方是DHT11传输时序图，由于采用单总线通信，需要先将PA0默认置高电平，PA0口为推挽输出，代码如下。

// DHT11 数据结构体typedef struct{    uint8_t humidity_int;      // 湿度整数部分    uint8_t humidity_dec;      // 湿度小数部分    uint8_t temperature_int;   // 温度整数部分    uint8_t temperature_dec;   // 温度小数部分    uint8_t check_sum;        // 校验和} DHT11_Data_TypeDef;/** * @brief  初始化DHT11 * @param  无 * @retval 无 */void DHT11_Init(void){    DHT11_GPIO_OUT();    HAL_GPIO_WritePin(DHT11_GPIO_Port, DHT11_Pin, GPIO_PIN_SET);    HAL_Delay(1000);  // 上电等待1s}/** * @brief  配置DHT11的GPIO为输出模式 * @param  无 * @retval 无 */void DHT11_GPIO_OUT(void){    GPIO_InitTypeDef GPIO_InitStruct = {0};        GPIO_InitStruct.Pin = DHT11_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;    HAL_GPIO_Init(DHT11_GPIO_Port, &GPIO_InitStruct);}/** * @brief  配置DHT11的GPIO为输入模式 * @param  无 * @retval 无 */void DHT11_GPIO_IN(void){    GPIO_InitTypeDef GPIO_InitStruct = {0};        GPIO_InitStruct.Pin = DHT11_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(DHT11_GPIO_Port, &GPIO_InitStruct);}

通信

开始通信先将PA0口置低电平，等待2s，后再拉高，保持30us，同时将PA0口置为浮空输入模式，等待DHT11发送响应输出信号到PA0口（即将PA0口电平拉低），等待时间为100us。采用轮询的方式不断判断PA0口的电平，若为低，则将其拉高准备通信，若超时则认为通信失败。接下来就可以接受40bit的数据，前2字节为湿度，3-4字节为温度，最后一字节为校验，具体代码如下。

/** * @brief  读取DHT11的数据 * @param  dht11_data: DHT11数据结构体指针 * @retval 0: 读取成功, 1: 读取失败 */uint8_t DHT11_Read_Data(DHT11_Data_TypeDef *dht11_data){    uint8_t i, j, temp;    uint8_t buf[5];    uint8_t retry = 0;        // 主机发送开始信号    DHT11_GPIO_OUT();    HAL_GPIO_WritePin(DHT11_GPIO_Port, DHT11_Pin, GPIO_PIN_RESET);    delay_us(20000);    HAL_GPIO_WritePin(DHT11_GPIO_Port, DHT11_Pin, GPIO_PIN_SET);    delay_us(30); //延迟30us        // 切换为输入模式,等待DHT11响应    DHT11_GPIO_IN();        // 等待DHT11拉低(响应信号) 等待100us    retry = 0;    while(HAL_GPIO_ReadPin(DHT11_GPIO_Port, DHT11_Pin) && retry < 100)    {        retry++;        delay_us(1);    }    if(retry >= 100) return 1;        // 等待DHT11拉高    retry = 0;    while(!HAL_GPIO_ReadPin(DHT11_GPIO_Port, DHT11_Pin) && retry < 100)    {        retry++;        delay_us(1);    }    if(retry >= 100) return 1;        // 等待DHT11拉低(准备发送数据)    retry = 0;    while(HAL_GPIO_ReadPin(DHT11_GPIO_Port, DHT11_Pin) && retry < 100)    {        retry++;        delay_us(1);    }    if(retry >= 100) return 1;        // 开始接收40bit数据    for(i = 0; i < 5; i++)    {        temp = 0;        for(j = 0; j < 8; j++)        {            // 等待50us低电平结束            retry = 0;            while(!HAL_GPIO_ReadPin(DHT11_GPIO_Port, DHT11_Pin) && retry < 100)            {                retry++;                delay_us(1);            }            if(retry >= 100) return 1;                        // 延时40us            delay_us(40);                        // 判断数据位是1还是0            temp <<= 1;            if(HAL_GPIO_ReadPin(DHT11_GPIO_Port, DHT11_Pin))            {                temp |= 1;                // 等待高电平结束                retry = 0;                while(HAL_GPIO_ReadPin(DHT11_GPIO_Port, DHT11_Pin) && retry < 100)                {                    retry++;                    delay_us(1);                }                if(retry >= 100) return 1;            }        }        buf[i] = temp;    }        // 验证校验和    if(buf[4] == (buf[0] + buf[1] + buf[2] + buf[3]))    {        dht11_data->humidity_int = buf[0];        dht11_data->humidity_dec = buf[1];        dht11_data->temperature_int = buf[2];        dht11_data->temperature_dec = buf[3];        dht11_data->check_sum = buf[4];        return 0;    }        return 1;}

下个模块实现将DHT11获取的温湿度信息通过USART传给ESP32。

温湿度传给ESP32

首先先重写printf函数，映射到usart1，在usart.c中添加该函数即可实现映射。

int fputc(int ch, FILE *f){  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 1000);  return ch;}

接下来在main.c中编写。

DHT11_Data_TypeDef dht11_data;if(DHT11_Read_Data(&dht11_data) == 0)    {        printf("Temperature: %d.%dC, Humidity: %d.%d%%",               dht11_data.temperature_int, dht11_data.temperature_dec,               dht11_data.humidity_int, dht11_data.humidity_dec);    }    else    {        printf("DHT11 Read Failed!\r\n");    }

这样要是获取到的湿度是60.1，温度是12.2的话，ESP32通过串口接受到的就是Temperature: 12.2C, Humidity: 60.1%

ESP32

ESP32采用在ubuntu 20.04系统上用esp-idf编程，在此前在ubuntu上安装对应依赖

使用命令sudo apt-get install git wget flex bison gperf python3-pip python3-venv cmake ninja-build ccache libffi-dev dfu-util libusb-1.0-0 net-tools

先拉取esp工具

git clone https://gitee.com/EspressifSystems/esp-gitee-tools.git

到esp-gitee-tools目录下执行jihu-mirror.sh set，将镜像改为极狐

然后通过git拉取esp-idf

git clone --recursive https://github.com/espressif/esp-idf.git

再在esp-gitee-tools目录执行install.sh，安装编译工具。

还需要设置esp-idf的环境变量，在esp-idf目录下执行source export.sh，就会自动设置环境变量。

若烧录idf.py flash权限不够时，直接将权限设置为最大,sudo chmod 777 /dev/ttyUSB0。

WIFI模块实现

#define WIFI_SSID "wifi账号"#define WIFI_PASS "wifi密码"static const char *TAG = "WIFI_LINK";static bool s_wifi_connected = false;static esp_netif_t *s_sta_netif = NULL;

使用函数wifi_init_sta()来初始化wifi，ESP_ERROR_CHECK()来核对错误代码。

ESP_ERROR_CHECK(wifi_init_sta(WIFI_SSID, WIFI_PASS));

wifi_init_sta()具体实现：

esp_err_t wifi_init_sta(const char *ssid, const char *password){    ESP_ERROR_CHECK(esp_netif_init());    ESP_ERROR_CHECK(esp_event_loop_create_default());    s_sta_netif = esp_netif_create_default_wifi_sta();    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();    ESP_ERROR_CHECK(esp_wifi_init(&cfg));    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL));    wifi_config_t wifi_config = {        .sta = {            .threshold.authmode = WIFI_AUTH_WPA2_PSK,            .pmf_cfg = {                .capable = true,                .required = false            },        },    };        strncpy((char *)wifi_config.sta.ssid, ssid, sizeof(wifi_config.sta.ssid) - 1);    strncpy((char *)wifi_config.sta.password, password, sizeof(wifi_config.sta.password) - 1);    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));    ESP_ERROR_CHECK(esp_wifi_start());    ESP_LOGI(TAG, "WiFi initialization completed");    return ESP_OK;}

1. 函数定义

esp_err_t wifi_init_sta(const char *ssid, const char *password)
  • 这是一个函数定义，函数名为 wifi_init_sta，返回类型为 esp_err_t（表示 ESP-IDF 中的错误码类型）。
  • 函数接受两个参数：
    • const char *ssid：要连接的 Wi-Fi 网络的 SSID（账号）。
    • const char *password：要连接的 Wi-Fi 网络的密码。

2. 初始化网络接口

ESP_ERROR_CHECK(esp_netif_init());
  • 调用 esp_netif_init() 初始化 ESP32 的网络接口（TCP/IP 协议栈）。
  • ESP_ERROR_CHECK 是一个宏，用于检查函数返回值是否为 ESP_OK，如果不是，则触发错误处理。

3. 创建默认事件循环

ESP_ERROR_CHECK(esp_event_loop_create_default());
  • 调用 esp_event_loop_create_default() 创建默认的事件循环。
  • 事件循环用于处理系统中发生的各种事件（如 Wi-Fi 连接成功、断开连接等）。

4. 创建默认的 STA 模式网络接口

s_sta_netif = esp_netif_create_default_wifi_sta();
  • 调用 esp_netif_create_default_wifi_sta() 创建默认的 Wi-Fi STA（Station Mode）网络接口。
  • s_sta_netif 是一个全局变量，用于保存创建的 STA 网络接口对象。

5. 初始化 Wi-Fi 配置

wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();ESP_ERROR_CHECK(esp_wifi_init(&cfg));
  • wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();：使用默认配置初始化 Wi-Fi 配置结构体。
  • esp_wifi_init(&cfg)：根据配置初始化 Wi-Fi 驱动。

6. 注册事件处理函数

ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL));
  • 注册事件处理函数 event_handler，用于处理 Wi-Fi 和 IP 事件。
    • 第一行：注册处理所有 Wi-Fi 事件（WIFI_EVENT）。
    • 第二行：注册处理获取 IP 地址事件（IP_EVENT_STA_GOT_IP）。

7. 配置 Wi-Fi 连接参数

wifi_config_t wifi_config = {    .sta = {        .threshold.authmode = WIFI_AUTH_WPA2_PSK,        .pmf_cfg = {            .capable = true,            .required = false        },    },};
  • 定义 wifi_config_t 结构体变量 wifi_config，用于配置 Wi-Fi 连接参数。
  • sta 是 STA 模式的配置部分：
    • threshold.authmode = WIFI_AUTH_WPA2_PSK：设置认证模式为 WPA2-PSK（常用的 Wi-Fi 加密方式）。
    • pmf_cfg：配置 Protected Management Frames（PMF，保护管理帧）功能。
      • capable = true：设备支持 PMF。
      • required = false：不强制要求 PMF。

8. 设置 SSID 和密码

strncpy((char *)wifi_config.sta.ssid, ssid, sizeof(wifi_config.sta.ssid) - 1);strncpy((char *)wifi_config.sta.password, password, sizeof(wifi_config.sta.password) - 1);
  • 将传入的 ssid 和 password 复制到 wifi_config 结构体中。
  • strncpy 用于安全地复制字符串，避免缓冲区溢出。
  • sizeof(wifi_config.sta.ssid) - 1 确保字符串以 \0 结尾。

9. 设置 Wi-Fi 模式为 STA

ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
  • 调用 esp_wifi_set_mode(WIFI_MODE_STA) 设置 Wi-Fi 模式为 STA 模式（客户端模式）。

10. 设置 Wi-Fi 配置

ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
  • 调用 esp_wifi_set_config() 设置 STA 模式的 Wi-Fi 配置。

11. 启动 Wi-Fi

ESP_ERROR_CHECK(esp_wifi_start());
  • 调用 esp_wifi_start() 启动 Wi-Fi 模块。

若成功启动WIFI后会调用event_handler()函数。

**event_handler()**函数说明

在上方WIFI模块共注册两个事件基，WIFI_EVENT和IP_EVENT事件，当对应事件发生时会调用该函数。

static void event_handler(void* arg, esp_event_base_t event_base,                         int32_t event_id, void* event_data){    if (event_base == WIFI_EVENT) {        switch (event_id) {            case WIFI_EVENT_STA_START:                esp_wifi_connect();                break;            case WIFI_EVENT_STA_DISCONNECTED:                s_wifi_connected = false;                ESP_LOGI(TAG, "Disconnected from WiFi, trying to reconnect...");                esp_wifi_connect();                break;            default:                break;        }    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;        ESP_LOGI(TAG, "Got IP: " IPSTR, IP2STR(&event->ip_info.ip));        s_wifi_connected = true;    }}

在该函数中判断若事件基是wifi事件则监听是连接还是断开，ip事件只有判断获取ip事件。

若成功获取到ip则认为成功连接上wifi。

MQTT模块实现

// MQTT连接配置#define MQTT_BROKER_URL "mqtts://mqtt地址:端口"#define MQTT_CLIENT_ID "esp32_client"#define MQTT_USERNAME "用户名"#define MQTT_PASSWORD "密码"#define MQTT_TOPIC "esp32/data"//发布的主题// EMQX的根证书static const char *MQTT_SERVER_ROOT_CERT = "填入证书";
esp_err_t mqtt_ali_init(void){    // MQTT客户端配置    esp_mqtt_client_config_t mqtt_cfg = {        .broker.address.uri = MQTT_BROKER_URL,        .credentials.client_id = MQTT_CLIENT_ID,        .credentials.username = MQTT_USERNAME,        .credentials.authentication.password = MQTT_PASSWORD,        .broker.verification.certificate = MQTT_SERVER_ROOT_CERT,    };    // 创建MQTT客户端    mqtt_client = esp_mqtt_client_init(&mqtt_cfg);    if (mqtt_client == NULL) {        ESP_LOGE(TAG, "Failed to initialize MQTT client");        return ESP_FAIL;    }    // 注册MQTT事件处理函数    ESP_ERROR_CHECK(esp_mqtt_client_register_event(mqtt_client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL));    // 启动MQTT客户端    ESP_ERROR_CHECK(esp_mqtt_client_start(mqtt_client));    ESP_LOGI(TAG, "MQTT client initialized");    return ESP_OK;}

初始化部分和wifi大部分相同，不再赘述。

创建完成后若有响应事件会调用回调函数mqtt_event_handler()

// MQTT事件处理函数void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data){    esp_mqtt_event_handle_t event = event_data;        switch ((esp_mqtt_event_id_t)event_id) {        case MQTT_EVENT_CONNECTED:            ESP_LOGI(TAG, "MQTT Connected to broker");            mqtt_connected = true;            break;                    case MQTT_EVENT_DISCONNECTED:            ESP_LOGI(TAG, "MQTT Disconnected from broker");            mqtt_connected = false;            break;                    case MQTT_EVENT_SUBSCRIBED:            ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);            break;                    case MQTT_EVENT_UNSUBSCRIBED:            ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);            break;                    case MQTT_EVENT_PUBLISHED:            ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);            break;                    case MQTT_EVENT_DATA:            ESP_LOGI(TAG, "MQTT_EVENT_DATA");            printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);            printf("DATA=%.*s\r\n", event->data_len, event->data);            break;                    case MQTT_EVENT_ERROR:            ESP_LOGI(TAG, "MQTT_EVENT_ERROR");            if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {                ESP_LOGI(TAG, "Last error code reported from esp-tls: 0x%x", event->error_handle->esp_tls_last_esp_err);                ESP_LOGI(TAG, "Last tls stack error number: 0x%x", event->error_handle->esp_tls_stack_err);                ESP_LOGI(TAG, "Last captured errno : %d (%s)",  event->error_handle->esp_transport_sock_errno,                        strerror(event->error_handle->esp_transport_sock_errno));            }            break;                    default:            ESP_LOGI(TAG, "Other event id:%d", event->event_id);            break;    }}

UART模块

需要将波特率和数据位调成和STM32一致。

void uart_init(void){    uart_config_t uart_config = {        .baud_rate = 115200,                   // 波特率        .data_bits = UART_DATA_8_BITS,         // 数据位8        .parity = UART_PARITY_DISABLE,         // 无校验        .stop_bits = UART_STOP_BITS_1,         // 停止位1        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, // 硬件流控制关闭        .source_clk = UART_SCLK_APB,           // 时钟源    };        ESP_ERROR_CHECK(uart_param_config(UART_NUM, &uart_config));    ESP_ERROR_CHECK(uart_set_pin(UART_NUM, UART_TX_PIN, UART_RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));    ESP_ERROR_CHECK(uart_driver_install(UART_NUM, BUF_SIZE * 2, 0, 0, NULL, 0));        ESP_LOGI(TAG, "UART initialized successfully");}

TCP模块

在使用WIfi模块和mqtt时需要启动tcp这一运输层协议。

void tcp_server_task(void *pvParameters){    char rx_buffer[BUFFER_SIZE];  // 定义一个缓冲区，用于存储从客户端接收的数据    int listen_sock, client_sock;  // 定义两个套接字：listen_sock用于监听连接，client_sock用于与客户端通信    struct sockaddr_in server_addr, client_addr;  // 定义两个结构体，分别用于存储服务器和客户端的地址信息    socklen_t addr_len = sizeof(client_addr);  // 定义客户端地址结构体的大小    // 创建TCP套接字    listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);  // 创建一个IPv4的TCP套接字    if (listen_sock < 0) {  // 如果套接字创建失败        ESP_LOGE(TAG, "Failed to create socket");  // 记录错误日志        vTaskDelete(NULL);  // 删除当前任务    }    // 配置服务器地址    server_addr.sin_family = AF_INET;  // 设置地址族为IPv4    server_addr.sin_port = htons(TCP_PORT);  // 设置服务器端口号，htons函数将端口号从主机字节序转换为网络字节序    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 设置服务器IP地址为任意地址，htonl函数将IP地址从主机字节序转换为网络字节序    // 绑定套接字    if (bind(listen_sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {  // 将套接字绑定到服务器地址        ESP_LOGE(TAG, "Failed to bind socket");  // 如果绑定失败，记录错误日志        close(listen_sock);  // 关闭套接字        vTaskDelete(NULL);  // 删除当前任务    }    // 监听连接    if (listen(listen_sock, MAX_CLIENTS) < 0) {  // 开始监听连接请求，MAX_CLIENTS为最大连接数        ESP_LOGE(TAG, "Failed to listen");  // 如果监听失败，记录错误日志        close(listen_sock);  // 关闭套接字        vTaskDelete(NULL);  // 删除当前任务    }    ESP_LOGI(TAG, "TCP server started on port %d", TCP_PORT);  // 记录日志，表示TCP服务器已启动    while (1) {  // 进入无限循环，持续处理客户端连接        // 接受客户端连接        client_sock = accept(listen_sock, (struct sockaddr *)&client_addr, &addr_len);  // 接受客户端连接请求        if (client_sock < 0) {  // 如果接受连接失败            ESP_LOGE(TAG, "Failed to accept connection");  // 记录错误日志            continue;  // 继续下一次循环        }        ESP_LOGI(TAG, "New client connected");  // 记录日志，表示有新客户端连接        // 处理客户端数据        while (1) {  // 进入无限循环，持续处理客户端发送的数据            int len = recv(client_sock, rx_buffer, sizeof(rx_buffer) - 1, 0);  // 从客户端接收数据            if (len < 0) {  // 如果接收数据失败                ESP_LOGE(TAG, "Error receiving data");  // 记录错误日志                break;  // 退出内层循环            } else if (len == 0) {  // 如果客户端断开连接                ESP_LOGI(TAG, "Client disconnected");  // 记录日志，表示客户端已断开连接                break;  // 退出内层循环            }            rx_buffer[len] = '\0';  // 在接收到的数据末尾添加字符串结束符            ESP_LOGI(TAG, "Received: %s", rx_buffer);  // 记录日志，显示接收到的数据            // 处理命令            if (strstr(rx_buffer, "LED_ON") != NULL) {  // 如果接收到的数据包含"LED_ON"命令                uart_send_data("1", 1);  // 通过UART发送"1"，控制LED灯打开                send(client_sock, "LED IS ON\n", 10, 0);  // 向客户端发送响应，表示LED灯已打开            } else if (strstr(rx_buffer, "LED_OFF") != NULL) {  // 如果接收到的数据包含"LED_OFF"命令                uart_send_data("0", 1);  // 通过UART发送"0"，控制LED灯关闭                send(client_sock, "LED IS OFF\n", 11, 0);  // 向客户端发送响应，表示LED灯已关闭            } else {  // 如果接收到的命令无效                send(client_sock, "Invalid command\n", 16, 0);  // 向客户端发送响应，表示命令无效            }        }        close(client_sock);  // 关闭客户端套接字    }    close(listen_sock);  // 关闭监听套接字    vTaskDelete(NULL);  // 删除当前任务}

软件层

  1. 数据收集
    • 温度和湿度数据
      • 可以使用API或网站（如OpenWeatherMap）获取当前天气状况的温度和湿度数据。
      • 可以使用历史数据（如气象站记录）来预测天气模式。
    • 地理信息数据
      • 使用GIS库（如Folium或Geopandas）获取地理坐标、城市信息和气象站数据。
      • 使用地图数据（如OpenStreetMap或国土测绘数据）获取城市和区域信息。
    • 其它相关数据
      • 可以使用API或网站获取城市人口、经济情况和其它环境因素（如空气质量、噪音指数等）。
      • 使用社交媒体或用户评论数据，了解用户对所在城市的感受和需求。
  2. 数据预处理
    • 数据清理和转换
      • 转换所有数据为标准格式和单位，以便进行比较和分析。
      • 删除异常值或错误数据。
    • 数据集成和标准化
      • 集成来自各个数据源的数据，确保所有数据与所在城市的坐标和信息相关联。
      • 进行标准化（如归一化或标准化），使不同特征的数据具有相同的范围和分布。
  3. 特征工程
    • 提取城市环境特征
      • 使用GIS功能提取城市环境特征，如面积、人口密度、交通网络、绿地面积等。
      • 使用机器学习算法提取城市环境模式，如天气模式、空气指数等。
    • 构建特征矩阵
      • 将提取的特征构建为矩阵格式，以便进行分析和比较。
  4. 环境模拟
    • 机器学习算法
      • 选择适合的机器学习算法，如决策树、随机森林、支持向量机等。
      • 使用这些算法训练一个模型，根据用户所在地的环境数据预测相应城市的环境数据。
    • 城市环境推断
      • 使用训练好的模型，对用户所在地的环境数据进行预测，推断出与所在地环境相近的城市。
  5. 结果评估和优化
    • 结果评估
      • 使用评估指标（如准确性、召回率、F1分数等）评估模型的性能。
      • 进行错误分析，找出错误数据或模式的原因。
    • 模型优化
      • 根据错误分析结果和评估指标对模型进行优化和改进。
      • 试验不同算法和参数，以找到最佳的模型性能。

以下是一些常用的算法和库：

  • 决策树和随机森林：scikit-learn（Python）
  • 支持向量机：libsvm（C++）和scikit-learn（Python）
  • K近邻算法：scikit-learn（Python）
  • GIS库：Folium（Python）、Geopandas（Python）和GeoServer（Java）
  • 地图数据：OpenStreetMap（Osmosis）和国土测绘数据
]]> https://lsworl.github.io/2025/02/04/stm32-gen-ju-dht11-wen-shi-du-fen-xi-cheng-shi-xiang-si-du-xiang-mu-zong-jie/ 2025-02-04T03:03:33.000Z 总结 STM32、DHT11、ESP32、MQTT、数据库和天气 API 组成的温湿度采集与城市相似度分析项目。 STM32根据DHT11温湿度分析城市相似度项目总结 2026-05-23T07:33:06.000Z LsWorld

使用的型号为stm32f103c8t6与w25q64。

STM32CubeMX配置与引脚衔接

根据stm32f103c8t6引脚手册，采用B12-B15四个引脚与W25Q64连接，实现SPI通信。

W25Q64SCK（CLK）PB13
MOSI（DI）PB15
MISO(DO)PB14
CS（这里不采用硬件CS，所以接任意GPIO口都可以）PB12

STM32CubeMX配置

这里对于时钟相关的配置就不做赘述了，由于是练习所以将系统时钟配置成了72MHz，主要是配置引脚。

在引脚配置将PB12配置为推挽输出，默认电平为高。

PB13，PB14，PB15均使用硬件的SPI。

可以在系统核心的GPIO中的SPI中看到这三个配置。

然后到SPI2中将参数配置，采用高位优先，波特率为18MB/s，若不是则需要调整Prescaler分频到18MB/s，传输以字节为单位。

这里先不开启中断，所以NVIC setting里面的中断没有选上，做好基础配置后就可以生成代码，点击GENERATE CODE。

在Src中就会出现spi.c文件

查看PB13和PB15应该是默认配置为复用推挽，PB14为浮空输入。

spi2的stm32cubemx生成的默认配置如下。

配置完成后代码实现与W25Q64通信

接下来就是实现与W25Q64的通信，先测试能不能获取到W25Q64的厂商ID和设备ID。

对SPI的收发函数进行了封装，通过HAL_SPI_TransmitReceive()函数，将byte发送给w25q64，并将收到的数据放入rByte。该函数第一个参数为句柄的指针，由于才用spi2，句柄为hspi2，第二个参数为要发送的字节，第三个为接受的字节，第四个为大小（以字节为单位），第五个为超时时长，以ms为单位。

uint8_t SPI_SwapByte(uint8_t byte){  uint8_t rByte = 0;  HAL_SPI_TransmitReceive(&hspi2, &byte, &rByte, 1, 1000);  return rByte;}
void W25Q64_ReadID(uint8_t *mid, uint16_t *did){  // 读取ID  // 开启片选信号  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);  // 发送读取ID命令  SPI_SwapByte(0x9f);  // 读取制造商id  *mid = SPI_SwapByte(0xff);  // 读取设备id  *did = 0;  *did |= SPI_SwapByte(0xff) << 8;   // 高8位  *did |= SPI_SwapByte(0xff) & 0xff; // 低8位  // 关闭片选信号  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);  // 发送调试信息到串口  char debugMsg[50];  int msgLength = snprintf(debugMsg, sizeof(debugMsg), "Manufacturer ID: 0x%02X, Device ID: 0x%04X\r\n", *mid, *did);  HAL_UART_Transmit(&huart1, (uint8_t *)debugMsg, msgLength, HAL_MAX_DELAY);}
]]> https://lsworl.github.io/2025/01/31/stm32-ying-jian-shi-xian-yu-w25qxx-tong-xin/ 2025-01-31T01:05:54.000Z 记录 STM32F103C8T6 通过 SPI 与 W25Q64 Flash 通信的硬件连接、CubeMX 配置和代码实现。 stm32硬件实现与w25qxx通信 2026-05-23T07:33:06.000Z LsWorld

代码项目地址为stm32综合学习项目。

项目概述（详细可在项目的Project_Structure中查看）

该项目基于STM32F103C8T6芯片，学习I2C,GPIO,ADC,EXTI,PWM等基础模块的使用，并通过模块化的方式使代码具有良好的可读性与健壮性。

准备的模块

  1. OLED显示屏（I2C）
  2. 蜂鸣器模块（GPIO）
  3. 光敏电阻传感器（ADC）
  4. 热敏电阻传感器（ADC）
  5. MPU6050陀螺仪（I2C）
  6. 旋转编码器（EXTI+TIM）
  7. 舵机（PWM）
  8. LED指示灯（GPIO）
  9. 按钮（GPIO+EXTI）
  10. STM23F103C8T6芯片

文件结构设计

硬件驱动层
Hardware/├── OLED.c├── OLED.h├── OLED_Font.h├── beeper.c├── beeper.h├── light_sensor.c├── light_sensor.h├── temp_sensor.c├── temp_sensor.h├── mpu6050.c├── mpu6050.h├── encoder.c├── encoder.h├── servo.c├── servo.h├── led.c├── led.h├── button.c└── button.h
中间件层
Middlewares/├── i2c.c├── i2c.h├── adc.c├── adc.h├── pwm.c├── pwm.h├── exti.c├── exti.h├── gpio.c└── gpio.h
应用层
Application/├── system.c├── system.h├── menu.c├── menu.h├── alarm.c├── alarm.h├── control.c├── control.h├── indicator.c└── indicator.h
主程序
User/├── main.c└── stm32f10x_it.c
各模块所接入的GPIO口（在Hardware/pin_config.h中）
// OLED 引脚#define OLED_SCL_PIN        GPIO_Pin_6  // PB6#define OLED_SDA_PIN        GPIO_Pin_7  // PB7#define OLED_PORT           GPIOB  // OLED引脚所在的端口//MPU6050引脚#define MPU6050_SDA_PIN     GPIO_Pin_10  // PB10#define MPU6050_SCL_PIN     GPIO_Pin_11  // PB11#define MPU6050_PORT        GPIOB  // MPU6050引脚所在的端口// 光敏传感器引脚#define LIGHT_SENSOR_PIN    GPIO_Pin_0  // PA0#define LIGHT_SENSOR_PORT   GPIOA  // 光敏传感器引脚所在的端口// 温度传感器引脚#define TEMP_SENSOR_PIN     GPIO_Pin_1  // PA1#define TEMP_SENSOR_PORT    GPIOA   // 温度传感器引脚所在的端口// 蜂鸣器引脚#define BEEPER_PIN          GPIO_Pin_2  // PA2#define BEEPER_PORT         GPIOA// 编码器引脚#define ENCODER_A_PIN       GPIO_Pin_3  // PA3#define ENCODER_B_PIN       GPIO_Pin_4  // PA4#define ENCODER_PORT        GPIOA  // 编码器引脚所在的端口// 舵机引脚#define SERVO_PWM_PIN       GPIO_Pin_8  // PA8#define SERVO_PORT          GPIOA  // 舵机引脚所在的端口// LED引脚#define LED1_PIN            GPIO_Pin_9  // PA9#define LED2_PIN            GPIO_Pin_10  // PA10#define LED3_PIN            GPIO_Pin_11  // PA11#define LED4_PIN            GPIO_Pin_12  // PA12#define LED_PORT            GPIOA  // LED引脚所在的端口// 按钮引脚#define BTN1_PIN            GPIO_Pin_5  // PA5#define BTN2_PIN            GPIO_Pin_7  // PA7#define BTN3_PIN            GPIO_Pin_1  // PB1#define BTN4_PIN            GPIO_Pin_12  // PB12

以下的模块设计均以上方定义的名字为主，若要换成自己的具体引脚只需修改pin_config.h即可。

硬件驱动层模块设计

LED模块

该模块主要就是使能GPIO口（将LED的引脚正极接电源，负极接芯片引脚），通过芯片输出低电平导通，使LED点亮。

LED_Init()
void LED_Init(void){    GPIO_InitTypeDef GPIO_InitStructure;        // 使能LED所在的GPIO端口时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        // 配置LED引脚为推挽输出    GPIO_InitStructure.GPIO_Pin = LED1_PIN | LED2_PIN | LED3_PIN | LED4_PIN;    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    GPIO_Init(LED_PORT, &GPIO_InitStructure);        // 初始状态，所有LED关闭 该LED_Alloff();是自己写的一个函数，就是将所有引脚输出初始置为高电平，即LED全灭    LED_AllOff();}
LED_On()
void LED_On(uint16_t LED_PIN){    GPIO_ResetBits(LED_PORT, LED_PIN);}
LED_Off()
void LED_Off(uint16_t LED_PIN){    GPIO_SetBits(LED_PORT, LED_PIN);}
LED_Toggle()
void LED_Toggle(uint16_t LED_PIN){    LED_PORT->ODR ^= LED_PIN;    GPIOA->ODR}

模块所使用到的主要标准库函数：

  • GPIO_InitTypeDef：配置 GPIO（通用输入输出）引脚的结构体。
  • GPIO_SetBits(GPIOA, GPIO_Pin_11)：设置对应GPIO口的引脚为高电平。
  • GPIO_ResetBits(GPIOA, GPIO_Pin_11);：设置对应GPIO口的引脚为低电平。
  • GPIOA->ODR ^= GPIO_Pin_11;：将GPIO口的引脚电平取反。（ODR（Output Data Register），用于控制GPIO端口的输出状态）

蜂鸣器模块

使用的是有源蜂鸣器，具体如下图。

有源蜂鸣器可以直接通过引脚输出低电平直接引发鸣叫。

Beeper_Init()
void Beeper_Init(void){    GPIO_InitTypeDef GPIO_InitStructure;        // 使能GPIOA时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        // 配置蜂鸣器引脚为推挽输出    GPIO_InitStructure.GPIO_Pin = BEEPER_PIN;    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    GPIO_Init(BEEPER_PORT, &GPIO_InitStructure);        // 初始状态为关闭 关闭的逻辑与LED的一致，高电平关闭。    Beeper_Off(); }
Beeper_Beep()（控制蜂鸣器鸣叫时长）
void Beeper_Beep(uint16_t ms){    Beeper_On();//关闭就是用GPIO_ResetBits(BEEPER_PORT, BEEPER_PIN);    delay_ms(ms);//标准库中延迟函数需要自己写，可以找网上现成的    Beeper_Off();//开启就是用GPIO_SetBits(BEEPER_PORT, BEEPER_PIN);}

按钮模块

按钮采用中断的方式触发，需要设置中断向量，判断长按还是短按需要通过SysTick来协同工作，这里我总共接入了4个按钮，对应的引脚接口为A5,A7,B0,B12，所以我在初始化中需要初始两个GPIO口。

button模块的常量定义
// 按键参数定义#define BUTTON_SCAN_INTERVAL    20      // 扫描间隔（ms）#define LONG_PRESS_TIME         2000    // 长按时间（ms）#define DEBOUNCE_TIME          20       // 消抖时间（ms）// 按键引脚定义static const uint16_t KEY_PINS[KEY_COUNT] = {    BTN1_PIN,   // KEY_MODE  (BTN1)    BTN2_PIN,   // KEY_CONFIRM (BTN2)    BTN3_PIN,   // KEY_ALARM (BTN3)    BTN4_PIN    // KEY_RESET (BTN4)};static GPIO_TypeDef* const KEY_PORTS[KEY_COUNT] = {    GPIOA,      // KEY_MODE  (PA5)    GPIOA,      // KEY_CONFIRM (PA7)    GPIOB,      // KEY_ALARM (PB1)    GPIOB       // KEY_RESET (PB12)};// 按键逻辑状态定义typedef enum {    BTN_IDLE = 0,       // 空闲状态    BTN_DEBOUNCE,       // 消抖状态    BTN_SHORT_PRESS,    // 短按状态    BTN_LONG_PRESS      // 长按状态} ButtonState;// 按键编号定义typedef enum {    KEY_MODE = 0,   // 模式切换按键 (BTN1)    KEY_CONFIRM,    // 确认按键 (BTN2)    KEY_ALARM,      // 报警确认按键 (BTN3)    KEY_RESET,      // 复位按键 (BTN4)    KEY_COUNT       // 按键总数} KeyID;
Button_Init()
void Button_Init(void){    GPIO_InitTypeDef GPIO_InitStructure;    EXTI_InitTypeDef EXTI_InitStructure;    NVIC_InitTypeDef NVIC_InitStructure;    uint8_t i;s        // 使能GPIO时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO, ENABLE);        // 配置按键引脚为输入上拉    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        //逐一配置按键引脚    for(i = 0; i < KEY_COUNT; i++)    {        GPIO_InitStructure.GPIO_Pin = KEY_PINS[i];        GPIO_Init(KEY_PORTS[i], &GPIO_InitStructure);        keyInfo[i].state = BTN_IDLE;        keyInfo[i].isPressed = 0;    }        // 配置EXTI中断    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource5);  // KEY_MODE    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource7);  // KEY_CONFIRM    GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource1);  // KEY_ALARM    GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource12); // KEY_RESET        EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;   //采用中断触发    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;//下降沿触发    EXTI_InitStructure.EXTI_LineCmd = ENABLE;        EXTI_InitStructure.EXTI_Line = EXTI_Line5;  // KEY_MODE    EXTI_Init(&EXTI_InitStructure);    EXTI_InitStructure.EXTI_Line = EXTI_Line7;  // KEY_CONFIRM    EXTI_Init(&EXTI_InitStructure);    EXTI_InitStructure.EXTI_Line = EXTI_Line1;  // KEY_ALARM    EXTI_Init(&EXTI_InitStructure);    EXTI_InitStructure.EXTI_Line = EXTI_Line12; // KEY_RESET    EXTI_Init(&EXTI_InitStructure);        // 配置NVIC    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;    // 配置中断通道    NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;   // KEY_MODE, KEY_CONFIRM    NVIC_Init(&NVIC_InitStructure);    NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;     // KEY_ALARM    NVIC_Init(&NVIC_InitStructure);    NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn; // KEY_RESET    NVIC_Init(&NVIC_InitStructure);}
Button_Scan()

Button_Scan()每隔20ms扫描按钮状态，通过状态机的方式来进行消抖。

void Button_Scan(void){    static uint32_t lastScanTime = 0;    uint32_t currentTime;    uint8_t i;    currentTime = GetTickCount();        // 按扫描间隔进行处理 小于扫描间隔则不处理    if(currentTime - lastScanTime < BUTTON_SCAN_INTERVAL)        return;    // 更新扫描时间    lastScanTime = currentTime;        for(i = 0; i < KEY_COUNT; i++)    {        // 读取按键状态        uint8_t pinState = GPIO_ReadInputDataBit(KEY_PORTS[i], KEY_PINS[i]);                if(pinState == 0) // 按键按下        {            if(!keyInfo[i].isPressed) //isPressed为0表示按键未按下            {                keyInfo[i].isPressed = 1;                keyInfo[i].pressTime = currentTime;                keyInfo[i].state = BTN_DEBOUNCE;            }            else if(keyInfo[i].state == BTN_DEBOUNCE) // 按键处于消抖状态            {                if(currentTime - keyInfo[i].pressTime >= LONG_PRESS_TIME) // 按键按下时间大于长按时间                {                    keyInfo[i].state = BTN_LONG_PRESS; // 按键状态设置为长按状态                }            }        }        else // 按键释放        {            if(keyInfo[i].isPressed)            {                if(currentTime - keyInfo[i].pressTime >= DEBOUNCE_TIME)                {                    if(keyInfo[i].state != BTN_LONG_PRESS)                    {                        keyInfo[i].state = BTN_SHORT_PRESS;                    }                }                keyInfo[i].isPressed = 0;            }        }    }}

光敏传感器模块

以下图是所使用的光敏电阻模块，芯片引脚接AO。

light_sensor常量定义
// 光照强度等级定义typedef enum {    LIGHT_LEVEL_DARK = 0,    // 黑暗    LIGHT_LEVEL_DIM,         // 昏暗    LIGHT_LEVEL_NORMAL,      // 正常    LIGHT_LEVEL_BRIGHT       // 明亮} LightLevel;// 光照等级阈值定义（ADC值）#define LIGHT_THRESHOLD_DARK 3000   // 黑暗阈值#define LIGHT_THRESHOLD_DIM 1500    // 昏暗阈值#define LIGHT_THRESHOLD_NORMAL 1000 // 正常阈值
LightSensor_Init()

该模块主要配置GPIO口和ADC初始化。

void LightSensor_Init(void){  GPIO_InitTypeDef GPIO_InitStructure;  ADC_InitTypeDef ADC_InitStructure;  // 使能ADC1和GPIOA的时钟  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE);  // 配置PA0为模拟输入  GPIO_InitStructure.GPIO_Pin = LIGHT_SENSOR_PIN;  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;  GPIO_Init(LIGHT_SENSOR_PORT, &GPIO_InitStructure);  // ADC1配置  ADC_DeInit(ADC1);  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;    // 独立模式  ADC_InitStructure.ADC_ScanConvMode = DISABLE;         // 单通道模式  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;  // 单次转换模式  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; // 外部触发模式  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; // 数据对齐  ADC_InitStructure.ADC_NbrOfChannel = 1;  ADC_Init(ADC1, &ADC_InitStructure);  // 配置ADC通道和采样时间  ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_239Cycles5); // 配置ADC通道和采样时间  // 使能ADC1  ADC_Cmd(ADC1, ENABLE);  // ADC校准  ADC_ResetCalibration(ADC1); // 复位校准  while (ADC_GetResetCalibrationStatus(ADC1))    ;  ADC_StartCalibration(ADC1); // 开始校准  while (ADC_GetCalibrationStatus(ADC1))    ;}
LightSensor_GetValue()

获取ADC值主要通过ADC_GetConversionValue(ADC1);

uint16_t LightSensor_GetValue(void){  // 启动ADC转换  ADC_SoftwareStartConvCmd(ADC1, ENABLE);  // 等待转换完成  while (!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC))    ;  // 返回转换结果  return ADC_GetConversionValue(ADC1);}

MPU6050模块

由MPU6050官方文档可以知道默认寄存器值为0x68

]]> https://lsworl.github.io/2025/01/18/stm32f103c8t6-zong-he-xue-xi-xiang-mu-de-ju-ti-gong-neng-shi-xian-xiang-jie/ 2025-01-18T02:12:33.000Z

代码项目地址为

STM32F103C8T6综合学习项目的具体功能实现详解 2026-05-22T11:24:08.000Z LsWorld

该项目基于型号STM32F103C8T6，项目的具体内容参考GitHub仓库，根据各个模块来学习对应的功能的实现。

开发GPIO驱动

在开发GPIO模块前，需要对GPIO_TypeDef中的参数有一定的认识。

typedef struct{  __IO uint32_t CRL;  __IO uint32_t CRH;  __IO uint32_t IDR;  __IO uint32_t ODR;  __IO uint32_t BSRR;  __IO uint32_t BRR;  __IO uint32_t LCKR;} GPIO_TypeDef;

1. CRL (Configuration Register Low)

  • 作用：配置 GPIO 端口的低 8 个引脚（Pin 0 ~ Pin 7）的模式和速度。

  • 位域：

    • 每 4 位控制一个引脚：
      • MODEy[1:0]：配置引脚的模式（输入、输出、复用功能、模拟模式）。
      • CNFy[1:0]：配置引脚的输出类型（推挽、开漏、复用功能、模拟模式）。

  • 示例：

    • 设置 Pin 0 为推挽输出模式：

      GPIOx->CRL &= ~(0xF << 0); // 清除 Pin 0 的配置GPIOx->CRL |= (0x3 << 0);  // 设置 Pin 0 为推挽输出模式

2. CRH (Configuration Register High)

  • 作用：配置 GPIO 端口的高 8 个引脚（Pin 8 ~ Pin 15）的模式和速度。

  • 位域：

    • 每 4 位控制一个引脚：
      • MODEy[1:0]：配置引脚的模式（输入、输出、复用功能、模拟模式）。
      • CNFy[1:0]：配置引脚的输出类型（推挽、开漏、复用功能、模拟模式）。

  • 示例：

    • 设置 Pin 8 为开漏输出模式：

      c

      Copy

      GPIOx->CRH &= ~(0xF << 0); // 清除 Pin 8 的配置GPIOx->CRH |= (0x6 << 0);  // 设置 Pin 8 为开漏输出模式

3. IDR (Input Data Register)

  • 作用：读取 GPIO 端口的输入数据。

  • 位域：

    • 低 16 位（Bit 0 ~ Bit 15）对应 GPIO 的 16 个引脚。
    • 每个位的值为 0 或 1，表示对应引脚的输入状态。

  • 示例：

    • 读取 Pin 5 的输入状态：

      c

      Copy

      uint8_t pinState = (GPIOx->IDR & GPIO_PIN_5) ? 1 : 0;

4. ODR (Output Data Register)

  • 作用：设置 GPIO 端口的输出数据。

  • 位域：

    • 低 16 位（Bit 0 ~ Bit 15）对应 GPIO 的 16 个引脚。
    • 每个位的值为 0 或 1，表示对应引脚的输出状态。

  • 示例：

    • 设置 Pin 6 输出高电平：

      c

      Copy

      GPIOx->ODR |= GPIO_PIN_6;

    • 设置 Pin 6 输出低电平：

      c

      Copy

      GPIOx->ODR &= ~GPIO_PIN_6;

5. BSRR (Bit Set/Reset Register)

  • 作用：原子地设置或复位 GPIO 引脚。

  • 位域：

    • 低 16 位（Bit 0 ~ Bit 15）：设置对应引脚为高电平。
    • 高 16 位（Bit 16 ~ Bit 31）：复位对应引脚为低电平。

  • 示例：

    • 设置 Pin 7 为高电平：

      c

      Copy

      GPIOx->BSRR = GPIO_PIN_7;

    • 设置 Pin 7 为低电平：

      c

      Copy

      GPIOx->BSRR = GPIO_PIN_7 << 16;

6. BRR (Bit Reset Register)

  • 作用：复位 GPIO 引脚（设置为低电平）。

  • 位域：

    • 低 16 位（Bit 0 ~ Bit 15）：复位对应引脚为低电平。

  • 示例：

    • 复位 Pin 9 为低电平：

      c

      Copy

      GPIOx->BRR = GPIO_PIN_9;

7. LCKR (Configuration Lock Register)

  • 作用：锁定 GPIO 端口的配置寄存器（CRL 和 CRH），防止意外修改。

  • 位域：

    • 低 16 位（Bit 0 ~ Bit 15）：锁定对应引脚的配置。
    • Bit 16：锁定键（Lock Key），用于确认锁定操作。

  • 示例：

    • 锁定 Pin 10 的配置：

      c

      Copy

      GPIOx->LCKR = GPIO_PIN_10 | (1 << 16); // 锁定 Pin 10GPIOx->LCKR = GPIO_PIN_10;             // 确认锁定GPIOx->LCKR = GPIO_PIN_10 | (1 << 16); // 再次锁定uint32_t lockStatus = GPIOx->LCKR;     // 读取锁定状态

引脚初始化

void GPIO_Init_Pin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIOMode_TypeDef GPIO_Mode, GPIOSpeed_TypeDef GPIO_Speed){    GPIO_InitTypeDef GPIO_InitStruct;        /* 使能GPIO时钟 */    if(GPIOx == GPIOA)        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);    else if(GPIOx == GPIOB)        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);    else if(GPIOx == GPIOC)        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);    else if(GPIOx == GPIOD)        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);    else if(GPIOx == GPIOE)        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);        /* 配置GPIO */    GPIO_InitStruct.GPIO_Pin = GPIO_Pin;    GPIO_InitStruct.GPIO_Mode = GPIO_Mode;    GPIO_InitStruct.GPIO_Speed = GPIO_Speed;    GPIO_Init(GPIOx, &GPIO_InitStruct);}

设置引脚状态

]]> https://lsworl.github.io/2025/01/15/ji-yu-stm32-zong-he-xue-xi-xiang-mu-jie-gou-she-ji/ 2025-01-15T13:16:54.000Z 基于STM32综合学习项目结构设计 2026-05-22T11:24:08.000Z LsWorld

采用stm32f103c8t6芯片的A0引脚连接热敏电阻模块。采用ADC1的通道0，使用标准库实现。

实现功能所使用的常量为：

//温度传感器参数#define VREF 3.3f  // ADC参考电压 3.3V#define R1 10000.0f  // 电压分压阻值为10KΩ，与热敏电阻串联，用于计算热敏电阻的阻值#define B 3950.0f  // 热敏电阻的 B 常数，单位为开尔文（K），用于计算热敏电阻的温度#define T0 298.15f  // 参考温度，单位为开尔文（K），298.15K即 25°C#define R0 10000.0f  // 热敏电阻在参考温度 T0 下的阻值，用于计算热敏电阻在当前温度下的阻值// DMA内存存入位置#define ADC_BUFFER_SIZE 10uint16_t ADC_ConvertedValue[ADC_BUFFER_SIZE];

GPIO引脚配置：

void GPIO_Config(void){    GPIO_InitTypeDef GPIO_InitStructure;    // 使能GPIOA时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);    //配置PA0为模拟输入用于温度传感器    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;    GPIO_Init(GPIOA, &GPIO_InitStructure);}

ADC配置：

void ADC_Config(void){    ADC_InitTypeDef ADC_InitStructure;    // 使能ADC1时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);        // 配置 ADC1 的基本参数    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //配置为独立模式因芯片只有ADC1    ADC_InitStructure.ADC_ScanConvMode = ENABLE;//启用连续扫描，这里因只开一个通道，是否启用连续扫描都不影响结果    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;//启用连续转换，每次读入模拟量就进行转换    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;//不适用外部触发    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;//数据选择右对齐，转换结果低12位有效    ADC_InitStructure.ADC_NbrOfChannel = 1;//转换通道数设置为1    ADC_Init(ADC1, &ADC_InitStructure);    // 配置 ADC1 的通道，设置通道在规则组中的转换顺序为第 1 个，设置采样时间为 239.5 个时钟周期    ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_239Cycles5);    // 启用 ADC1 的 DMA 功能，可以通过DMA实现高速转换    ADC_DMACmd(ADC1, ENABLE);    // 启用 ADC1    ADC_Cmd(ADC1, ENABLE);    // 校准 ADC1，消除 ADC 的偏移误差    ADC_ResetCalibration(ADC1);//复位 ADC1 的校准寄存器    while(ADC_GetResetCalibrationStatus(ADC1));//等待复位校准完成，完成置0    ADC_StartCalibration(ADC1);//启动 ADC1 的校准    while(ADC_GetCalibrationStatus(ADC1));//等待完成    // 启动 ADC1 转换，使用软件触发转换功能，将结果通过DMA传输刀内存中    ADC_SoftwareStartConvCmd(ADC1, ENABLE);}

DMA模块实现：

void DMA_Config(void){    DMA_InitTypeDef DMA_InitStructure;        // 使能 DMA1 时钟    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);        // 配置 DMA1 通道1    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;//配置DMA读取数据位置为ADC1的DR寄存器中（每次通过A0引脚读入的值都放在DR中所以DMA通过DR读数据）    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADC_ConvertedValue;//配置DMA内存地址为ADC_ConvertedValue，即上方常量的地址    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;//传输方向为外设到内存    DMA_InitStructure.DMA_BufferSize = ADC_BUFFER_SIZE;//缓冲区大小为每次DMA传输的数据量，即上方常量中的值    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//禁用外设地址自增，ADC 数据寄存器地址是固定的    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//启用内存地址自增，数组的每个元素地址是连续的    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; //设置外设数据大小为半字（16位）    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;//设置内存数据大小为半字（16位），与 ADC 数据寄存器一致    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;//设置 DMA 模式为循环模式，即 DMA 传输完成后会自动重新开始    DMA_InitStructure.DMA_Priority = DMA_Priority_High;//设置 DMA 通道的优先级为高（因为就一个通道，不设置也没关系）    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//禁用内存到内存的传输模式    DMA_Init(DMA1_Channel1, &DMA_InitStructure);        // 使能 DMA1 通道1    DMA_Cmd(DMA1_Channel1, ENABLE);}

将模拟量转换为温度：

float GetTemperature(void){    uint32_t sum = 0;    uint8_t i;    float voltage, rt, temperature;    uint16_t adc_value;     // 计算10个样本的平均值 ADC_BUFFER_SIZE为10    for(i = 0; i < ADC_BUFFER_SIZE; i++) {        sum += ADC_ConvertedValue[i];    }    adc_value = sum / ADC_BUFFER_SIZE;        // 将ADC值转换为电压 12位为4096    voltage = (float)adc_value * VREF / 4096.0f;    // 计算热敏电阻阻值    rt = R1 * voltage / (VREF - voltage);    // 使用Steinhart-Hart公式计算温度    temperature = 1.0f / (1.0f/T0 + log(rt/R0)/B) - 273.15f;    return temperature;}

温度T的计算公式：
$$
T=\frac{1}{\frac{1}{T_0}+\frac{\frac{ln(R_t)}{R_0}}{B}}
$$

公式中的参数
  • T：参考温度，通常为 25°C（即 298.15K）。
  • R0：热敏电阻在参考温度 T0T0 下的阻值，通常为 10kΩ。
  • Rt：热敏电阻在当前温度下的阻值，通过分压电路和 ADC 测量得到。
  • B：热敏电阻的 B 常数，通常由热敏电阻的规格书提供，例如 3950。

通过以上的函数调用即可实现热敏电阻读取温度，最后在main函数中使用OLED显示温度：

int main(void){    // 初始化    GPIO_Config();    DMA_Config();    ADC_Config();        // 初始化 OLED（OLED的代码需要自行去搜索获取）    OLED_Init();    OLED_Clear();        while(1)    {        uint32_t i;        // 获取温度        float temperature = GetTemperature();        char temp_str[16];        sprintf(temp_str, "Temp:%.1fC", temperature); //格式化字符串        OLED_ShowString(2, 1, temp_str);  //OLED显示温度    }}
]]> https://lsworl.github.io/2025/01/15/stm32-zhong-re-min-dian-zu-mo-kuai-zai-oled-shang-shi-shi-xian-shi-wen-du/ 2025-01-15T01:11:56.000Z stm32中热敏电阻模块在OLED上实时显示温度 2026-05-22T11:24:08.000Z LsWorld

SG90舵机模块介绍

标准库代码实现驱动舵机

由上图可知可以通过PWM来实现驱动舵机，这里采用STM32F103C8T6的TIM2的通道4来实现，即该芯片的A3口引脚，如下图所示

配置20ms的时基单元（以PLL时钟频率为72MHz为例），那么就是将TIM2的定时器的周期配置为20ms（50Hz），即设置ARR= 2000 - 1，PSC = 720 -1，则定时器的时钟周期就为20ms，并且我在初始位置设置为90°，即起始值设置为150，代码如下：

void TIM2_PWM_Config(void){    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;    TIM_OCInitTypeDef TIM_OCInitStructure;    // 配置定时器周期为20ms（50Hz）    TIM_TimeBaseStructure.TIM_Period = 2000 - 1; // 72MHz / 7200 = 10KHz    TIM_TimeBaseStructure.TIM_Prescaler = 720 - 1; // 10KHz / 720 = 50Hz    TIM_TimeBaseStructure.TIM_ClockDivision = 0; // 时钟不分频    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 向上计数    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); // 初始化TIM2    // 配置PWM模式    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; // PWM模式1    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // 输出使能    TIM_OCInitStructure.TIM_Pulse = 150; // 初始位置1.5ms    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; // 输出极性高    TIM_OC4Init(TIM2, &TIM_OCInitStructure); // 使用通道4    // 使能TIM2    TIM_Cmd(TIM2, ENABLE);    TIM_CtrlPWMOutputs(TIM2, ENABLE); // 主输出使能}

这里我采用A3口作为舵机的驱动引脚，那么GPIO的配置就应该是以下：

void GPIO_Config(void){    GPIO_InitTypeDef GPIO_InitStructure;    // Enable GPIOA clock    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        // Configure PA3 as TIM2_CH4 alternate function push-pull output    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    GPIO_Init(GPIOA, &GPIO_InitStructure);}

然后可以通过TIM_SetCompare4();该函数设置捕获/比较寄存器4(CCR4)的值，来动态调整占空比，从而控制每个周期的高电平时间，实现舵机的转向。

即

TIM_SetCompare4(TIM2, 150); //此时占空比为7.5%，高电平时间为1.5ms

计算公式：
$$
高电平时间= \frac{定时器时钟频率}{TIM_Pulse}= \frac{150}{0.1MHz} =1.5ms
$$

$$
占空比=(\frac{TIM_Pulse}{TIM_Period +1})×100%=\frac{150}{2000}×100%=7.5%
$$

]]> https://lsworl.github.io/2025/01/09/stm32f1-xi-lie-qu-dong-sg90-duo-ji-mo-kuai/ 2025-01-09T04:06:02.000Z

STM32F1系列驱动SG90舵机模块 2026-05-22T11:24:08.000Z LsWorld

本文参考Python菜鸟教程

Python基础语法

#单行注释以`#`，多行注释以`"""`开头和`"""`结尾。#注释1"""多行注释"""#缩进与if，无需分号if True:    print('true')    #多行语句，变量通过‘\’来实现多行语句a = 1b = 2c = 3total = a + \b + \c + \print(total)  #输出6#字符串str = '012345'print(str) #输出012345print(str[0:-1]) #输出01234 取0到4左闭右开 -1表示最右边print(str[0:-2]) #输出0123print(str[1]) #输出 1print(str[2:])#输出 2345print(str[0:4:2])   #输出 02 范围[0,4),即0 1 2 3 步长为2print(str * 2)#输出012345012345print(str + '你好')  #输出012345你好 字符串拼接data =  input("输入数据") #读取数据print(data) #输出#同一行显示多条语句a = 1; b,c=2,'hello'print(a,b,c)#输出1 2 hello

Python基本数据类型：

a, b, c, d, e, f = 1,5.1,True,1+2j, "Hello", [1,2,3]print(isinstance(a, int), isinstance(b, float), isinstance(c, bool), isinstance(d, complex), isinstance(e, str), isinstance(f, list))  #全部输出Trueprint(type(a), type(b), type(c), type(d), type(e), type(f))#输出<class 'int'> <class 'float'> <class 'bool'> <class 'complex'> <class 'str'> <class 'list'>print(int(b)) #输出5 强制转换float为int类型

isinstance 和 type 的区别：

type()可以检测出是否是子类，isinstance()无法检测出是否是子类。

class Animal:    def __init__(self, name):        self.name = name    def speak(self):        print(f"{self.name} says something")    a=Animal("Dog")print(type(a)==Animal)#Trueprint(type(a)==object)#Falseprint(isinstance(a,Animal))#Trueprint(isinstance(a,object)) #True
bool布尔值

对于右方的值bool值判断均为False：None,False,0,'',(),[],{}。

其他的均为True。

a,b,c,d,e,f,g = None,False,0,'',(),[],{}print(bool(a),bool(b),bool(c),bool(d),bool(e),bool(f),bool(g)) #输出False False False False False False False# 布尔类型的整数print(int(True))   # 1print(int(False))  # 0
LIst列表
list = [1,2.1,'abc',True]list2 = [2,4]print(list)#输出[1, 2.1, 'abc', True]print(list[2])#输出abcprint(list[1:3])#输出[2.1, 'abc']print(list + list2)#输出[1, 2.1, 'abc', True, 2, 4]list[1:3] = [3, 'def']print(list)#输出[1, 3, 'def', True]
Tuple元组
tuple1 = (1,2.1,'abc',True)tuple2 = (2,)#一个元素后面要添加逗号print(tuple1)#输出(1, 2.1, 'abc', True)print(tuple1[2])#输出abcprint(tuple1[1:3])#输出(2.1, 'abc')print(tuple1 + tuple2)#输出(1, 2.1, 'abc', True, 2,)

注：元组中元素不可变，列表中元素可变

Set集合
set1 = {'a', 'b', 'c', 'd', 'e','a'}print(set1)   # 输出 {'a', 'b', 'c', 'd', 'e'} 自动去重if 'a' in set1:    print('a 在集合中')   # 走这条 输出 a 在集合中else:    print('a 不在集合中')set2 = set('abcde')print(set1 == set2)  # 输出 Trueset2 = set('abcdh')print(set1 - set2)  # 求set1和set2的差集 输出 {'e'}print(set1 | set2)  # 求set1和set2的并集 输出 {'a', 'b', 'c', 'd', 'e', 'h'}print(set1 & set2)  # 求set1和set2的交集 输出 {'a', 'b', 'c', 'd'}print(set1 ^ set2)  # 求set1和set2中不重复的元素 输出 {'e', 'h'}
Dictionary 字典
dict = {}dict['key1'] = 'value1'dict['key2'] = 'value2'dict['key3'] = 'value3'dict2 = {    'd_key1': 'd_value1',    0: 'd_value2',    }print(dict['key1']) # 输出 value1print(dict2[0]) # 输出 d_value2print(dict.keys()) # 输出 dict_keys(['key1', 'key2', 'key3']) 输出所有key值print(dict.values()) # 输出 dict_values(['value1', 'value2', 'value3']) 输出所有value值

Python运算符

算数运算符描述例子
+相加5+6输出11，’a’+’b’输出‘ab’
-相减只允许数之间集合中表示差集5-6输出-1
*相乘5*6输出30 ‘a’*2输出’aa’
/相除1/2输出0.5
//整除，向下取整，去掉小数部分1//2输出0
%取模1%2输出1
**取幂5**2输出25
赋值运算符描述例子
=直接赋值c=1
+=加法赋值c+=1等效 c = c+1
-=减法赋值c-=1等效 c = c-1
*=乘法赋值c*=1等效 c = c*1
/=除法赋值c/=1等效 c = c/1
//=整除赋值c//=1等效 c = c//1
%=取模赋值c%=1等效 c = c%1
**=取幂赋值c**=1等效 c = c**1
:=海象运算符，用于表达式中同时赋值和返回赋值的值（Pthon3.8新增）下方为例子
n = 10;if n > 5:    print(n)#使用海象运算符if (n := 10) >5:#可以直接在表达式中赋值，省去外部赋值    print(n)
位运算符例子
&与，print(0x5 & 0xf) 输出5 ，即0000 0101 & 0000 1111
|或，print(0x5 | 0xf) 输出15 ，即0000 0101 | 0000 1111
^异或，print(0x5 | 0xf) 输出10 ，即0000 0101 ^ 0000 1111，结果0000 1010
~取反（补码的形式），print(0x5)输出-6，即~0000 0101，输出1111 1010，原码为1000 0110
<<左移，print(0x5<<1)输出10，即0000 0101 << 1，结果0000 1010
>>右移，print(0xff>>1)输出127，即1111 1111>>1，结果0111 1111
逻辑运算符
andx and y，如果x为False，返回x，True则返回y，如 print(10 and 20)输出 20
orx or y，如果x为False，返回y，True则返回x，如 print(10 and 20)输出 10
notnot x,如果x为True，返回False，为False返回Ture。如print(not 20)输出 False
成员运算符
in判断x是否在y的序列中，若在返回True
not in判断x是否在y的序列中，若不在返回True
list = [0 ,1, 2,3,4]print(0 in list)#输出Trueprint(5 not in list)#输出True
身份运算符
isx is y判断是否x和y的id相同，相同返回Ture（id通过id()函数查看）
is notx is y判断是否x和y的id相同，相同返回False

Python常用函数

数学函数

from math import *import random#数学函数abs(-10) #取绝对值 输出10ceil(4.1) #向上取整 输出5exp(1) #e的1次方 输出2.718281828459045fabs(-10.2) #浮点数取绝对值 输出10.2floor(4.9) #向下取整 输出4log(100,10) #以10为底100的对数 输出2.0log2(4) #以2为底4的对数 输出2.0max(1,2,3,4,5) #取最大值 输出5min(1,2,3,4,5) #取最小值 输出1modf(4.5) #返回整数部分和小数部分 输出(0.5, 4.0)pow(2,3) #2的3次方 输出8.0round(4.6) #四舍五入 输出5sqrt(4) #开平方 输出2.0#随机数函数random.choice([1,2,3,4,5]) #从序列中随机选取一个元素 输出3random.randrange(1,10,2) #从指定范围内，按指定基数递增的集合中获取一个随机数 输出1random.random() #随机生成下一个实数，它在[0,1)范围内 输出0.940667311678628random.seed(10) #改变随机数生成器的种子seed 输出Noneprint(random.random()) #0.5714025946899135  与采用新种子生成上面的random.random()不同random.shuffle([1,2,3,4,5]) #将一个列表中的元素打乱 输出[2, 5, 3, 1, 4]random.uniform(1,10) #随机生成下一个实数，它在[x,y]范围内 输出7.750021655
]]> https://lsworl.github.io/2025/01/07/python3-yu-fa/ 2025-01-07T02:31:15.000Z 整理 Python3 基础语法、字符串、列表、字典、函数和常用内置方法，适合作为入门速查笔记。 Python3中常用函数 2026-05-23T07:33:06.000Z LsWorld

在本地可以用hexo来搭建自己的博客后（若还没有搭建可以看我的博客搭建这篇文章），再在Vercel实现线上访问（若想以其他静态页面而非Hexo来Vercel结合github实现线上访问可以看我的使用Vercel来部署静态页面并解决跨域问题这篇文章）。

经过以上两个步骤可以实现使用科技手段来访问搭建的网页或博客，但此时若不想使用科技手段对Vercel提供的域名在国内访问搭建的博客大概率是会访问失败。（这里的原理结合我所学的知识应该是因为Vercel所生成的默认的域名在国内dns服务器解析失败导致无法找到ip，从而使我们所搭建的网站在国内无法访问）

这个问题可以通过购买国内域名就可以实现，购买一些便宜的域名即可（域名购买的步骤不再演示了，便宜的域名6块1年也不是很贵，这里以阿里云的域名为例）。

域名购买完成后可在搜索栏中搜索域名，进入域名控制台页面。

然后点击全部域名查看自己购买到的域名。

下方应该就会有你所购买到的域名信息（若状态不是处于正常状态需要等待一段时间检查）。

然后打开Vercel，点击右上角的ADD NEW下面的Project。

在下方选择你的博客或其他静态页面仓库（我的博客是lsWorl.github.io，所以我选择这个进行import）

该页面下无需额外配置直接点部署。（当然也可以修改Framework Preset中改成hexo，或者你的build或output命令自己做了自定义则需修改build and output Setting，更详细的可以留言进行进一步交流，这里我直接点部署）

部署完成应该可以通过外网访问自己的博客了。

接下来就是添加域名，通过点击下方Add Domain。

点击Edit。

在输入框中输入你购买到的域名后点击Add。

直接点击Add即可，无需修改。

然后回到阿里云域名平台这点击解析设置。

点击添加记录。（我这里因为先前已经添加过两条记录所以下方有两条已经启用的主机记录）

进入到添加记录，如我下面两个这样进行填写。（这里的记录值得和Vercel要求填写的对应，每个人的应该是不相同的）

添加后两条记录应该处于启用状态，然后回到Vercel，下方所有都处于Valid Configuration就说明配置成功。

以上步骤都实现后就可以直接访问自己的博客，无需再使用科技手段！

]]> https://lsworl.github.io/2025/01/07/hexo-bo-ke-bang-ding-yu-ming-shi-xian-guo-nei-fang-wen/ 2025-01-07T00:30:18.000Z 记录 Hexo 博客绑定自定义域名的流程，并说明如何改善 GitHub Pages 或 Vercel 站点的国内访问体验。 hexo博客绑定域名实现国内访问 2026-05-23T07:38:38.000Z LsWorld

USART串口通信

stm32中使用USART串口通信主要通过RX和TX两个接口完成基础操作，发送的数据通过总线到发送数据寄存器TDR，然后TDR中数据会发送到发送移位寄存器，发送移位寄存器会将比特右移的传到USARTX_TX引脚，产生串口协议规定的波形，当数据从发送移位寄存器发送完成时，TXE标志位会置1，只需判断TXE就可以知道是否可以传下一个数据。

同样在接受控制器中通过USARTX_TX引脚接受数据，接受完成会将RXNE标志位置1。

在实际使用中只有DR寄存器可供读写，写入DR时，数据走TX发送，读出DR时，数据走TX接受。

发送数据的函数形式为

void Serial_SendChar(uint8_t ch){      // 发送字符  USART_SendData(USART1, ch);  // 等待发送缓冲区为空  发送完成会将USART_FLAG_TXE置1  while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);}

接受数据的形式为

if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)  {    // 读取接收到的数据    uint8_t RxData = USART_ReceiveData(USART1);        //do something...        //清除接收中断标志位    USART_ClearITPendingBit(USART1, USART_IT_RXNE);  }
波特率计算公式

$$
波特率=f_{PCLK2或1}/(16*DIV)
$$

发送器和接收器的波特率由波特率寄存器BRR里的DIV确定。

例：

若频率$f_{PCLK1}=72MHz$，波特率为9600，代入上式，解得$DIV=72MHz/9600/16=468.75$转为十六进制为0x01D4.CH

USARTX串口初始化(例子中采用USART1端口)
void Serial_Init(void){  GPIO_InitTypeDef GPIO_InitStructure; // 定义 GPIO 初始化结构体  USART_InitTypeDef USART_InitStructure; // 定义 USART 初始化结构体  // 使能 GPIOA 和 USART1 的时钟（改成对应端口）  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);  // 配置 GPIOA 的引脚 9 为复用推挽输出（改成对应端口）  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  GPIO_Init(GPIOA, &GPIO_InitStructure);  // 配置 GPIOA 的引脚 10 为浮空输入（改成对应端口）  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  GPIO_Init(GPIOA, &GPIO_InitStructure);  // 配置 USART 初始化结构体  USART_InitStructure.USART_BaudRate = 9600; // 波特率为 9600  USART_InitStructure.USART_WordLength = USART_WordLength_8b; // 数据位为 8 位  USART_InitStructure.USART_StopBits = USART_StopBits_1; // 停止位为 1 位  USART_InitStructure.USART_Parity = USART_Parity_No; // 无奇偶校验  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 无硬件流控  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // 支持接收和发送  // 初始化 USART1  USART_Init(USART1, &USART_InitStructure);  // 使能 USART1  USART_Cmd(USART1, ENABLE);}

I2C通信

I2C有两根通信线：SCL（Serial Clock），SDA（Serial Data），支持同步，半双工通信，支持总线挂载多设备（一主多从，多主多从）

设备的SCL和SDA均要配置程开漏输出模式，且SCL和SDA需各添加一个上拉电阻，阻值一般为4.7kΩ左右。

I2C时序基本单元

I2C总线进行通信的起始条件是SCL高电平期间，SDA从高电平转换到低电平，如下图所示。

终止条件是SDA从低电平转换到高电平，SCL处于高电平。

I2C发送数据：在SCL低电平期间，发送端将数据位依次按高位到低位放到SDA线上，然后由接收端在SCL高电平期间读取数据位。（若主机为接受端，需要在主机接受数据之前释放SDA，即相对于切换为输入模式）

在应答时候SCL处于高电平时，SDA应处于低电平表示收到应答信号。第一个发送字节通常都是主机寻找从机地址。

软件实现

  • 初始化（以stm32f103c8t6芯片的引脚为例，可知PB10是I2C_SCL的引脚，PB11是I2C_SDA的引脚）

void MyI2C_Init(void){    // 使能 I2C1 时钟    RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);    // 使能 GPIOB 时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);    // 配置 GPIOB 的引脚 10 和 11 为开漏输出    GPIO_InitTypeDef GPIO_InitStructure;    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    GPIO_Init(SCL_PORT, &GPIO_InitStructure);    GPIO_SetBits(GPIOB, GPIO_Pin_10 | GPIO_Pin_11); // 设置 PB10 和 PB11 为高电平    }
]]> https://lsworl.github.io/2025/01/03/chuan-kou-xie-yi/ 2025-01-03T13:42:33.000Z

串口协议 2026-05-22T11:24:08.000Z LsWorld

ADC可以将模拟电压转换为数字变量，

输入电压范围03.3V，转换结果的范围：04095，即0V对应0，3.3V对应4095，中间均为一一对应的线性关系。

STM32F10系列中ADC有多达18个通道，可测量16个外部和2个内部信号源。各通道的A/D转换可以单次、连续、扫描或间断模式执行。ADC的结果可以左对齐或右对齐方式存储在16位数据寄存器中。

STM32 ADC的总转换时间

$$
T_{CONV} = 采样时间+12.5个ADC周期
$$

例：

当ADCCLK =14MHz，采样时间为1.5个ADC周期， 则
$$
T_{CONV} = 1.5 +12.5 =14个ADC周期=1us
$$

]]> https://lsworl.github.io/2025/01/02/adc-mo-shu-zhuan-huan-qi/ 2025-01-02T08:32:08.000Z ADC模数转换器 2026-05-22T11:24:08.000Z LsWorld

中断优先级

配置NVIC来进行中断优先级配置（值越小，优先级越高）。

NVIC优先级分组

NVIC的优先级组通过NVIC_PriorityGroupConfig(NVIC_PriorityGroup_X)来配置X表示哪个分组。

NVIC组抢占优先级响应优先级
NVIC_PriorityGroup_00bits4bits，可分为0-15
NVIC_PriorityGroup_11bits3bits
NVIC_PriorityGroup_22bits2bits
NVIC_PriorityGroup_33bits1bits
NVIC_PriorityGroup_44bits0bits
计数器计数频率

$$
CK_CNT = CK_PSC/(PSC+1)
$$

CK_CNT：定时器时钟，CK_PSC：定时器时钟源，PSC：预频分值。

计数器溢出频率

$$
CK_CNT_OV = CK_CNT/(ARR +1)=CK_PSC/(PSC+1)/(ARR+1)
$$

ARR：自动重装值。

PWM

PWM频率

$$
Freq =CK_CNT /(PSC+1)/(ARR+1)
$$

PWM占空比

$$
Duty=CCR/(ARR+1)
$$

PWM分辨率

$$
Reso = 1/(ARR+1)
$$

标准库PWM设置

以TIM2的通道4为例。

void TIM2_PWM_Config(void){    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;    TIM_OCInitTypeDef TIM_OCInitStructure;    // 配置定时器周期为20ms（50Hz）    TIM_TimeBaseStructure.TIM_Period = 2000 - 1; // 72MHz / 7200 = 10KHz (ARR)    TIM_TimeBaseStructure.TIM_Prescaler = 720 - 1; // 10KHz / 720 = 50Hz (PSC)    TIM_TimeBaseStructure.TIM_ClockDivision = 0; // 时钟不分频    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 向上计数    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); // 初始化TIM2    // 配置PWM模式    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; // PWM模式1    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // 输出使能    TIM_OCInitStructure.TIM_Pulse = 150; // 初始位置1.5ms (初始值)    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; // 输出极性高    TIM_OC4Init(TIM2, &TIM_OCInitStructure); // 使用通道4    // 使能TIM2    TIM_Cmd(TIM2, ENABLE);    TIM_CtrlPWMOutputs(TIM2, ENABLE); // 主输出使能}

PWM模式1和PWM模式2的区别

特性PWM模式1 (TIM_OCMode_PWM1)PWM模式2 (TIM_OCMode_PWM2)
有效电平计数器值 < TIM_Pulse 时有效计数器值 ≥ TIM_Pulse 时有效
无效电平计数器值 ≥ TIM_Pulse 时无效计数器值 < TIM_Pulse 时无效
极性反转通过 TIM_OCPolarity 配置通过 TIM_OCPolarity 配置
适用场景常规PWM控制需要反向逻辑的PWM控制
]]> https://lsworl.github.io/2025/01/01/stm32tim-ding-shi-zhong-duan/ 2025-01-01T07:03:18.000Z

stm32TIM定时中断 2026-05-22T11:24:08.000Z LsWorld

标准库初始化

[!IMPORTANT]

采用Keil IDE基于C语言进行编写stm32运行代码（以stm32f10x系列为例），使用标准库首先需要引入相应的库文件，该文件需要自己去网上下载

新建工程

编写逻辑代码前需要对keil将文件夹中的内容读入到IDE中 ，点击keil上方tab栏中的Project里面的New μVisioon Project...，找到存放共工程的文件夹，并在该文件夹中在下方的文件名中输入该工程的名称，后点击保存。

选择芯片

在芯片选择中选择STM32F1x对应的芯片，后点击OK，后续的窗口直接关闭即可。

后面再将对应的固件库文件放入到该工程文件夹中。

keil中把文件导入工程

在keil中点击三个方块样式的工程管理按钮

在Project Items中的Groups可添加对应名的文件夹，然后在再右侧的files的下方Add Files添加对应的固件库文件，即可成功创建文件。

然后点击三个方块样式旁边的魔术棒按钮。

在Tab栏中C/C++中的Include Paths中添加工程所用到的文件以及Define中改为USE_STDPERIPH_DRIVER。

注：程序烧入到单片机中需要在该tab中的Debug中设置

这样就成功完成了工程创建。

操作STM32的GPIO所需的初始化

先引入包#include "stm32f10x.h"再进行后续操作

首先需要将stm32的时钟使能，对应的函数方法在stm32f10x_rcc.h中，主要函数为以下三个

void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState); //使能AHB的外设时钟void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState); //使能PB2的外设时钟void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState); //使能PB1的外设时钟

还需要使用void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)函数，使用结构体的参数来初始化GPIO口，使用该函数需要定义以该结构体GPIO_InitTypeDef为类型的结构体变量，以下为例： 

GPIO_InitTypeDef GPIO_InitStructure;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13; //GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_Init(GPIOA,&GPIO_InitStructure);

加上以上操作的完整代码为：

#include "stm32f10x.h"                  // Device headerint main(void){    //ENABLE CLOCK    GPIO_InitTypeDef GPIO_InitStructure;    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//采用推挽输出模式    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2;//使用GPIO0，1，2号引脚    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//输出速度设置为50MHz    GPIO_Init(GPIOA,&GPIO_InitStructure);//初始化GPIOA外设的0号引脚    while(1)    {            }}
GPIO的工作模式
typedef enum{ GPIO_Mode_AIN = 0x0,//模拟输入  GPIO_Mode_IN_FLOATING = 0x04, //浮空输入  GPIO_Mode_IPD = 0x28,//下拉输入  GPIO_Mode_IPU = 0x48,//上拉输入  GPIO_Mode_Out_OD = 0x14,//开漏输出  GPIO_Mode_Out_PP = 0x10,//推挽输出  GPIO_Mode_AF_OD = 0x1C,//复用开漏  GPIO_Mode_AF_PP = 0x18//复用推挽}GPIOMode_TypeDef;
GPIO八种模式特点以及应用
模拟输入ADC和DAC使用。此模式下引脚电平不被采样或拉动。在此模式GPIO的数字输入功能关闭。
浮空输入不使用内部电阻，完全浮空，默认状态不定，通常用于外部电路已经提供明确的上拉或下拉信号的场景。如 I²C 总线 SDA/SCL 引脚，外部已经设计有上拉电阻。
下拉输入使用内部下拉电阻，默认输入低电平。适用于引脚通常为低电平，仅在特定情况下拉高。
上拉输入使用内部上拉电阻，默认输入高电平。适用于检测低电平的输入信号，例如开关按钮的闭合状态。
开漏输出引脚通过 MOS 管连接到地，输出低电平时导通，输出高电平时需外部上拉电阻。适用于多设备共享总线，如 I²C、多个设备的中断信号线以及电平兼容，如3.3V和5V设备互联。
推挽输出引脚可以输出高电平或低电平，内部由MOS管驱动。适用于控制 LED、蜂鸣器、继电器等负载。
复用开漏配置为复用功能，并使用开漏输出方式。适用于I²C 总线通信的 SDA 和 SCL 引脚以及多设备共享复用引脚时。
复用推挽配置为复用功能，并使用推挽输出方式驱动信号。适用于外设信号需要主动输出高低电平。如 USART 的 TX、SPI 的 SCK/ MOSI 等时序信号。
模拟输入（下方所有×号代表不启用）

浮空输入

输入上拉（上开关打开，默认为高电平）

输入下拉（下开关打开，默认为低电平）

开漏输出（允许输入，且输出低电平导通）

推挽输出（输出数据寄存器输出高电平P-MOS导通，低电平N-MOS导通）

复用开漏（类似开漏输出，不过输出电平来自片上外设）

复用推挽（类似推挽输出，不过输出电平来自片上外设）

GPIO的函数使用

设置函数
void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);//将GPIO_Pin设置为高电平，支持多引脚void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);//将GPIO_Pin设置为低电平，支持多引脚void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, BitAction BitVal);//第三个参数为Bit_SET置为高电平，Bit_RESET置为低电平，仅支持单引脚配置void GPIO_Write(GPIO_TypeDef* GPIOx, uint16_t PortVal);

使用实例：

GPIO_SetBits(GPIOA,GPIO_Pin_0); //将GPIOA端口的第0号引脚置为高电平GPIO_ResetBits(GPIOA,GPIO_Pin_0); //将GPIOA端口的第0号引脚置为低电平GPIO_WriteBit(GPIOA,GPIO_Pin_0,Bit_RESET); //将GPIOA端口的第0号引脚置为低电平GPIO_Write(GPIOA,~0x0001);  //将GPIOA端口的第0号引脚置为低电平
读取函数
uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);//读取GPIO_Pin的输入值，返回值代表该端口的电平uint16_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx);//读取整个输入寄存器，返回每一位端口的电平uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); //uint16_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx);//

AHB总线连接的外设

注：在APB1的操作速度最大频率为36MHz，在APB2的操作速度最大频率为72MHz

AFIO重映射

当使用的引脚的功能冲突时可以通过AFIO重映射来使用其他引脚来实现对应的功能，如USART1和TIM1的CH2和CH3引脚冲突，此时就可以使用AFIO将USART1_TX和USART1_RX的引脚改为PB6和PB7。

void USART1_Remap_Init(void) {    // 1. 启用 GPIOB 和 AFIO 时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO, ENABLE);    // 2. 重映射 USART1 引脚到 PB6 (TX) 和 PB7 (RX)    GPIO_PinRemapConfig(GPIO_Remap_USART1, ENABLE);    // 3. 配置 GPIOB 的引脚为复用功能    GPIO_InitTypeDef GPIO_InitStruct;        // 配置 PB6 为复用推挽输出（USART1_TX）    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;    GPIO_Init(GPIOB, &GPIO_InitStruct);    // 配置 PB7 为浮空输入（USART1_RX）    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;    GPIO_Init(GPIOB, &GPIO_InitStruct);    // 4. 启用 USART1 时钟    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);    // 5. 配置 USART1 参数    USART_InitTypeDef USART_InitStruct;    USART_InitStruct.USART_BaudRate = 9600;                      // 波特率 9600    USART_InitStruct.USART_WordLength = USART_WordLength_8b;     // 数据位 8 位    USART_InitStruct.USART_StopBits = USART_StopBits_1;          // 停止位 1 位    USART_InitStruct.USART_Parity = USART_Parity_No;             // 无校验    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 无硬件流控    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // 收发模式    USART_Init(USART1, &USART_InitStruct);    // 6. 启用 USART1    USART_Cmd(USART1, ENABLE);}

时钟

在STM32中由三种不同的时钟源来驱动系统时钟（SYSCLK）:

SYSCLK通过时钟树分发到不同的子系统和外设，如

  1. SYSCLK->AHB时钟
    • 通过AHB Prescaler分频器生产AHB时钟（HCLK）用于：
      • Cortex-M内核
      • DMA控制器
      • 内存接口（SRAM、FLASH等）
  2. HCLK->APB时钟
    • 通过APB和APB Prescaler 分频器生成APB时钟（PCLK1和PCLK2),用于：
      • APB1 外设（如 TIM2、USART2 等）
      • APB2 外设（如 ADC、USART1 等）

时钟配置可以使高速设备接高速时钟，低速设备接低速时钟，起到最大程度的节能效果。

名称频率外部连接功能用途特性
HSE（High-Speed External），高速外部时钟4~16MHz4~16MHz晶体系统时钟/RTC成本高，温漂小
LSE(Low-Speed External)，低速外部时钟32kHz32.768kHz晶体带校准功能RTC成本高，温漂小
HSI（High-Speed Internal），高速内部时钟8MHz无经出产调校系统时钟成本低，温漂大
LSI（Low-Speed Interal）,低速内部时钟40kHz无带校准功能RTC成本低，温漂大

时钟树

]]> https://lsworl.github.io/2024/12/30/stm32-xue-xi/ 2024-12-30T05:54:55.000Z 以 STM32F10x 为例，整理 Keil 工程创建、标准库导入、GPIO 初始化和基础外设配置流程。 stm32标准库初始化 2026-05-23T07:33:06.000Z LsWorld
基础概念
  1. 数据：传送信息的实体，通常是有意义的符号序列。
  2. 信号：数据的电气/电磁的表现，是数据在传输过程中的存在形式。
  3. 信源：产生和发送数据的源头。
  4. 信宿：接受数据的终点。
  5. 信道：信号的传输媒介。一般用来表示向某一个方向传送信息的介质。
  6. 码元：码元指用一个固定时长的信号波形（数字脉冲），代表不同离散数值的基本波形，是数字通信中数字信号的计量单位，这个时长内的信号称为k进制码元，而该时长称为码元宽度。一码元可以携带多个比特的信息量。
  7. 速率：也叫数据率，指数据的传输速率，表示单位时间内传输的数据量。可以用码元传输速率和信息传输速率表示。
  8. 码元传输速率：表示单位时间内数字通信系统所传输的码元个数，单位是波特，1波特表示数字通信系统每秒传输一个码元。
  9. 信息传输速率：表示单位时间内数字通信系统传输的二进制码元个数（即比特数），单位是比特/秒。

三种基本通信方式

  1. 单向通信。只有一个方向的通信而没有反方向的交互，仅需要一条信道。如，无线电广播、电视广播就属于这种类型。
  2. 半双工通信。通信的双方都可以发送或接收信息，但任何一方都不能同时发送和接受信息，需要两条信道。
  3. 全双工通信。通信双方可以同时发送和接受信息，也需要两条信道。
奈氏准则

由于具体的信道所能铜棍的频率范围是有限的，信号中的许多高频分类往往不能通过信道，奈氏准则就是在理想低通的条件下，为了避免码间串扰，规定极限码元传输速率为2W Baud（波特），W是信道带宽，单位是Hz。
$$
理想低通信道下的极限数据传输速率=2W\log_2V (b/s)
$$
对于奈氏准则，可以得出以下结论：

  1. 在任何信道中，码元传输速率氏有上限的。
  2. 信道的频带越宽，就可以用更高的速率进行码元的有效传输。
  3. 奈氏准则给出了码元传输速率的限制，但并未对信息传输速率给出限制，即未对一个码元可以对应多少个二进制给出限制。
香农定理

香农定理给出了带宽受限且有高斯白噪声干扰的信道的极限数据传输速率。

信噪比=信号的平均功率/噪声的平均功率，记为S/N，并用分贝（dB）作为度量单位，即：
$$
信噪比(dB)=10\log_{10}(S/N)
$$
香农定理：在带宽受限且有噪声的信道中，为了不产生误差，信息的数据传输率有上限值。
$$
信道的极限数据传输速率=W\log_2(1+S/N)(b/s)
$$
W是信道的带宽，S为信道所传输信号的平均功率，N为信道内部的高斯噪声功率。

香农定理可得出以下结论：

  1. 信道的带宽或信道中的信噪比越大，信息的极限传输速率越高。
  2. 对一定的传输带宽和一定的信噪比，信息传输速率的上限是确定的。
  3. 只要信息传输速率低于信道的极限传输速率，就能找到某种方法来实现无差错的传输。
  4. 香农定理得出的是极限信息传输速率，实际信道能达到的传输速率要比它低。
]]> https://lsworl.github.io/2024/02/11/ji-suan-ji-wang-luo-wu-li-ceng/ 2024-02-11T11:16:09.000Z
计算机网络-物理层 2026-05-22T11:24:08.000Z LsWorld
多层次ISP结构

ISP：因特网服务提供者/因特网服务提供商，是一个向广大用户综合提供互联网接入业务、信息业务、和增值业务的公司，如中国电信、中国联通、中国移动等。

分为主干ISP、地区ISP和本地ISP。

图中IXP可以提高同地区的网络通信速度。

计算机网络OSI七层模型中，下三层网络层，数据链路层和物理层就代表着通信子网（各种传输介质、通讯设备、相应的网络协议组成），路由器是网络层的通讯设备，交换机、网桥是数据链路层的通讯设备，集线器，中继器是物理层的通讯设备。

上三层应用层、表示层和会话层则是资源子网（实现资源共享功能的设备和软件的集合）。

计算机网络的分类

按分布范围分类

按分布范围可分为以下几种：

  1. 广域网（WAN）。广域网实现只要通过交换技术，需要交换机及路由器作为媒介来进行报文交换，一般各节点交换机都是高速链路，具有较大的通信容量。
  2. 城域网（MAN）。城域网大多采用以太网技术，有时也常并入局域网的范围讨论。
  3. 局域网（LAN）。局域网一般通过广播技术实现，覆盖范围较小。
  4. 个人区域网（PAN）。个人区域网指用无线技术连接起来的网络。
按交换技术分类

按交换技术分类可分为以下几种：

  1. 电路交换。电路交换类似于双方打电话，会先在源节点和目的节点之间建立一条专用的通路用于传送数据。
  2. 报文交换。用户数据加上源地址、目的地址、校验码等辅助信息，然后封装成报文，通过链路再进行发送，根据目的地址来判断目的源。
  3. 分组交换。分组交换就是将多个报文组成一个分组后发送。
按拓扑结构分类

网络拓扑结构是指由网中结点（路由器、主机等）与通信线路（网线）之间的几何关系表示的网络结构，主要指通信子网的拓扑结构。

可分为以下几种：

  1. 总线型。用单根传输线把计算机连接起来。
  2. 星型。每个终端或计算机都以单独的线路与中央设备相连。现在中央一般是交换机或路由器。
  3. 环形。所有计算机接口设备连接成一个环。如令牌环局域网，环可以是单环，也可以是双环，环中信号是单向传输的。
  4. 网状型。一般情况下，每个结点至少由两条路径与其他结点相连，多用在广域网中。

性能指标

  1. 速率。即数据率或称数据传输率或比特率。单位是b/s,kb/s,Mb/s,Gb/s,Tb/s等。（速率中$1k=10^3$，存储中$1k=2^{10}$）

  2. 带宽。原本指某个信号具有的频带宽度，在计算机网络中，带宽表示网络的通信线路所能传送数据的能力，是数字信道所能传送的“最高数据传输速率”的同义词，即网络设备所支持的最高速度，单位是b/s。

  3. 吞吐量。表示在单位时间内通过某个网络（或信道、接口）的数据量。单位b/s，kb/s等。

  4. 时延。指数据从网络（或链路）的一端传送到另一端所需的时间。也叫延迟或迟延单位是s。

    时延由四部分构成：发送时延、传播时延、处理时延和排队时延。

    • 发送时延。结点将分组的所有比特推向链路所需的时间，即整个数据都上链路的所花费的时间。
      $$
      发送时延=分组长度/信道宽度
      $$

    • 传播时延。即一个比特从链路的一端传播到另一端所需的时间。计算公式为
      $$
      传播时延=信道长度/电磁波在信道上的传播速率
      $$

    • 处理时延。数据在交换结点为存储转发而进行的一些必要的处理所花费的时间。例，分析分组的首部、从分组中提取数据部分、进行差错校验或查找适当的路由等。

    • 排队时延。分组在进入路由器后要先在输入队列中排队等待处理。路由器确定转发端口后，还要在输出队列中排队等待转发。

  5. 时延宽带积。指发送端发送的第一个比特即将到达终点时，发送端已经发出了多少个比特，因此又称以比特为单位的链路长度。
    $$
    时延带宽积=传播时延\times 带宽
    $$

  6. 往返时延RTT。从发送方发送数据开始，到发送方收到接收方的确认，总共经历的时延。

    RTT总共包括：往返传播时延=传播时延*2，末端处理时间。

  7. 信道利用率。指再某一信道有百分之多少的时间是有数据通过的，即
    $$
    信道利用率=有数据通过时间/(有+无)数据通过时间
    $$

计算机网络分层结构

计算机网络体系结构分层的基本原则如下：

  1. 每层都实现一种相对独立的功能，降低大系统的复杂度。
  2. 各层之间界面自然清晰，易于理解，相互交流尽可能少。
  3. 各层功能的精确定义独立于具体的实现方法，可以采用最适合的技术来实现。
  4. 保持下层对上层的独立性，上层单向使用下层提供的服务。
  5. 整个分层结构应能促进标准化工作。
OSI参考模型

OSI参考模型中上三层应用层、表示层、会话层称为资源子网，下三层网络层、数据链路层、物理层称为通信子网。

  1. 物理层。物理层的传输单位是比特，功能是在物理媒体上为数据端设备透明地传输原始比特流。
  2. 数据链路层。数据链路层的传输单位是帧，任务是将网络层传来的IP数据包组装成帧，在次层也会进行差错控制等功能。
  3. 网络层。网络层的传输单位的是数据包，它关心的是通信子网的运行控制，主要任务是把网络层的协议数据单元从源端传到目的端。
  4. 传输层。传输单位是报文段（TCP）或用户数据报（UDP），传输层负责主机中两个进程之间的通信，功能是为端到端连接提供可靠的传输服务。
  5. 会话层。会话层运行不同主机上的各个进程之间进行会话。会话层利用传输层提供的端到端的服务，向表示层提供它的增值服务。
  6. 表示层。表示层主要处理在两个通信系统中交换信息的表示方式。
  7. 应用层。应用层是用户与网络的界面，应用层为特定类型的网络应用提供访问OSI参考模型环境的手段。

]]> https://lsworl.github.io/2024/02/09/ji-suan-ji-wang-luo-ji-suan-ji-wang-luo-ti-xi-jie-gou/ 2024-02-09T11:02:56.000Z 梳理计算机网络体系结构、协议分层、OSI 与 TCP/IP 模型，以及各层的基本功能。 计算机网络-计算机网络体系结构 2026-05-23T07:33:06.000Z LsWorld

IO设备

IO设备就是可以将数据输入到计算机，或者可以接受计算机输出数据的外部设备，属于计算机中的硬件设备。

IO设备的分类

  • 按使用特性

    人机交互类外部设备。例如鼠标、键盘、打印机等——用于人机交互

    存储设备。例移动硬盘、光盘等——用于数据存储

    网络通信设备。调制解调器等——用于网络通信

  • 按传输速率

    低速设备。例如鼠标、键盘等——传输速率为每秒几个到几百字节。

    中速设备。如激光打印机等——传输速率为每秒数千至上万个字节。

    高速设备。如硬盘等——传输速率为每秒数千字节至千兆字节。

  • 按信息交换的单位分类

    块设备。传输速率较高，可寻址，即对它可随机地读/写任一块，如磁盘等。

    字符设备。传输速率较慢，不可寻址，在输入/输出时常采用中断驱动方式，如鼠标、键盘等。

IO控制方式

程序直接控制方式

从计算机外部设备读取的每个字，CPU需要对外设状态进行循环检查，直到确定该字已经在IO控制器的数据寄存器中。

优点：实现简单。在读/写指令之后，加上实现循环检查的一系列指令即可。

缺点：CPU和IO设备只能串行工作，CPU需要一直轮询检查，长期处于“忙等”状态，CPU利用率低。

中断驱动方式

引入中断机制。由于IO设备速度要远慢于CPU速度，因此在CPU发出读写命令后，可将等待IO的进程阻塞，先切换到别的进程指向。当IO完成后，控制器会向CPU发出一个中断信号，CPU检测到中断信号后，会保存当前进程运行环境，转去执行中断处理程序处理该中断。

优点：与程序直接控制方式相比，在中断驱动方式中，IO控制器会通过中断信号主动报告IO已完成，CPU不再需要不停地轮询。CPU和IO设备可以并行工作，CPU利用率得到明显提升。

缺点：每个字在IO设备与内存之间的传输，都需要经过CPU，而频繁的中断处理会消耗较多的CPU时间。

DMA方式

DMA（Direct Memory Access，直接存储器存取）方式主要用于块设备的IO控制，对于中断驱动方式有以下几点改进：

  • 数据的传输单位是“块”，一次可以传输多个字。
  • 数据的流向是从设备直接放入内存，或从内存直接到设备，无需经历CPU中转。

DMA方式中会从IO中读入的数据线存入到DR（数据寄存器）中，然后再根据MAR（内存地址寄存器）来将IO读入的数据放到内存相应地址中。

优点：传输以块为单位，CPU介入频率进一步降低。数据传输效率进一步增加。CPU和IO设备的并行性得到提升。

缺点：CPU每发出一条IO指令，只能读写一个或多个连续的数据块。

SPOOLing技术（假脱机技术）

假脱机技术是为了缓和CPU的高速性和IO设备低速性之间的矛盾，该技术利用专门的外围控制机，将低速IO设备上的数据传送到高速磁盘上，或者相反。

系统会在磁盘开辟出输入井和输出井两个存储区域。

“输入井”模拟脱机输入时的磁带，用于收容IO设备输入的数据，“输出井”模拟脱机输出时的磁带，用于收容用户进程输出的数据。

然后通过内存的输入缓冲区和输出缓冲区作为中转，来实现磁盘与输入输出设备的交互。

SPOOLing技术是必须要有多道程序技术的支持，系统会建立输入进程和输出进程。

缓冲区管理

缓冲区是一个存储区域，是用于缓和CPU与IO设备之间速度不匹配的矛盾，减少对CPU的中断频率，放宽对CPU中断相应时间的限制，解决数据粒度不匹配的问题，并提高CPU与IO之间的并行性。

缓冲区的实现方法：

  1. 采用硬件缓冲区，用一个寄存器或其他部件来作为数据间的缓冲区，但由于成本太高，一般不建议采用硬件缓冲区。
  2. 采用内存缓冲区。将内存一部分空间作为缓冲区使用。

根据系统设置缓冲器的个数，缓冲技术可以分为以下几种：

单缓冲

操作系统会在主存中为其分配一个缓冲区。当设备和处理机交换数据时，会先将数据写入缓冲区，然后需要数据的设备或处理机从缓冲区取走数据，在缓冲区写入或取出时，其他需要使用的设备要等待。

采用单缓冲策略，处理一块数据平均耗时为Max(输入时间，处理时间)+传送时间。

双缓冲

采用双缓冲策略，操作系统会在主存中为其分配两个缓冲区。

若假设初始状态为：工作区空，其中一个缓冲区满，另一个缓冲区空

假设输入时间<处理时间+传送时间

由此可得处理一块数据所消耗的时间，只有当回到初始状态才算数据处理完成，所以首先会经历M传送时间，然后再经历C处理时间，同步地再从工作区读入一块数据，输入时间为T，由于输入时间<处理时间+传送时间，所以处理一块数据所消耗的时间为T。

循环缓冲区

循环缓冲区是将内存中多个大小相等的缓冲区链接成一个循环队列。

磁盘与固态硬盘

磁盘就是由表面涂有磁性物质的物理盘片，通过一个称为磁头的导体线圈从磁盘存取数据。

磁盘进行读写操作时，磁头固定，磁盘再下面高速旋转。

由上图可得，可以通过柱面号，盘面号，扇区号来定位任意一个“磁盘块”。在“文件的物理结构”中存放在外存中的几号块，就可以转换成柱面号，盘面号，扇区号的地址形式。

磁盘按不同的形式可分为若干类型：

磁头相对于盘片的径向方向固定的称为固定头磁盘，每个磁道对应一个磁头。（磁头不可移动）

磁头可移动的，称为活动头磁盘，磁头臂可来回伸缩定位磁道；

磁盘永久固定在磁盘驱动器内的，称为固定盘磁盘；

可移动和替换的，称为可换盘磁盘。

磁盘调度算法

磁盘调度算法了解前需要知道相关判断算法好坏的指标：

  • 寻找时间（寻道时间）$T_s$：在读/写数据前，将磁头移动到指定磁道所花的时间。

  • 延迟时间$T_R$：通过旋转磁盘，使磁头定位到目标扇区所需要的时间，设磁盘转速为r（单位：转/秒），则平均所需的延迟时间
    $$
    T_R=(1/2)*(1/r)=1/2r
    $$

  • 传输时间$T_t$：从磁盘读出或向磁盘写入数据所经历的时间，假设磁盘转速为r，此次读写的字节数为b，每个磁道上的字节数为N，则传输时间
    $$
    T_t=\frac{1}{r}*\frac{b}{N}=\frac{b}{rN}
    $$

先来先服务算法（FCFS）

根据进程请求访问磁盘的先后顺序进行调度。

假设磁头初始位置是100号磁道

55、58、39、18、90、160、150、38、184号磁道陆续来访问，

根据FCFS的规则，根据请求到达的顺序来响应。

最短寻找时间优先（SSTF）

SSTF会优先处理磁道是与当前磁头最近的磁道。可以保证每次的寻道时间最短，但是并不能保证总的寻道时间最短。

假设磁头初始位置是100号磁道

55、58、39、18、90、160、150、38、184号磁道陆续来访问，

根据SSTF的规则，根据离磁头初始位置最近的磁道来响应。

扫描算法（SCAN）

扫描算法规定只要磁头移动到最外侧磁道的时候才能往内移动，移动到最内侧磁道的时候才能往外移动。也称电梯算法。

假设某磁盘的磁道为0~200号，磁头的初始位置是100号磁道，且此时磁头正在往磁道号增大的方向移动，有多个进程先后陆续地请求访问

55、58、39、18、90、160、150、38、184号磁道

LOOK调度算法

LOOK调度算法在如果磁头移动方向上已经没有别的请求，就可以立即改变磁头移动方向。

假设某磁盘的磁道为0~200号，磁头的初始位置是100号磁道，且此时磁头正在往磁道号增大的方向移动，有多个进程先后陆续地请求访问

55、58、39、18、90、160、150、38、184号磁道

循环扫描算法（C-SCAN）

C-SCAN算法规定只要磁头朝某个特定方向移动时才处理磁道访问请求，而返回时直接快速移动至起始端而不处理任何请求。

假设某磁盘的磁道为0~200号，磁头的初始位置是100号磁道，且此时磁头正在往磁道号增大的方向移动，有多个进程先后陆续地请求访问

55、58、39、18、90、160、150、38、184号磁道

C-LOOK调度算法

C-LOOK调度算法主要是用于解决C-SCAN算法需要到达最边上的磁道时才能改变磁头移动方向的缺点，用C-LOOK算法如果磁头移动的方向上已经没有磁道访问请求了，就可以立即让磁头返回，并且磁头只需要返回到有磁道访问请求的位置即可。

假设某磁盘的磁道为0~200号，磁头的初始位置是100号磁道，且此时磁头正在往磁道号增大的方向移动，有多个进程先后陆续地请求访问

55、58、39、18、90、160、150、38、184号磁道

]]> https://lsworl.github.io/2024/02/05/cao-zuo-xi-tong-shu-ru-shu-chu-guan-li/ 2024-02-05T11:07:34.000Z

操作系统-输入输出管理 2026-05-22T11:24:08.000Z LsWorld

内存管理的概念

内存空间的分配与回收

为了更好能适应不同大小的程序要求和提高内存的利用率，就需要对内存空间进行分配与回收。

覆盖与交换

覆盖于交换技术是在多道程序环境下用来扩充内存的两种方法。

  1. 覆盖技术

    覆盖技术的思想就是将程序分为多个段。常用的段常驻内存，不常用的段在需要时调入内存。

    常驻内存的段放在“固定区”中，调入后就不再调出（除非运行结束），

    不常用的段放在“覆盖区”，需要用到时调入内存，用不到时调出内存。

    缺点：由于必须由程序员声明覆盖结构，操作系统完成自动覆盖。对用户不透明，增加了用户编程负担

  2. 交换技术

    交换技术的思想技术当内存空间紧张时，系统将内存某些进程暂时换出外存，把外存中某些以具备运行条件的进程换入内存（类似进程在内存与磁盘间动态调度）。

连续分配管理方式

连续分配是为用户程序分配一个连续的内存空间。

单一连续分配

在单一连续分配方式中，内存被分为系统区和用户区。系统区通常位于内存的低地址部分，存放操作系统相关数据；用户区用于存放用户进程相关数据。

在单一连续分配中，内存只能有一道用户程序，用户程序独占整个用户区空间。

优点：实现简单，无外部虽破；可以采用覆盖技术扩充内存；不一定需要采取内存保护。

缺点：只能用于单用户、单任务的操作系统中；有内部碎片（即分配给某进程的内存区域中，有些没有用上的部分就称内部碎片）；存储器利用率极低。

固定分区分配

固定分区分配就是将整个用户空间划分未若干个固定大小的分区，在每个分区中只装入一道作业。

固定分区分配分为分区大小相等和分区大小不等两种情况。

分区大小相等：会缺乏灵活性，但是很适合用于用一台计算机控制多个相同对象的场合。

分区大小不等：增加了灵活性，可以满足不同大小的进程需求。根据常在系统中运行的作业大小情况进行划分。

优点：

实现简单，无外部碎片。

缺点：

当用户程序太大时，可能所有分区都不能满足需求，需要采用覆盖技术来解决，这回导致性能降低；

会产生内部碎片，内存利用率低。

动态分区分配

动态分区分配又称为可变分区分配。这种分配方式是在进程装入内存时，根据进程的大小动态地建立分区，并使分区的大小正好适合进程的需要。

动态分区没有内部碎片，但有外部碎片。

内部碎片，分配给某进程的内存区域中，如果有些部分没有用上就称没有用上的部分为内部碎片。

外部碎片，是指内存中某些空闲分区由于太小而难以利用，而没有用上的部分就称外部碎片。

可以通过紧凑（拼凑，Compaction）技术来解决外部碎片，紧凑即对内存中进程的位置进行挪位，从而减去外部碎片。

动态分区分配算法

基本分页存储管理

页式存储就是将内存分为一个个大小相等的分区，每个分区就是一个“页框”（也称内存块、物理块）。每个页框有一个编号，即“页框号”（也称内存块号、物理块号），页框号从0开始。

将进程的逻辑地址空间页分为与页框大小相等的一个个部分，每个部分称为一“页”或“页面”。每个页面也有一个编号，即“页号”，也会也是从0开始。

根据内存块数列计算页表项的字节数：

例：假设某系统物理内存大小为4GB，页面大小为4KB，则每个页表项至少应该为多少字节？

由题可得内存块数：
$$
内存块数=\frac{4GB}{4KB}=\frac{2^{32}B}{2^{12}B}=2^{20}块
$$
所以内存块号的地址范围应该是0~$2^{20}-1$

所以内存块号至少要20bit来表示。

换成字节为3B来表示块号。

在页表中页号无需计算，是隐含的（类似于数组）。

基本地址变换机构

基本地址变换机构可以借助进程的页表将逻辑地址转换为物理地址。

通常会再系统中设置一个页表寄存器（PTR），存放页表再内存中的起始地址F和页表长度M。

注：页面大小是2的整数幂

页面逻辑地址到物理地址的转变过程如下：

具有快表的地址变换机构

快表，又称联想寄存器（TLB, translation lookaside buffer），是一种访问速度比内存快很多的高速缓存，用来存放最近访问的页表项的副本。

快表的功能和cache差不多，快表会存放最近使用的页表项，然后下次访问若命中就可以直接通过快表获得物理地址，增加了查表的速度。

基于局部性原理，一般快表的命中率可以达到90%以上。

基本地址变换机构和具有快表的地址变换机构的区别

两级页表

为了解决单级页表中：

的问题，就需要使用两级页表。

两级页表实现离散分配就是为页表在建立一张页表，称为页目录表。

若想让页表不常驻内存，可采用虚拟存储技术，在页表项中增加一个标志位，用于表示该页面是否已经调入内存。

使用二级页表需要注意的细节:

虚拟内存管理

虚拟内存的的定义和特征

虚拟内存是基于局部性原理，在程序装入时，可以将程序中很快会用到的部分装入内存，暂时用不到的部分留在外存，就可以让程序开始执行。

在执行过程中，当所访问的信息不在内存时，由操作系统负责将所需信息从外存调入内存，然后执行。

若内存不够，由操作系统负责将内存暂时用不到的信息换出到外存。

在操作系统的管理下，在用户看来似乎有比实际大得多的内存，这就是虚拟内存。

虚拟内存的三个特征：

由于连续分配方式不方便实现虚拟内存技术，所以会建立在离散分配上实现虚拟内存技术。

与传统的非连续分配存储管理的区别：

在程序执行过程中，当所访问的信息不在内存时，由操作系统负责将所需信息从外存调入内存，然后继续执行。

若内存空间不够，由操作系统负责将内存暂时用不到的信息换出外存。

请求分页管理方式

在请求分页管理系统中，当访问的页面不在内存时，便产生一个缺页中断，然后由操作系统的缺页中断处理程序处理中断。

此时缺页的进程阻塞，等调页完成后再将其唤醒，放回就绪队列。

如果内存中有空闲块，则为进程分配一个空闲块。

如果内存中没有空闲块，则有页面置换算法选择一个页面淘汰，若该页面再内存期间被修改过，则要写回外存。未经修改无需写回。

页面置换算法

最佳置换算法（OPT）

最佳置换算法时每次选择淘汰的页面将是以后永不使用，或者再最长时间内不再被访问的页面，这样可以保证最低的缺页率。

例：假设有三个内存块，并考虑到有一下页面号引用串（会依次访问这些页面）：

7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1

通过最佳置换算法可得：

每当内存块满时换出最长时间不被访问的页面号。

最佳置换算法可以保证最低的缺页率，但实际上，只有再进程执行的过程中才能知道接下来会访问哪个页面。操作系统无法提前预判页面访问序列。因此，最佳置换算法是无法实现的。

先进先出置换算法（FIFO）

每次选择淘汰的页面是最早进入内存的页面。

例：假设系统为某进程分配了三个内存块，并考虑到有以下页面号引用串：

3，2，1，0，3，2，4，3，2，1，0，4

Belady异常：当为进程分配的物理块数增大时，缺页次数不减反增的异常现象。

在所有置换算法中，只有FIFO算法会产生Belady异常。虽然FIFO算法实现简单，但由于算法与进程实际运行时的规律不适应，算法性能较差。

最近最久未使用置换算法（LRU）

每次淘汰的页面是最近最久未使用的页面。

在该算法会为每个页面添加一个访问记录字段，该字段用于记录上次被访问依赖所经历的时间。

例：假设系统为某进程分配了四个内存块，并考虑到有以下页面号引用串：

1，8，1，7，8，2，7，2，1，8，3，8，2，1，3，1，7，1，3，7

在实际做题只需逆向检查此时内存中的页面号最后一个出现的页号就是要淘汰的页面。

该算法的实现需要专门的硬件支持，虽然算法性能好，但是实现困难，开销大。

时钟置换算法（CLOCK）

时钟置换算法又称最近未用算法（NRU），时钟置换算法又分为简单的CLOCK算法和改进的CLOCK算法。

页面分配策略

驻留集：指请求分页存储管理中给进程分配的物理块的集合。

采用虚拟存储技术的系统中，驻留集大小一般小于进程的总大小。

置换策略

在请求分页系统中，可采取固定分配和可变分配两种内存分配策略。在进行置换时，可采用全局置换和局部置换两种策略。

固定分配：操作系统位每个进程分配一组固定数目的物理块，在进程运行期间不可改变。即驻留集大小不变。

可变分配：操作系统位每个进程分配一定数目的物理块，在进程运行期间可改变。即驻留集大小可变。

局部置换：发生缺页时只能选进程自己的物理块进行置换。

全局置换：可以将操作系统保留的空闲物理块分配给缺页进程，也可以将别的进程持有的物理块置换到外存，再分配给缺页进程。

可变分配全局置换：只要缺页就给分配新物理块。

可变分配局部置换：要根据缺页的频率来动态地增加或减少进程的物理块。

抖动现象

刚刚换出的页面马上又要换入内/外存，这种频繁的页面调度行为称为抖动，或颠簸。产生抖动的主要原因是进程频繁访问的页面数目高于可用的物理块数。

工作集

为了减少抖动现象，就提出了工作集的概念。

工作集指在某段时间间隔里，进程实际访问页面的集合。

操作系统会根据“窗口尺寸”来算出工作集。

例：

某进程的页面访问序列如下，窗口尺寸为4，各时刻的工作集为：

工作集大小可能小于窗口尺寸，实际应用中，操作系统可以统计进程的工作集大小，根据工作集大小给进程分配若干内存块。

]]> https://lsworl.github.io/2024/01/30/cao-zuo-xi-tong-nei-cun-guan-li/ 2024-01-30T10:48:11.000Z 整理操作系统内存管理中的分页、分段、虚拟内存、页面置换算法和地址转换机制。 操作系统-内存管理 2026-05-23T07:33:06.000Z LsWorld

进程的概念

为了让使参与的每个程序都能独立地运行，为之专门配置的一个数据结构就称为进程块（Process Control Block, PCB）。而由程序段、相关数据段和PCB三部分构成了进程实体（又称进程映像）。

PCB是进程存在的唯一标识，当进程被创建时，操作系统会为其创建PCB，结束后会回收其PCB。

若执行相同的三个程序，此时会将三个程序载入进程，它们的PCB、数据段各不相同，但程序段的内容都是相同的。

进程的状态与转换

进程通常有以下几种状态：

  1. 运行态。进程正在处理机上运行。
  2. 就绪态。进程获得了除处理机外的一切所需资源，一旦得到处理机，便可立即运行。
  3. 阻塞态。又称等待态，进程正在等待某一事件（不是在等待CPU处理完成）而暂停运行，如等待某资源为可用（不包括处理机）或等待输入/输出完成。即使根据阻塞原因的不同，可设置多个阻塞队列。
  4. 创建态。进程正在被创建，尚未转到就绪态。
  5. 终止态。进程正从系统中小时，可能是进程正常结束或其他原因推出运行。

由于进程的整个生命周期都在运行态、就绪态、阻塞态三种状态，所以也称这三状态为基本状态。

进程控制

进程控制主要是对系统中的所有进程实施有效的管理，可为了保证进程连续，一般进程控制会用原语（即运行时不可被中断，通过关中断指令和开中断指令实现）来实现。

进程的创建

进程创建需要使用创建原语，即：

  1. 申请空白PCB。
  2. 为新进程分配所需资源。
  3. 初始化PCB。
  4. 将PCB插入就绪队列

当用户登录、作业调度（把外存中的应用运行到CPU上）、提供服务、应用请求时会引起进程创建。

进程的终止

在进程结束前需要使用撤销原语来撤销事件，即

  1. 从PCB集合中找到终止进程的PCB
  2. 若进程正在运行，立即剥夺CPU，将CPU分配给其他进程。
  3. 终止其所有子进程
  4. 将其进程拥有的所有资源归还给父进程或操作系统。
  5. 删除PCB

使用撤销原语能使就绪态/阻塞态/运行态来转为终止态。

进程的阻塞和唤醒

进程的阻塞就是主动将进程从运行态转变到阻塞态。

阻塞原语的步骤为：

  1. 找到要阻塞进程对应的PCB。
  2. 保护进程运行现场（CPU通过栈顶和栈底寄存器来执行），将PCB状态信息设置为“阻塞态”，暂时停止进程运行。
  3. 将PCB插入相应事件的等待队列。

进程的唤醒就是被动地被CPU从阻塞态改为就绪态。

唤醒原语的步骤为：

  1. 在事件等待队列中找到PCB
  2. 将PCB从等待队列移除，设置进程为就绪态。
  3. 将PCB插入就绪队列，等待被调度。
进程的切换

进程切换就是将运行态切换为就绪态或把就绪态切换为运行态。

切换原语的步骤为：

  1. 将运行环境信息存入PCB
  2. PCB移入相应队列
  3. 选择另一个进程执行，并更新其PCB
  4. 根据PCB恢复新进程所需的运行环境。

进程的通信

由于进程与进程不能访问相互的地址空间，所以得通过进程通信来实现交互。

共享存储

共享存储时在内存中开辟一个共享存储区，所有进程都可以对其进行访问。

为了保证可靠性，要求进程进行访问的操作是互斥的，即当一个进程访问该空间时，其他进程在此时无法访问。

基于存储区的共享方式是一种高级通信方式。

而基于数据结构（通过开辟数组等操作）的共享方式是低级通信方式。

消息传递

消息传递就是将进程要传递的数据进行格式化为消息头和消息体两部分，通过操作系统的发送和接受原语来实现。

消息传递分为两种通信方式。

  1. 直接通信方式

    直接将消息通过发送原语来发到接收方的消息队列中，然后接收方通过接受原语来从消息队列取数据。

  2. 间接通信方式

    通过一个中间实体“信箱”来实现消息传递。发送方通过发送原语来将数据发送到操作系统所开辟的“信箱”中，然后接收方通过接受原语来将对应“信箱”中的数据取走。

    多个进程可以往同一个信箱发送消息，也可以多个进程从同一个信箱中接受消息。

管道通信

管道通信就是在发送方和接受方建立一个“管道”（FIFO，采用队列的方式实现），发送方只能在管道的一端写，而接收方只能在管道的另一方读。

管道只采用半双工通信，某一时间段内只能实现单向的传输。如果要实现双向同时通信，则需要设置两个管道。

并且各进程需要互斥地访问管道。

线程概念和多线程模型

线程的基本概念

为了更好的并发执行多道程序，引入了线程概念，线程相对于微量型进程，作为基本的CPU执行单元，也是程序执行流的最小单位。

一个进程中会蕴含多个线程。而当CPU进行一个进程时可以并发调用多个线程，从而提高计算机的并发性。

线程的实现方式

线程实现可以分为两类：用户级线程（User-Level Thread, ULT），和内核级线程（Kernel-Level Thread, KLT）。

  1. 用户级线程

    1. 是程序员自己通过代码来创建一个线程库来实现，从代码角度看，线程就是一段代码逻辑，通过线程库来实现对线程的管理工作。

    优点：用户级线程的切换在用户空间即可完成，不需要切换到核心态，线程管理的系统开销小，效率高。

    缺点：当一个用户级线程被阻塞后，整个线程都会被阻塞，并发度不高。多个线程不可再多核处理器上并行运行。

  2. 内核级线程

    内核级线程的管理工作由操作系统内核完成。

    线程内核级切换需要在核心态下才能完成。

    并且操作系统内核视角可以“看到”线程。

    优点：当一个线程被阻塞后，别的线程还可以继续执行。

    缺点：一个用户进程会占用多个内核级线程，线程切换由操作系统内核完成，需要切换到核心态，因此线程管理的成本高，开销大。

多线程模型

在支持内核级线程的系统中，根据用户和内核级线程的映射关系，可以划分为多种多线程模型。

  1. 一对一模型。一个用户级线程映射一个内核级线程。

    优点：当一个线程被阻塞后，别的线程还可以继续执行，并发能力强。多线程可在多核处理器上并行执行。

    缺点：线程管理成本高，开销大。

  2. 多对一模型。多个用户线程映射一个内核级线程。

    优点：用户级线程切换不需要切换到核心态，线程管理系统开销小，效率高。

    缺点：当一个用户级线程被阻塞后，整个进程都会被阻塞，并发性不高。

  3. 多对多模型。n个用户级线程映射到m个内核级线程（用户级线程数量大于等于内核级线程数量，即n>=m）。每个用户进程对应m个内核级线程。

处理机调度

调度的基本概念

调度就是当有一堆任务要处理，但由于资源有限，这些事情没法同时处理时候就需要根据某种规则来调整这些任务的顺序，这就是调度研究的问题。

调度的层次

调度往往需要经历三个层次。

高级调度（作业调度）

按一定的原则从外存的作业后备队列中挑选一个作业调入内存，并创建进程。每个作业只调入一次，调出一次。作业调入时会建立PCB，调出时才撤销PCB。

中级调度（内存调度）

由于内存不够时，CPU可将某些进程的数据调出外存，当内存空闲或进程需要运行时再重新调入内存。

暂时调到外存等待的进程状态为挂起状态。被挂起的进程PCB会被组织成挂起队列。

将挂起队列中的进程重新调入到内存就称内存调度。

低级调度（进程调度）

进程调度就是按照某种策略从就绪队列中选取一个进程，将处理机分配给它。进程调度是操作系统中最基本的一种调度，在一般的操作系统中都必须配置进程调度。进程调度的频率很高。

三层调度的联系、对比

调度的算法评价指标

CPU利用率

CPU利用率指CPU“忙碌”的时间占总时间的比例。
$$
利用率=\frac{忙碌的时间}{总时间}
$$

系统吞吐量

系统吞吐量是指单位时间内完成作业的数量。
$$
系统吞吐量=\frac{总共完成了多少道作业}{总共花了多少时间}
$$

周转时间

周转时间是指作业被提交给系统开始道作业完成为止过程所需要花费的时间。

包括四个部分：

  1. 作业再外存后备队列上等待作业调度（高级调度）的时间
  2. 进程在就绪队列上等待进程调度（低级调度）的时间
  3. 进程在CPU上执行的时间
  4. 进程等待I/O操作完成的时间

$$
周转时间=作业完成时间 - 作业提交时间
$$

$$
带权周转时间=\frac{作业周转时间}{作业实际运行的时间}
$$

由上可得带权周转时间越小，用户满意度越高。
$$
平均带权周转时间=\frac{各作业带权周转时间之和}{作业数}
$$

等待时间

等待时间指进程/作业处于等待处理机状态时间之和，等待时间越长，用户满意度越低。

对于进程来说，等待时间就是指进程建立后等待被服务的时间之和，在等待I/O完成的期间其实进程也是在被服务的，所以不计入等待时间。

对于作业来说，不仅要考虑建立进程后的等待时间，还要加上作业在外存后备队列中等待的时间。

响应时间

响应时间是指从用户提交请求道首次产生响应所用的时间。

调度算法

先来先服务（FCFS）

先来先服务算法是根据作业的先后顺序进行服务，为非抢占式算法。

作业/进程调度时，考虑的是哪个作业先到达后备队列；用于进程调度时，考虑的是哪个进程先到达就绪队列。

优点：公平、算法实现简单。

缺点：FCFS算法对长作业有利，对短作业不利。

短作业优先（SIF）

短作业优先是将最短的作业/进程优先得到服务。短作业优先即可用于作业调度也可用于进程调度。当用于进程调度时称为“短进程优先”（SPF）。

优点：可以获得一个很短的平均等待时间、平均周转时间。

缺点：对短作业有利，对长作业不利，可能产生饥饿现象。若长作业一直得不到服务会产生“饿死”现象。

高响应比优先（HRRN）

高响应比是根据响应比来将响应比最高的作业/进程来为其服务。
$$
响应比=\frac{等待时间+要求服务时间}{要求服务时间}
$$
高响应比即可用于作业调度，也可用于进程调度。

优点：综合考虑了等待时间和运行时间，既有SIF的优点，也有FCFS的优点，且避免了长作业饥饿的问题。

时间片轮转（RR）

时间片轮转算法就是可以公平地、轮流地为各个进程服务，让每个进程在一定时间间隔内都可以得到响应。

算法具体是按照各进程到达就绪队列的顺序，轮流让每个进程执行一个时间片（如100ms），若进程未在一个时间片内执行完，则剥夺处理机重新排队。因此时间片轮转属于抢占式算法。

如果时间片太大，使得每个进程都可以在一个时间片内就完成，则时间片轮转算法将会退化成先来先服务调度算法，并且会增大进程响应时间。因此时间片不能太大。

由于进程调度、切换是有时间代价的，因此如果时间片太小，会导致进程切换过于频繁，系统会花大量的时间来处理进程切换，从而导致实际用于进程执行的实际比例减少。

优点：公平；响应快，适用于分时操作系统；

缺点：由于高频率的进程切换，因此有一定开销；不区分任务的紧急程度。

优先级调度

优先级调度算法就是根据任务的紧急程度来决定处理顺序。

该算法会给每个作业设置各自的优先级，调度时选择优先级最高的作业。

优先级调度算法会根据优先级是否可以动态改变又分为静态优先级和动态优先级两种。

  • 静态优先级：创建进程时确定，之后一直不变。
  • 动态优先级：创建进程时有一个初始值，之后会根据情况动态地调整优先级。
多级反馈队列调度算法

多级反馈队列调度算法是前几种算法的折中权衡。

该算法会设置多级就绪队列，各级队列优先级从高到低，时间片从小到大。

进程到达时候先进入第1级队列，按FCFS原则排队等待被分配时间片，若用完时间片进程还未结束，则进程进入下一级队列队尾。

只有第k级队列为空时，才会从k+1级队头的进程分配时间片用于进程调度。

该算法属于抢占式算法，在k级队列进程运行过程中，1~k-1级队列中进入一个新进程就会进行抢占。

同步与互斥

同步就是让进程之间有直接制约关系，它是为了某些进程需要在某些为止上协调它们的工作次序而产生的制约关系。

进程互斥是因为有临界资源（要求一个时间段内只允许一个进程使用）必须互斥的访问，即不能同时访问同个临界资源，此时产生了间接制约关系，因此称为进程互斥。

对于临界资源的访问可分成四部分：

  • 进入区。负责检测是否可以进入临界区。
  • 临界区。访问临界资源的那段代码。
  • 退出区。负责解除正在访问临界资源的标志。
  • 剩余区。做其他处理。
do{    entry selection;//进入区    critical selection;//临界区    exit selection;//退出区    remainder selection;//剩余区}while(true)

注：进入区和退出区是负责实现互斥的代码段。

实现临界区互斥的基本方法

软件实现

单标志法

该算法会设置一个公用变量turn，用于指示被允许进入临界区的进程编号。

如下面有p0和p1两个进程。

P0:while(turn!=0);//进入区critical selection;//临界区turn = 1;//退出区remainder slection;//剩余区
P1:while(turn!=1);//进入区critical selection;//临界区turn = 1;//退出区remainder slection;//剩余区

若turn==0时进入P0进程，turn==1时进入P1进程。

仅当退出的时候会修改turn的值。

双标志检查法

该算法会设置一个布尔型数组flag[]，数组中存放标记各进程想进入临界区的意愿。只有当对方为false时才能使用临界区。

如下面有p0和p1两个进程。

P0:while(flag[1]);//进入区flag[0] = true;//进入区critical selection;//临界区flag[0] = false;//退出区remainder slection;//剩余区
P1:while(flag[0]);//进入区flag[1] = true;//进入区critical selection;//临界区flag[1] = false;//退出区remainder slection;//剩余区

若flag[1]==false时进入P0进程，flag[0]==false时进入P1进程。

仅当退出的时候会修改flag的值。

由于双标志先检查法在并发环境进入区的“检查”和“上锁”不是同时完成，有可能会违法“忙则等待”原则。

双标志后检查法是先上锁后检查。但在并发环境下会出现饥饿现象，导致谁都无法使用临界区

Peterson算法

Peterson算法就是结合双标志法、单标志法的思想，设置turn和flag两变量实现。

如下面有p0和p1两个进程。

P0:flag[0] = true; turn = 1;//进入区while(flag[1] && turn==1);//进入区critical selection;//临界区flag[0] = false;//退出区remainder slection;//剩余区
P1:flag[1] = true; turn = 0;//进入区while(flag[1] && turn==0);//进入区critical selection;//临界区flag[1] = false;//退出区remainder slection;//剩余区

仅有当flag[0]==true且turn==1时才执行P0进程，很好的防止并发情况下会卡在while循环的情况，但仍然未能解决其他未能进入临界区的进程退出进入区的情况。

硬件实现

中断屏蔽方法

通过开关中断来实现互斥，即进程进入临界区后关中断，退出临界区再开中断。

优点：简单、高效。

缺点：由于开关中断指令只能在内核态中运行，因此不适用于多处理机。

互斥锁

解决临界区最简单的工具就是互斥锁（mutex lock），当进程进入临界时候会获得锁；退出后释放锁。

互斥锁的主要缺点就是忙等待，当有一个进程在临界区，其他任何进程进入临界区必须进行等待。

而需要连续循环忙等待的互斥锁就称为自旋锁（spin lock）。

优点：等待期间不需要切换进程上下文，多核处理器系统中，若上锁时间段，则等待代价很低。

信号量

信号量机制是可以很好的用来解决互斥和同步问题的机制，它只能被两个标准原语wait(S)和signal(S)访问，也可以记作P(S)、P(S)。

信号量实际就是一个变量（可以为整数，也可以是更复杂的记录型变量）。

整型信号量

对于整型信号量只有三种操作，即初始化、p操作、v操作。

C语言模拟实现信号量的wait(s),signal(s)

void wait(int S){//wait原语，相对于“进入区”    while(S<=0);//如果资源数不够。就一直循环等待    S = S-1;//如果资源数够，就占用一个资源}void signal(int S){//signal原语，相对于“退出区”    S = S+1;//使用完资源后，在退出区释放资源}
记录型信号量

记录型信号量使用一个记录型的数据结构来表示。

//记录型信号量的定义typedef struct{    int value;//剩余资源数    struct process *L;//等待队列} semaphore;

相应的wait(S)和signal(S)操作。

void wait(semaphore S){    S.value--;    if(S.value < 0){        block(S.L);//若资源数不够将进程从运行态进入阻塞态    }}
void signal(semaphore S){    S.value++;    if(S.value <= 0){        wakeup(S.L); //释放资源后若等待队列中还有进程，则将该进程从阻塞态变为就绪态    }}
信号量机制实现进程互斥

实现进程互斥只需在临界区使用一个互斥信号量mutex即可实现，初值为1.

semaphore mutex = 1; //初始化信号量P1(){    ...    P(mutex);//使用临界资源前需要加锁    临界区代码段...    V(mutex);//使用临界资源后需要解锁    ...}
信号量机制实现进程同步

通过设置同步信号量S，初始为0，在“前操作”之后执行V(S)（来唤醒后操作），在“后操作”之前执行P(S)（确保前操作没执行完前block）。

semaphore S=0;P1(){    代码1;    代码2;    V(S);//S++，并唤醒等待队列中进程    代码3;}P(2){    P(S);//S--，若此时P1未执行导相应代码则进入阻塞态    代码4;    代码5;    代码6;}

死锁

死锁的定义：

死锁就是指当多个进程并发执行时因竞争资源而产生的一种僵局（互相等待），导致各进程都阻塞，无法向前推进的现象。

死锁、饥饿、死循环的区别和共同点

死锁产生的的必要条件

  • 互斥条件。只有当对必须互斥使用资源的争抢才会导致死锁（如哲学家的筷子、打印机设备）。
  • 不剥夺条件。进程所获得的资源在未使用完之前，不能由其他进程强行夺走，只能主动释放。
  • 请求和保持条件。进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源又被其他进程占有，此时请求进程被阻塞。
  • 循环等待条件。存在一种进程资源的循环等待链。

处理死锁总共有三种方法：

  1. 死锁预防。设置某些限制条件，破环产生死锁的4个必要条件中的一个或多个。
  2. 避免死锁。在资源的动态分配过程中，用某种方法防止系统进入不安全状态。
  3. 死锁的检测及解除。允许进程发生死锁，但发生死锁后会采取措施解除死锁。

死锁预防

  1. 破环互斥条件

    将只能互斥使用的资源改造未共享使用。如SPOOLing技术。

  2. 破环不剥夺条件

    方案一：当某个进程请求新的资源得不到满足时，它必须立即释放保持的所有资源，待以后需要时再重新申请。也就是即使某些资源尚未使用完，也需要主动释放。

    方案二：当某个进程需要的资源被其他进程所占有的时候，可以由操作系统协助，将想要的资源强行剥夺。这种一般需要考虑各个进程的优先级。

  3. 破环请求和保持条件

    可以采用静态分配资源，即进程在运行前一次申请完它所需要的全部资源，在它资源未满足前，不让它投入运行。

  4. 破环循环等待条件。

    可采用顺序资源分配法。首先给系统中的资源编号，规定每个进程必须按编号递增的顺序请求资源，同类资源一次申请完。

避免死锁

避免死锁就是在进程运行之前会施加一些限制条件来避免使用资源后会进入死锁状态。

安全序列、不安全状态、死锁的联系

所谓安全序列，就是指如果系统按照这种序列分配资源，则每个进程都能顺利完成。只要能找出一个安全序列，系统就是安全状态。当然，安全序列可能有多个。

如果分配资源后，系统中找不出任何一个安全序列，系统就进入了不安全状态，就意味着之后如果分配了资源之后可能所有进程都无法顺利的执行下去。

若系统处于安全状态，就一定不会发生死锁。

若系统进入不安全状态，就可能会发生死锁。

安全性算法

安全性算法即每一轮都从编号较小的进程开始检测，通过循环来获得安全序列，从此达到避免死锁。

]]> https://lsworl.github.io/2024/01/19/cao-zuo-xi-tong-jin-cheng-yu-xian-cheng/ 2024-01-19T14:21:49.000Z 系统整理操作系统中进程、线程、调度、同步互斥、信号量和死锁等核心知识点。 操作系统-进程与线程 2026-05-23T07:33:06.000Z