Embedded Development on NomadJoe

基于CubeMX的STM32学习笔记

Thu, 09 Apr 2026 19:44:59 +0800

个人学习笔记

中断简介

中断定义 CPU执行程序中，由于发生了某种随机的事件(外部或内部)，引起CPU暂时中断正在运行的程序，转去执行一段特殊的服务程序(称为中断服务程序或中断处理程序)，以处理该事件，该事件处理完后又返回被中断的程序继续执行，这一过程称为中断对于单片机来说

中断事件发生
产生中断信号
单片机接收到中断信号，停止执行当前函数，跳转至中断处理函数
执行完中断处理函数后，单片机自动跳转回主函数执行被中断处

NVIC

NVIC是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。同时掌控中断优先级和中断向量表。

中断流程

请求挂起寄存器的改变由外设导致
中断信号传递至NVIC，然后NVIC查找对应中断向量，执行中断处理函数
另外中断处理函数都需要去清除请求挂起寄存器对应位，避免中断处理函数被重复调用

HAL库的中断处理及回调函数实现流程

首先是外设发出中断请求信号，NVIC接收到后会根据中断向量表查询对应中断处理函数的入口，在HAL中是对应外设的外设number_IRQHandler，然后再进入HAL库统一的外设中断处理函数HAL_外设_IRQHandler，再调用对应的回调函数

NVIC嵌套向量中断控制器

NVIC会一直检测某一个中断线是否处于激活状态，当中断处理函数运行完成后，需要在中断处理函数中将请求挂起寄存器对应的位清除为0，避免NVIC一直检测到1，一直重复执行中断处理函数，而这一部分代码，在HAL库写的总IRQHandler中已经完成。

另外，NVIC对于中断还有中断优先级的设置，stm32f103c8t6中断优先级由NVIC的优先级寄存器里的4位决定。中断优先级分为抢占优先级和响应优先级（它们一起用这4位）

抢占优先级的级别越高，越能够抢占中断通道，优先执行中断
响应优先级的级别越高，可以优先排队。
中断的优先级，都是数字越小，优先级越高

EXTI外部中断

EXTI外部中断实现

EXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，这两个功能从硬件上就有所不同。我们的主要关注点是中断。

边沿检测电路用来检测输入的电平信号的高低电平的转换，同时会根据上升沿/下降沿触发选择寄存器来决定是否向后产生高电平信号
软件中断事件寄存器使用软件来模拟产生一个中断
请求挂起寄存器接收到高电平后会将对应通道的位置1（例如EXTI_9产生高电平进入请求挂起寄存器，则该寄存器会将第9位置1）
最后上面的线路就会进入NVIC(嵌套向量中断控制器)
下面的线路，脉冲发生器作为事件信号送到对应外设，这个脉冲信号可以给其他外设电路使用，比如定时器TIM、模拟数字转换器ADC等等，这样的脉冲信号一般用来触发TIM或者ADC开始转换产生中断线路目的是把输入信号输入到NVIC，进一步会运行中断服务函数，实现功能，这样是软件级的。产生事件线路目的就是传输一个脉冲信号给其他外设使用，并且是电路级别的信号传输，属于硬件级的。

调用流程

以EXTI1为例，下降沿触发，当出现下降沿时，就会触发EXTI5的外部中断，进入EXTI9_5_IRQHandler，在EXTI9_5_IRQHandler中调用HAL_GPIO_EXTI_IRQHandler函数统一处理外部中断，在该函数中对挂起寄存器进行清0操作，并调用HAL_GPIO_EXTI_Callback中断回调函数

按键实现外部中断控制小灯亮灭

Cube配置

EXTI配置

打开中断

配置的是下降沿触发，检测下降沿，上拉模式

配置参数解释

上升沿触发：指的是当引脚电平从低电平(0)转变为高电平(1)时，触发事件
下降沿触发：指的是当引脚电平从高电平(1)转变为低电平(0)时，触发事件
双边沿触发：指的是当引脚的电平发生任何变化（即从低电平到高电平或从高电平到低电平）时，都会触发事件
上拉：指使引脚在未连接（悬空）时默认为高电平(1)
下拉：指使引脚在未连接（悬空）时默认为低电平(0)

GPIO配置

推挽模式，初始输出为Low低电平

按键消抖

方式1

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {//外部中断回调函数
    if( GPIO_Pin == GPIO_PIN_5 ) {
	    //HAL_Delay(10);
	    for( int i = 0 ; i <= 72000*100 ; ++ i );//空循环延时
	    HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_2);
    }
}

方式2

int lastTick = 0 ;
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {//外部中断回调函数
	if( GPIO_Pin == GPIO_PIN_5 ) {
		if( HAL_GetTick()-lastTick > 150 ) {
			HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_2);
			lastTick = HAL_GetTick();
		}
	}
}

代码实现

int lastTick = 0 ;
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {//外部中断回调函数
	if( GPIO_Pin == GPIO_PIN_5 ) {
		if( HAL_GetTick()-lastTick > 150 ) {
			HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_2);
			lastTick = HAL_GetTick();
		}
	}
}

TIM定时器定时中断

在f103c8t6中，TIM1是高级定时器，TIM2，TIM3，TIM4是通用计时器下面例子中配置的是TIM1，实现每秒翻转1次小灯亮灭

调用流程

触发更新中断后进入更新中断服务函数TIM1_UP_IRQHandler，其中调用HAL_TIM_IRQHandler，在该函数中调用了HAL_TIM_PeriodElapsedCallback回调函数

CubeMX参数配置

使用内部时钟模式

参数配置如下，实现1s触发一次定时器更新中断

Prescaler:预分频，实际分频数是number+1
Counter Mode:计数模式设置
Counter Period:自动重装载计数器计数值
Internal Clock Division:内部时钟预分频
Repetition Counter:重复计数器 (RCR -8 bits)，属于高级控制寄存器专用寄存器位，利用它可以非常容易控制输出 PWM 的个数，与内部时钟模式无关
auto-reload preload:是否开启影子寄存器模式

还需要开启定时器更新中断

代码实现

用的PA2作GPIO输出

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
	if( htim == &htim1 ) {
		HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_2);
	}
}

int main(void)
{
  /* USER CODE BEGIN 1 */
  /* USER CODE END 1 */
  /* MCU Configuration--------------------------------------------------------*/
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
  /* USER CODE BEGIN Init */
  /* USER CODE END Init */
  /* Configure the system clock */
  SystemClock_Config();
  /* USER CODE BEGIN SysInit */
  /* USER CODE END SysInit */
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

USART中断

USART的轮询模式会阻塞程序运行，浪费CPU资源

说明：本节保留“中断视角”的基础讲解；若需要串口 + DMA + 空闲中断的完整实践，请结合后文“UART、DMA与空闲中断（综合）”章节阅读。

轮询模式

CPU不断查询发送数据寄存器或者接受数据寄存器导致程序的阻塞

发送

在UART底层有发送移位寄存器和发送数据寄存器，发送数据时，需要CPU将发送数据寄存器的数据移动至发送移位寄存器，然后UART按照指定的波特率发送数据，CPU则不断查询数据发送寄存器是否空，如果空则需要移动数据进来

接收

在UART底层有接收移位寄存器和接收数据寄存器，接收数据时，UART按照指定的波特率接收数据至接收移位寄存器，然后数据会存储在接收数据寄存器，CPU则不断查询数据接收寄存器是否有数据，如果有数据，CPU会把寄存器的数据移动至我们用来接收数据的变量的内存里

当HAL_UART_Receive执行完成，我们就可以知道数据接收完成

中断模式

底层中断实现数据每传送一字节，召回CPU继续运输数据，不需要我们考虑，HAL库底层已经帮我们实现上层中断实现数据接收完成后的数据处理，通过中断回调函数实现，需要我们自己设计

发送

CPU将数据送入发送数据寄存器，然后就去执行其他代码，当发送移位寄存器的数据发送后，发送数据寄存器空，会触发发送数据寄存器空中断，CPU再次将数据送入发送数据寄存器，然后又去执行其他代码，所有数据发送完成后会触发传送完成中断，调用HAL_UART_TxCpltCallback中断回调函数

接收

CPU在处理其他代码，接收移位寄存器将一帧数据移动至接受数据寄存器后，会触发接收数据寄存器非空中断，CPU会回来将接收数据寄存器的数据移动至我们用来接收数据的变量的内存里，然后又去执行其他代码，所有数据完成后会调用_HAL_UART_RxCpltCallback_中断回调函数处理接收的数据而执行HAL_UART_Receive_IT后，我们不能直接对数据继续处理，数据还没接收完成，因为CPU不会进入阻塞态，会去执行其他代码，需要通过HAL_UART_RxCpltCallback回调函数处理接收的数据

定时器中断（补充）

说明：本节偏“更新中断”专题补充；如果想系统学习定时器，优先看后文的“定时器（系统学习）”章节。

基于HAL库 STM32中断详述 - 知乎 STM32–中断使用（超详细！）_stm32中断-CSDN博客

中断机制图解

TIM定时器中断

25_1_TIM，UPDATE定时中断（B站）

定时器更新中断

【话说定时器系列】之四：STM32定时器更新事件及案例分享 - 知乎

更新操作是一种动作，是更新事件的源头，即事件源；更新事件是基于更新操作所导致的后续影响或结果。

部分更新事件触发定时器更新中断或触发DMA请求。

软件更新操作，触发了更新事件，它不仅仅实现了影子寄存器的数据更新，同时还置位了状态寄存器的更新中断标志位，且使能定时器更新中断，之后就会进入更新中断服务程序。

初始化后立即进入定时器更新中断

基于此，在MX_TIMx_Init()中，初始化了影子寄存器（自动重装载寄存器等），进行了数据的更新，同时还置位了更新中断标志位，所以在时基参数初始化，使能定时器中断之后，就会进入更新中断服务程序。若要解决此问题，我们可以在时基参数初始化完成之后，使能定时器更新中断HAL_TIM_Base_Init_IT()之前，做更新中断标志的清除操作。

复位模式`trigger`触发后进入更新中断

trigger触发后，计数寄存器被置零，会置位状态寄存器的更新中断标志位，如果使能了更新中断，则会进入更新中断服务函数

更新操作事件源

可能的更新操作【事件源】有3类：

核心计数器的溢出【上溢或下溢】
软件复位操作【对UG@TIMX_EGR置位】
工作在复位模式下的定时器收到触发信号【即复位触发信号】【特别提醒，对于高级定时器必须发生RCR+1次溢出动作后才可以产生更新事件。对于通用或基本定时器，每溢出一次都可以产生更新事件。】

ADC模块

STM32H743-梳理ADC模数转换器在CubeMX上的配置_overrun behaviour-CSDN博客（写的很好，很详细）

STM32-HAL库-ADC学习 - 曲杨 - 博客园

ADC定义

模数转换器(Analog to Digital Converter,ADC) 模拟信号->数字信号转换器

通过对输入的模拟信号进行测量，将其分级转换为数字信号

STM32单片机中的ADC

一般计算采用一下逻辑方式进行转换

if( V>V_ref_low && V<V_ref_high ) {
	return (V-V_ref_low)/(V_ref_high-V_ref_low) * (2<<X-1);
	//归一化，再按照配置的x进行转换
}
else {
	return erro ;
}

STM32单片机中的ADC，x一般是12，也可以是其他数值一般情况下，参考电压为0V，参考高电压为3.3V

分辨率与精度

分辨率与位数有关，精度与性能有关，位数越高，分辨率越高，性能越高，波动越小，精度越强 ADC位数为12位，则分辨率是1/4096

使用时PLCK频率控制在36MHz以内，不然ADC模块的精度会大幅降低

STM32CubeMX配置

这里以STM32C8T6为例

x即Resolution 12bits( 15ADC时钟周期 )（看芯片型号，有的需要配置）
数据选择右对齐，得到的数据就是转换后的值
Mode选择Independent mode

Scan Conversion Mode（扫描转换模式），会采集ADC开启的所有通道，按顺序采集所有通道 Continuous Conversion Mode（连续转换模式），可以在使能ADC时自动开始采集，而非手动采集 Discontinuous Conversion Mode（间断采集模式），可以在一轮采集完成后暂停等待指令控制下一轮采集

Number Of Discontinuous Conversions（单次转换次数）此参数定义每次触发后ADC执行的转换次数，每次转换完都需要HAL_ADC_GetValue来获取值。如果它设为2，且ADC1使能了通道1，2，5，7的话，那么第一次触发ADC1采样时，就会采样通道1与通道2的值，再一次触发ADC1采样的话，就会采样通道5与通道7值，如此类推。

ADC_Regular_ConversionMode 可以配置每个通道的采集顺序和采样时间

代码使用

1.开始采集

`1`	`HAL_ADC_Start(&hadc2);`

2.采集后转换

`1`	`HAL_ADC_PollForConversion(&hadc2,20);//地址，等待时间`

关于多数据通道采集

ADC_value[1]对应rank_1的通道的值，第一次采集rank1通道 ADC_value[2]对应rank_2的通道的值，第一次采集rank2通道 rank指在ADC_Regular_ConversionMode中的rank设置

for( int t = 1 ; t <= 10 ; ++ t ) {
	for( int i = 0 ; i < 2 ; ++ i ) {
		HAL_ADC_Start(&hadc2);
		HAL_ADC_PollForConversion(&hadc2,20);//采集后转换
		AD_value[i] += HAL_ADC_GetValue(&hadc2) ;//采集十次，平均值处理
	}
}

检测

1
2
3

if(HAL_IS_BIT_SET( HAL_ADC_GetState(&hadc2),HAL_ADC_STATE_REG_EOC) ) {//检测是否正常采集
	ADC_value += HAL_ADC_GetValue(&hadc2);
}

关于Number Of Discontinuous Conversions

在STM32CubeMX中，Number Of Discontinuous Conversions（单次转换次数）是ADC（模数转换器）的一个配置选项，主要用于控制ADC在非连续采样模式（Discontinuous Mode下的转换行为。以下是详细解释和使用方法：

1. 功能含义

作用：
当ADC配置为非连续模式（Discontinuous Mode）时，此参数定义每次触发后ADC执行的转换次数。
- 例如，设置为3，则每次触发ADC后，会自动连续完成3次转换（无需额外触发信号）。
- 若设置为1，则每次触发仅执行1次转换（等同于标准单次模式）。
应用场景：
适用于需要分组采样的场景，例如：
- 周期性触发ADC，但每次触发需采集多个通道的数据。
- 降低CPU干预频率（通过一次触发完成多次转换）。

2. 配置步骤（STM32CubeMX）

启用Discontinuous Mode：
- 在ADC配置界面，勾选 Discontinuous Mode（通常在Parameter Settings选项卡中）。
- 此时，Number Of Discontinuous Conversions选项会生效。
设置转换次数：
- 输入需要的转换次数（取值范围取决于型号，通常为1~8）。
- 该值必须 ≤ 总启用通道数（例如，若启用5个通道，最多可设置为5）。
配置触发源：
- 选择触发方式（如定时器触发、外部引脚触发等）。
- 每次触发信号到来时，ADC会自动完成设定的转换次数。

3. 工作流程示例

硬件环境：
- ADC通道：CH0、CH1、CH2
- 配置：Discontinuous Mode + Number Of Discontinuous Conversions = 2
行为：

触发信号到来（如定时器溢出）。
ADC自动连续转换2个通道（例如CH0→CH1）。
转换完成后产生中断/DMA请求。
下次触发时，继续从下一个通道开始（CH2→CH0，依此类推）。

在该配置下（Discontinuous Mode + Number Of Discontinuous Conversions = 2），每次触发后ADC会连续转换2个通道（例如CH0→CH1），因此你需要调用两次 HAL_ADC_GetValue(&hadc2) 来分别读取这两个通道的转换结果。以下是具体说明和注意事项：

1. 数据读取方式

方法一：轮询模式（Polling）

每次触发后，需手动读取两次ADC值：

HAL_ADC_Start(&hadc2);  // 启动ADC（或通过触发信号启动）
//开启一次，采集两次
if (HAL_ADC_PollForConversion(&hadc2, timeout) == HAL_OK) {//采集后第一次转换
    uint32_t ch0_value = HAL_ADC_GetValue(&hadc2);  // 读取CH0结果
}
if (HAL_ADC_PollForConversion(&hadc2, timeout) == HAL_OK) {//采集后第二次转换
    uint32_t ch1_value = HAL_ADC_GetValue(&hadc2);  // 读取CH1结果
}

注意：每次调用 HAL_ADC_GetValue() 会返回最后一次完成的转换结果，因此需按顺序读取。

方法二：中断模式（Interrupt）

在ADC转换完成中断中读取：

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
    if (hadc == &hadc2) {
        uint32_t ch0_value = HAL_ADC_GetValue(&hadc2);  // 第一次转换结果（CH0）
        uint32_t ch1_value = HAL_ADC_GetValue(&hadc2);  // 第二次转换结果（CH1）
    }
}

关键点：在中断回调中需连续读取两次，顺序由ADC的Rank配置决定。

方法三：DMA模式（推荐）

若启用DMA，ADC会自动将多次转换结果存入指定数组，无需手动调用 HAL_ADC_GetValue()：

1
2

uint32_t adc_results[2];  // 存储2次转换结果
HAL_ADC_Start_DMA(&hadc2, adc_results, 2);  // 启动DMA传输

结果存储：
adc_results[0] → CH0的值，adc_results[1] → CH1的值（顺序由Rank决定）。

4. 注意事项

与连续模式（Continuous Mode）的区别：
- 连续模式：ADC无限循环转换所有启用通道，无需触发。
- 非连续模式：需外部触发，且每次触发仅转换设定的次数。
DMA配合：
- 建议启用DMA，以高效搬运多组转换结果（尤其是高频触发场景）。
- DMA缓冲区大小需 ≥ 转换次数 × 通道数。
通道顺序：
- 转换顺序由Rank（在ADC配置中定义）决定，而非通道编号。

总结

Number Of Discontinuous Conversions 是ADC非连续模式下每次触发的转换次数。
关键配置：启用Discontinuous Mode → 设置转换次数 → 配置触发源。
优势：灵活控制采样节奏，减少CPU负担，适合分组采样需求。

中科大RM电控合集：CAN通信+STM32CubeMX编程（B站）

STM32 CAN快速配置（HAL库版本）_stm32 can hal-CSDN博客

一文搞懂CAN和CAN FD总线协议_fdcan-CSDN博客

FDCAN

CubeMX配置解析

这里的配置以STM32G474CET6为例

Frame-Format

Classic mode：普通CAN FD mode without BitRate Switching：FDCAN，没有波特率转换 FD mode with BitRate Switching：FDCAN，带有波特率转换，数据段使用更高波特率注意选用FD mode with BitRate Switching后还可以通过txheader去选定是否开启BitRateSwithcing，以及是采用CAN的帧格式还是 FDCAN帧格式

也就是说这个帧格式选择是决定是否允许拥有FDCAN的特殊格式和能否开启BitRateSwitching，至于发送的帧实际是否用，取决于txheader

从这一段HAL_FDCAN_Init初始化代码中可以看出，只有FD mode with BitRate Switching才会去初始化数据段的传输参数

HAL_StatusTypeDef HAL_FDCAN_Init(FDCAN_HandleTypeDef *hfdcan)
{
  uint32_t tickstart;
  /* Check FDCAN handle */
  //...
  /* Check function parameters */
  //...
  if (hfdcan->Init.FrameFormat == FDCAN_FRAME_FD_BRS)
  {
    assert_param(IS_FDCAN_DATA_PRESCALER(hfdcan->Init.DataPrescaler));
    assert_param(IS_FDCAN_DATA_SJW(hfdcan->Init.DataSyncJumpWidth));
    assert_param(IS_FDCAN_DATA_TSEG1(hfdcan->Init.DataTimeSeg1));
    assert_param(IS_FDCAN_DATA_TSEG2(hfdcan->Init.DataTimeSeg2));
  }
  //....
  //...
}

1. Classic Mode（传统模式）

本质：完全兼容传统 CAN 2.0B 协议，不启用 FDCAN 的扩展功能
数据长度：最大 8 字节（DLC=0~8）
波特率：全程使用标称波特率（Nominal Bit Rate），无速率切换
帧结构：与传统 CAN 帧一致，仅包含仲裁段、控制段、数据段（≤8 字节）、CRC 段等
核心作用：用于对接仅支持传统 CAN 协议的设备（如老旧传感器、执行器），确保兼容性

2. FD mode with BitRate Switching（带波特率切换的 FD 模式）

本质：启用 FDCAN 的核心扩展功能，支持高速长数据传输，且数据段使用更高波特率
数据长度：最大 64 字节（DLC=0~~15，其中 DLC=9~~15 对应 32~64 字节）
波特率：
- 仲裁段（Arbitration Phase）：使用标称波特率（与传统模式一致，确保仲裁兼容性）
- 数据段（Data Phase）：使用更高的数据波特率（Data Bit Rate）（可配置为标称波特率的 2~8 倍，如 8Mbps）

3. FD mode without BitRate Switching（不带波特率切换的 FD 模式）

本质：启用 FDCAN 的长数据功能，但不切换波特率，全程使用标称波特率
数据长度：最大 64 字节（与带切换的 FD 模式一致）
波特率：仲裁段和数据段均使用标称波特率，无速率提升
帧结构：包含 FD 帧标志（FDF），但无波特率切换标志（BRS=0）
核心作用：用于需要长数据传输（＞8 字节）但总线上存在不支持高速数据段的设备场景，或因硬件限制（如线缆质量差）无法使用高速率的场景

Mode

一般使用Normal mode

Normal mode（正常模式）
Restricted operation（受限操作模式）
Bus Monitoring mode（总线监听模式）
Internal LoopBack mode（内部回环模式）
External LoopBack mode（外部回环模式）

Auto-Retransmission & Transmit-Pause & Protocol-Exception

Auto-Retransmission：自动重传，如果发送的帧没有收到应答，出现错误，就不断重新发送，在总线负载较高的时候一定要关掉，会严重拉低控制频率

Transmit-Pause：一种临时停止 FDCAN 发送功能的机制，用于在特定场景下主动暂停数据发送，避免干扰总线或等待特定条件，可以通过软件主动触发，调用HAL库函数

Protocol-Exception：检测到异常情况（帧格式错误等），会去触发异常处理机制（例如异常处理中断）

Data & Nominal

此处提一下，Data Sync Jump Width（数据段同步跳转宽度）是针对数据波特率（Data Bit Rate） 配置的关键时序参数

Data（数据波特率相关）

“Data” 特指 FDCAN 在FD 模式（Flexible Data Rate Mode） 下，帧的数据段（Data Phase） 所使用的传输速率，即数据波特率（Data Bit Rate）

Nominal（标称波特率相关）

“Nominal” 特指 FDCAN 帧在仲裁段（Arbitration Phase）、控制段（Control Phase）、CRC 段（CRC Phase） 和ACK 段（Acknowledgment Phase） 中使用的传输速率，即标称波特率（Nominal Bit Rate）

Filter and Std-Filters-Nbr&Ext-Filters-Nbr

Std Filters Nbr（标准帧过滤器数量） 和Ext Filters Nbr（扩展帧过滤器数量） 是配置 FDCAN（Flexible Data Rate CAN）接收过滤功能的核心参数。它们分别用于定义标准帧（11 位 ID） 和扩展帧（29 位 ID） 的硬件过滤器数量，直接影响 FDCAN 控制器能接收的帧类型和数量

Std Filters Nbr：配置标准帧（11 位 ID） 的过滤器数量。每个过滤器可匹配一个或多个标准 ID，或通过掩码模式匹配 ID 范围
Ext Filters Nbr：配置扩展帧（29 位 ID） 的过滤器数量。每个过滤器可匹配一个或多个扩展 ID，或通过掩码模式匹配 ID 范围

过滤器类型

FDCAN 支持多种过滤模式，不同模式对过滤器数量的需求不同：

掩码模式（Mask Mode）：通过 ID 和掩码匹配 ID 范围。例如，1 个标准过滤器可匹配 0x100~0x1FF 范围内的所有 ID（掩码 = 0x100，ID=0x1FF）
双 ID 模式（Dual ID Mode）：匹配两个特定 ID。例如，1 个扩展过滤器可同时匹配 0x12345678 和 0x87654321
范围模式（Range Mode）：匹配 ID 在两个值之间的所有帧。例如，1 个标准过滤器可匹配 0x000~0x0FF 范围内的 ID

配置示例

// 配置4个扩展过滤器，每个匹配1个特定ID（双ID模式）
FDCAN_FilterTypeDef sFilterConfig;
sFilterConfig.IdType = FDCAN_EXTENDED_ID;
sFilterConfig.FilterType = FDCAN_FILTER_DUAL;
sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXBUFFER;

// 过滤器0匹配ID=0x01
sFilterConfig.FilterIndex = 0;
sFilterConfig.FilterID1 = 0x01;
sFilterConfig.FilterID2 = 0x01;
sFilterConfig.RxBufferIndex = 0;
HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig);

// 过滤器1匹配ID=0x02
sFilterConfig.FilterIndex = 1;
sFilterConfig.FilterID1 = 0x02;
sFilterConfig.FilterID2 = 0x02;
sFilterConfig.RxBufferIndex = 1;
HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig);

// 依此类推配置过滤器2和3

Txheader

关于Txheader的配置

	FDCAN_TxHeaderTypeDef Txheader_gimbal ;
	Txheader_gimbal.DataLength = 0x08 ;//数据长度
	Txheader_gimbal.Identifier = 0x1FF ;//标识符
	Txheader_gimbal.TxFrameType = FDCAN_DATA_FRAME ;
	Txheader_gimbal.IdType = FDCAN_STANDARD_ID ;
	Txheader_gimbal.ErrorStateIndicator=FDCAN_ESI_ACTIVE;//开启错误状态指示
	Txheader_gimbal.BitRateSwitch=FDCAN_BRS_OFF;
	Txheader_gimbal.FDFormat=FDCAN_CLASSIC_CAN;//传统的CAN模式
	//Txheader_gimbal.FDFormat=FDCAN_FD_CAN;//FDCAN模式
	Txheader_gimbal.TxEventFifoControl = FDCAN_NO_TX_EVENTS;//无发送事件
    Txheader_gimbal.MessageMarker = 0;

时间片

不做解析，硬件方面计算出来拿来用即可

使用代码

FilterInit-and-FDCANStart

void FDCAN_IntFilterAndStart(FDCAN_HandleTypeDef *hfdcan) {
    //--------FDCAN1 Filter and Start--------//
    FDCAN_FilterTypeDef sFilterConfig;
    sFilterConfig.IdType = FDCAN_STANDARD_ID;
    sFilterConfig.FilterIndex = 0;
    sFilterConfig.FilterType = FDCAN_FILTER_MASK;
    sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
    sFilterConfig.FilterID1 = 0x00;//0x500;
    sFilterConfig.FilterID2 = 0x00;//0x780;
    if (HAL_FDCAN_ConfigFilter(hfdcan, &sFilterConfig) != HAL_OK)
    {
        FDCAN_ErrorHandler();
    }
    if (HAL_FDCAN_ConfigGlobalFilter(hfdcan, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE) != HAL_OK)
    {
        FDCAN_ErrorHandler();
    }
    if (HAL_FDCAN_Start(hfdcan) != HAL_OK)
    {
        FDCAN_ErrorHandler();
    }
    if (HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0) != HAL_OK)
    {
        FDCAN_ErrorHandler();
    }
    if (HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_BUS_OFF, 0) != HAL_OK)
    {
        FDCAN_ErrorHandler();
    }
}

解析一下

`1`	`if (HAL_FDCAN_ConfigGlobalFilter(hfdcan, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE) != HAL_OK)`

HAL_FDCAN_ConfigGlobalFilter用于定义未被任何特定过滤器匹配的帧的处理规则，参数含义如下：

第 2 个参数（FDCAN_REJECT）：未匹配的标准帧被 “拒绝”（不接收）；
第 3 个参数（FDCAN_REJECT）：未匹配的扩展帧被 “拒绝”（不接收）；
第 4 个参数（FDCAN_FILTER_REMOTE）：未匹配的标准远程帧被 “拒绝”；
第 5 个参数（FDCAN_FILTER_REMOTE）：未匹配的扩展远程帧被 “拒绝”。结合前面的过滤器配置（所有标准帧都被第 0 号过滤器匹配），这里的全局规则实际效果是：
所有标准帧被第 0 号过滤器接收（存入 FIFO0）；
扩展帧、远程帧（无论标准还是扩展）因未被匹配，全部被拒绝。

数据发送

如果需要兼容CAN，将FDFormat修改为FDCAN_CLASSIC_CAN即可

void FDCAN_InitTxHander(FDCAN_TxHeaderTypeDef* pheader, uint32_t id, uint32_t dlc,uint32_t baudrateswitch,uint32_t can_type){
    pheader->Identifier = id;
    if(id>=0x800) {
	    pheader->IdType = FDCAN_EXTENDED_ID;
    }
    else {
	    pheader->IdType =   FDCAN_STANDARD_ID;
    }
    pheader->TxFrameType =  FDCAN_DATA_FRAME;
    pheader->DataLength = dlc;
    pheader->ErrorStateIndicator = FDCAN_ESI_ACTIVE;//开启错误状态指示
    pheader->BitRateSwitch =  baudrateswitch;
    pheader->FDFormat = can_type;
    pheader->TxEventFifoControl = FDCAN_NO_TX_EVENTS;
    pheader->MessageMarker = 0;
}

void FDCAN_SendMessageWithBaudSwitch(FDCAN_HandleTypeDef *hfdcan,uint8_t* pdata,uint32_t dlc,uint32_t id)
{
    FDCAN_TxHeaderTypeDef txhead;
    FDCAN_InitTxHander(&txhead,id,dlc,FDCAN_BRS_ON,FDCAN_FD_CAN);
    HAL_FDCAN_AddMessageToTxFifoQ(hfdcan, &txhead, pdata);
}

void FDCAN_SendMessageWithOutBaudSwitch(FDCAN_HandleTypeDef *hfdcan,uint8_t* pdata,uint32_t dlc,uint32_t id)
{
    FDCAN_TxHeaderTypeDef txhead;
    FDCAN_InitTxHander(&txhead,id,dlc,FDCAN_BRS_OFF,FDCAN_CLASSIC_CAN);
    HAL_FDCAN_AddMessageToTxFifoQ(hfdcan, &txhead, pdata);
    if(HAL_FDCAN_AddMessageToTxFifoQ(hfdcan, &txhead, pdata)!=HAL_OK) {
        FDCAN_ErrorHandler();
    }
}

数据接收

uint8_t RxData[64];
void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)
{
    if((RxFifo0ITs & FDCAN_IT_RX_FIFO0_NEW_MESSAGE)!=RESET)//判断是否是新消息中断
    {
        if(hfdcan->Instance == FDCAN1) //Slave Arm
        {
            HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO0, &RxHeader, RxData);
            //...
        }
    }

}

CAN

Cube配置

模式设置（Mode）

Normal mode（正常模式）：正常发送和接收帧，用于实际总线通信
Loopback mode（回环模式）：发送的帧会被自身接收，无需外部总线，用于调试
Silent mode（静默模式）：只能接收帧，不能发送，用于监听总线
Silent Loopback mode（静默回环模式）：结合静默和回环，仅内部测试

波特率

$$波特率 = APB时钟频率 / [ Prescaler × (1 + TimeSeg1 + TimeSeg2) ]$$

CAN 的波特率由位时间（Bit Time） 决定，位时间 = 1 / 波特率（如 1Mbps 对应位时间 1μs）。位时间由 3 部分组成：

Prescaler（预分频器）：将 APB 时钟（如 APB1=36MHz）分频为时间量子（TQ），公式：TQ = 1/(APB时钟频率 / Prescaler)
Sync Jump Width (SJW)：同步跳转宽度，用于补偿节点间时钟偏差，取值 1~4TQ（通常设为 1 或 2）
Time Seg1：包含传播段（PropSeg）和相位段 1（PS1），取值 4~16TQ（用于补偿总线延迟）
Time Seg2：相位段 2（PS2），取值 2~8TQ（用于同步补偿）

Basic-Parameters

Time Triggered Communication（时间触发通信）

Automatic Bus-Off Management（自动总线关闭管理）当节点因错误计数超限进入 “总线关闭” 状态（无法发送和接收帧）时，是否需要软件手动恢复，还是控制器自动恢复

Automatic WakeUP mode（自动唤醒模式）是一种针对低功耗场景的功能，用于让 CAN 控制器在休眠（低功耗）状态下，通过检测总线上的有效活动（如特定 CAN 帧）自动恢复到正常工作状态，无需软件手动触发唤醒

Automatic Retransmission（自动重传）

Receive FIFO Locked Mode（接收 FIFO 锁定模式）当接收 FIFO（CAN 通常有 2 个接收 FIFO，FIFO0 和 FIFO1）存储的帧数量达到最大深度（如 3 个或 6 个，依芯片型号而定）时，新接收的帧是否覆盖旧的帧

Transmit FIFO Priority（发送 FIFO 优先级）当发送 FIFO（CAN 通常有 1 个发送 FIFO，可存储多个待发送帧）中有多个帧等待发送时，帧的发送顺序规则

使用代码

FilterInit-and-FDCANStart

void CAN_Config(void)
{
  CAN_FilterTypeDef  sFilterConfig;
  /* Configure the CAN Filter */
  sFilterConfig.FilterBank = 0;                      // 过滤器编号，使用一个CAN，则可选0-13；使用两个CAN可选0-27
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;  // 过滤器模式，掩码模式或列表模式
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽
  sFilterConfig.FilterIdHigh = 0x0000;               // 过滤器验证码ID高16位，0-0xFFFF
  sFilterConfig.FilterIdLow = 0x0000;                // 过滤器验证码ID低16位，0-0xFFFF
  sFilterConfig.FilterMaskIdHigh = 0x0000;           // 过滤器掩码ID高16位，0-0xFFFF
  sFilterConfig.FilterMaskIdLow = 0x0000;            // 过滤器掩码ID低16位，0-0xFFFF
  sFilterConfig.FilterFIFOAssignment = CAN_FilterFIFO0; // FIFOx，0或1
  sFilterConfig.FilterActivation = ENABLE;           // 使能过滤器
  sFilterConfig.SlaveStartFilterBank = 14;           // 从过滤器编号，0-27，对于单CAN实例该参数没有意义
  if (HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
  {
    /* Filter configuration Error */
  }
  /* Start the CAN peripheral */
  if (HAL_CAN_Start(&hcan1) != HAL_OK)
  {
    /* Start Error */
  }
  /* Activate CAN RX notification */
  if (HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING) != HAL_OK)
  {
    /* Notification Error */

  }
}

发送

uint8_t CAN_Send_Msg(uint16_t output , uint8_t len)
{
  uint8_t message[8];
  uint32_t TxMailbox;
  CAN_TxHeaderTypeDef CAN_TxHeader;
  // 设置发送参数
  CAN_TxHeader.StdId = 0x200;                 // 标准标识符(12bit)
  //CAN_TxHeader.ExtId = 0x00;                 // 扩展标识符(29bit)
  CAN_TxHeader.IDE = CAN_ID_STD;             // 使用标准帧
  CAN_TxHeader.RTR = CAN_RTR_DATA;           // 数据帧
  CAN_TxHeader.DLC = 0x08;                    // 发送长度      
  CAN_TxHeader.TransmitGlobalTime = DISABLE;//关闭can的时间触发通信模式
  // 装载数据
  memset(message, 0, sizeof(message));
  message[0] = (output >> 8) & 0xFF;
  message[1] = output & 0xFF;
  // 发送CAN消息
  if(HAL_CAN_AddTxMessage(&hcan1, &CAN_TxHeader, message, &TxMailbox) != HAL_OK)
  {
    return 0;
  }
  return 1;
}

接收

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{// 收到CAN数据会触发接收中断，进入该回调函数
  uint8_t RxData[8];
  CAN_RxHeaderTypeDef CAN_RxHeader;
  if(HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &CAN_RxHeader, RxData) != HAL_OK)
  {
    while(1) {};
  }
  if(hcan==&hcan1) // 只处理CAN1
  {
    // 处理CAN1接收到的数据
    switch (CAN_RxHeader.StdId) // 标准标识符
    {
      case 0x201:
        // 处理ID为0x201的消息
        test_motor.motor_raw_angle = (RxData[0] << 8) | RxData[1];
        test_motor.motor_angle = (float)test_motor.motor_raw_angle/8191.f*360.f;
        test_motor.motor_speed = (RxData[2] << 8) | RxData[3];
        test_motor.motor_current = (RxData[4] << 8) | RxData[5];
        test_motor.temp = RxData[6];
        break;
      default:
        break;
    }
  }
}

定时器（系统学习）

【STM32】HAL库 STM32CubeMX教程七—PWM输出(呼吸灯)_stm32 hal pwm-CSDN博客

STM32CubeIde中互补PWM配置项的详细解读_ch idle state-CSDN博客

【【STM32入门教程】应该是全B站最好的STM32教程了！！】(https://www.bilibili.com/video/BV12v4y1y7uV?vd_source=5a0790755035f26a67935abfbfcdfd5b)

基于上述博客以及keyskingSTM32教程写的个人学习文档

定时器简介

HAL库开启定时器的基本函数

开启定时器

1
2

HAL_TIM_Base_Start(&htim1);//仅开启定时器
HAL_TIM_Base_Start_IT(&htim1);//开启定时器和中断

1
2

HAL_TIM_Base_Stop(&htim1);//关闭定时器
HAL_TIM_Base_Stop_IT(&htim1);//既关闭定时器，同时关闭中断

框架

解释整个TIM外设的构成

计数信号来源

有内部时钟以及外部时钟

内部时钟模式

在f103c8t6中，TIM1是高级定时器，TIM2，TIM3，TIM4是通用计时器

CubeMX参数配置

Prescaler:预分频，实际分频数是number+1
Counter Mode:计数模式设置
Counter Period:自动重装载计数器计数值
Internal Clock Division:内部时钟预分频
Repetition Counter:重复计数器 (RCR -8 bits)，属于高级控制寄存器专用寄存器位，利用它可以非常容易控制输出 PWM 的个数，与内部时钟模式无关
auto-reload preload:是否开启影子寄存器模式

还需要开启定时器更新中断

代码实现

用的PA2作GPIO输出

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {//中断回调函数
	if( htim == &htim1 ) {
		HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_2);
	}
}

int main(void)
{
  /* USER CODE BEGIN 1 */
  /* USER CODE END 1 */
  /* MCU Configuration--------------------------------------------------------*/
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
  /* USER CODE BEGIN Init */
  /* USER CODE END Init */
  /* Configure the system clock */
  SystemClock_Config();
  /* USER CODE BEGIN SysInit */
  /* USER CODE END SysInit */
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

外部时钟模式

STM32动画讲解定时器外部时钟 & 实战传送带测速装置（B站）

__HAL_GET_COUNTER(&htim)获取计数值

外部时钟模式2

在Clock Source处选择

注意外部时钟的滤波器Clock Filter，输入滤波输入滤波，极性选择，预分频器

采样频率等于内部时钟的频率

一般推荐选择1110（15）

外部时钟模式1

通过定时器的Slave Mode 进行选择启用从模式，选择外部时钟模式1

选择Trigger Source时，就是选择什么方式来外部计数就是选择触发器的来源 TI_ED是双边沿触发，且只能是双边沿触发

使用外部计数ETR

可以在外部时钟模式1下，Trigger Source选择ETR1 芯片上会有引脚被设置为ETR1
直接选择外部时钟模式2，引脚上会自动有一个ETR2

关于定时器的事件更新中断

关于定时器中断（本笔记内）

计数值到达自动重装载值时，触发更新中断在Cube中开启global interrupt

关于MX_TIM2_Init()启动时会将中断标志位置1

在MX_TIM2_Init()时，会将定时器更新中断标志位置1，在调用HAL_TIM_Base_Start_IT后，NVIC会检测到更新中断标志位被置1，会立马触发中断

在HAL_TIM_Base_Start_IT前选择下面两个函数其中一个写上即可

事件更新中断的逻辑

先是NVIC中断向量表查找到TIM2_IRQhandler，在该函数中，调用了HAL_TIM_IRQhandler函数其中的事件更新处理的代码(HAL库中HAL_TIM_IRQHandler中的处理事件更新中断的代码) 判断标志位，判断是否开启事件更新中断，清零标志位，调用HAL_TIM_PeriodElapsedCallback函数

定时器的从模式

STM32一看就懂的定时器从模式讲解（B站）

定时器从模式

Reset Mode 复位模式
Gate Mode 门模式
Trigger Mode 触发模式

复位模式

设定为复位模式时

选取计数信号，计数信号可以时内部时钟，也可以是外部时钟模式2（不是从模式控制器下外部时钟模式1）
触发器的信号，每出现一次，执行一次复位操作（向上计数模式恢复为0，向下计数模式恢复为自动重装载值）例子：选取计数信号为内部时钟，计数器不断计数，当触发器信号来临时（TI1的TIFP1检测到信号上升沿），则触发一次更新事件，计数器值复位

注意：如果开启定时器的事件更新中断，触发器信号也会触发事件更新中断

复位模式下的从模式控制器，在接收到触发信号后，就会让计数器重新开始计数，并且会触发定时器更新中断

如何判断事件更新中断的产生原因

在复位模式中，需要区分事件更新中断是触发信号的复位导致还是自动挡重装载时导致

从模式收到触发信号后，会设置触发器中断标志位，可以借此来区分中断原因

使用该函数来获取触发器中断标志位

`1`	`__HAL_TIM_GET_FLAG(htim,TIM_FLAG_UPDATE)//可以获取定时器对应标志位的值`

TIM_FLAG_TRIGGER是触发器中断标志位

`1`	`__HAL_TIM_GET_FLAG(htim,TIM_FLAG_TRIGGER)`

使用上述语句可以获取其标志位使用时需要注意，HAL库为了方便我们判断，并不会对该标志位清零，所以在获取标志位的值后，需要对其进行清零

1
2
3

if(__HAL_TIM_GET_FLAG(htim,TIM_FLAG_TRIGGER)==SET) {
	__HAL_TIM_CLEAR_FLAG(htim,TIM_FLAG_TRIGGER);
}

HAL_TIM_PeriodElapsedCallback回调函数

void HAL_TIM_PeriodElapsedCallback( TIM_HandleTypeDef *htim ) {
	if( htim == &htim2 ) {
		if( __HAL_TIM_GET_FLAG(htim,TIM_FLAG_TRIGGER) == SET ) {//获取触发标志位，用来区分复位引起的中断还是自动重装载引起的中断
		__HAL_TIM_CLEAR_FLAG(htim,TIM_FLAG_TRIGGER);
		HAL_UART_Transmit( &huart2 , (uint8_t*)triggerMsg , strlen(triggerMsg) , 100 );
		}
		else {
			HAL_UART_Transmit( &huart2 , (uint8_t*)updateMsg , strlen(updateMsg) , 100 );
		}
	}
}

关于MX_TIM2_Init()启动时会将中断标志位置1

在MX_TIM2_Init()时，会将定时器更新中断标志位置1，在调用HAL_TIM_Base_Start_IT后，NVIC会检测到更新中断标志位被置1，会立马触发中断

在HAL_TIM_Base_Start_IT前选择下面两个函数其中一个写上即可

事件更新中断的逻辑

先是NVIC中断向量表查找到TIM2_IRQhandler，在该函数中，调用了HAL_TIM2_IRQhandler函数其中的事件更新处理处的代码(HAL库中HAL_TIM_IRQHandler中的处理事件更新中断的代码) 判断标志位，判断是否开启事件更新中断，清零标志位，调用HAL_TIM_PeriodElapsedCallback函数

门模式

如果TI1的TI1FP1为上升沿检测，则是当触发信号是高电平时，时钟信号可以正常进入定时器，定时器能正常计数当触发信号时低电平时，门关闭，时钟信号不能正常进入定时器，定时器停止计数若将触发器的极性改为检测下降沿的话，门的控制作用则相反触发器的极性选择

需要注意，在门模式情况下，上升下降沿的时刻，也会将触发器中断标志位置1，但是不会触发事件更新中断（因为没有对计数值进行复位，就不会触发事件更新中断）

触发模式

在检测到设定的边沿后，让定时器开始计数开始后不能设定停止触发模式仅能启动定时器，并不能停止计数器计数

一般配合计时器的单脉冲模式使用单脉冲模式，是指计数器计数到重装载计数值后，就停止计数（不再循环计数）

一般需要勾选单脉冲模式

三种模式的总结

Trigger Source 触发源的滤波器设置

在有触发源的时候，对触发源的信号的滤波设置

定时器的输入捕获

软件层面上的模拟

在软件层面检测Echo端的电平高低，进行计时，到那时再极高精度要求的情况则力不足

输入捕获的概括

硬件在检测到上升或者下降沿时，就记录计数器值到捕获寄存器

输入捕获的运行机制

在TI1检测到上升沿时，捕获寄存器立即复制计数器的值还可以开启输入捕获中断，输入捕获后，启动中断，可以快速处理捕获寄存器上的值

一个通道只能进行一种边沿检测捕获的模式

注意：TI3和TI4没有接入从模式控制器中

TI1和TI2是一对，可以相互借用 TI3和TI4是一对，可以相互借用

Cube上的配置

注意设置边沿检测

打开捕获中断

启动，该例子中是需要在CHANNEL4捕获到后进行处理，所以CHANNEL44开启了中断输入捕获的开启

可能遇到的问题

用SET_COUNTER来清零一下

中断回调函数

`1`	`HAL_TIM_IC_CaptureCallback(htim);`

回调函数的代码编写判断是否是TIM1，判断是否是TIM1的4通道（HAL_TIM_ACTIVE_CHANNEL_4）再读取指定寄存器的值

定时器的输出比较模式

较为鸡肋，对这些模式能理解其行为即可

定时器的PWM

【STM32】HAL库 STM32CubeMX教程七—PWM输出(呼吸灯)_stm32 hal pwm-CSDN博客

STM32CubeIde中互补PWM配置项的详细解读_ch idle state-CSDN博客

PWM

脉冲宽度调制，用数字信号去模拟模拟信号

PWM模式

PWM模式1 是计数器值小于比较器值时输出有效电平
PWM模式2 是计数器值大于比较器值时输出有效电平

Cube配置

为实现一个呼吸灯，进行以下配置 PWM的频率为1000Hz，最大计数值为1000-1

基础时钟配置

预分频器值，计数模式选择（向上计数模式，向下计数模式，中央对齐模式），自动重装载值，内部时钟分频，重复计数器值，是否开启影子寄存器

PWM配置

Mode：选择PWM模式
Pulse：设置比较寄存器的值
Output compare preload：是否开启影子寄存器
Fast Mode：是否需要输出非常高频的PWM信号
CH Polarity：设置有效电平极性
CH Idle State：空闲时，PWM通道的输出

HAL库PWM常用函数

1
2
3

HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_1);//开启PWM
HAL_TIM_PWM_Stop(&htim1,TIM_CHANNEL_1);//关闭PWM
__HAL_TIM_SET_COMPARE(&htim1,TIM_CHANNEL_1,num);//设置比较寄存器的值

使用PWM控制流水灯 PWM的频率为1000Hz，最大计数值为1000-1

int main(void)
{
  /* USER CODE BEGIN 1 */
  /* USER CODE END 1 */
  /* MCU Configuration--------------------------------------------------------*/
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
  /* USER CODE BEGIN Init */
  /* USER CODE END Init */
  /* Configure the system clock */
  SystemClock_Config();
  /* USER CODE BEGIN SysInit */
  /* USER CODE END SysInit */
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_1);
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		for( int i = 0 ; i < 1000 ; ++ i ) {
			__HAL_TIM_SET_COMPARE(&htim1,TIM_CHANNEL_1,i);
			HAL_Delay(1);
		}
		for( int i = 1000-1 ; i >= 0 ; -- i ) {
			__HAL_TIM_SET_COMPARE(&htim1,TIM_CHANNEL_1,i);
			HAL_Delay(1);
		}
    /* USER CODE END WHILE */
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

编码器的使用

（给我自己看的） STM32CubeMX笔记（10）–定时器TIM4的Encoder Mode（编码器模式）使用-CSDN博客

UART、DMA与空闲中断（综合）

（stm32之HAL库）UART工作在DMA模式要打开串口中断吗？_hal uart dma-CSDN博客

10 通用同步异步收发器（USART） - 知乎

串口简介

串口是串行接口的简称常用串口：RS232,RS485,USB(Universal Serial Bus)通用串行接口,TTL串口 TTL是Transistor-Transistor Logic的简写，是一种电平逻辑，晶体管-晶体管逻辑

USART简介

USART，即通用同步/异步收发传输器（Universal Asynchronous Receiver/Transmitter)，是单片机上的一个外设

UART遵循异步串行通信协议的，USART遵循同步串行通信协议异步不需要统一时钟信号，同步需要统一时钟信号

一般使用最多的是UART，我们此次学习也是针对UART

UART通信协议

起始位：发出1位低电平信号，表示开始传输字符
数据位：真正发送的数据，一般为8位（1个字节），常采用ASCII编码，从最低位开始发送
校验位：用于检验接收到的数据是否正确，分为奇校验和偶校验
停止位：一组数据的结束传输的标志。可以是1位、1.5位、2位的高电平
空闲位：空闲时数据线为高电平状态，代表无数据传输
波特率：衡量传输速率的指标。UART通信中波特率等于比特率

UART发送/接收机制

UART发送端口，首先是CPU将数据放入数据发送寄存器，然后发送移位寄存器会将数据从数据发送寄存器取出进行移位并通过UART_TX发送出去

UART接收端口，首先是UART_RX接收串行数据至接收移位寄存器，接收移位寄存器将串行数据移位变换为并行数据给数据接收寄存器，再通过APB总线给STM32内部

UART模式

轮询模式 / 中断模式（去重说明）

这两种模式的底层原理与发送/接收时序，前文USART中断章节已经完整展开，此处不再重复。

如果你想快速回看：

轮询模式：CPU持续查询寄存器状态，流程直观但会阻塞。
中断模式：底层按字节触发中断搬运，上层在回调中处理完整数据。

DMA模式

DMA，全称为Direct Memory Access，直接内存访问，本质是将传输数据从一个内存空间搬运至另一个内存空间，可以用来提供外设和内存，内存和外设之间的高速数据传输

DMA模式中也会有中断参与，在Cube配置中需要开启中断

发送

DMA接管“内存 -> 串口寄存器”的搬运，CPU不再逐字节参与发送中转。

接收

DMA接管“串口寄存器 -> 内存”的搬运，CPU主要负责在回调函数里处理数据。

Cube配置解析

基础参数配置

Baud Rate：波特率
Word Length：包含校验位在内的数据包长度
Parity：奇偶校验位
Stop Bits：停止位位数
Data Direction：发送和

NVIC配置

如果使用中断模式，需要在NVIC settings开启USARTi global interrupt

DMA配置

Add：选择添加USARTi_RX的DMA或者USARTi_TX的DMA
Delete：删除对应的DMA
Mode：选择normal模式或者circular模式
Data Byte：数据传输的位数
Increment Address：开启地址自增，外设只有一个寄存器，地址固定，不需要开启地址自增，而内存中我们存数据的变量是数组，接受一字节数据后需要往后移，需要开启地址自增
Priority：优先级设置
Direction：方向，固定死的

GPIO配置

一般用来查看引脚的GPIO配置，不需要更改（有特殊需求时，可以按需修改）在GPIO Settings处可以查看TX和RX的GPIO引脚配置，此处可以看到RX为输入模式，无上拉无下拉

HAL库UART常用函数

轮询模式

1
2

HAL_UART_Receive(&huart1, rxBuffer, 16 , HAL_MAX_DELAY);//接收
HAL_UART_Transmit(&huart1 , txBuffer , sizeof(txBuffer) , 100 );//发送

中断模式

只能接收一次，接收完成后需要再次开启

HAL_UART_Receive_IT(&huart1, rxBuffer, 16 );//接收
HAL_UART_Transmit_IT(&huart1 , txBuffer , sizeof(txBuffer) );//发送

//回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {

}

DMA模式

（stm32之HAL库）UART工作在DMA模式要打开串口中断吗？hal uart dma-CSDN博客

HAL_UART_Receive_DMA(&huart1, rxBuffer, 16 );//接收
HAL_UART_Transmit_DMA(&huart1 , txBuffer , sizeof(txBuffer) );//发送

//回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {

}

HAL库中使用的HAL_UART_Transmit_DMA，HAL_UART_Receive_DMA等都有中断的参与，需要在Cube中开启中断

Demo

接收定长数据Nomad_violet，同时在主函数中翻转小灯

轮询实现数据收发

Cube配置

模式选择为异步

波特率选择115200 Bit/s，其余不动即可

将PA8配置为GPIO_Output

GPIO配置保持默认即可

代码实现


#include "string.h"

#define rxBufferLen 16
#define txBufferLen 25
uint8_t rxBuffer[rxBufferLen] ;
uint8_t txBuffer[txBufferLen] = "to feel,to experience ";// 去感受，去经历「感其生，历其境」

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  while (1)
  {
    HAL_UART_Receive(&huart1, rxBuffer, 12 , HAL_MAX_DELAY);//只能接收定长数据
		if( !strcmp( (char *)rxBuffer , "Nomad_violet" ) ) {//Nomad_violet 12字节
			HAL_UART_Transmit(&huart1 , txBuffer , sizeof(txBuffer) , 100 );
		}
	HAL_GPIO_TogglePin(GPIOA , GPIO_PIN_8 );
  }
}

中断实现数据收发

Cube配置

配置同上，只需额外开启中断即可

代码实现


#include "string.h"

#define rxBufferLen 12
#define txBufferLen 25
uint8_t rxBuffer[rxBufferLen] ;
uint8_t txBuffer[txBufferLen] = "to feel,to experience ";// 去感受，去经历「感其生，历其境」

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
	if(huart == &huart1) {
		if( !strcmp( (char *)rxBuffer , "Nomad_violet" ) ) {
			HAL_UART_Transmit(&huart1 , txBuffer , sizeof(txBuffer) , 100 );
		}
		HAL_UART_Receive_IT(&huart1, rxBuffer, rxBufferLen );
	}
}


int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();
	HAL_UART_Receive_IT(&huart1, rxBuffer, rxBufferLen );
  while (1)
  {
		HAL_GPIO_TogglePin(GPIOA , GPIO_PIN_8 );
	    HAL_Delay(500); 
  }
}

【STM32】 DMA原理，步骤超细详解，一文看懂DMA-CSDN博客（非常详细）

STM32CubeIDE HAL库DMA与UART不定长数据接收实现：空闲中断详解-物联沃-IOTWORD物联网

HAL库串口空闲中断+DMA接收不定长数据详解及踩坑_hal库串口空闲中断-CSDN博客

（stm32之HAL库）UART工作在DMA模式要打开串口中断吗？hal uart dma-CSDN博客

（写的非常好，非常有助于提升底层理解）

DMA（补充）

说明：本节是 DMA 原理与细节补充，和上文“UART、DMA与空闲中断（综合）”互为补充。

在HAL库中直接使用的HAL_UART_Transmit_DMA，HAL_UART_Receive_DMA，HAL_UARTEx_ReceiveToIdle_DMA等都有中断的参与，需要在Cube中开启中断

对具体底层原理和DMA模式实现底层与中断模式底层实现区别感兴趣可参考以下博客（stm32之HAL库）UART工作在DMA模式要打开串口中断吗？_hal uart dma-CSDN博客

USART发送

轮询/中断下的发送机制前文已讲，这里只保留 DMA 发送新增的关键点。

USART的DMA发送

没有DMA的话，CPU会作为数据发送的中转站，而使用DMA的话，整个数据传输过程不需要CPU的参与，由DMA代理执行，DMA负责将内存数据搬运至外设的传输寄存器

在整个数据发送过半时会触发一个传输过半中断，所有数据传输完成后会调用传输完成中断回调函数（HAL_UART_TxCpltCallback）

`1`	`HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef huart, const uint8_t pData, uint16_t Size)`

HAL_UART_Transmit_DMA的传输完成中断回调函数HAL_UART_TxCpltCallback以及传输过半中断回调函数HAL_UART_TxHalfCpltCallback（这两个回调函数在HAL_UART_Transmit_IT中同样有）

DMA发送注意事项

在传输的过程中，当传输一半的数据后，半传输标志(HTIF)被置1，当设置了允许半传输中断位(HTIE)时，将产生一个中断请求。在数据传输结束后，传输完成标志(TCIF)被置1，当设置了允许传输完成中断位 (TCIE)时，将产生一个中断请求

会触发的三个中断，传输完成中断，传输过半中断，错误中断在stm32f1xx_hal_uart.c的HAL_UART_Transmit_DMA函数中可以查看到

HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, const uint8_t *pData, uint16_t Size)  
{  
	  .
	  .
	  .
    /* Set the UART DMA transfer complete callback */  
    huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;  

    /* Set the UART DMA Half transfer complete callback */  
    huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;  

    /* Set the DMA error callback */  
    huart->hdmatx->XferErrorCallback = UART_DMAError; 
	  .
	  .
	  .
  }  
}

USART接收

轮询/中断下的接收机制前文已讲，这里只保留 DMA 接收新增的关键点。

USART的DMA接收

没有DMA的话，CPU会作为数据转运的中转站，而使用DMA的话，整个数据转运过程不需要CPU的参与，由DMA代理执行

在整个数据接收过半时会触发一个传输过半中断，所有数据接收完成后会调用传输完成中断回调函数（HAL_UART_RxCpltCallback）

`1`	`HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef huart, const uint8_t pData, uint16_t Size)`

HAL_UART_Receive_DMA的接收完成中断回调函数HAL_UART_RxCpltCallback以及接收过半中断回调函数HAL_UART_RxHalfCpltCallback（这两个回调函数在HAL_UART_Receive_IT中同样有）

DMA接收注意事项

同DMA发送，类比即可

HAL库USART使用DMA（补充）

说明：本节聚焦 HAL API 视角，示例与上文综合章节可交叉阅读。

如果USART串口的DMA出现错误，会调用HAL_UART_ErrorCallback

DMA发送

`1`	`HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef huart, const uint8_t pData, uint16_t Size)`

会触发中断，对应回调函数为

HAL_UART_TxCpltCallback
HAL_UART_TxHalfCpltCallback

DMA接收

`1`	`HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef huart, const uint8_t pData, uint16_t Size)`

会触发的中断，对应的回调函数为

HAL_UART_RxCpltCallback
HAL_UART_RxHalfCpltCallback

DMA模式

normal模式

以接收为例单次接收，接收至数据上限，完成整个固定数据接收后停止，再次接收需要再次开启HAL_UART_Receive_DMA ，需要软件显式重启，触发接收过半和接收完成中断

总结：单次传输，完成后停止，需要软件显式重启，接收过半和接收完成中断

circular模式

以接收为例无限循环，接收至数据上限一半，触发接收过半中断，接受至数据上限，触发接收完成中断，同时会硬件自动重启，接收完成中断会调用对应的接收完成中断回调函数

总结：无限循环，硬件自动重启，接收过半和接收完成中断

空闲中断

空闲中断定义

空闲中断（IDLE Interrupt） 是UART通信中的一种特殊中断类型，它在检测到UART接收线路连续空闲超过1个字节传输时间时触发的中断。“空闲"指线路保持逻辑1状态（高电平），线上无数据传输

HAL库自带的空闲中断实现

使用的是HAL库提供的拓展函数，同时都需要在Cube中开启中断

1
2

//在阻塞模式下接收一定数量的数据，直到接收到预期数量的数据或发生空闲事件。 
HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint16_t *RxLen, uint32_t Timeout);

1
2

//在中断模式下接收一定数量的数据，直到接收到预期数量的数据或发生空闲事件。 
HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);

1
2

//在DMA模式下接收一定数量的数据，直到接收到预期数量的数据或发生空闲事件。 
HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);

1
2

//使用空闲中断时的接收回调函数 
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size);

在触发空闲中断，接收完成中断都会调用HAL_UARTEx_RxEventCallback回调函数，需要注意的是在F103c8t6单片机以及其他st系列单片机上，使用HAL_UARTEx_ReceiveToIdle_DMA时，接收过半中断也会去调用该回调函数

接收过半中断的处理

STM32CubeIDE HAL库DMA与UART不定长数据接收实现：空闲中断详解-物联沃-IOTWORD物联网 HAL_UARTEx_ReceiveToIdle_DMA会调用UART_Start_Receive_DMA(huart, pData, Size)函数，该函数会把DMA中断传输完成，半传输，传输错误全部开启

`1`	`__HAL_DMA_ENABLE_IT(DMA_IT_TC \| DMA_IT_HC \| DMA_IT_TE)`

UART_Start_Receive_DMA(huart, pData, Size) 设置接收数组缓存到达数组一半时会执行下面的回调函数

1
2

/* Set the UART DMA Half transfer complete callback */  
  huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;

在DMA的中断处理函数中，会调用huart->hdmarx->XferHalfCpltCallback，此处即UART_DMARxHalfCplt

void HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma)
{
  uint32_t flag_it = hdma->DmaBaseAddress->ISR;
  uint32_t source_it = hdma->Instance->CCR;

  /* Half Transfer Complete Interrupt management ******************************/
  if (((flag_it & (DMA_FLAG_HT1 << hdma->ChannelIndex)) != RESET) && ((source_it & DMA_IT_HT) != RESET))
  {
   ......
    if(hdma->XferHalfCpltCallback != NULL)
    {
      /* Half transfer callback */
      hdma->XferHalfCpltCallback(hdma);
    }
    ......
  }
  ......
}

而UART_DMARxHalfCplt会调用HAL_UARTEx_RxEventCallback

static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)  
{  
  UART_HandleTypeDef *huart = (UART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;  

  /* Initialize type of RxEvent that correspond to RxEvent callback execution;  
     In this case, Rx Event type is Half Transfer */
     huart->RxEventType = HAL_UART_RXEVENT_HT;  

  /* Check current reception Mode :  
     If Reception till IDLE event has been selected : use Rx Event callback */  if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)  
  {  
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)  
    /*Call registered Rx Event callback*/  
    huart->RxEventCallback(huart, huart->RxXferSize / 2U);  
#else  
    /*Call legacy weak Rx Event callback*/  
    HAL_UARTEx_RxEventCallback(huart, huart->RxXferSize / 2U);  
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */  
  }  
  else  
  {  
    /* In other cases : use Rx Half Complete callback */  
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)  
    /*Call registered Rx Half complete callback*/  
    huart->RxHalfCpltCallback(huart);  
#else  
    /*Call legacy weak Rx Half complete callback*/  
    HAL_UART_RxHalfCpltCallback(huart);  
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */  
  }  
}

为了避免接收过半中断的调用，需要使用下面的语句

`1`	`__HAL_DMA_DISABLE_IT(&hdma_usart1_rx,DMA_IT_HT);//关闭dma接收半满中断函数，这样我们在接收一组数据时就不会触发半满中断，dma就可以正常接收一组数据`

另外在UART_DMAReceiveCplt函数中也调用了HAL_UARTEx_RxEventCallback函数

`1`	`static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)`

DMA+空闲中断的实现接收不定长数据

方式1

自定义DMA+空闲中断

前置内容

需要自己写的宏定义

1
2

#define __HAL_DMA_SET_COUNTERT(__HANDLE__,__COUNTER__)  ((__HANDLE__)->Instance->CNDTR = (uint16_t)(__COUNTER__))
//重新设定计数值

1
2

//用法
__HAL_DMA_SET_COUNTERT(huart->hdmarx,rxBufferLen);

用到的宏定义

1
2

__HAL_DMA_GET_COUNTER(huart->hdmarx)
//获取剩余未传输的计数值

用到的关于中断的操作

__HAL_DMA_DISABLE(huart->hdmarx)//关闭DMA
__HAL_DMA_ENABLE(huart->hdmarx)//开启DMA

//清除空闲标志位
__HAL_UART_CLEAR_IDLEFLAG(&huart1)

//开启空闲中断
__HAL_UART_ENABLE_IT(&huart1 , UART_IT_IDLE )
//关闭空闲中断
__HAL_UART_DISABLE_IT(&huart1, UART_IT_IDLE )

代码实现

1
2
3

#define rxBufferLen 10
uint8_t rxBuffer[rxBufferLen];  
uint8_t txBuffer[rxBufferLen];

void UART_InitDMAReceive() {  
    __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除空闲中断标志位
    __HAL_UART_ENABLE_IT(&huart1 , UART_IT_IDLE );//使能空闲中断  
    HAL_UART_Receive_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);//开启DMA接收
}

需要关闭DMA才能重设DMA的COUNTER

//自定义的DMA空闲中断回调函数
void UART_DMAIdleCallback(UART_HandleTypeDef *huart) {  
    if (huart == &huart1 ) {  
        __HAL_DMA_DISABLE(huart->hdmarx);//失能DMA
        int datalen = rxBufferLen - __HAL_DMA_GET_COUNTER(huart->hdmarx);  
        for(int i=0;i<datalen;i++) {  
            char temp = rxBuffer[i];  
            txBuffer[i] = (temp >= 'a' && temp <= 'z') ? temp-32:temp;
        }  
        HAL_UART_Transmit_DMA(&huart1,(uint8_t*)txBuffer,datalen);  
        __HAL_DMA_SET_COUNTERT(huart->hdmarx,rxBufferLen);//重置DMA计数
        __HAL_DMA_ENABLE(huart->hdmarx);//使能DMA 
    }  

}

void USART1_IRQHandler(void)  
{  
  /* USER CODE BEGIN USART1_IRQn 0 */  

  /* USER CODE END USART1_IRQn 0 */  HAL_UART_IRQHandler(&huart1);  
  /* USER CODE BEGIN USART1_IRQn 1 */ 
  //触发空闲中断后，会进入中断请求处理函数 
    if (__HAL_UART_GET_FLAG(&huart1 , UART_FLAG_IDLE) != RESET ) {//在此判断是否为空闲中断
        __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除空闲中断标志位
        __HAL_UART_DISABLE_IT(&huart1, UART_IT_IDLE);//失能空闲中断
        UART_DMAIdleCallback(&huart1);//调用自定义中断回调函数 
        __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);//使能空闲中断  
    }  

  /* USER CODE END USART1_IRQn 1 */  
}

关于normal和circular在方式1的空闲中断实现的区别

normal模式

在上述空闲中断实现中，如果使用normal模式，需要注意接收的数据一定不能超过rxBufferLen，一旦超过，DMA接收就会终止

执行流程是，触发空闲中断，进入USART1_IRQHandler，再进入自定义空闲中断，在里面重新设置了DMA的计数值（指针也会重新设置，重新指向rxBuffer[0]），最开始开启的HAL_UART_Receive_DMA始终没有接收完完整的数据，就不会关闭，一直接收

但如果接收的数据超过rxBufferLen，会触发接收过半和接收完成中断（对应回调函数没使用，约等于空函数），同时HAL_UART_Receive_DMA会结束，需要软件显式重启

例如：rxBufferlen=10，发送12345678910，会回复1234567891，随后DMA终止，再发送数据无回复

circular模式

在上述空闲中断实现中，如果使用circular模式，则接收的数据可以超过rxBufferLen，超过后，DMA接收会自动重启

执行流程是，触发空闲中断，进入USART1_IRQHandler，再进入自定义空闲中断，在里面重新设置了DMA的计数值（指针也会重新设置，重新指向rxBuffer[0]），就算接收数据超过rxBufferLen，HAL_UART_Receive_DMA也会重新启动

但是需要注意，如果达到rxBufferLen,会触发接收过半和接收完成中断，然后硬件重启，重新回到rxBufferLen[0]的位置读数据，直至发生空闲中断

例如：rxBufferlen=10，发送12345678910，会回复0，随后DMA仍然正常工作

方式2

使用HAL库提供的拓展空闲中断，使用normal模式

该方式下的空闲中断回调函数为HAL_UARTEx_RxEventCallback ，需要注意接收过半中断也会调用HAL_UARTEx_RxEventCallback的问题，在每次开启HAL_UARTEx_ReceiveToIdle_DMA后都需要关闭接收过半中断

`1`	`__HAL_DMA_DISABLE_IT(&hdma_usart1_rx,DMA_IT_HT);//关闭dma接收半满中断函数，这样我们在接收一组数据时就不会触发半满中断，dma就可以正常接收一组数据`

注意需要添加

1
2
3

extern UART_HandleTypeDef huart1;
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;

当接收数据超过rxBufferLen时，接收完成中断函数会调用HAL_UARTEx_RxEventCallback回调函数，然后重新开启接收

例如：rxBufferLen=10，接收12345678910，发送1234567891（就是因为接收完成中断导致），后面DMA空闲中断接收正常开启

代码实现

extern UART_HandleTypeDef huart1;
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;

#define rxBufferLen 512
uint8_t rxBuffer[rxBufferLen];
uint8_t txBuffer[rxBufferLen];

void Init_IdleDMA(void) {//初始化，开启DMA空闲中断接收
    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);  
    __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭f103板子DMA的接收过半中断  
}

void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {//接收完成和接收过半，空闲中断都会调用该中断回调函数  
    if (huart == &huart1 ) {  
        memcpy(txBuffer, rxBuffer, Size);  
        HAL_UART_Transmit(&huart1, (uint8_t*)txBuffer, Size,10);  
        HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);//normal模式，接受一次后需要重新开启  
        __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭f103板子DMA的接收过半中断  
    }  
    //Init_IdleDMA();
}

关于normal和circular在方式2下的空闲中断实现的区别

normal模式

方式2中，在数据接收过半，接收完成，空闲时会触发对应中断，最后调用HAL_UARTEx_RxEventCallback回调函数，在回调函数中软件显式重启HAL_UARTEx_ReceiveToIdle_DMA

circular模式

方式2中，若使用circular模式，则数据会一直积累，到达rxBufferLen时，会硬件重启，同时也会有数据接收过半，接收完成，空闲时会触发对应中断，最后调用HAL_UARTEx_RxEventCallback回调函数

例如： (1)关闭接收过半中断 rxBufferLen=10，接收123，发送123，再接收456，发送123456，再接收78910，会先发送1234567891（接收完成），再发送0（空闲中断），再接收111213，发送0111213

(2)未关闭接收过半中断 rxBufferLen=10，接收123，发送123，再接收123，会先发送12312（接收过半中断），再发送123123空闲中断，再接收12345，会先发送1231231234（接收完成中断），再发送5空闲中断

方式3

使用HAL库提供的空闲中断，但是使用circular模式实现

在circuar要想实现一帧一帧不定长数据的接收主要需要考虑的就是如何实现在接收完一帧后让DMA的计数值重置

实现原理

关闭

要实现DMA计数值的重置，需要使用HAL_UART_DMAStop(&huart1)函数将DMA关闭

HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart)  
{  
  uint32_t dmarequest = 0x00U;  
  /* The Lock is not implemented on this API to allow the user application  
     to call the HAL UART API under callbacks HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback():     when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated     and the correspond call back is executed HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback()     */  
  /* Stop UART DMA Tx request if ongoing */  
  dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT);  
  if ((huart->gState == HAL_UART_STATE_BUSY_TX) && dmarequest)  
  {  
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);  

    /* Abort the UART DMA Tx channel */  
    if (huart->hdmatx != NULL)  
    {  
      HAL_DMA_Abort(huart->hdmatx);  
    }  
    UART_EndTxTransfer(huart);  
  }  

  /* Stop UART DMA Rx request if ongoing */  
  dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);  
  if ((huart->RxState == HAL_UART_STATE_BUSY_RX) && dmarequest)  
  {  
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);  

    /* Abort the UART DMA Rx channel */  
    if (huart->hdmarx != NULL)  
    {  
      HAL_DMA_Abort(huart->hdmarx);  
    }  
    UART_EndRxTransfer(huart);  
  }  
  return HAL_OK;  
}

其中会调用HAL_DMA_Abort(huart->hdmatx)，但都不会重置DMA的计数值

开启

在关闭DMA后，需要HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen)重新开启DMA以及空闲中断

在HAL_UARTEx_ReceiveToIdle_DMA中，会进行判断if (huart->RxState == HAL_UART_STATE_READY) ，判断RxState是否为HAL_UART_STATE_READY，如果是，则说明uart没有开启，但是是在预备状态，随后会去调用UART_Start_Receive_DMA(huart, pData, Size)开启uart以及DMA

HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)  
{  
  HAL_StatusTypeDef status;  

  /* Check that a Rx process is not already ongoing */  
  if (huart->RxState == HAL_UART_STATE_READY)  
  {  
    if ((pData == NULL) || (Size == 0U))  
    {  
      return HAL_ERROR;  
    }  

    /* Set Reception type to reception till IDLE Event*/  
    huart->ReceptionType = HAL_UART_RECEPTION_TOIDLE;  
    huart->RxEventType = HAL_UART_RXEVENT_TC;  

    status =  UART_Start_Receive_DMA(huart, pData, Size);  

    /* Check Rx process has been successfully started */  
    if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)  
    {  
      __HAL_UART_CLEAR_IDLEFLAG(huart);  
      ATOMIC_SET_BIT(huart->Instance->CR1, USART_CR1_IDLEIE);  
    }  
    else  
    {  
      /* In case of errors already pending when reception is started,  
         Interrupts may have already been raised and lead to reception abortion.         (Overrun error for instance).         In such case Reception Type has been reset to HAL_UART_RECEPTION_STANDARD. */      status = HAL_ERROR;  
    }  
    return status;  
  }  
  else  
  {  
    return HAL_BUSY;  
  }  
}

在UART_Start_Receive_DMA中会将uart的RxState设置为HAL_UART_STATE_BUSY_RX，中间还会去调用HAL_DMA_Start_IT

HAL_StatusTypeDef UART_Start_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)  
{  
  uint32_t *tmp;  

  huart->pRxBuffPtr = pData;  
  huart->RxXferSize = Size;  

  huart->ErrorCode = HAL_UART_ERROR_NONE;  
  huart->RxState = HAL_UART_STATE_BUSY_RX;

  ......
  HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->DR, *(uint32_t *)tmp, Size);
  ......

}

在HAL_DMA_Start_IT会调用DMA_SetConfig去对DMA计数值等进行重置

HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)  
{
	......
	/* Configure the source, destination address and the data length & clear flags*/
	DMA_SetConfig(hdma, SrcAddress, DstAddress, DataLength);
	......
}

原理总结

1.HAL_UARTEx_ReceiveToIdle_DMA如果判断出huart->RxState == HAL_UART_STATE_READY会调用UART_Start_Receive_DMA

2.UART_Start_Receive_DMA会调用HAL_DMA_Start_IT，同时会将RxState修改为BUSY huart->RxState = HAL_UART_STATE_BUSY_RX

3.HAL_DMA_Start_IT会调用DMA_SetConfig进行DMA计数值等的重置

而使用HAL_UART_DMAStop可以保证在回调函数处理数据时停止DMA接收，保证数据不会被覆盖，同时可以将huart->RxState状态设置为HAL_UART_STATE_READY，随后再次开启DMA空闲中断接收就能重置DMA计数值

从而实现非定长数据的接收

代码实现

同样注意，需要关闭接收过半中断


extern UART_HandleTypeDef huart1;
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;

#define rxBufferLen 512
uint8_t rxBuffer[rxBufferLen];  
uint8_t txBuffer[rxBufferLen];

//初始化
void Init_IdleDMA(void) {  
    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);  
    __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭DMA的接收过半中断  
}

//回调函数
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {//接收完成和接收过半，空闲中断都会调用该中断回调函数  
    if (huart == &huart1 ) {  
        HAL_UART_DMAStop(&huart1);//不会改变DMA的计数值 
        memcpy(txBuffer, rxBuffer, Size);  
        HAL_UART_Transmit(&huart1, (uint8_t*)txBuffer, Size,10);  
        memset(txBuffer, 0, Size);  

        HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);//如果是normal模式，接受一次后需要重新开启，如果关闭了DMA，也需要重新启动  
        __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭f103板子DMA的接收过半中断  
    }  
}

实验检验

我们设置cnt_i去记录HAL_UART_DMAStop(&huart1)前后以及HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen)前后的DMA计数值变化

#define rxBufferLen 512
uint8_t rxBuffer[rxBufferLen];  
uint8_t txBuffer[rxBufferLen];

void Init_IdleDMA(void) {  
    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);  
    __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭DMA的接收过半中断  
}  

void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {//接收完成和接收过半，空闲中断都会调用该中断回调函数  
    if (huart == &huart1 ) {  
        uint32_t cnt_1 = __HAL_DMA_GET_COUNTER(huart1.hdmarx);  

        HAL_UART_DMAStop(&huart1);//不会改变DMA的计数值  
        uint32_t cnt_2 = __HAL_DMA_GET_COUNTER(huart1.hdmarx);  

        memcpy(txBuffer, rxBuffer, Size);  
        HAL_UART_Transmit(&huart1, (uint8_t*)txBuffer, Size,10);  
        memset(txBuffer, 0, Size);  

        HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);//如果是normal模式，接受一次后需要重新开启，如果关闭了DMA，也需要重新启动  
        __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭f103板子DMA的接收过半中断  

        uint32_t cnt_3 = __HAL_DMA_GET_COUNTER(huart1.hdmarx);  

        sprintf(txBuffer, "\ncnt_1=%d cnt_2=%d cnt_3=%d\n", cnt_1,cnt_2,cnt_3);  
        HAL_UART_Transmit(&huart1, (uint8_t*)txBuffer, sizeof(txBuffer), 10);  

    }  
}

实验结果

输入：123456789101112131415161718192021

输出：123456789101112131415161718192021  
cnt_1=479 cnt_2=479 cnt_3=512

证明我们在重启DMA空闲中断时实现了DMA计数值重置

方式4

再仔细想一想，在circuar要想实现一帧一帧不定长数据的接收主要需要考虑的就是如何实现在接收完一帧后让DMA的计数值重置，也就是说没有必要为此使用HAL_UART_DMAStop再重启DMA空闲中断接收

如何优化呢，结合方式1的实现就可以得到答案

1
2
3

__HAL_DMA_DISABLE(huart->hdmarx);//需要关闭DMA才能重设DMA的COUNTER  
__HAL_DMA_SET_COUNTERT(huart->hdmarx,rxBufferLen);
__HAL_DMA_ENABLE(huart->hdmarx);//需要关闭DMA才能重设DMA的COUNTER

代码实现

#define __HAL_DMA_SET_COUNTERT(__HANDLE__,__COUNTER__)  ((__HANDLE__)->Instance->CNDTR = (uint16_t)(__COUNTER__))  
//重新设定计数值  

extern UART_HandleTypeDef huart1;
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;

#define rxBufferLen 512
uint8_t rxBuffer[rxBufferLen];  
uint8_t txBuffer[rxBufferLen];

void Init_IdleDMA(void) {  
    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, (uint8_t*)rxBuffer, rxBufferLen);  
    __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭DMA的接收过半中断  
}

void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {  
    if (huart == &huart1 ) {  
        __HAL_DMA_DISABLE(huart->hdmarx);//需要关闭DMA才能重设DMA的COUNTER  
        __HAL_DMA_SET_COUNTERT(huart->hdmarx,rxBufferLen);  
        memcpy(txBuffer, rxBuffer, Size);  
        HAL_UART_Transmit(&huart1, (uint8_t*)txBuffer, Size,10);  
        __HAL_DMA_ENABLE(huart->hdmarx);//需要关闭DMA才能重设DMA的COUNTER  
    }  
}

常见问题汇总

UART传输

![](Pasted image 20240904161021.png) 易错点，发送数据也需要花费时间，如果没有延时，可能造成rxBuffer先清空，再发送

外设的速度是远远小于单片机代码的执行速度，核心要等待外设执行完动作

STM32F103C8T6 特殊引脚

https://blog.csdn.net/weixin_51462579/article/details/130033153

字符串拼接

`1`	`sprintf(message,"counter: %d", counter);`

按键消抖

此处是检测下降沿，使用的是上拉电平

检测上升沿，下拉电平检测下降沿，上拉电平

FDCAN通信消息队列Fifo已满

硬件速度远远低于单片机执行程序的速度

关于CubeMX的STM32项目创建

在选定创建的文件路径时，一定要保证路径没有中文和空格 尤其注意不要有空格

关于STM32CubeMX更新

在软件内check for updates无法勾选最新版进行更新

解决方法：需要以管理员模式运行

电控成长指南

Wed, 17 Sep 2025 23:37:07 +0800

violet 感其生，历其境

初步入门嵌入式开发后（假定已经会使用Keil和CubeMX进行开发），需要回头补充的基础以及提升，本指南只起到抛砖引玉的作用，对所需知识仅作精简的概述，主要在于帮助构建知识框架

Step1 Keil+CubeMX工具链使用，HAL库使用，基本外设，基本开发常识

开发常识

该部分内容摘自队内文档部分内容

开发环境

开发环境是软件开发过程中使用的软件和硬件的组合。通常情况下包括代码编辑器、编译器、调试工具和其他工具。开发环境帮助程序员编写、测试和调试代码的环境。

IDE集成开发环境

集成开发环境是一种包含代码编辑器、编译器和调试器的综合性软件应用程序。IDE提供了方便编写、测试和调试程序的一体化界面。例如Keil，Clion，RTT Studio，CubeIDE等，本文中主要介绍Keil和Clion

代码编辑器

代码编辑器是用于编写和修改代码的工具。它提供了基本的文本编辑功能，通常还包括语法高亮、代码格式化和错误检查等特性。比如我们所使用的VScode。一般来讲，对于一个项目，代码编辑器的选择通常是无所谓的

关于单片机

单片机是一种微型计算机

单片机（Microcontroller Unit，简称MCU）是一种将微处理器、存储器（包括程序存储器和数据存储器）、输入/输出接口和其他必要的功能模块集成在单个芯片上的微型计算机。它通常用于控制应用，可以在没有外部支持芯片的情况下独立运行。

可以理解为单片机=微处理器+存储器+片上外设

微处理器主要负责运算与控制逻辑的执行
存储器用于存储代码与数据
外设用于实现单片机的各种功能，例如定时器的定时，输入捕获功能，USART的串口通信功能

外设

单片机外设是指用于扩展单片机功能的辅助电路，包括内部外设和外部外设，能够与单片机协同工作，实现各种控制和处理任务

例如定时器TIM和USART就是两个常见的单片机的片上外设定时器可以用来实现定时，PWM调制，输入捕获等复杂功能 USART可以用来实现同步/异步的串口通信

关于CubeMX

CubeMX本质是代码生成器，图形化嵌入式开发辅助工具，用于快速配置STM32硬件资源并生成初始化代码框架，降低底层开发门槛，通过图形化界面，自动配置好用户所需的外设资源

CubeMX生成的代码与HAL库强绑定

关于HAL库

HAL库（Hardware Abstraction Layer，硬件抽象层）是ST公司为STM32微控制器设计的标准化硬件驱动库。作为嵌入式开发的关键基础设施，其实质是在硬件寄存器与用户应用之间构建了一个抽象接口层，彻底改变了传统嵌入式开发模式

用户只需要关注HAL库提供的抽象层，而不用去关注抽象层之下的外设寄存器操作（这类设计思想很值得借鉴）

HAL库提供统一的接口函数，例如HAL_xxxx_Transmit发送执行函数，xxxxCallback回调函数等

开发范式变为：应用层->HAL库的抽象层->具体硬件平台

下面讨论HAL库，CMSIS协议，以及两者关系

HAL库（Hardware Abstraction Layer 硬件抽象层库）

HAL 库是 STMicroelectronics（意法半导体） 为自家 STM32 系列微控制器（MCU） 量身打造的底层软件库，是 STM32 生态中核心的开发工具之一，基于 ARM 的 CMSIS 标准构建。

CMSIS（Cortex Microcontroller Software Interface Standard）

CMSIS 是 ARM 公司 制定的 行业统一软件接口标准（注意：不是具体的软件库，而是 “规范 / 协议”），面向所有基于 ARM Cortex-M 内核（M0/M0+/M3/M4/M7 等）的微控制器，所有主流 MCU 厂商（ST、NXP、Microchip、TI、瑞萨等）均需遵循该标准。

HAL 库与 CMSIS 的关系

层级关系：CMSIS 是 底层标准，HAL 库是 基于 CMSIS 标准的具体实现——HAL 库的内核操作（如中断配置、Systick 定时器、时钟初始化）完全遵循 CMSIS-Core 规范，外设驱动接口也兼容 CMSIS-Driver 模板。

简单总结：CMSIS 是 “通用接口规则”，HAL 库是 ST 按规则为 STM32 定制的 “工具包”，两者结合既保证了跨平台兼容性，又提升了 STM32 的开发效率。

Step2 工具链的基础认知构建与工具链换新

对于整个工具链的理解，需要建立在对单片机（微型计算机）的基本工作方式有一定认知的基础上

计算机的运行都是基于机器语言，我们编写的C语言程序，最后经过编译得到汇编代码，再经过汇编，得到二进制代码（已经是机器语言，但不可运行），最后经过链接，得到一个能运行于单片机上的可执行程序

同时，还需要提一下的是，在一种计算机环境中运行的编译程序，能编译出在另外一种环境下运行的代码，这个编译过程就叫交叉编译。简单地说，就是在一个平台上生成另一个平台上的可执行代码，嵌入式开发的程序编译就是典型的交叉编译，用到的编译器用被称作交叉编译器

目前队内的开发工具链是VScode/Clion+arm-none-eabi/armclag+CMake+Ninja+Ozone+clangd/intellisence/Clion_LSP（编辑器+编译器+项目构建工具+项目构建的执行工具+烧录器+语法服务支持LSP），个人认为还是相当现代化且高度自定义的

下面简单讲解C语言到机器语言的定义以及编译过程

从C语言到机器语言

机器语言

计算机（包括单片机）是不能直接识别我们所编写的C语言程序。它只能识别机器语言，而机器语言是用二进制代码表示的计算机能直接识别和执行的一种机器指指令系统令的集合

汇编语言

汇编语言是一种用于微处理器、微控制器或其他可编程器件的低级语言。在不同的设备中，汇编语言对应着不同的机器语言指令集。一种汇编语言专用于某种计算机系统结构，而不像许多高级语言，可以在不同系统平台之间移植。汇编语言的主体是汇编指令，汇编语言是二进制指令的文本形式，与指令是一一对应的关系。比如，有一些架构的汇编指令中的加法指令00000011写成汇编语言就是 Add

通俗的理解，汇编语言与对应计算机的架构相关，x86和arm结构的计算机分别有一套对应的汇编指令，而汇编语言是机器语言的文本化表达，例如某一汇编指令中00000011可以简记为Add

高级语言（C&C++&Java等）到机器语言

高级语言到汇编语言需要经过编译，例如 .c文件经过编译后，会生成 .s文件
汇编语言到机器语言需要经过汇编，例如 .s文件经过汇编后，会生成 .o文件

需要注意的是，高级语言具有迁移性，在不同架构的计算机上高级语言是不变的，但是汇编语言对于不同的架构会有不同的指令，这就需要我们选择对应的编译器，例如stm32是arm架构的芯片，在C编译器的选择上需要选择将C语言编译为arm架构汇编语言的编译器，例如armcc，armclang，arm-none-eabi等编译器

所以在嵌入式开发中，需要根据单片机的架构选择对应的编译器

编译原理

C语言编译原理涉及将C语言代码转换为机器语言的过程。这个过程包括预处理、编译、汇编和链接。编译器在这个过程中对源代码进行优化和转换，生成可执行文件，主要包括以下几个阶段：

1. 预处理（Preprocessing）

作用：处理源代码文件中的预处理指令，如#include和#define 过程：替换宏定义，处理条件编译指令，包含头文件内容工具：预处理器，如cpp、armclang

2.编译（Compilation）

作用：将预处理后的源代码转换成汇编语言过程：进行语法分析和语义分析，生成汇编代码工具：编译器，如GCC、armclang

3.汇编（Assembly）

作用：将汇编语言转换成机器语言，即目标代码（Object Code）过程：汇编器将汇编指令转换为机器码工具：汇编器，如as、armasm

4.链接（Linking）

作用：将多个目标代码文件和库文件合并成一个单独的可执行文件

过程：解决外部符号引用，如函数和全局变量合并不同模块中的相同段（如.text，.data）生成最终的可执行文件或库文件工具：链接器，如ld、armlink

编译器与链接器

在整个编译过程中，编译器和链接器是核心组件，一般的环境配置也主要针对这二者展开：

编译器（Compiler）：负责将源代码转换成汇编代码或直接生成目标代码。编译器的高级优化包括循环优化、常数传播、死码删除等 链接器（Linker）：负责将多个目标代码文件整合为一个可执行文件。链接器处理符号解析、重定位等任务

多文件编程

简单来说就是头文件提供声明（就是给编译器说有某一个函数），源文件里面有函数的具体定义/实现

多文件编译时会生成多个二进制文件，链接器会实现重定位后生成唯一的可执行文件（也就是最后实现 main.c能使用usart.c里面的函数）

核心原理：分离式编译与链接

编译链接过程 关键步骤

预处理阶段：处理#include指令，将头文件内容复制到源文件中
编译阶段：将每个.c文件独立编译为目标文件(.o)
链接阶段：合并所有目标文件，解析符号引用，生成可执行文件

作用域与链接属性

1. 存储类说明符

关键字	文件内作用	文件间作用	典型用途
`static`	私有	不可访问	内部辅助函数
`extern`	声明	可访问	全局变量声明
(默认)	定义	可访问	公共函数

2. 作用域控制示例

// module.c
static int internal_counter = 0; // 文件内私有变量
//只有在该文件内的函数才可以访问

void public_function(void) {
    internal_counter++;
}

// header.h
extern int global_variable; // 声明全局变量
//注意，声明不等于定义
// main.c
int global_variable = 10; // 定义全局变量

符号解析与重定位

链接器核心任务

符号解析：将符号引用与符号定义关联
重定位：合并目标文件，调整地址引用

符号类型

符号类型	定义位置	引用位置	链接器处理
强符号	.text/.data	其他文件	必须唯一
弱符号	未初始化全局变量	其他文件	可覆盖
外部引用	未定义	当前文件	需在其它文件找到定义

符号解析示例


// module.c
//需要#include "helper.h"
void helper(void); // 外部引用（未定义）

void public_func(void) {
    helper();
}

// helper.c
void helper(void) { // 强符号定义
    /* 实现 */
}

// main.c
extern void public_func(void); // 外部引用

int main() {
    public_func(); // 链接器解析到module.c中的定义
}

链接器符号表处理

扫描所有目标文件，收集符号定义
构建全局符号表：
- 强符号：记录地址
- 弱符号：标记为可选（weak关键字）
解析引用：
- 找到匹配的强符号
- 或使用弱符号（如果存在）
报告未解析引用错误

总结

在上述内容的基础上，我们可以知道，无论是Clion还是VScode，其本质都还是代码编辑器（虽然Clion内置了编译器），配环境实际上配的都还是对应的编译器（现代的编译器包含了编译器，汇编器，链接器等），如arm-none-eabi的gcc/g++或者是 arm-clang和arm-cc

Step3 C&C++混合编程，CMake&Make&Ninja

C&C++混合编程

核心原理在于C与C++的符号修饰，如何利用extern "C"命令实现C call C++以及C++ call C

【关于C和C++混合编程中编译和链接的问题】https://www.bilibili.com/video/BV1Zm4y1E7nm?vd_source=5a0790755035f26a67935abfbfcdfd5b

extern “c"的用法：c与c++的互相调用 - 青山牧云人 - 博客园 C++–名字修饰_c++的函数名修饰是在哪个阶段进行的-CSDN博客 C/C++ 函数签名与名字修饰（符号修饰）-CSDN博客 C/C++中的 extern 和extern“C“关键字的理解和使用（对比两者的异同）_c extern c-CSDN博客

符号修饰

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

名字修饰（Name Mangling）是一种在编译过程中，将函数、变量的名称重新改编的机制，简单来说就是编译器为了区分各个函数，将函数通过一定算法，重新修饰为一个全局唯一的名称。

由于C++和C的名字修饰规则不同（不同操作系统下的编译器的名字修饰方式也会不同），导致C++可以支持函数重载，而C不支持函数重载

可以简单理解为，c++中支持函数重载，c语言不支持函数重载，这造成了c++和c语言的函数名解析不同（名字修饰/符号修饰）。c语言函数名就是函数名，c++的函数名是函数名+参数组合起来的。

C与C++符号修饰的实例

extern “c"的用法：c与c++的互相调用 - 青山牧云人 - 博客园（直接copy自该博客）

比如，函数void func(double a) 在C和C++中的编译阶段函数名称会被解析成什么呢？

在C语言中，由于没有名称修饰，所以在编译时函数名称仍然是func，不会因为参数类型或数量而改变。

在C++中，由于名称修饰的存在，函数名称在编译阶段会被编译器转换成一个包含函数原型信息的唯一标识符。通常会涉及函数返回类型、参数类型以及参数数量。以GCC(GNU Compiler Collection)为例，func(double a)会被转换成_Z4funcd ，这里：

_Z：是GCC用来表示修饰名称的前缀
4：表示函数名称func的的字符数
d：是double类型的编码

因此，用c++的方式去寻找c语言的符号是无法寻找到的。extern "C"为何可以做到？

extern "C"的作用就是修改了符号表的生成方式，将c++符号的生成方式换成了c的生成方式。

即c库中生成的符号是c编译器的符号，因此c语言可以直接链接。而c++程序需要使用extern "C"让编译器使用c的符号命名方式去进行链接，这样才能找到对应的符号。

extern “C”

C/C++中的 extern 和extern“C“关键字的理解和使用（对比两者的异同）_c extern c-CSDN博客

看这一篇就够了看实例

cpp调用c，cpp编译时会有C++的符号修饰，导致链接C库的函数找不到，需要用extern “C"告诉g++编译器以C语言的风格进行编译
c调用cpp（不涉及C++的类和成员函数），设计一个C的接口，接口的实现在cpp中，接口函数内部去使用C++的特性
c中调用c++成员函数，需要一个接口函数

CMake这一块

CMake是一个C/C++项目构建工具根据CMakeLists.txt来构建makefile/ninja文件，再根据makefile/ninja文件来编译C和C++文件并生成可执行文件

只需要理解在命令行使用g++ 进行多文件编译时，每次输入都需要输入一大堆的文件，非常麻烦使用CMake+make/ninja进行简化操作即可（个人认为的CMake的一个核心思想（极简化理解））

层级关系

开发者层：编写CMakeLists.txt定义构建规则
生成器层：CMake解析配置，生成底层构建文件
执行器层：Make/Ninja执行具体构建命令
工具链层：编译器(如gcc)、链接器等实际执行编译

cmake

cmake是一个生成 .ninja 和 .makefile 的工具。cmake只需要用户通过对源码文件的简单描述（就是CMakeLists.txt文件），就能自动生成一个project的makefile文件或者ninja文件，然后就可以通过ninja或者make进行启动编译了，很多IDE都在用cmake作为项目管理工具。

make与ninja

make功能强大，可以给人看，ninja启动速度快，项目构建速度快，但不是给人看的
可以认为两者同级。

Step4 C++提升&设计模式

这一节也是本人极其欠缺的，目前正在恶补

C++的提升推荐C&C++ 系统学习（自荐这一块儿）

设计模式推荐：暂无

C++提升

内存对齐

一文轻松理解内存对齐 - 知乎这里仅以结构体的内存对齐为例，不提供具体例子，具体例子详见上面的博客

结构体（struct）对齐

规则 1：成员地址 = min(自身对齐值, 有效对齐值) 的倍数

规则 2：结构体总大小 = 最大成员对齐值的整数倍

规则 3：成员排列顺序影响最终大小

#pragma pack(1)//设置默认对齐数为1
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

int main()
{
	//输出的结果是什么？
	printf("%d\n", sizeof(struct S1));
	
	return 0;
}

#pragma pack(push, 1)//设置默认对齐数为1
struct MyStruct { 
	char a; 
	int b; 
	double c; 
	}; 
#pragma pack(pop)//取消设置的默认对齐数，还原为默认

struct MyStruct { 
	char a; 
	int b; 
	double c; 
} __attribute__((packed));

深拷贝与浅拷贝

1. 浅拷贝（Shallow Copy）

原理：仅复制对象的成员值（包括指针的值），不复制指针指向的实际资源。
结果：原对象和拷贝对象的指针成员指向同一块内存地址。

class Shallow {
public:
    int* data;
    
    Shallow(int d) {
        data = new int(d);  // 分配堆内存
    }
    
    // 编译器生成的默认拷贝构造函数（浅拷贝）
    Shallow(const Shallow& other) : data(other.data) {} 
    
    ~Shallow() { delete data; }
};

// 使用示例
Shallow obj1(10);
Shallow obj2 = obj1;  // 浅拷贝：obj2.data 指向 obj1.data 的内存

*obj1.data = 20;      // 修改 obj1
cout << *obj2.data;   // 输出 20（obj2 也被修改）

// main结束时：obj2 和 obj1 会先后调用析构函数
// 导致同一内存被 delete 两次 → 程序崩溃！

浅拷贝的核心问题：

悬空指针：一个对象释放资源后，另一个对象的指针失效
重复释放：多个对象尝试释放同一块内存 → 崩溃
数据篡改：通过一个对象修改数据会影响其他对象

2. 深拷贝（Deep Copy）

主要用于拷贝构造函数，赋值运算符原理：不仅复制对象成员，还复制指针指向的资源。
结果：原对象和拷贝对象拥有完全独立的资源副本。

class Deep {
public:
    int* data;
    
    Deep(int d) {
        data = new int(d);
    }
    
    // 自定义拷贝构造函数（深拷贝）
    Deep(const Deep& other) {
        data = new int(*other.data);  // 关键：分配新内存并复制值
    }
    
    // 深拷贝赋值运算符
    Deep& operator=(const Deep& other) {
        if (this != &other) {  // 防止自赋值
            delete data;              // 释放原有资源
            data = new int(*other.data);  // 创建新副本
        }
        return *this;
    }
    
    ~Deep() { delete data; }
};

// 使用示例
Deep obj1(10);
Deep obj2 = obj1;  // 深拷贝：obj2 拥有独立的内存副本

*obj1.data = 20;   // 修改 obj1
cout << *obj2.data; // 输出 10（obj2 不受影响）

// 析构时各自释放独立内存 → 安全

深拷贝的核心优势：

资源独立：每个对象拥有自己的资源副本
安全析构：不会发生重复释放
数据隔离：修改一个对象不影响其他对象

构造函数&拷贝构造函数&赋值运算符

大疆C++一面：C++什么时候生成默认拷贝构造函数？

1.构造函数

用于初始化对象的特殊成员函数，与类同名，无返回值

可重载，支持默认参数
若未显式定义，编译器生成默认构造函数
对象创建时自动调用

```cpp
class Point {
private:
    int x, y;
public:
    // 1. 默认构造函数
    Point() : x(0), y(0) {}
    
    // 2. 带参数构造函数
    Point(int x_val, int y_val) : x(x_val), y(y_val) {}
    
};

// 使用
Point p1;           // 调用默认构造函数
Point p2(3, 4);     // 调用带参数构造函数

2.拷贝构造函数

用已有对象初始化新对象时调用的特殊构造函数，注意与赋值运算符区分

参数为同类对象的 const 引用
若未显式定义，编译器生成默认拷贝构造函数（浅拷贝）
涉及动态内存时必须显式定义（深拷贝）

class String {
private:
    char* data;
public:
    // 普通构造函数
    String(const char* str) {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }
    
    // 拷贝构造函数（深拷贝）
    String(const String& other) {
	    //不需要提前处理data，这是在构造是调用的
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
    
    // 禁用拷贝构造函数（C++11）
    // String(const String&) = delete;
    
    ~String() { delete[] data; }
};

// 使用
String s1("hello");
String s2(s1);  // 调用拷贝构造函数

需要注意的是，不用再拷贝构造函数中先判断是否删除data的动态内存，因为拷贝构造函数本质还是一个构造函数，初始化时调用

3.赋值运算符

当类中包含指针或需要深拷贝的数据成员时，使用默认的赋值运算符可能会导致问题，如内存泄漏或重复释放内存。因此，在这些情况下，需要显式地重载赋值运算符。

注意赋值运算符在内存管理上的细节

避免自赋值
赋值前先回收，避免内存泄漏

#include <iostream>
#include <string.h>
using namespace std;
class ClassA {
public:
	ClassA() {}
	ClassA(const char* pszInputStr) {
		pszTestStr = new char[strlen(pszInputStr) + 1];
		strncpy(pszTestStr, pszInputStr, strlen(pszInputStr) + 1);
	}

	virtual ~ClassA() {
		delete pszTestStr;
	}

	// 赋值运算符重载函数
	ClassA& operator=(const ClassA& cls) {
		// 避免自赋值
		if (this != &cls) {
		// 避免内存泄露
			if (pszTestStr != NULL) {
				delete pszTestStr;
				pszTestStr = NULL;
			}
		pszTestStr = new char[strlen(cls.pszTestStr) + 1];
		strncpy(pszTestStr, cls.pszTestStr, strlen(cls.pszTestStr) + 1);
		}
		return *this;
	}
public:
	char* pszTestStr;
};

int main() {
	ClassA obj1("liitdar");
	ClassA obj2;
	obj2 = obj1;
	cout << "obj2.pszTestStr is: " << obj2.pszTestStr << endl;
	return 0;
}

模板(函数模板&类模板)

函数模板生成的实例化成为模板函数，类模板和模板类的定义同理

函数模板

定义：通用函数定义，支持多种数据类型，编译器根据实际类型（隐式实例化）或者显式实例化生成具体函数特点：

用 template 关键字声明
可显式或隐式实例化
支持函数重载和特化模板的定义（实现），还是模板的全特化，都建议放在头文件

// 1. 基本函数模板
template<typename T>
T max(T a, T b) {
    return a > b ? a : b;
}

// 2. 函数模板特化（针对特定类型）
template<>
const char* max<const char*>(const char* a, const char* b) {
    return strcmp(a, b) > 0 ? a : b;
}

// 使用
int i = max(3, 5);                // 隐式实例化int版本
const char* s = max("apple", "banana");  // 调用特化版本

类模板

定义：通用类定义，成员变量和函数可使用模板参数类型。

特点：

类内成员函数可在类内定义（默认内联） 或类外定义
支持全特化和部分特化
实例化时需指定具体类型

// 1. 基本类模板
template<typename T, int Size>
class Array {
private:
    T data[Size];
public:
    Array() {}
    
    T& operator[](int index) {
        return data[index];
    }
    
    int getSize() const { return Size; }
};

// 2. 类模板特化（针对bool类型优化）
template<int Size>
class Array<bool, Size> {
private:
    unsigned char data[(Size + 7) / 8];  // 位压缩存储
public:
    bool get(int index) const {
        return (data[index / 8] >> (index % 8)) & 1;
    }
};

// 使用
Array<int, 10> intArray;        // 实例化int类型数组
Array<bool, 100> boolArray;     // 使用特化版本

现代C++相关（待补充）

自推导，lambda表达式，智能指针，RAII与RTTI的概念

设计模式

To be continued

Step5 arm-cortex-M学习&启动文件与链接器脚本

在对上面的抽象层级有一定了解后，还需要将上述偏软件的抽象层与具体的硬件相连接，建立软硬结合的认知需要有一定微机原理的知识

自荐一下笔者的博客从CPU架构到操作系统实现

cortex-M

架构特性

Cortex-M 系列作为微控制器内核，采用哈佛架构（指令与数据独立存储但共享内存空间），具备低功耗、高性能、中断易用性强、代码密度高等优势，支持嵌入式操作系统运行。其内核演变包含 Cortex-M0/M3/M4 等多个型号，其中 M3/M4 集成 3 级流水线（取指 - 译码 - 执行），M4F 额外支持浮点运算单元

核心组件包括：

NVIC（嵌套向量中断控制器）：管理中断响应，支持多级中断优先级。
MPU（内存保护单元）：实现内存访问权限控制，保障系统安全。
调试接口：支持 JTAG 或 Serial Wire 调试，搭配嵌入式跟踪模块（ETM）实现代码跟踪。
指令集：主要支持 Thumb/Thumb2 指令集（16 位 + 32 位混合），兼顾代码密度与执行效率，属于 RISC 架构（精简指令系统），每条指令仅完成单一操作，硬件实现简单高效。

内存分布规则

重点看Flash和RAM，以及对应的段分配规则

Cortex-M 芯片内存分为 FLASH和 RAM两大区域，具体分布由硬件特性和链接脚本共同定义，以 STM32F103C8Tx（64K FLASH、20K RAM）为例：

内存类型	起始地址	大小	权限	存储内容
FLASH	0x8000000	64K	可读可执行	中断向量表、.text 代码段、.rodata 只读常量段
RAM	0x20000000	20K	可读可写	.data 初始化数据段、.bss 未初始化数据段、堆、栈
内存段特性：

.isr_vector：位于 FLASH 起始地址，存储栈顶地址和中断 / 异常处理函数地址，是复位后内核首个访问的区域。
.text：存放可执行代码（函数实现），包括用户代码和启动文件逻辑。
.rodata：存储只读常量（如 const 变量、字符串字面量），节省 RAM 空间。
.data：存放已初始化的全局 / 静态变量，编译时初始值存于 FLASH，运行时复制到 RAM。
.bss：存放未初始化的全局 / 静态变量，运行时由启动文件清零，无需占用 FLASH 空间。
堆 / 栈：堆从低地址向上生长（供 malloc 使用），栈从高地址向下生长（供函数调用、局部变量使用），由链接脚本预留空间。

Flash 区：64 KiB，地址范围为 [0x0800_0000, 0x0801_0000)

表中的结束地址均为区间上界，不包含在对应段内；各段之间可能因对齐要求产生填充。

输出段或区域	起始地址	结束地址（不含）	内容
`.isr_vector`	`0x0800_0000`	`ADDR(.isr_vector) + SIZEOF(.isr_vector)`	中断向量表
`.text`	前一段结束后按 4 字节对齐	`_etext`	程序代码以及 `.init`、`.fini`
`.rodata`	前一段结束后按 4 字节对齐	`ADDR(.rodata) + SIZEOF(.rodata)`	只读常量和字符串
`.ARM.extab`	前一段结束后按 4 字节对齐	`ADDR(.ARM.extab) + SIZEOF(.ARM.extab)`	ARM 栈展开信息
`.ARM`	`__exidx_start`	`__exidx_end`	包含 `.ARM.exidx*` 的栈展开索引
`.preinit_array`	`__preinit_array_start`	`__preinit_array_end`	在普通初始化函数之前执行的预初始化函数数组
`.init_array`	`__init_array_start`	`__init_array_end`	初始化函数数组，包含 C++ 全局对象和文件作用域静态对象的构造函数入口
`.fini_array`	`__fini_array_start`	`__fini_array_end`	结束函数数组，包含 C++ 全局对象和文件作用域静态对象的析构函数调用入口
`.data` 初值镜像（LMA）	`_sidata = LOADADDR(.data)`	`_sidata + SIZEOF(.data)`	已初始化变量及 `.RamFunc` 的加载镜像，复位后复制到 RAM

.init_array 在 main 执行前参与 C++ 对象构造；.fini_array 在程序正常退出阶段参与对象析构。裸机程序通常不会从 main 返回，其析构流程是否执行取决于运行库和退出路径。

RAM 区：20 KiB，地址范围为 [0x2000_0000, 0x2000_5000)

0x2000_5000 位于 RAM 最后一个有效地址之后，也是该链接脚本中 _estack 的初始值。

项目	地址或范围	内容与作用
`.data`（VMA）	`_sdata` 到 `_edata`	已初始化的全局变量、静态变量及在 RAM 中运行的 `.RamFunc`；复位时从 Flash 的 `_sidata` 复制
`.bss`	`_sbss` 到 `_ebss`	未初始化或初始化为零的全局变量和静态变量；复位时由启动代码清零
`_end`	`.bss` 结束后按 8 字节对齐的位置	静态分配区域的结束标记，常作为 C 运行库堆的起点
`._user_heap_stack`	从 `_end` 开始，增加 `_Min_Heap_Size` 和 `_Min_Stack_Size` 后按 8 字节对齐	用于链接期容量检查，不表示运行时堆和栈的固定分界
C 运行库堆	通常从 `_end` 向高地址增长	供 `malloc`、`free` 等接口使用，实际边界由运行库实现决定
主栈	从 `_estack = 0x2000_5000` 向低地址增长	MSP 的初始位置，用于函数调用、局部变量和中断现场保存
堆栈间可用空间	当前堆末端与当前栈指针之间	大小随程序运行动态变化；堆和栈相遇时会发生内存冲突

_Min_Heap_Size 和 _Min_Stack_Size 只用于验证最小容量能否装入 RAM，并不会在运行时建立固定的堆栈边界。

启动文件与启动原理

启动原理

硬件复位：内核读取 FLASH 起始地址的中断向量表，初始化 MSP（栈顶地址），将 PC 指向Reset_Handler。
执行 Reset_Handler：完成时钟配置、内存段初始化（.data 复制、.bss 清零）。
进入用户代码：跳转至main函数，启动流程结束，正式运行应用逻辑。
中断响应：运行中触发中断时，内核从向量表查找对应处理函数地址，执行后返回断点。

启动模式

STM32F103 支持 3 种启动模式，由 BOOT0 和 BOOT1 引脚电平决定：

BOOT0=0：主 FLASH 启动（默认模式），从用户代码区启动。
BOOT0=1、BOOT1=0：系统内存启动，从芯片出厂固化的 Bootloader 启动。
BOOT0=1、BOOT1=1：嵌入式 SRAM 启动，从 RAM 加载代码（用于调试）。

启动文件

启动文件（如startup_stm32f103xb.s）是汇编语言编写的底层程序，作为 “硬件到软件的桥梁”，负责衔接硬件复位与用户main函数，核心功能包括硬件初始化、内存初始化、中断系统准备和引导用户代码

启动文件结构拆解

（1）汇编环境配置

指定处理器架构、指令集和浮点模式，确保汇编代码与硬件兼容，例如：

.syntax unified          ; 兼容ARM与Thumb指令集
.cpu cortex-m3           ; 目标内核为Cortex-M3
.fpu softvfp             ; 软件模拟浮点运算（无硬件FPU）
.thumb                   ; 启用Thumb指令集

（2）关键符号声明

引用链接器脚本定义的内存地址符号，建立启动文件与内存布局的关联，例如：

.word _sidata  ; .data段在FLASH的加载地址
.word _sdata   ; .data段在RAM的运行起始地址
.word _edata   ; .data段在RAM的运行结束地址
.word _sbss    ; .bss段在RAM的起始地址
.word _ebss    ; .bss段在RAM的结束地址

（3）复位处理函数（Reset_Handler）

复位后执行的核心逻辑，是启动流程的入口，分为 5 个关键步骤：

系统时钟初始化：调用SystemInit函数配置 HSE/PLL，将时钟从 8MHz HSI 提升至 72MHz
.data 段复制：从 FLASH 的_sidata地址复制初始值到 RAM 的_sdata至_edata区域
.bss 段清零：将 RAM 中_sbss至_ebss区域全部置 0，符合 C 语言标准
C++ 静态构造函数初始化：调用__libc_init_array，执行全局对象构造（兼容 C++ 项目）
跳转至 main 函数：完成底层初始化后，将程序控制权交给用户代码

（4）中断向量表（g_pfnVectors）

存储所有异常 / 中断的处理函数地址，位于 FLASH 起始地址，核心特性包括：

第 0 个元素为栈顶地址（_estack），用于初始化主栈指针（MSP）
第 1 个元素为Reset_Handler地址，是复位后程序计数器（PC）的初始指向
向量表顺序隐含中断优先级，靠前元素对应优先级更高（如硬 fault 优先级高于 SysTick）

（5）默认中断处理函数（Default_Handler）

为未自定义的中断提供 “兜底” 逻辑，通过无限循环防止程序跑飞，同时支持弱别名机制（.weak），允许用户在 C 代码中重定义中断函数覆盖默认逻辑

链接器脚本

链接脚本（.ld）是链接器的配置文件，本质是告知链接器芯片内存布局、代码 / 数据的段分配规则、全局符号定义和内存合法性检查，是生成可执行文件（.elf/.hex）的关键，没有它链接器无法确定 “代码放哪里、变量放哪里”

（1）入口点与栈顶定义

指定程序入口和栈堆大小，例如：

ENTRY(Reset_Handler)        ; 程序入口为Reset_Handler
_estack = ORIGIN(RAM) + LENGTH(RAM); 栈顶地址=RAM起始+RAM大小
_Min_Heap_Size = 0x200;     最小堆大小（512字节）
_Min_Stack_Size = 0xF00;    最小栈大小（3840字节）

（2）内存区域定义（MEMORY 块）

描述 FLASH 和 RAM 的物理属性，例如：

MEMORY
{
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 20K  ; RAM：可读可写可执行
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 64K  ; FLASH：可读可执行
}

（3）段分配规则（SECTIONS 块）

定义编译生成的段与物理内存的映射关系，核心段包括：

.isr_vector：分配到 FLASH 起始地址，用KEEP关键字防止被优化删除。
.text：存放代码段，定义_etext标记结束地址。
.rodata：存放只读常量，分配到 FLASH。
.data：运行地址在 RAM，加载地址在 FLASH，定义_sidata（加载地址）、_sdata（运行起始）、_edata（运行结束）。
.bss：分配到 RAM，定义_sbss（起始）、_ebss（结束）。
._user_heap_stack：预留堆和栈空间，检查 RAM 容量是否充足。
/DISCARD/：丢弃无用段（如标准库冗余代码），减小文件大小。

链接脚本与启动文件的协同关系

启动文件与链接脚本通过全局符号和段分配紧密耦合，二者协作关系如下：

协作维度	启动文件角色	链接脚本角色
内存地址提供	引用`_sdata`、`_ebss`等符号	计算并定义内存地址符号
段分配依据	将代码 / 数据放入指定段（如.text）	规定段的存储位置（如 FLASH/RAM）
程序入口指定	实现`Reset_Handler`函数	通过`ENTRY`指定入口为`Reset_Handler`
内存合法性检查	依赖符号确保内存访问不越界	检查堆 / 栈 / 数据段总大小是否超过 RAM 容量

架构→内存→链接脚本：Cortex-M 的哈佛架构决定内存分为 FLASH 和 RAM，链接脚本根据硬件内存参数（起始地址、大小）定义存储规则。
链接脚本→启动文件：链接脚本提供内存地址符号（如_sdata），启动文件依赖这些符号完成.data 复制、.bss 清零等初始化操作。
启动文件→架构：启动文件根据 Cortex-M 内核特性（如向量表位置、栈初始化要求）实现底层逻辑，最终引导程序进入用户代码。

待续

从CPU架构到操作系统实现

Thu, 04 Sep 2025 00:36:07 +0800

跟着下面的视频，系统梳理复习过往的嵌入式知识，同时也算是电控成长指南的一个部分实现，能有效且快速的建立一个嵌入式系统和工具链的整体认知

【《从CPU架构到操作系统实现》系列课程 - Git 开源】https://www.bilibili.com/video/BV1ksNCzXEny?vd_source=5a0790755035f26a67935abfbfcdfd5b

视频中详细且硬核的实例不会出现在此笔记中

概述

关于ARM架构

目前arm内核主要演变分为Cortex-X，Cortex-A，Cortex-R，Cortex-M

Cortex-A：应用处理器，设计用来处理复杂应用（例如高端嵌入操作系统Linux，iOS，Android，Windows），对标PC和手机处理器的性能

Cortex-X：比Cortex-M更高的性能

Cortex-R：Real-time，主要用于实时系统

Cortex-M：Microcontrol，微处理器

Cortex-M优点

低功耗
高性能
中断易用
代码密度高（原因在于指令集）
可调式
支持操作系统哈佛架构，指令与数据在同一内存

指令集

多套指令集用于处理不同的场景

1.CISC（Complex Instruction Set Computer）

复杂指令系统计算机，CISC指令集包含大量复杂的指令，每条指令可以完成多个操作，这种设计使得编程简单，但硬件实现复杂，执行效率低

x86架构（Intel的8086，8088，80286，80386）

2.RISC（Reduced Instruction Set Computer）

精简指令系统计算机，RISC指令集包含较少的简单指令，每条指令只完成一个操作，使得硬件实现更简单，执行效率更高，但编程更复杂

ARM架构，RISC-V架构，MIPS架构

开发环境（DEV）

GUN-GCC编译器，CMake->makefile STM32F103C8（C8T6）经典控制器（Cortex-M3）

编译

编译链工具

ARM-Cortex-M处理器的编译器很多，常用的是MDK-ARM(ARM公司自研的)(Keil)，以及GCC(GNU-Compiler-Collection)

编译器之间的最大区别在于汇编伪代码，链接语法，还有使用参数

arm-none-eabi

arm是指arm架构，none是指编译出的可执行文件是运行在硬件上，而不是操作系统上，eabi(The Embedded-Application Binary Interface)嵌入式应用二进制接口

arm-none-eabi-objcopy是一个二进制生成工具

嵌入式编译烧录流程

个人更喜欢将编译过程拆解为预编译，编译，汇编，链接

转换这里是将.elf文件转换为.bin文件 .bin文件是代码的纯机器码

一文看懂hex文件、bin文件、axf文件的区别 - 知乎

预编译

将所有头文件和宏展开，同时去掉注释，生成.i文件（c中间文件）

编译

将.i文件编译为.s汇编文件，编译优化发生在此处

汇编

将.s文件汇编为.o二进制文件（机器码）二进制文件中还包含很多的其他信息

在汇编时，可以指定汇编器的参数来选择指令集

链接

链接是将各个二进制文件里面的机器码所在的各个段拼接起来，以形成可执行文件.elf（带有调试信息）

在链接这个阶段才能检测出有不有重复定义和未定义的错误

对于GNU来说，可以编写.ld链接脚本来编排代码的分区地址

转换

通过转换器能将.elf文件转换为.hex和.bin文件，主要用于提取信息

.bin文件只包含二进制机器码 .hex文件是Intel定义的包含地址和二进制数值的ASC码文本文件

烧录

烧录的过程是将编译好的机器码写到CPU存储器中

反汇编

GCC中的反汇编工具Disassembler是arm-none-eabi-objdump

启动

主要是讲解STM32的启动流程

中断向量表

中断向量表的构建，根据不同的编译工具，有不同的方式构建

中断向量表的前两项（.woed，4字节）是最关键的第一项是堆栈指针的值第二项是Reset_Handler函数入口

在启动时，需要先设置堆栈指针，否则无法进行压栈的操作，从宏观上说，意味着C语言函数体不能调用子函数

VTOR寄存器，中断向量表偏移寄存器

启动原理

启动后，从零地址（零地址是经过映射的）处读取堆栈指针和程序计数器的值（此时程序计数器的值指向Reset_Handler），此外每个芯片的Boot code是定制化的，需要参考手册

最后Reset_Handler会指向main函数

以STM32F103为例

这里有三种启动模式，根据启动时BOOT1和BOOT0的电平来选择不同的启动地址（即将该不同的地址映射为零地址）

三种启动模式分别是从 flash 引导启动，从 system memory 引导启动和从 SRAM 引导启动（即将该不同的地址映射为零地址）

从主 Flash 启动：将主 Flash 地址 0x0800 0000 映射到 0x0000 0000，代码启动后相当于从 0x0800 0000 开始运行，使用 JTAG 或者 SWD 模式下载程序时会下载到 Flash 并从中启动
从系统存储器启动：将系统存储器地址 0x1FFF F000 映射到 0x0000 0000，系统存储器是芯片内部的 ROM 区域，芯片出厂时在其中预置了 Bootloader，称为 ISP 程序。Bootloader 由厂家设置，一般无法修改
从内置 SRAM 启动：将 SRAM 地址 0x2000 0000 映射到 0x0000 0000，代码启动后相当于从 0x2000 0000 开始运行。由于 SRAM 是易失性存储器，因此这个模式一般仅用于程序调试（以STM32F103为例）

存储分布

以stm32f103c8t6为例

Flash区

Flash 区：64 KiB，地址范围为 [0x0800_0000, 0x0801_0000)

表中的结束地址均为区间上界，不包含在对应段内；各段之间可能因对齐要求产生填充。

输出段或区域	起始地址	结束地址（不含）	内容
`.isr_vector`	`0x0800_0000`	`ADDR(.isr_vector) + SIZEOF(.isr_vector)`	中断向量表
`.text`	前一段结束后按 4 字节对齐	`_etext`	程序代码以及 `.init`、`.fini`
`.rodata`	前一段结束后按 4 字节对齐	`ADDR(.rodata) + SIZEOF(.rodata)`	只读常量和字符串
`.ARM.extab`	前一段结束后按 4 字节对齐	`ADDR(.ARM.extab) + SIZEOF(.ARM.extab)`	ARM 栈展开信息
`.ARM`	`__exidx_start`	`__exidx_end`	包含 `.ARM.exidx*` 的栈展开索引
`.preinit_array`	`__preinit_array_start`	`__preinit_array_end`	在普通初始化函数之前执行的预初始化函数数组
`.init_array`	`__init_array_start`	`__init_array_end`	初始化函数数组，包含 C++ 全局对象和文件作用域静态对象的构造函数入口
`.fini_array`	`__fini_array_start`	`__fini_array_end`	结束函数数组，包含 C++ 全局对象和文件作用域静态对象的析构函数调用入口
`.data` 初值镜像（LMA）	`_sidata = LOADADDR(.data)`	`_sidata + SIZEOF(.data)`	已初始化变量及 `.RamFunc` 的加载镜像，复位后复制到 RAM

RAM区

RAM 区：20 KiB，地址范围为 [0x2000_0000, 0x2000_5000)

0x2000_5000 位于 RAM 最后一个有效地址之后，也是该链接脚本中 _estack 的初始值。

项目	地址或范围	内容与作用
`.data`（VMA）	`_sdata` 到 `_edata`	已初始化的全局变量、静态变量及在 RAM 中运行的 `.RamFunc`；复位时从 Flash 的 `_sidata` 复制
`.bss`	`_sbss` 到 `_ebss`	未初始化或初始化为零的全局变量和静态变量；复位时由启动代码清零
`_end`	`.bss` 结束后按 8 字节对齐的位置	静态分配区域的结束标记，常作为 C 运行库堆的起点
`._user_heap_stack`	从 `_end` 开始，增加 `_Min_Heap_Size` 和 `_Min_Stack_Size` 后按 8 字节对齐	用于链接期容量检查，不表示运行时堆和栈的固定分界
C 运行库堆	通常从 `_end` 向高地址增长	供 `malloc`、`free` 等接口使用，实际边界由运行库实现决定
主栈	从 `_estack = 0x2000_5000` 向低地址增长	MSP 的初始位置，用于函数调用、局部变量和中断现场保存
堆栈间可用空间	当前堆末端与当前栈指针之间	大小随程序运行动态变化；堆和栈相遇时会发生内存冲突

_Min_Heap_Size 和 _Min_Stack_Size 只用于验证最小容量能否装入 RAM，并不会在运行时建立固定的堆栈边界。

如果使用了FreeRTOS的话，FreeRTOS的内存布局如下

内存分配规则

全局变量、局部静态变量：根据是否初始化决定分配在.data段或.bss段
用const关键字声明的常量：分配在Flash中
使用C标准的malloc申请的内存：分配在系统堆中
不在任务中定义的临时变量：分配在系统栈中
使用pvPortMalloc开辟的内存或调用FreeRTOS标准API自动分配的内存：分配在FreeRTOS堆中
在任务中定义的临时变量：分配在对应任务的任务栈中
在中断中使用*pvPortMallocFromISR分配的内存：分配在FreeRTOS堆中
在中断中禁止使用C标准的malloc和free
中断中定义的临时变量：分配在系统

启动文件详解

一、STM32F103 启动文件（startup_stm32f103xb.s）核心定位

STM32 的启动文件（如startup_stm32f103xb.s）是汇编语言编写的底层程序，是硬件复位后执行的第一段代码，负责衔接 “硬件初始化” 与 “用户 C 代码（main函数）”。其核心功能包括：设置栈指针、构建中断向量表、初始化数据段（.data）、清零未初始化数据段（.bss）、配置系统时钟，最终引导程序进入main函数，是 STM32 程序运行的 “底层基石”。

二、启动文件整体结构拆解

该启动文件按功能可划分为 5 个核心模块，各模块职责明确且环环相扣：

汇编环境配置：指定处理器架构、指令集、浮点模式，确保汇编代码与硬件兼容。
关键符号声明：引用链接器脚本（.ld）中定义的内存地址符号，建立启动文件与内存布局的关联。
复位处理函数（Reset_Handler）：复位后执行的核心逻辑，完成初始化并跳转到main。
中断向量表（g_pfnVectors）：存储所有异常 / 中断的处理函数地址，供内核响应中断时调用。
默认中断处理函数（Default_Handler）：未自定义的中断会默认进入此处，避免系统崩溃。

三、逐段解析启动文件代码

1. 汇编环境配置（开头基础设置）

  .syntax unified       ; 使用统一汇编语法（兼容ARM与Thumb指令集）
  .cpu cortex-m3        ; 目标处理器为Cortex-M3（STM32F103内核型号）
  .fpu softvfp          ; 浮点模式：软件模拟（STM32F103无硬件FPU）
  .thumb                ; 启用Thumb指令集（Cortex-M3仅支持Thumb/Thumb2指令）

作用：告诉汇编器（如arm-none-eabi-as）“如何编译这段代码”，确保生成的指令能被 STM32F103 正确执行。
关键细节：softvfp对应 STM32F103 的硬件特性 —— 该型号无硬件浮点处理单元（FPU），需通过软件模拟浮点运算，与之前解析的.ld文件中未配置 FPU 参数完全匹配。

2. 关键符号声明（与链接器脚本联动）

.global g_pfnVectors    ; 全局符号：中断向量表（供链接器识别并分配地址）
.global Default_Handler ; 全局符号：默认中断处理函数（供中断向量表引用）

/* 引用链接器脚本（.ld）中定义的内存地址符号 */
.word _sidata  ; .data段在FLASH中的加载地址（LMA，初始值存放位置）
.word _sdata   ; .data段在RAM中的运行起始地址（VMA，变量实际存储位置）
.word _edata   ; .data段在RAM中的运行结束地址
.word _sbss    ; .bss段在RAM中的起始地址（未初始化变量存储区）
.word _ebss    ; .bss段在RAM中的结束地址

.equ  BootRAM, 0xF108F85F  ; 定义RAM启动模式的特殊地址（仅用于特定boot配置）

核心意义：通过.word指令声明的符号，直接引用.ld文件中根据硬件内存布局（64K FLASH、20K RAM）计算出的地址。例如：
- _sdata和_edata确定了.data段在 RAM 中的范围，_sidata确定了其初始值在 FLASH 中的位置，为后续 “数据段复制” 提供地址依据。
- 若缺少这些符号，启动文件无法知道 “数据该从哪里复制到哪里”，内存初始化会彻底失败。

3. 复位处理函数（`Reset_Handler`：启动核心逻辑）

Reset_Handler是复位后执行的第一个函数（由中断向量表指定），对应 STM32 启动流程中的 “软件初始化” 阶段，代码逻辑可分为 5 步：

  .section .text.Reset_Handler  ; 将函数放入.text段（代码段，.ld中分配到FLASH）
  .weak Reset_Handler           ; 弱定义：允许用户代码重定义该函数（覆盖默认逻辑）
  .type Reset_Handler, %function ; 标记为函数类型（汇编器识别函数边界）
Reset_Handler:

  /* 步骤1：初始化系统时钟 */
    bl  SystemInit  ; 跳转到STM32库函数SystemInit（配置HSE/PLL，将时钟从8MHz HSI切换到72MHz）

  /* 步骤2：复制.data段（从FLASH到RAM） */
  ldr r0, =_sdata   ; r0 = .data段在RAM的起始地址（VMA）
  ldr r1, =_edata   ; r1 = .data段在RAM的结束地址
  ldr r2, =_sidata  ; r2 = .data段在FLASH的加载地址（LMA）
  movs r3, #0       ; r3 = 偏移量（初始为0，每次复制4字节后递增）
  b LoopCopyDataInit ; 跳转到循环复制入口

CopyDataInit:
  ldr r4, [r2, r3]  ; 从FLASH读取数据：r4 = *(r2 + r3)（源地址=加载地址+偏移量）
  str r4, [r0, r3]  ; 写入RAM：*(r0 + r3) = r4（目标地址=运行地址+偏移量）
  adds r3, r3, #4   ; 偏移量+4（32位数据，每次复制1个word）

LoopCopyDataInit:
  adds r4, r0, r3   ; r4 = 当前复制位置（运行地址+偏移量）
  cmp r4, r1        ; 比较当前位置与结束地址：是否复制完成？
  bcc CopyDataInit  ; 若未完成（r4 < r1），继续循环复制
  
  /* 步骤3：清零.bss段（未初始化变量区） */
  ldr r2, =_sbss    ; r2 = .bss段在RAM的起始地址
  ldr r4, =_ebss    ; r4 = .bss段在RAM的结束地址
  movs r3, #0       ; r3 = 0（用于清零）
  b LoopFillZerobss ; 跳转到循环清零入口

FillZerobss:
  str  r3, [r2]     ; 将0写入当前地址：*r2 = 0
  adds r2, r2, #4   ; 地址+4（每次清零1个word）

LoopFillZerobss:
  cmp r2, r4        ; 比较当前地址与结束地址：是否清零完成？
  bcc FillZerobss   ; 若未完成（r2 < r4），继续循环清零

  /* 步骤4：初始化C++静态构造函数（兼容C++项目） */
    bl __libc_init_array  ; 调用C库函数，执行全局对象构造（纯C项目可忽略，不影响运行）

  /* 步骤5：跳转到用户main函数 */
  bl main   ; 跳转到用户C代码的main函数（启动流程结束，交权给用户）
  bx lr     ; 若main函数返回（实际中main通常是死循环），跳回当前位置（无实际意义）
.size Reset_Handler, .-Reset_Handler  ; 定义函数大小（.表示当前地址，计算函数长度）

关键步骤解读：

系统时钟初始化（SystemInit）：STM32 复位后默认使用 8MHz 的内部高速时钟（HSI），SystemInit函数会配置外部高速时钟（HSE）和锁相环（PLL），将系统时钟提升到 72MHz（F103 的常用工作频率），确保外设和 CPU 高效运行。
.data 段复制：.data段存储 “已初始化的全局 / 静态变量”（如int a = 10;），这些变量需要读写权限，因此运行时必须在 RAM 中；但编译时其初始值会存放在 FLASH（节省 RAM），需通过此步骤复制到 RAM。
.bss 段清零：.bss段存储 “未初始化的全局 / 静态变量”（如int b;），C 语言标准要求其初始值为 0，因此无需在 FLASH 中存储初始值，直接将 RAM 对应区域清零即可。
跳转到main：这是启动文件的 “最终目标”—— 完成所有底层初始化后，将程序控制权交给用户代码，正式进入应用逻辑。

4. 中断向量表（`g_pfnVectors`：中断响应的 “地址簿”）

中断向量表是Cortex-M3 内核复位后访问的第一个数据结构，存储了所有异常（如复位、硬 fault）和外设中断（如串口、定时器）的处理函数地址。当发生中断 / 异常时，内核会从向量表中找到对应地址，跳转到处理函数执行。

  .section .isr_vector,"a",%progbits  ; 将向量表放入.isr_vector段（.ld中分配到FLASH起始地址0x8000000）
  .type g_pfnVectors, %object         ; 标记为数据对象（而非函数）
  .size g_pfnVectors, .-g_pfnVectors  ; 定义向量表大小（计算表的总字节数）

g_pfnVectors:
  .word _estack                       ; 第0个元素：栈顶地址（MSP初始值，来自.ld文件）
  .word Reset_Handler                 ; 第1个元素：复位处理函数地址（复位后PC指向这里）
  .word NMI_Handler                   ; 第2个元素：不可屏蔽中断（NMI）处理函数
  .word HardFault_Handler             ; 第3个元素：硬fault异常处理函数（严重错误，如内存访问越界）
  .word MemManage_Handler             ; 第4个元素：内存管理异常处理函数
  .word BusFault_Handler              ; 第5个元素：总线fault异常处理函数（如访问不存在的外设地址）
  .word UsageFault_Handler            ; 第6个元素：用法fault异常处理函数（如指令错误）
  .word 0                             ; 第7-10个元素：保留（未使用）
  .word 0
  .word 0
  .word 0
  .word SVC_Handler                   ; 第11个元素：系统服务调用（SVC）处理函数（OS常用）
  .word DebugMon_Handler              ; 第12个元素：调试监控处理函数
  .word 0                             ; 第13个元素：保留
  .word PendSV_Handler                ; 第14个元素：PendSV异常处理函数（任务切换常用）
  .word SysTick_Handler               ; 第15个元素：系统滴答定时器（SysTick）处理函数
  /* 以下为外设中断向量（第16个元素开始） */
  .word WWDG_IRQHandler               ; 窗口看门狗中断
  .word PVD_IRQHandler                ; 电源电压检测中断
  .word TAMPER_IRQHandler             ; 篡改检测中断
  .word RTC_IRQHandler                ; RTC时钟中断
  .word FLASH_IRQHandler              ; FLASH操作中断
  .word RCC_IRQHandler                ; RCC时钟控制中断
  .word EXTI0_IRQHandler              ; 外部中断0（如PA0）中断
  ...（省略其余外设中断，共60+个，对应F103所有外设）...
  .word BootRAM                       ; RAM启动模式的特殊地址（仅用于从RAM启动，默认从FLASH启动时无用）

核心特性：

位置固定：在.ld文件中，.isr_vector段被强制分配到 FLASH 起始地址（0x8000000），这是 Cortex-M3 内核的硬件规定 —— 复位后内核会自动从0x8000000读取向量表。
第 0 个元素必为栈顶：内核复位后做的第一件事是 “初始化栈指针（MSP）”，因此向量表第 0 个元素必须是栈顶地址（_estack，来自.ld 文件），否则后续函数调用、局部变量存储会因栈地址错误崩溃。
中断优先级隐含：向量表中元素的顺序对应中断 / 异常的优先级（靠前的优先级更高），例如 “硬 fault”（第 3 个元素）优先级高于 “SysTick”（第 15 个元素）。

5. 默认中断处理函数（`Default_Handler`：中断 “兜底” 逻辑）

当用户未为某个中断定义处理函数时，中断向量表会将该中断的地址指向Default_Handler，避免系统因 “找不到中断处理函数” 而进入未知状态。

    .section .text.Default_Handler,"ax",%progbits  ; 放入.text段，属性为可执行（ax）
Default_Handler:
Infinite_Loop:
  b Infinite_Loop  ; 无限循环（死循环），防止程序跑飞
  .size Default_Handler, .-Default_Handler  ; 定义函数大小

弱别名机制（用户可重定义中断函数）

启动文件通过 “弱别名（.weak）” 允许用户在 C 代码中重定义中断处理函数，具体逻辑如下：

1
2

  .weak NMI_Handler                  ; 弱定义：NMI_Handler可被用户代码覆盖
  .thumb_set NMI_Handler,Default_Handler  ; 若用户未定义，NMI_Handler默认指向Default_Handler

工作原理：
1. .weak标记表示 “该符号是弱定义的，若用户定义了同名符号，优先使用用户定义的版本”。
2. 用户只需在 C 代码中编写void USART1_IRQHandler(void) { ... }，链接时会自动覆盖启动文件中的弱定义，使串口 1 中断触发时执行用户代码。
3. 若用户未定义，则使用默认的Default_Handler（无限循环）。

四、启动文件与链接器脚本（.ld）的配合关系

启动文件与.ld文件是紧密耦合的 “搭档”，二者通过 “全局符号” 和 “段分配” 协同工作，缺一不可：

协作维度	启动文件角色	链接器脚本（.ld）角色
内存地址提供	引用`.ld`定义的`_sdata`、`_ebss`、`_estack`等符号	根据硬件内存布局（64K FLASH、20K RAM）计算并定义这些符号
段分配依据	将`Reset_Handler`放入`.text`段、向量表放入`.isr_vector`段	规定`.text`、`.isr_vector`等段的存储位置（如`.isr_vector`分配到 FLASH 起始地址）
程序入口指定	实现`Reset_Handler`函数（入口逻辑）	通过`ENTRY(Reset_Handler)`指定程序入口为该函数
内存合法性检查	依赖`.ld`确保`_sdata`、`_ebss`不超出 RAM 范围	检查堆、栈、数据段总大小是否超过 RAM/FLASH 容量，溢出则报错

五、总结：启动文件的核心价值

STM32 启动文件是 “从硬件到软件的桥梁”，其核心作用可概括为 3 点：

硬件初始化：完成栈指针设置、系统时钟配置，为程序运行提供基础硬件环境。
内存初始化：通过复制.data段、清零.bss段，确保全局 / 静态变量符合 C 语言标准要求。
中断系统准备：构建中断向量表，提供默认中断处理逻辑，支持用户自定义中断函数。
引导用户代码：最终跳转到main函数，将程序控制权交给用户，完成 “底层初始化→应用逻辑” 的过渡。简言之：没有启动文件，STM32 复位后无法完成任何初始化，更无法进入main函数 —— 它是 STM32 程序运行的 “第一块拼图”。

STM32 启动流程、.ld 文件作用及示例解析

要理解 STM32 的启动流程、.ld文件（链接器脚本）的作用，以及你提供的具体.ld文件内容，我们需要从宏观启动逻辑到链接器脚本细节逐步拆解，最终建立两者的关联。

一、STM32 的启动流程（从复位到`main`函数）

STM32 的启动流程是硬件复位→内核初始化→软件初始化→进入main 的过程，核心依赖「中断向量表」和「启动文件」，而.ld文件为这个流程提供了内存地址映射和段分配规则。

1. 硬件复位：PC 指针的初始指向

当 STM32 上电或复位时，Cortex-M 内核会自动执行以下操作：

读取中断向量表的第一个元素（栈顶地址_estack），初始化主栈指针（MSP）—— 这是内核执行的第一个动作，因为函数调用、局部变量都依赖栈。
将程序计数器（PC）指向中断向量表的第二个元素（Reset_Handler的地址）—— 这是复位后的第一个执行函数（启动流程的入口）。

关键：中断向量表的默认地址是0x8000000（STM32 FLASH 的起始地址），这也是.ld文件中FLASH的ORIGIN（起始地址）设置为0x8000000的原因。

2. 执行`Reset_Handler`（启动文件核心逻辑）

Reset_Handler是启动文件（如startup_stm32f103c8tx.s）中的汇编函数，是软件初始化的核心，其逻辑完全依赖.ld文件定义的全局符号（如_sdata、_ebss），具体步骤如下：

初始化数据段（.data）：
.data段存放「初始化过的全局 / 静态变量」（如int a = 10;），这些变量需要读写权限，因此运行时必须在 RAM 中；但编译时会把它们的初始值存放在 FLASH 中（节省 RAM 空间）。
Reset_Handler会执行复制操作：从.ld文件定义的_sidata（.data 在 FLASH 的加载地址）复制到_sdata（.data 在 RAM 的运行地址），直到_edata（.data 的结束地址）。
清零未初始化数据段（.bss）：
.bss段存放「未初始化的全局 / 静态变量」（如int b;），C 语言标准要求它们初始化为 0。
Reset_Handler会将_sbss（.bss 的起始地址）到_ebss（.bss 的结束地址）的 RAM 区域全部清零。
初始化系统时钟（SystemInit）：
调用SystemInit函数（由 STM32 标准库 / LL 库提供），配置 HSE/PLL 等，将系统时钟从默认的 HSI（8MHz）切换到更高频率（如 72MHz）。
调用main函数：
完成所有初始化后，跳转到 C 语言的main函数，进入用户应用逻辑。

3. 异常 / 中断的触发（补充）

若程序运行中触发中断（如定时器、串口），内核会再次读取「中断向量表」，根据中断号找到对应的中断服务函数（ISR）地址，跳转到 ISR 执行，执行完成后返回断点继续运行。

二、.ld 文件（链接器脚本）的核心作用

.ld文件是链接器（ld）的配置文件，其本质是告诉链接器：

芯片的内存布局：FLASH（只读、存代码 / 常量）和 RAM（可读写、存变量 / 栈 / 堆）的起始地址和大小。
代码 / 数据的段分配规则：将编译生成的各个「段（Section）」（如.text、.data）分配到对应的内存区域（FLASH/RAM）。
定义全局符号：生成_sdata、_ebss、_estack等符号，供启动文件和用户代码使用（如启动文件依赖这些符号初始化内存）。
内存合法性检查：确保堆、栈、数据段的总大小不超过 RAM/FLASH 的实际容量，避免内存溢出。简单说：没有.ld文件，链接器无法知道 “代码该放哪里、变量该放哪里”，无法生成可执行的.elf/.hex文件。

三、解析 STM32F103C8Tx 的.ld 文件

以下按文件结构逐段解析，结合 STM32F103C8Tx 的硬件参数（64K FLASH、20K RAM）说明每部分的作用。

1. 入口点与栈顶定义

/* Entry Point */
ENTRY(Reset_Handler)  // 定义程序的入口函数：Reset_Handler（与启动文件对应）

/* Highest address of the user mode stack */
_estack = ORIGIN(RAM) + LENGTH(RAM);  // 栈顶地址 = RAM起始地址 + RAM总大小
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200;      // 最小堆大小（512字节，供malloc使用）
_Min_Stack_Size = 0xF00;     // 最小栈大小（3840字节，供函数调用/局部变量使用）

ENTRY(Reset_Handler)：强制链接器将Reset_Handler作为程序第一个执行的函数，与启动流程中 PC 指向Reset_Handler完全对应。
_estack：定义栈顶地址（STM32F103C8Tx 的 RAM 是0x20000000~0x20004FFF，因此_estack=0x20005000），启动文件会将这个地址加载到 MSP（主栈指针）。
堆 / 栈大小：_Min_Heap_Size和_Min_Stack_Size是最小要求，若用户代码中堆 / 栈使用超过这个值，链接器会报错（防止 RAM 溢出），可根据需求调整（如栈不够时增大_Min_Stack_Size）。

2. 内存区域定义（MEMORY 块）

/* Specify the memory areas */
MEMORY
{
RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 20K  // RAM区域
FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 64K   // FLASH区域
}

这是.ld文件的核心，定义了芯片的物理内存属性：

RAM (xrw)：
- xrw：权限（x= 可执行，r= 可读，w= 可写）——RAM 支持读写，理论上可执行（但通常不放代码）。
- ORIGIN = 0x20000000：STM32 所有 Cortex-M3 内核芯片的 RAM 起始地址（硬件规定）。
- LENGTH = 20K：STM32F103C8Tx 的 RAM 实际大小（20KB = 0x5000 字节，范围0x20000000~0x20004FFF）。
FLASH (rx)：
- rx：权限（r= 可读，x= 可执行，w= 不可写）——FLASH 是只读存储器，只能存放代码和常量。
- ORIGIN = 0x8000000：STM32 FLASH 的起始地址（硬件规定，复位后 PC 默认指向这里）。
- LENGTH = 64K：STM32F103C8Tx 的 FLASH 实际大小（64KB = 0x10000 字节，范围0x8000000~0x800FFFF）。

3. 段分配规则（SECTIONS 块）

SECTIONS块是最复杂的部分，定义了「编译生成的段」如何映射到「MEMORY 块定义的物理内存」，每一个子段都对应特定的代码 / 数据类型。

Flash 区：64 KiB，地址范围为 [0x0800_0000, 0x0801_0000)

表中的结束地址均为区间上界，不包含在对应段内；各段之间可能因对齐要求产生填充。

输出段或区域	起始地址	结束地址（不含）	内容
`.isr_vector`	`0x0800_0000`	`ADDR(.isr_vector) + SIZEOF(.isr_vector)`	中断向量表
`.text`	前一段结束后按 4 字节对齐	`_etext`	程序代码以及 `.init`、`.fini`
`.rodata`	前一段结束后按 4 字节对齐	`ADDR(.rodata) + SIZEOF(.rodata)`	只读常量和字符串
`.ARM.extab`	前一段结束后按 4 字节对齐	`ADDR(.ARM.extab) + SIZEOF(.ARM.extab)`	ARM 栈展开信息
`.ARM`	`__exidx_start`	`__exidx_end`	包含 `.ARM.exidx*` 的栈展开索引
`.preinit_array`	`__preinit_array_start`	`__preinit_array_end`	在普通初始化函数之前执行的预初始化函数数组
`.init_array`	`__init_array_start`	`__init_array_end`	初始化函数数组，包含 C++ 全局对象和文件作用域静态对象的构造函数入口
`.fini_array`	`__fini_array_start`	`__fini_array_end`	结束函数数组，包含 C++ 全局对象和文件作用域静态对象的析构函数调用入口
`.data` 初值镜像（LMA）	`_sidata = LOADADDR(.data)`	`_sidata + SIZEOF(.data)`	已初始化变量及 `.RamFunc` 的加载镜像，复位后复制到 RAM

RAM 区：20 KiB，地址范围为 [0x2000_0000, 0x2000_5000)

0x2000_5000 位于 RAM 最后一个有效地址之后，也是该链接脚本中 _estack 的初始值。

项目	地址或范围	内容与作用
`.data`（VMA）	`_sdata` 到 `_edata`	已初始化的全局变量、静态变量及在 RAM 中运行的 `.RamFunc`；复位时从 Flash 的 `_sidata` 复制
`.bss`	`_sbss` 到 `_ebss`	未初始化或初始化为零的全局变量和静态变量；复位时由启动代码清零
`_end`	`.bss` 结束后按 8 字节对齐的位置	静态分配区域的结束标记，常作为 C 运行库堆的起点
`._user_heap_stack`	从 `_end` 开始，增加 `_Min_Heap_Size` 和 `_Min_Stack_Size` 后按 8 字节对齐	用于链接期容量检查，不表示运行时堆和栈的固定分界
C 运行库堆	通常从 `_end` 向高地址增长	供 `malloc`、`free` 等接口使用，实际边界由运行库实现决定
主栈	从 `_estack = 0x2000_5000` 向低地址增长	MSP 的初始位置，用于函数调用、局部变量和中断现场保存
堆栈间可用空间	当前堆末端与当前栈指针之间	大小随程序运行动态变化；堆和栈相遇时会发生内存冲突

_Min_Heap_Size 和 _Min_Stack_Size 只用于验证最小容量能否装入 RAM，并不会在运行时建立固定的堆栈边界。

（1）.isr_vector：中断向量表（放 FLASH）

.isr_vector :
{
  . = ALIGN(4);          // 地址4字节对齐（Cortex-M内核要求，否则触发硬 fault）
  KEEP(*(.isr_vector))   // 保留中断向量表，防止链接器优化删除（核心！）
  . = ALIGN(4);
} >FLASH  // 分配到FLASH区域

作用：存放 STM32 的中断向量表（如复位向量、定时器中断向量、串口中断向量等），是复位后内核第一个访问的段。
KEEP(*(.isr_vector))：中断向量表由启动文件定义（如startup_stm32f103c8tx.s中的g_pfnVectors数组），KEEP关键字确保链接器不会因为 “看似未被调用” 而删除这个段 —— 如果删除，复位后内核找不到Reset_Handler地址，程序会崩溃。
>FLASH：明确将该段分配到MEMORY块定义的FLASH区域（符合硬件要求，向量表默认在 FLASH 起始地址）。

（2）.text：代码段（放 FLASH）

.text :
{
  . = ALIGN(4);
  *(.text)           // 所有.c/.s文件的代码（如main函数、自定义函数）
  *(.text*)          // 扩展代码段（如C++的成员函数）
  *(.glue_7)         // ARM指令与Thumb指令的胶水代码（Cortex-M用Thumb指令，兼容用）
  *(.glue_7t)        // 同上
  *(.eh_frame)       // C++异常处理相关（若用C可忽略）

  KEEP (*(.init))    // 程序初始化函数（如构造函数）
  KEEP (*(.fini))    // 程序结束函数（如析构函数）

  . = ALIGN(4);
  _etext = .;        // 定义符号：.text段的结束地址（供后续段定位）
} >FLASH

作用：存放所有可执行代码（C 函数、汇编函数），是 FLASH 中占用空间最大的段。
_etext = .：.代表当前地址，_etext是全局符号，标记.text段的结束地址 —— 后续的.rodata段会从_etext之后的地址开始分配，避免段重叠。

（3）.rodata：只读常量段（放 FLASH）

.rodata :
{
  . = ALIGN(4);
  *(.rodata)         // 只读常量（如const int a = 10;、字符串常量"hello"）
  *(.rodata*)        // 扩展只读常量段
  . = ALIGN(4);
} >FLASH

作用：存放只读数据，因为这些数据不需要修改，放在 FLASH 中可节省 RAM 空间。
示例：const char str[] = "STM32";会被编译到.rodata段，运行时直接从 FLASH 读取，不会复制到 RAM。

（4）.ARM.extab/.ARM：ARM 架构兼容段（放 FLASH）

.ARM.extab (READONLY) : 
{
  . = ALIGN(4);
  *(.ARM.extab* .gnu.linkonce.armextab.*)
  . = ALIGN(4);
} >FLASH

.ARM (READONLY) : 
{
  . = ALIGN(4);
  __exidx_start = .;
  *(.ARM.exidx*)     // ARM异常索引表（C++异常处理用）
  __exidx_end = .;
  . = ALIGN(4);
} >FLASH

作用：主要用于ARM 架构与 Thumb 架构的兼容，以及 C++ 的异常处理（若项目用纯 C，这些段几乎为空，但保留可避免链接错误）。
READONLY：标记为只读，与 FLASH 的权限匹配（GCC11 + 支持，低版本需删除）。

（5）.preinit_array/.init_array/.fini_array：初始化 / 结束函数数组（放 FLASH）

.preinit_array (READONLY) : 
{
  . = ALIGN(4);
  PROVIDE_HIDDEN (__preinit_array_start = .);
  KEEP (*(.preinit_array*))  // 预初始化函数（如动态库预初始化）
  PROVIDE_HIDDEN (__preinit_array_end = .);
  . = ALIGN(4);
} >FLASH

.init_array (READONLY) : 
{
  . = ALIGN(4);
  PROVIDE_HIDDEN (__init_array_start = .);
  KEEP (*(SORT(.init_array.*)))  // 初始化函数（如C++全局对象的构造函数）
  KEEP (*(.init_array*))
  PROVIDE_HIDDEN (__init_array_end = .);
  . = ALIGN(4);
} >FLASH

.fini_array (READONLY) : 
{
  . = ALIGN(4);
  PROVIDE_HIDDEN (__fini_array_start = .);
  KEEP (*(SORT(.fini_array.*)))  // 结束函数（如C++全局对象的析构函数）
  KEEP (*(.fini_array*))
  PROVIDE_HIDDEN (__fini_array_end = .);
  . = ALIGN(4);
} >FLASH

作用：存放程序启动 / 退出时自动执行的函数数组（主要用于 C++），例如：
- init_array：main函数执行前，会自动调用这里的函数（如全局对象A a;的构造函数）。
- fini_array：main函数退出后，会自动调用这里的函数（如全局对象的析构函数）。
PROVIDE_HIDDEN：若用户代码未定义__init_array_start等符号，链接器自动提供（隐藏符号，避免冲突）；KEEP确保这些段不被优化删除。

（6）.data：初始化数据段（放 RAM，加载地址在 FLASH）

/* used by the startup to initialize data */
_sidata = LOADADDR(.data);  // 定义符号：.data在FLASH的加载地址（LMA）

.data :
{
  . = ALIGN(4);
  _sdata = .;        // 定义符号：.data在RAM的运行地址（VMA）
  *(.data)           // 初始化的全局/静态变量（如int a = 10;）
  *(.data*)          // 扩展初始化数据段
  *(.RamFunc)        // 要放到RAM中执行的函数（如某些快速中断处理函数）
  *(.RamFunc*)       // 同上

  . = ALIGN(4);
  _edata = .;        // 定义符号：.data在RAM的结束地址
} >RAM AT> FLASH  // 运行地址（VMA）在RAM，加载地址（LMA）在FLASH

核心概念：VMA（虚拟 / 运行地址）和LMA（加载地址）：
- >RAM：.data段的运行地址（VMA） 在 RAM（因为变量需要读写）。
- AT>FLASH：.data段的加载地址（LMA） 在 FLASH（编译时将变量初始值存到 FLASH，节省 RAM）。
与启动流程关联：启动文件的Reset_Handler会从_sidata（FLASH 的 LMA）复制数据到_sdata（RAM 的 VMA），直到_edata—— 这就是 “初始化.data 段” 的具体实现。
.RamFunc：某些对执行速度要求高的函数（如高频中断服务函数），可通过__attribute__((section(".RamFunc")))标记，链接时会放到 RAM 中执行（RAM 访问速度比 FLASH 快）。

（7）.bss：未初始化数据段（放 RAM）

.bss :
{
  _sbss = .;         // 定义符号：.bss在RAM的起始地址
  __bss_start__ = _sbss;
  *(.bss)            // 未初始化的全局/静态变量（如int b;）
  *(.bss*)           // 扩展未初始化数据段
  *(COMMON)          // 未初始化的全局变量（如extern int c;）

  . = ALIGN(4);
  _ebss = .;         // 定义符号：.bss在RAM的结束地址
  __bss_end__ = _ebss;
} >RAM

作用：存放未初始化的全局 / 静态变量，C 语言标准要求这些变量初始化为 0，因此不需要在 FLASH 中存储初始值（节省 FLASH 空间）。
与启动流程关联：启动文件的Reset_Handler会将_sbss到_ebss的 RAM 区域清零 —— 这就是 “清零.bss 段” 的具体实现。
COMMON：对应未声明但外部引用的全局变量（如extern int c;），链接时会分配到.bss 段。

（8）._user_heap_stack：堆和栈的占位段（放 RAM）

._user_heap_stack :
{
  . = ALIGN(8);      // 8字节对齐（堆/栈通常要求更高对齐，避免内存访问错误）
  PROVIDE ( end = . );    // 定义符号：RAM已分配区域的结束地址
  PROVIDE ( _end = . );
  . = . + _Min_Heap_Size; // 堆区域：从当前地址分配_Min_Heap_Size大小
  . = . + _Min_Stack_Size;// 栈区域：在堆之后分配_Min_Stack_Size大小
  . = ALIGN(8);
} >RAM

作用：为堆和栈预留空间，并检查 RAM 是否足够 —— 若堆 + 栈 + 已分配段（.data+.bss）的总大小超过 RAM 容量，链接器会报错。
end/_end：标记 RAM 中 “已分配段（.data+.bss）” 的结束地址，堆从end开始向上生长，栈从_estack（栈顶）开始向下生长。
堆 / 栈生长方向：
- 堆：从end向上（地址增大方向）生长，供malloc/free使用。
- 栈：从_estack向下（地址减小方向）生长，供函数调用、局部变量使用。
- 若堆和栈生长时重叠，会导致内存溢出（硬 fault），因此需合理设置_Min_Heap_Size和_Min_Stack_Size。

如果使用了FreeRTOS的话，FreeRTOS的内存布局如下

（9）/DISCARD/：丢弃无用段（减小可执行文件大小）

/DISCARD/ :
{
  libc.a ( * )    // 丢弃标准C库的所有段
  libm.a ( * )    // 丢弃标准数学库的所有段
  libgcc.a ( * )  // 丢弃GCC编译器库的所有段
}

作用：嵌入式系统通常不需要标准库的完整功能（如printf的文件输出、malloc的复杂内存管理），丢弃这些段可大幅减小.elf/.hex文件的大小。
注意：若项目需要使用标准库功能（如printf、sqrt），需删除对应行，否则会出现 “未定义引用” 错误（需搭配newlib-nano等嵌入式精简库）。

四、总结：启动流程与.ld 文件的关联

硬件复位 → 内核读取FLASH起始地址（0x8000000）的.isr_vector段 → 找到Reset_Handler地址。
执行Reset_Handler → 利用.ld定义的_sdata/_sidata/_edata复制.data段 → 利用_sbss/_ebss清零.bss段。
调用main → 用户代码中的变量（.data/.bss）已在 RAM 中初始化，函数（.text）在 FLASH 中执行，堆 / 栈在 RAM 中预留空间。可以说：.ld 文件是 STM32 启动流程的 “地图”，没有它，启动文件不知道如何初始化内存，链接器不知道如何分配代码和数据，程序无法正常运行。

寄存器

认识一个CPU最直接的是去认识它的寄存器组（Register bank）

arm系统寄存器组

还有5个特殊寄存器

浮点数寄存器

通用寄存器

通用寄存器通用性强，常用于存储临时的数据其中R0-R7是低组寄存器，R8-R12是高组寄存器，高组寄存器部分指令无法访问

PC程序计数器&程序如何跑起来

arm架构中的R15寄存器，是程序计数器（program counter），该寄存器可读可写

在arm cortex-M的CPU内，每一次PC自增4（即向下移动了4个字节），但是在使用thumb指令集时，thumb指令集的部分指令是2个字节，这与处理器的执行流水线pipeline的特性有关，实际取址的时候是一次去4字节，也就是对于2字节的指令是一次取两条

CPU在不断执行程序，本质就是程序计数器的不断更新，PC指向的就是当前要执行的指令的地址

堆栈指针&双堆栈指针机制

栈是高址向低址方向生长，堆是低址向高址方向生长

arm cortex-M架构中R13是堆栈指针寄存器在物理上该寄存器是两个不同的寄存器MSP主堆栈指针和PSP进程堆栈指针，在程序运行时选用哪一个寄存器会有Control控制寄存器的值来决定

默认启动时，处理器使用的是主堆栈指针，可以修改Control控制寄存器的第一位的值来修改处理器使用的堆栈指针

双堆栈指针-MSP主堆栈指针，PSP进程堆栈指针可以用来实现隔离系统内核和应用程序任务

LR链接寄存器&函数调用的本质

函数调用的本质是程序执行流的动态转移与上下文管理，其核心在于通过栈来实现代码模块化执行和状态的保存与恢复

arm架构的CPU有专门设立一个寄存器R14(link register)，用于存放子函数的返回地址

以arm的bl指令为例（用于函数调用） bl <label>是跳转到标签地址，同时将返回地址存入LR寄存器

需要注意的是，arm cortex-M架构的处理器指令都是半字对齐（两字节对齐），所以其反汇编的地址都是偶数，存在lr寄存器的返回地址也都是偶数，但是lr寄存器的第0位必须设置为1来指示thumb指令集的状态，所以lr寄存器的值会是返回地址+1

在多级函数调用时，lr寄存器的值会被压入栈中

另外lr寄存器还能记录异常返回值。当处理器进入中断时，链接寄存器会更新为异常返回值，用来实现异常返回机制，用来记录区分一些工作模式现场，这些信息是恢复中断上下文需要的

地址分配

存储器系统

cortex-M处理器是32位地址，因此会有 4GB的地址空间，所有的指令和数据通过这个地址访问

硬件资源都是通过地址映射的方式访问另外cortex-M架构没有设置MMU内存管理单元，所以没有MMU内存管理单元，一般也不会搭载Linux,Windows这种通用类型的系统

地址映射图

F103C8的地址映射图

系统架构图

cortex-M3M4内核架构图

三级流水线外的设备属于CPU的内核外设，例如NVIC,SysTick系统滴答定时器，MPU等，用0xE004 0000-0xE00F F000地址访问

软件上就是通过读写外设地址空间来控制这些外设，对应的地址空间单元映射到外设寄存器

嵌入式编程本质就是在操作存储器，每一段CPU代码指令都是在读取某个地址空间的单元，高级编程语言就是不断向上封装抽象

C语言每条语句追溯到汇编都是在读写存储器的地址空间单元

关于内存和编译优化

指针是内存地址的容器关于i++与++i执行效率的问题，在O0优化的情况下，不同编译器的具体实现是不一样的，执行效率是不能直接比较的

编译优化会使汇编的指令在执行速度上提高，例如会使用mov去代替ldr，或者将一些简单的函数改为内嵌，以减少函数调用带来的开销

中断

在微机原理中已有涉及，后面只做简单回顾用

关于中断

中断的事件一般由硬件触发（实际有硬中断和软中断），会改变程序执行流

NVIC属于内核外设，专门管理中断

在cortex-M芯片中，前15项中断向量都一样

处理器具有向量表重定位功能，通过向量表偏移寄存器(VTOR)来获取向量表的起始地址

中断触发时，处理器通过中断向量表去获取中断处理函数的入口地址

中断返回&中断上下文

电脑为什么能边玩游戏边聊天？CPU这个骚操作，99%的程序员都说不清！| CPU / 多任务 / 进程上下文 / 中断机制_哔哩哔哩_bilibili

该视频中最后讲解的就类似于arm架构采用的方式

在阅读中断的汇编时，会发现中断没有保存和恢复上下文的代码，实际上是硬件帮忙实现上述功能

关于上下文，如程序上的函数调用需要保存上下文，在操作系统中需要处理线程上下文（任务上下文），其本质都在于保存和恢复若干寄存器的值

cortex-M3M4中断需要入栈保存上下文的8个寄存器选择保存上述8个寄存器主要是根据arm架构的过程调用标准，C语言的函数实现会改动这些寄存器，为例能让C函数能作为异常（中断）处理函数，中断（异常）机制需要能自动地保存这些寄存器，这些寄存器也被称之为调用者保存寄存器

处理器恢复上下文，回到原执行流，需要lr寄存器存储异常返回值来记录区分一些工作模式现场，这些信息是恢复中断上下文需要的

错误处理

介绍arm cortex-M处理器架构如何捕获和记录错误故障

有专门的寄存器去记录故障，通过查找其对应的地址查看寄存器的位来获取错误信息

在发生错误时，对应错误寄存器的对应位被置1，同时触发错误中断处理

程序执行非法指令操作导致系统进入不可恢复的故障状态，系统软件就会介入终止程序执行流，其实现机制是中断

待续

工具链的一些杂知识

Thu, 26 Jun 2025 15:21:07 +0800

MDK介绍及其使用

一文教你使用MDK开发工具-CSDN博客

MDK、KEIL、uVision 之间的区别

MDK（ Microcontroller Development Kit ），也称 MDK-ARM 、KEIL MDK、KEIL For ARM，都是同一个东西。ARM 公司现在统一使用 MDK-ARM 的称呼，MDK 的设备数据库中有很多厂商的芯片，是专为微控制器开发的一款工具，为满足基于 MCU 进行嵌入式软件开发的工程师需求而设计，支持 ARM7，ARM9，Cortex-M4/M3/M1，Cortex-R0/R3/R4 等 ARM 微控制器内核。KEIL 是公司的名称，有时候也指 KEIL 公司的所有软件开发工具。Keil 公司在2005年被 ARM 公司收购。

uVision 是 KEIL 公司开发的一个集成开发环境（IDE）。它包括工程管理，源代码编辑，编译设置，下载调试和模拟仿真等功能，uVision 有 uVision2、uVision3、uVision4 和 uVision5 四个版本，目前最新的版本是 uVision5。它提供一个环境，让开发者易于操作。uVision 通用于 KEIL 的开发工具中，例如 MDK，PK51，PK166，DK251等。

armclang

就是俗称的AC6 armclang是ARM公司提供的一款C/C++编译器，专门用于为ARM架构的处理器生成高性能代码。该编译器通常与ARM的其他工具链一起使用，适合嵌入式系统开发。

请注意，确保在项目中使用合适的工具和版本，并根据需求查阅最新的文档。

OpenOCD

跟我一起学OpenOCD(一) - 知乎 (zhihu.com)

OpenOCD是一个开源的调试/编程工具，主要用于嵌入式系统，它支持多种硬件设备和调试协议，如JTAG和SWD。它通常与GNU工具链结合使用，可以为开发人员提供硬件调试和烧录固件的功能。

Ozone

Ozone使用介绍-基础功能 - 开发环境 - 硬汉嵌入式论坛 - Powered by Discuz! (armbbs.cn)

MinGW

mingw 是一个为 Microsoft Windows 平台编译和运行 Unix 程序的工具套装，它提供了类似于 Unix 环境下的编译器、链接器等工具，以便在 Windows 平台上开发使用 GCC（GNU 编译器集合）和其他开源 Unix 工具的软件。

LLVM

LLVM基本概念入门 - 知乎

来自于百度百科的解释

LLVM 命名最早源自于底层虚拟机（Low Level Virtual Machine）的缩写，由于命名带来的混乱，LLVM就是该项目的全称。LLVM 核心库提供了与编译器相关的支持，可以作为多种语言编译器的后台来使用。能够进行程序语言的编译器优化、链接优化、在线编译优化、代码生成。LLVM的项目是一个模块化和可重复使用的编译器和工具技术的集合。

现在的LLVM是一个编译器框架。LLVM作为编译器框架，是需要各种功能模块支撑起来的，你可以将clang和lld都看做是LLVM的组成部分，框架的意思是，你可以基于LLVM提供的功能开发自己的模块，并集成在LLVM系统上，增加它的功能，或者就单纯自己开发软件工具，而利用LLVM来支撑底层实现。LLVM由一些库和工具组成，正因为它的这种设计思想，使它可以很容易和IDE集成（因为IDE软件可以直接调用库来实现一些如静态检查这些功能），也很容易构建生成各种功能的工具（因为新的工具只需要调用需要的库就行）

arm-none-eabi-gcc

arm-none-eabi-gcc 是一个专为 ARM 架构的嵌入式系统设计的 GCC 编译器版本。它可以生成裸机代码，适用于没有操作系统的应用程序。开发者常用它来编译针对 ARM Cortex 和其他 ARM 设备的软件。

arm-none-eabi-gcc 和 armclang的区别

arm-none-eabi-gcc 和 armclang 是两种不同的编译工具链，主要用于嵌入式系统中基于 ARM 处理器的代码编译。它们之间存在一些关键的区别，以下是它们各自的特点及区别的简要概述：

开发者和背景：
- arm-none-eabi-gcc: 是 GNU 编译器集合（GCC）的一个变体，专门用于 ARM 处理器。这个工具链是开源的，由 GNU 项目支持。
- armclang: 是 ARM 公司推出的编译器，属于 ARM Compiler 工具链的一部分。ARM Compiler 6及更高版本基于开源的 LLVM/Clang 技术，但包含许多 ARM 提供的专有优化和扩展。
编译技术和优化：
- arm-none-eabi-gcc: 利用 GCC 的优化技术，提供了广泛的架构支持和成熟的优化方法。
- armclang: 使用 LLVM 编译技术框架，通常提供更现代的优化策略和更好的代码生成质量，尤其是在 C++ 的高级特性支持方面。
语言支持：
- 两者都支持主要的编程语言如 C 和 C++。但是，由于 ARM Compiler 包括来自 LLVM/Clang 的优势，armclang 可能在支持最新 C++ 标准方面有更好的表现。
调试和错误信息：
- armclang 通常提供更详细的错误和警告信息，这可以使调试过程更加高效。
- arm-none-eabi-gcc 的错误信息较为传统，但由于广泛使用，网上有大量关于其调试的资源和社区支持。
生态系统和集成：
- arm-none-eabi-gcc 由于是开源和免费，被广泛应用于多种开发环境和项目中。其生态系统非常成熟，有大量的第三方库和工具支持。
- armclang 尽管集成了许多 ARM 特定的优化，但作为商业产品，可能在使用上不如 GCC 灵活，特别是在版权和许可证管理方面。
性能：
- 性能比较并不绝对，依赖于具体的应用场景和代码特性。在某些情况下，armclang 生成的代码运行效率更高，而在其他情况下，arm-none-eabi-gcc 可能表现得更好。

在选择哪一个编译器进行项目开发时，需要考虑多个因素，如团队的熟悉度、项目需求对优化的依赖程度、成本（尤其是 armclang 可能涉及的许可成本）以及与其他工具的兼容性等。

clangd

clangd是llvm项目推出的C++语言服务器，通过LSP(Language Server Protocal)协议向编辑器如vscode/vim/emacs提供语法补全、错误检测、跳转、格式化等等功能。C++的LSP曾经是cquery, ccls, clangd三足鼎立。但是clangd支持clang-tidy实时检查的功能是另外两者不具备的，而且cquery和ccls都是单个开发者主导的项目，clangd背后则是有llvm的背书。目前来看，“姓赵”的clangd在这场c++ lsp赛跑中已经有了不小的领先优势。

VScode的IntelliSense

IntelliSense 是 VS Code 提供的智能代码补全和理解功能，它结合了代码补全、参数信息、快速信息和成员列表等功能，极大地提高了开发效率。

IntelliSense 的核心组成

代码补全 (Code Completion)
- 输入时自动显示建议列表
- 包含变量、函数、类、方法等
- 支持模糊匹配 (如输入 fs.rm 可匹配 fs.rmdir)
参数提示 (Parameter Hints)
- 显示函数参数信息
- 当前参数位置高亮显示
- 函数重载时可通过箭头切换
快速信息 (Quick Info)
- 悬停时显示符号定义
- 包含文档注释、类型信息等
错误检查 (Error Checking)
- 实时语法检查
- 类型错误检测
- 未定义符号提示

IntelliSense 的工作原理

VS Code 通过以下方式提供 IntelliSense：

基于词法分析：简单的文本匹配补全
基于语言服务器协议 (LSP)：通过语言服务器获取深度分析
基于 TypeScript/JavaScript 的 TS Server：专为 JS/TS 优化
基于标签 (Tag Parser)：如 C/C++ 扩展使用的方案

交叉编译器

在一种计算机环境中运行的编译程序，能编译出在另外一种环境下运行的代码，这个编译过程就叫交叉编译.简单地说，就是在一个平台上生成另一个平台上的可执行代码

arm 交叉编译器各种gcc 傻傻分不清楚：gnueabi,gnueabhf,none-eaib - 知乎

交叉编译工具链的命名规范

arch [-vendor] [-os] [-(gnu)eabi]

arch : 架构的意思，如ARM ，MIPS

vendor：工具链的提供厂商

os：支持的操作系统

eabi：嵌入式应用二进制接口（Embedded Application Binary Interface）

arm gcc还分为是否支持操作系统 支持操作系统： arm-none-linux-eabi-gcc 不支持操作系统： arm-none-eabi-gcc none表示vendor是none，也就是不属于某一公司的（更多的解释是none是指无操作系统）

ABI 和 EABI

ABI：二进制应用程序接口(Application Binary Interface (ABI) for the ARM Architecture)。在计算机中，应用二进制接口描述了应用程序（或者其他类型）和操作系统之间或其他应用程序的低级接口。

EABI：嵌入式ABI。嵌入式应用二进制接口指定了文件格式、数据类型、寄存器使用、堆积组织优化和在一个嵌入式软件中的参数的标准约定。开发者使用自己的汇编语言也可以使用 EABI 作为与兼容的编译器生成的汇编语言的接口。

两者主要区别是，ABI是计算机上的，EABI是嵌入式平台上（如ARM，MIPS等）

ninja，make，cmake

cmake

make与ninja

make功能强大，可以给人看，ninja启动速度快，项目构建速度快，但不是给人看的可以认为两者同级。

层级关系

开发者层：编写CMakeLists.txt定义构建规则
生成器层：CMake解析配置，生成底层构建文件
执行器层：Make/Ninja执行具体构建命令
工具链层：编译器(如gcc)、链接器等实际执行编译

HAL库（Hardware Abstraction Layer 硬件抽象层库）

1. 核心定义与归属

2. 核心组成模块

外设驱动模块：覆盖 STM32 所有常用外设（GPIO、UART、SPI、I2C、ADC、DAC、定时器、DMA、CAN、USB 等），每个外设都封装了完整的操作接口（初始化、配置、数据收发 / 采集、中断处理等）。
系统级功能模块：包含时钟树配置（HAL_RCC_XXX 系列函数）、中断控制器配置、低功耗模式（睡眠 / 停机 / 待机）管理、复位处理等核心系统功能。
工具链适配模块：兼容主流开发环境（STM32CubeIDE、Keil MDK、IAR EWARM），支持与 STM32CubeMX（图形化配置工具）联动，可自动生成初始化代码，大幅减少手动编码工作量。
辅助功能模块：提供延时函数（HAL_Delay）、错误处理机制、外设状态查询等通用工具函数，提升开发便捷性。

CMSIS（Cortex Microcontroller Software Interface Standard）

1. 核心定义与归属

2. 核心组成模块（关键子规范）

CMSIS-Core（内核核心层）：最基础、最核心的模块，定义了：
- 内核寄存器的统一访问接口（如 NVIC 中断控制器、Systick 定时器、MPU 内存保护单元的配置函数）；
- 系统初始化函数（SystemInit()）、时钟配置接口，统一不同厂商 Cortex-M MCU 的内核启动流程；
- 内核状态查询、中断优先级管理等通用 API，避免开发者直接操作内核寄存器导致的兼容性问题。
CMSIS-Driver（外设驱动接口层）：定义了外设驱动的统一接口模板（如 UART、SPI、GPIO、ADC 等），厂商需按该模板实现驱动函数（如UART_Transmit、SPI_Receive），确保不同厂商的外设驱动接口一致。
CMSIS-RTOS（实时操作系统接口层）：定义了 RTOS 的统一 API 规范（如任务创建、信号量、消息队列、定时器等），主流 RTOS（FreeRTOS、RTX5、μC/OS-III）均遵循该标准，使 RTOS 能跨厂商 MCU 无缝移植。
CMSIS-DSP（数字信号处理库接口层）：定义了 DSP 功能的统一接口（如 FFT、滤波、矩阵运算、PID 控制等），ARM 提供了标准的 CMSIS-DSP 库实现，开发者可直接调用，无需关注底层算法细节。
CMSIS-Pack（软件包格式层）：统一了 MCU 设备描述、驱动库、中间件、示例代码的打包格式，方便开发工具（如 Keil MDK、STM32CubeIDE）自动识别、导入和管理软件资源。

3. 特点与适用场景

优点：通用性极强、跨平台性好、生态完善，是 Cortex-M MCU 开发的 “通用语言”，适用于所有基于 Cortex-M 内核的 MCU 项目，尤其适合需要跨厂商移植、使用中间件（RTOS/DSP）的复杂项目。
缺点：仅定义接口规范，不提供具体的驱动实现（需厂商或第三方基于规范开发），开发者无法直接使用 CMSIS，必须结合厂商库（如 HAL 库）或第三方库才能落地。

HAL 库与 CMSIS 的关系

层级关系：CMSIS 是 底层标准，HAL 库是 基于 CMSIS 标准的具体实现——HAL 库的内核操作（如中断配置、Systick 定时器、时钟初始化）完全遵循 CMSIS-Core 规范，外设驱动接口也兼容 CMSIS-Driver 模板。
作用互补：
- CMSIS 解决 “跨厂商兼容性”：让代码能在 ST、NXP、TI 等不同厂商的 Cortex-M MCU 间移植；
- HAL 库解决 “ST 内部跨型号开发效率”：让 STM32 用户无需关注 CMSIS 底层细节，快速调用封装好的 API 开发功能。
依赖关系：HAL 库必须遵循 CMSIS 标准才能保证兼容性（否则无法适配 Cortex-M 内核）；而 CMSIS 需要 HAL 库这类厂商库来落地实现，才能被开发者直接使用（CMSIS 本身只是 “规则”，不是可执行代码）。简单总结：CMSIS 是 “通用接口规则”，HAL 库是 ST 按规则为 STM32 定制的 “工具包”，两者结合既保证了跨平台兼容性，又提升了 STM32 的开发效率。

微机原理

Tue, 24 Jun 2025 23:16:11 +0800

常见名词

CPU，中央处理单元，Central Processing Unit

ALU，算术逻辑单元，Arithmetic and Logic Units

CU，控制单元，控制器，Control Unit

CPU通常由中央处理单元，算术逻辑单元，寄存器组三部分组成

EU，执行单元，Execution Unit

BIU，总线接口单元，Bus Interface Unit

PC，程序计数器，Program Counter

IR，指令寄存器，Instruction Register

GR，通用寄存器，General Register

注意$IO$端口和$IO$接口不是同一个东西

操作系统知识：程序计数器（pc）、指令寄存器（IR）、通用寄存器（GR）、状态寄存器（SR）、程序状态字PSW_pc和ir-CSDN博客

特殊运算符和指令

PTR用来指定存储器操作数的字长 Byte PTR[BX]

所有单操作数指令要求操作数不能是立即数，如果是存储器操作数，需要指定字长

微型计算机基础概论

微型计算机系统

微型计算机系统由硬件系统和软件系统组成 硬件系统 硬件系统由微型计算机（主机）和外设组成

微型计算机（主机）由微处理器（CPU），存储器，IO接口，总线组成
外设就包括键盘，鼠标，显示器，硬盘等

软件系统 软件系统由系统软件和应用软件构成

微型计算机运行流程 微机运行的基本流程为，程序存储在存储器中，按程序流程自动连续取出指令并执行；自动连续的实现是程序计数器 PC 的自增；步骤可概括为取指令、译码、执行。修改 PC 指针的值，可实现程序的顺序执行、跳转、循环、过程调用和中断服务等功能。

计算机中的数制与编码

十进制D，二进制B，十六进制H，八进制O

有符号二进制数的表示

最高位是符号位，0表示正号，1表示负号

原码数值部分保持不变，最高位是符号位反码正数的反码与正数的原码一样负数的反码等于负数原码数值部分按位取反补码正数的补码与正数的反码和原码一样负数的补码的符号位与负数原码一致，数值部分等于负数原码数值部分取反后再加1

特殊数-128的补码表示为10000000

微处理器与总线

CPU中央处理单元

CPU是微型计算机的运算和指挥控制中心一般由ALU（运算器），CU（控制单元），寄存器组组成 CPU内还有两个独立部件：EU（执行单元）和BIU（总线接口单元）

微处理器主要性能指标

CPU的字长/位数，及其一次性能处理的位数 CPU主频，指的是CPU时钟频率

CU控制单元

控制器的作用是控制程序的执行，是整个系统的指挥中心具备以下功能

指令控制
时序控制
操作控制

EU执行单元

EU负责分析指令（指令译码），执行指令在工作时不断从BIU的指令队列取指令

BIU总线接口单元

BIU主要功能是负责CPU与存储器，IO接口之间的信息传送 BIU可以负责取指令，取操作数，写结果 BIU内部有一个指令队列和地址加法器地址加法器能产生20位的物理地址

CPU程序执行步骤

从存储器取出下一条指令
指令译码
如果指令需要，从存储器中读取操作数
执行指令（算术逻辑运算，IO操作，数据传输等）
如果需要，写入存储器核心步骤，取指令，译码指令，执行指令

工作时序

时钟周期：每个时钟脉冲持续的时间
总线周期：通过总线进行一次读或写操作的过程称为一个总线周期，一个总线周期包含多个时钟周期
指令周期：执行一条指令所需的时间，一个指令周期包含多个总线周期一个基本的总线周期由四个时钟周期构成，若内存或 IO 接口速度较慢，则还会在 T3 后插入 Tw 等待周期。

写操作为例的总线周期包含4个时钟周期（T1,T2,T3,T4） T1地址输出，T2缓存，T3和T4数据输出

8088/8086 CPU

8088与8086处理器的区别

8088 外部数据线为8根（8086为16根），为准16位CPU，16 位数据要分两次传送；（注意：8088和8086均为16位处理器，内部数据线均为16位，且地址总线均为20位）指令预取队列：8088为4字节，8086为6字节

两者均有两种工作模式，最小工作模式和最大工作模式

8088/8086指令流水线

采用EU（执行单元）和BIU（总线接口单元）并行工作，可同时取指令，执行指令，分析指令

补充-流水线技术

在指令执行过程中，有几类指令相关影响流水线中指令的执行，使得指令不能在预先设定的执行周期中执行，造成流水线断流 相关问题 结构相关；数据相关；控制相关

结构相关

当CPU的硬件结构不能够同时支持几条指令的执行时，这几条指令将发生结构相关，比如流水线同时访问同一个存储器

数据相关

一条指令的执行需要上一条或者上几条指令的执行结果时，会造成流水线的断流现象。

所以，当发生数据相关时，需要尽可能早的把上一条或上几条指令的执行结果交给相关指令作为操作数。这就需要“内部前推

控制相关

当指令执行到分支指令或者跳转指令时，将产生控制相关，此时会产生流水线断流。解决方法：

阻塞流水线直到确定走向
预测分支是否发生，并给予该预测执行指令

8088/8086内存分段

8088/8086内部结构为16位，为了增大内存管理能力使其能产生20位的物理地址，采用了分段管理方法

段首地址即段基地址 20位物理地址=段基地址 * 16+段偏移地址

8088/8086内部寄存器

8088/8086内部寄存器分为通用寄存器（8个），段寄存器（4个），控制寄存器（2个）

通用寄存器

通用寄存器包括数据寄存器，地址指针寄存器，变址寄存器

数据寄存器

AX（Accumulator）：累加器，常用于存放算术逻辑运算中的操作数，另外所有的IO指令都是用累加器与外设接口传送信息
BX（Base）：基址寄存器，常用来存放访问内存时的偏移地址（一般和DS一起用DS:[BX]）
CX（Count）：计数寄存器，在循环和串操作指令中用作计数器
DX（Data）：数据寄存器，在寄存器间接寻址的IO指令中存放IO端口地址

都可拆分为H，L两个8位寄存器

在做双字节乘除法运算时，DX与AX可以合起来存一个双字长的数（32位），DX存高16位，AX存低16位

地址指针寄存器

SP（Stack Pointer）：堆栈指针寄存器，常用来存放栈顶偏移地址
BP（Base Pointer）：基址指针寄存器，一般也用来存放访问内存时的偏移地址（一般和SS一起用SS:[BP]）

BX和BP区别: (1)作为通用寄存器，二者均可用于存放数据；(2)作为基址寄存器，用BX表示所寻找的数据在数据段；用BP则表示数据在堆栈段

变址寄存器

SI（Source Index）：源变址寄存器
DI（Destination Index）：目的变址寄存器

段寄存器

段寄存器，用于存放段基址，即段起始地址的高16位

CS（Code Segment）：代码段寄存器
SS（Stack Segment）：堆栈段寄存器
DS（Data Segment）：数据段寄存器
ES（Extra Segment）：附加数据段寄存器

控制寄存器

IP（Instruction Pointer）：指令指针寄存器，其内容为下一条要执行指令的偏移地址（CS段中）

标志寄存器

FLAGS：状态寄存器，16位寄存器 状态标志位
CF（Carry Flag）：进位标志位，进行加减运算时，若最高位向前有进位错位，则CF=1
PF（Parity Flag）：奇偶标志位，运算结果低8位中1的个数为偶数，PF=1
AF（Auxiliary Carry Flag）：辅助进位标志位，加减法运算，D3向D4进位时，AF=1
ZF（Zero Flag）：零标志位，运算结果为0时，ZF=1
SF（Sign Flag）：当运算结果最高位为1时，SF=1
OF（Overflow Flag）：当算术结果超出了 带符号数的范围时，即溢出时，OF=1

控制标志位

TF（Trap Flag）：陷井标志位，也叫跟踪标志位。TF=1时，使CPU处于单步执行指令的工作方式
IF（Interrupt Enable Flag）：中断允许标志位。IF=1使CPU可以响应可屏蔽中断请求
DF（Direction Flag）：方向标志位。在数据串操作时确定操作的方向

IF=1，允许响应可屏蔽中断请求，对应指令：STI IF=0，禁止响应可屏蔽中断请求，对应指令：CLI

DF=0，串操作指令中的地址是增加方向，对应指令：CLD DF=1，串操作指令中的地址是减少方向，对应指令：STD

TF=1，CPU按跟踪方式（单步方式）执行程序

8088外部引脚及其功能

最小模式下的引脚描述

按功能对引脚进行划分：

基础工作引脚：$Vcc,GND,CLK(4.77Mhz)$
地址总线：${AD}0-{AD}7,A_8-A{15},A{16}-A_{19}$
数据总线：${AD}_0-{AD}_7$
模式控制引脚：$MN/\overline{MX}$
读写控制引脚：$IO/\overline M,\overline{RD},\overline{WR}$
中断控制引脚：$INTR,NMI,INTA$
复位：$RESET$
总线保持请求/响应：$HOLD,HLDA$
地址锁存信号：$ALE$
外部就绪信号：$READY$
测试信号输入：$\overline {TEST}$
数据传输方向控制：$DT/\overline R$
数据允许信号：$\overline {DEN}$
系统状态输出：$\overline{{SS}_0}$（与$IO/\overline M,DT/\overline R$合作）

各引脚具体功能

$A_{16}-A_{19}/S_3-S_6$：地址，状态复用的引脚，三态输出。（分时复用）状态信号中$S_6$恒等于0，$S_5$指示中断允许标志位$IF$的状态，$S_4,S_5$组合指示CPU正在使用的段寄存器
$A_8-A_{15}$：8位地址信号，三态输出
${AD}{0}-{AD}{7}$：地址，数据分时复用的双向信号线，三态。当$ALE=1$时，这些引脚上传输的是地址信号，当$\overline {DEN}=0$时，这些引脚上传输的是数据信号
$IO/\overline M$：输入输出/存储器控制信号，三态。该引脚是用来区分当前操作是访问存储器还是访问$IO$端口
$\overline {WR}$：写信号输出，三态。当此引脚输出为低电平时，表示CPU正在对存储器或IO端口进行写操作
$DT/\overline {R}$：数据传送方向控制信号，三态。高电平时，CPU向存储器或IO端口发送数据；低电平时，CPU从存储器或IO接口接收数据
$\overline {DEN}$：数据允许信号，三态。该信号有效时，表示数据总线上具有有效信号。它在每次访问内存或IO接口以及在中断响应期间有效，常用作数据总线驱动信号
$ALE$：地址锁存信号，三态输出，高电平有效。它为高电平时，表示CPU地址线上有有效地址
$\overline {RD}$：读选通信号，三态输出，低电平有效。其有效时，表示CPU正在对存储器或IO接口进行读操作
$READY$：外部同步控制输入信号，高电平有效。它是由被访问的内存或IO设备所发出的响应信号。它为高电平时，表示存储器或IO设备已经准备好，CPU可以进行数据传送。CPU在T3的周期采样$READY$信号，若其为低，CPU自动插入等待周期$T_w$
$INTR$ ：可屏蔽中断请求输入信号，高电平有效。CPU在每条指令的最后一个周期采样该信号，以决定是否进入中断响应周期
$\overline {TEST}$：测试信号输入引脚
$NMI$：非屏蔽中断请求输入信号，上升沿触发。这个引脚上的中断请求信号不能用让软件屏蔽，CPU在当前指令
$RESET$：系统复位输入信号，高电平有效。
$\overline {INTA}$：中断响应信号输出，低电平有效，此信号是CPU对中断请求信号$INTR$ 的响应。在响应过程中，CPU在$\overline {INTA}$上连续输出两个负脉冲用作外部中断的中断向量码的读选通信号
$HOLD$：总线保持请求信号输入，高电平有效。当某一总线主控设备要占用系统总线时，通过此引脚向CPU提出请求
$HLDA$：总线保持响应信号输出，高电平有效。这是CPU对$HOLD$请求的响应信号。CPU收到$HOLD$信号后，就会对其做出响应，一方面会使CPU的所有三态输出的地址信号，数据信号和对应的控制信号变为高阻态；同时输出一个有效的$HLDA$，表示CPU已放弃对总线的控制。当CPU检测到$HOLD$信号变低后，就立即使$HLDA$变低，同时恢复对总线的控制
${SS}_0$：系统状态信号输出
$CLK$：时钟信号输入引脚
$Vcc$：5V电源输入引脚
$GND$：地线

8088/8086结构功能

外部结构

总线

总线定义

总线是传输信号或信息的公共路径，是遵循同一技术规范的连接与操作方式

总线特点

公共性，可同时挂在多个设备

总线分类

按传送的信息类型分类

数据总线（Data Bus）
地址总线（Address Bus）
控制总线（Control Bus）

按总线的层次结构划分

前端总线
系统总线
外设总线

总线结构

单总线结构，多总线结构

总线基本功能

总线上任意时刻只能允许一对设备进行信息交换

总线传输同步：协调通信双方的传输操作
总线仲裁控制：避免多个设备同时使用总线造成的冲突，确定总线上哪个设备可以占用总线传输数据
出错处理：检错和处理
总线驱动：增加驱动能力

总线的数据传送

1.同步定时的传输方式

用公共的时钟统一各部件数据发送和接收的时机（严格按节拍进行，不需要握手信号，效率高）

2.异步定时的传输方式

用控制和状态信号协调各部件数据发送和接收的时机（应答式）

3.半同步定时的传输方式

允许不同速度的部件协同工作，主控设备可以根据从设备的状态延长总线时钟周期，但总线周期一定是时钟周期的整数倍

常用系统总线和外设总线标准

常用的系统总线标准包括：ISA 总线、PCI 总线、PCIE 总线、AGP 总线常用的外设总线标准包括：SATA 总线、USB 总线、RS485 总线、IDE 总线、RS232 总线

指令系统

指令：控制计算机完成指定操作并能够被计算机所识别的命令。指令系统：一台计算机能够识别的所有指令的集合称为该机的指令系统

指令格式： 操作码操作数1，操作数2 操作数数量：零操作数指令，单操作数指令，双操作数指令

指令中操作数类型：立即操作数，寄存器操作数，存储器操作数寄存器操作数的指令执行速度> 立即数操作数> 存储器操作数

CISC（Complex Instruction Set Computer），复杂指令系统计算机 RISC（Reduced Instruction Set Computer），精简指令系统计算机

指令性指令是CPU中实际存在的可执行的语句。指示性语句是用于说明程序结构，变量等的语句，后者在编译过程中执行，编译完成后不再存在

对于每个指令

指令码的含义
指令对操作数的要求
指令对标志位的影响
指令的功能

寻址方式

立即寻址（Immediate Addressing）

源操作数是立即数，立即数存放在代码段 MOV AX,3102H

直接寻址（Direct Addressing）

操作数是存储器操作数，存放的地址由指令直接给出 MOV AX,[3102H]

寄存器寻址（Register Addressing）

操作数为CPU内部寄存器 MOV AX,BX

寄存器间接寻址（Register Indirect Addressing）

寄存器存放的不是数据本身，而是存放数据的偏移地址寄存器间接寻址方式中存放操作数偏移地址的寄存器只允许是 $SI,DI,BX,BP$，它们也被称为间址寄存器

选择$SI,DI,BX$作为间址寄存器时，操作数在数据段，段基址由$DS$决定
选择$BP$作为间址寄存器，则操作数在堆栈段，段基地址由$SS$决定允许段重设 MOV AX,[BX] MOV AX,ES:[SI]

寄存器相对寻址

操作数在内存中的偏址地址由间址寄存器的值加上一个8位或16位的偏移量 MOV AX,DATA[BX] MOV AX,[BX+DATA]

基址-变址寻址

基址-变址寻址方式由一个基址寄存器存的值和一个变址寄存器存的值相加得到偏移地址

不允许出现两个基址寄存器
不允许出现两个变址寄存器 MOV AX,[BX][SI] MOV AX,[SI][BX] MOV AX,[BX+SI]

基址-变址-相对寻址

所寻地址在内存中，偏移地址由一个基址寄存器、一个变址寄存器和数值偏移量相加给出。其它规定同“基址-变址寻址” MOV AX,DATA[SI][BX] MOV AX,[BX+DATA][SI] MOV AX,[BX+SI+DATA] MOV AX,[BX+SI]DATA MOV AX,[BX]DATA[SI]

隐含寻址

指令中隐含了部分固定的操作数的地址 MUL BL 把AL与BL相乘的乘积放入AX

堆栈段

规定由SS指示堆栈段的段基址，堆栈的最低地址堆栈指针SP始终指向堆栈的顶部（栈顶）。堆栈的最高地址叫栈底栈的压入指令 PUSH src 栈的弹出指令 POP dest

操作原则

操作数为1个字，且只能是寄存器或存储器操作
存放数据从高地址向低地址方向增长
堆栈段位置由SS决定，SP指向栈顶
PUSH压入过程为先减SP再压数据

1
2
3

SP-2 -> SP
src高8位->[SP+1]
src低8位->[SP]

POP弹出过程为先弹数据再加SP

1
2
3

[SP]->dest低8位
[SP+1]->dest高8位
SP+2->SP

堆栈主要用途：保护现场

数据传送指令

数据传送指令的执行均不影响标志位

一般传送指令MOV

MOV dest,src 对操作数要求：

两个操作数字长相同
两个操作数不能同时为存储器操作数
不能用立即数直接给段寄存器赋值
两个操作数不能同时为段寄存器
IP和CS只作为MOV的源操作数，不做目标操作数
FLAGS整体不能作为操作数

两个操作数不能同时为存储器操作数，原因是存储器不能确定字长，是在存储器中取1个字节还是多个字节，没有限定

堆栈操作指令PUSH和POP

PUSH src POP dest 操作数为1个字，且只能是寄存器或存储器操作，不能是立即数

交换指令XCHG

功能：交换源地址与目标地址中的内容 XCHG OPRD1,OPRD2

输入/输出指令IN和OUT

功能：对输入/输出端口进行读写输入指令IN用于从IO端口读数据到累加器AL（AX）中输出指令OUT用于把累加器AL（AX）的内容写到IO端口 IO端口寻址

直接寻址：指令中的IO端口地址为8位

1
2

IN AL/AX,port
OUT port,AL/AX

寄存器间接寻址：端口地址为16位，由DX寄存器指定

1
2

IN AL/AX,DX 
OUT DX,AL/AX

操作原则

只有AL或AX可以与I/O端口进行数据交换
IO端口地址可以是8位立即数指向的地址（即直接寻址）或由DX保存的16 位地址（即间接寻址）当端口地址是16位时，只能用DX取给定端口地址

取偏移地址指令LEA （Load Effect Address）

功能：将存储器操作数的16位偏移地址送到指定寄存器 LEA reg16, mem 操作原则

源操作数必须是存储器操作数，如： LEA BX, BUFFER LEA BX, [SI]
目标操作数必须是16位通用寄存器，最好使用间址寄存器（BX, SI, DI, BP）源操作数必须是存储器操作数

算数运算指令

不带进位和带进位的加减指令无符号和有符号的乘除指令

算术运算指令的执行会影响状态标志位乘法指令执行结果为相乘数的双倍字长除法指令被除数是除数的双倍字长

乘法指令

乘法指令采用隐含寻址，隐含了存放被乘数的累加器AL或AX，以及存放结果的AX或AX，DX

无符号乘法指令 MUL BYTE PTR[BX] 有符号乘法指令 IMUL OPRD

除法指令

DIV OPRD 如果$OPRD$是单字节数意思是$AX/OPRD$ 结果：AL=商，AH=余数如果$OPRD$是双字节数意思是$DX,AX/OPRD$ 结果：AX=商，DX=余数

算数移位指令

非循环移位

算数移位，逻辑移位左移，右移

循环移位

分为带进位移位和不带进位移位

存储器

RAM（Random-Acess Memory）一般可分为SRAM（静态RAM），DRAM（动态RAM） ROM（Read Only Memory）一般可分为掩膜ROM，一次性可写ROM，EPROM，EEPROM，闪速存储器Flash

高位地址，选通芯片低位地址，选芯片的读写单元

译码，将输入的一组高位地址信号通过变换，产生一个有效的输出信号，用于选中某一个存储器芯片，从而确定了该存储器芯片在内存的地址范围

全地址译码 用全部高位地址信号作为译码信号，使得存储器芯片的每一个单元都占据一个唯一的内存地址 部分地址译码 用部分高位地址信号作为译码信号，使得被选中存储器芯片占有几组不同的地址范围

Cache高速缓冲器 Cache高速缓冲存储器，Cache是构成内存储器的部件之一，设置Cahce的原因是内存的速度与处理器的工作速度不匹配

微机中的存储器系统

Cache存储器系统
虚拟存储器系统 Cache存储系统 Cache存储系统主要有Cache高速缓冲器和主内存构成，有硬件系统负责管理

IO系统

输入输出系统 在计算机系统中，通常把处理器和主存储器之外的部分统称为输入/输出系统，包括输入/输出设备、输入/输出接口和输入/输出软件

IO接口 IO接口就是外设连接到系统总线上的一组逻辑电路的总称

IO端口 端口是接口电路中用于缓存数据及控制信息的部件 CPU与I/O接口进行通信实际上是通过I/O接口内部的一组寄存器实现的，这些寄存器通常称为I/O端口（I/O Port）。它包括3种类型：数据端口、状态端口和命令（控制）端口

IO端口编址方式 分为统一编址和独立编址

I/O端口与内存单元统一编址，指令及控制信号统一，内存地址资源减少
I/O端口独立编址，内存地址资源充分利用，使用不同的控制信号，能够应用于端口的指令较少

输入接口需要具备数据控制能力，一般采用三态门接口，防止外设的输入影响数据总线，如74LS244

输出接口需要具备数据锁存能力，一般采用锁存器接口，如74LS273

基本输入输出方式

1.无条件传送方式 2.查询方式 3.中断方式 4.直接存储器存取方式（DMA）

中断

CPU执行程序中，由于发生了某种随机的事件(外部或内部)，引起CPU暂时中断正在运行的程序，转去执行一段特殊的服务程序(称为中断服务程序或中断处理程序)，以处理该事件，该事件处理完后又返回被中断的程序继续执行，这一过程称为中断

中断响应过程

可屏蔽外部中断响应过程

通过两个连续的中断响应总线周期获取中断类型码获取中断向量后并调用中断，服务程序

内部中断响应过程

无中断响应总线周期中断类型码固定或由指令（INT n）给出

主要芯片

1.计数器8253

特殊引脚

CLK——时钟脉冲输入
GATE——门控信号输入
OUT——定时输出

编程方式

控制字直接写入控制寄存器
计数值写入对应计数器

工作方式

总览

16位减法计数，计数值减为0时输出相应控制信号
输出控制信号的形式可通过软件设置

方式0——计数结束中断

软件启动，不自动重复计数计时结束输出高电平，输出可以用作中断请求信号

不自动重复计数是指 每写入一次计数初值只计数一个周期

方式1——可重复触发的单稳态触发器

硬件启动，不自动重复计数但是可以通过GATE重复触发计数，当GATE出现上升沿时，下一个CLK的下降沿开始计数计数结束后，OUT端输出高电平

方式2——频率发生器

既可以软件启动，也可以硬件启动自动重复计数，OUT端输出N-1个时钟周期的高电平，1个时钟周期的低电平

方式3——方波发生器

软硬件启动，自动重复计数输出对称方波（连续方波） N为偶数，完全对称，N为奇数，正脉冲会长一点

方式4——软件触发选通

软件启动，不自动重复计数计数结束输出一个CLK宽度的低电平

方式5——硬件触发选通

硬件启动，不自动重复计数波形与方式4一致，计数结束输出一个CLK宽度的低电平

小结

需要两个写脉冲——两次写操作

第一次写脉冲写入控制字
第二次写脉冲写入计数初值

能输出连续波形的只有方式2和方式3

2.可编程并行接口8255

三个端口

A口：支持0，1，2工作方式 B口：支持0，1工作方式 C口，支持0工作方式

工作方式

方式0——基本输入输出方式

方式1——选通工作方式

方式1输出接口A

$\overline {OBF}$：接口输出缓冲器满信号，告诉外设可以从该端口读走信号 $\overline {ACK}$：外设从端口取走数据，发出响应信号外设取走信号后，发出$\overline {ACK}$响应信号，同时使$\overline {OBF}=1$，同时还会产生一个有效的$INTR$信号

方式1输入接口A

$\overline {{STB}_A}$：外设写入 ${{IBF}_A}$：当输入缓冲器满后，接口发出的高电平有效信号

方式2——双向传送方式

可以既作为输入口，又作为输出口只有A口可以工作在此模式下，当A口工作在方式2时，B口可以工作在方式0或1

控制字

方式控制字：用于确定3个端口的工作方式及数据传送方向位控制字：仅用于C端口，可设置C口某位的初始状态（高低电平）

D7=1，方式控制字 D7=0，位控制字

3.DA转换芯片DAC0832

差动输出，双缓冲

工作方式

单缓冲工作方式

双缓冲工作方式

4.AD转换芯片ADC0809

5.可编程中断控制器8259A

特殊引脚

$INT$：接CPU的中断请求引脚 $\overline {INTA}$：接CPU的中断响应引脚 $A0$：8259A内部寄存器选择信号 $CAS0-CAS2$：多个8259级联引脚时使用，级联控制线 $\overline {SP}$：在非缓冲模式下，用来指定8259A是从片还是主片，$\overline {SP}$=1的8259是主片

内部结构

工作过程

工作方式

中断优先方式与中断嵌套

（1）固定优先级方式（2）循环优先级方式

屏蔽中断源的方式

普通屏蔽方式：对IMR某位置1，则屏蔽该位对应的中断请求

级联工作方式

（1）主片、从片有不同的地址（2）主片、从片分别进行编程

8259A的编程

初始化编程

初始化命令字ICW1（初始化字）：单片/多片级联、电平/边沿触发初始化命令字ICW2（中断向量码）：给CPU提供中断向量注意：例如，写入ICW1，端口地址为20H，写入ICW2时，端口地址为21H

初始化命令字ICW3（级联控制字）：指出哪个引脚进行了级联初始化命令字ICW4（中断结束方式字）：给出8259A结束中断处理的方式

操作方式编程

操作命令字OCW1（中断屏蔽字）：某位为1则该引脚中断被屏蔽操作命令字OCW2（中断结束和优先级循环）：指定优先级顺序和中断结束方式操作命令字OCW3（屏蔽方式和状态读出控制字）：设置特殊屏蔽、查询方式

Embedded Development on NomadJoe

基于CubeMX的STM32学习笔记

中断简介

NVIC

中断流程

HAL库的中断处理及回调函数实现流程

NVIC嵌套向量中断控制器

EXTI外部中断

EXTI外部中断实现

调用流程

按键实现外部中断控制小灯亮灭

Cube配置

EXTI配置

GPIO配置

按键消抖

方式1

方式2

代码实现

TIM定时器定时中断

调用流程

CubeMX参数配置

代码实现

USART中断

轮询模式

发送

接收

中断模式

发送

接收

定时器中断（补充）

TIM定时器中断

定时器更新中断

初始化后立即进入定时器更新中断

复位模式trigger触发后进入更新中断

更新操作事件源

ADC模块

ADC定义

STM32单片机中的ADC

分辨率与精度

STM32CubeMX配置

代码使用

关于多数据通道采集

检测

关于Number Of Discontinuous Conversions

1. 功能含义

2. 配置步骤（STM32CubeMX）

3. 工作流程示例

1. 数据读取方式

方法一：轮询模式（Polling）

方法二：中断模式（Interrupt）

方法三：DMA模式（推荐）

4. 注意事项

总结

FDCAN

CubeMX配置解析

Frame-Format

1. Classic Mode（传统模式）

2. FD mode with BitRate Switching（带波特率切换的 FD 模式）

3. FD mode without BitRate Switching（不带波特率切换的 FD 模式）

Mode

Auto-Retransmission & Transmit-Pause & Protocol-Exception

Data & Nominal

Data（数据波特率相关）

Nominal（标称波特率相关）

Filter and Std-Filters-Nbr&Ext-Filters-Nbr

过滤器类型

配置示例

Txheader

时间片

使用代码

FilterInit-and-FDCANStart

数据发送

数据接收

CAN

Cube配置

模式设置（Mode）

波特率

Basic-Parameters

使用代码

FilterInit-and-FDCANStart

复位模式`trigger`触发后进入更新中断