代码收藏家技术教程 2023-12-02

STM32 HAL库开发函数意义及笔记详解

快速查阅相关函数，请从目录查找

GPIO

`GPIOB->BSRR |= GPIO_PIN_7`

在STM32F103中，GPIOB->BSRR |= GPIO_PIN_7 的作用是将GPIOB的第7位引脚设置为高电平（将引脚置1），而GPIOB->BRR |= GPIO_PIN_7 的作用是将GPIOB的第7位引脚设置为低电平（将引脚置0）。下面是对这两个语句的详细说明：

GPIOB->BSRR |= GPIO_PIN_7：
GPIOB是STM32F103的GPIOB端口的寄存器地址。通过GPIOB指针可以访问和操作该端口的寄存器。
BSRR是GPIOB的置位设置寄存器。通过对该寄存器进行操作，可以将对应引脚置为高电平。
GPIO_PIN_7是位掩码，表示第7位引脚。使用|=位操作符，将BSRR寄存器中对应引脚的位置1，实现将引脚置高电平的操作。
GPIOB->BRR |= GPIO_PIN_7：
BRR是GPIOB的复位寄存器。通过对该寄存器进行操作，可以将对应引脚置为低电平。
与上述相似，使用|=位操作符，将BRR寄存器中对应引脚的位置1，实现将引脚置低电平的操作。

输入捕获

`__HAL_TIM_SetCounter(）`

__HAL_TIM_SetCounter(htim, 0) 的意义是将指定的定时器的计数器值归零。

在使用定时器时，计数器用于记录定时器的计数值，可以用来测量时间的过程，比如测量脉冲宽度、计算时间间隔等。当调用 __HAL_TIM_SetCounter(htim, value) 函数时，参数 htim 是定时器的句柄，value 是要设置的计数器值。

而对于 __HAL_TIM_SetCounter(htim, 0)，将计数器值设置为0的操作会将定时器的计数器重置为最开始的起始值，即重新开始计数。这可以在某些场景下用于同步控制，比如需要在特定条件下重新开始计时。

需要注意的是，在使用定时器时，如果计数器溢出或者达到设定的自动重载值（Auto-Reload Register）时会触发对应的中断或事件，所以在调用 __HAL_TIM_SetCounter(htim, 0) 之后，你可能还需要重新配置一些定时器相关的参数，比如计数模式、通道模式、自动重载值等，以便于后续的计时操作能正常进行。

总而言之，__HAL_TIM_SetCounter(htim, 0) 的意义是将指定的定时器的计数器值归零，并且可能需要重新配置一些相关参数以确保后续计时操作的准确性和可靠性。

在STM32F407的输入捕获模块中，最大可测量的脉冲频率取决于定时器的时钟频率和分辨率。

STM32F407的定时器时钟频率可以达到最高168 MHz。分辨率取决于定时器的位数。

对于16位定时器，其最大分辨率为65535。因此，最大可测量的脉冲频率为：

最大脉冲频率 = 定时器时钟频率 / 分辨率例如，如果使用16位定时器和168 MHz的定时器时钟频率，则最大可测量的脉冲频率为：

最大脉冲频率 =168 MHz /65535 ≈2565 Hz请注意，这只是一个近似值，实际的最大可测量脉冲频率可能会受到其他因素的限制，如定时器的工作模式和输入捕获通道的设置。

详细的限制和配置应参考相关的STM32F407参考手册或数据手册。

`__HAL_TIM_GET_COUNTER()`

函数 __HAL_TIM_GET_COUNTER(&htim1) 是用于获取定时器的计数器值的函数。下面是对该函数的详细说明：

作用：
__HAL_TIM_GET_COUNTER(&htim1) 函数用于获取指定定时器（TIM）的计数器值。

参数意义：

&htim1：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要读取计数器值的定时器。

使用场景：
该函数在需要读取定时器的计数器值时非常有用。定时器的计数器值通常与时间有关，可以用于测量、计时等场景。例如，可以用它来编写精确的时间测量、PWM（脉冲宽度调制）生成以及时间相关的应用程序。

使用方法：

在使用 __HAL_TIM_GET_COUNTER 函数之前，确保已经正确初始化了相关的定时器（htim1指向的定时器）。
调用该函数，传入指向定时器结构体的指针 &htim1，即 __HAL_TIM_GET_COUNTER(&htim1)。
函数将返回当前定时器计数器的值。

下面是一个例子，可以帮助你更好地理解函数的使用方法：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim1; // 定义定时器结构体，存储定时器的相关信息
// 初始化定时器
void TIM1_Init(void)
{
  // 初始化定时器的相关设置
  // ...
}
// 获取定时器计数器值
uint32_t Get_Timer_Counter(void)
{
  uint32_t counter = __HAL_TIM_GET_COUNTER(&htim1);
  return counter;
}

在上面的示例中，HAL_TIM_GET_COUNTER 函数帮助获取了定时器 htim1 的计数器值，并将其返回给调用它的函数 Get_Timer_Counter。需要注意的是，示例中省略了定时器的初始化过程，你需要根据你的具体硬件平台和需求进行适当的初始化。

`__HAL_TIM_SET_COUNTER()`

__HAL_TIM_SET_COUNTER(&htim1, 0) 是用于设置定时器的计数器值的函数。下面是对该函数的详细说明：

作用：
__HAL_TIM_SET_COUNTER(&htim1, 0) 函数用于将指定定时器(TIM)的计数器值设置为指定的值。

参数意义：

&htim1：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要设置计数器值的定时器。

0：指定的计数器值，将被设置到定时器的计数器中。

使用场景：
该函数在需要设置定时器的计数器值时很有用。通过手动设置计数器值，你可以在一些特定的场景下控制定时器的工作方式。例如，你可以用它来设置定时器的初始计数值，或者在特定的时间点重置定时器。

使用方法：

在使用 __HAL_TIM_SET_COUNTER 函数之前，确保已经正确初始化了相关的定时器（htim1指向的定时器）。
调用该函数，传入指向定时器结构体的指针 &htim1，以及要设置的计数器值，即 __HAL_TIM_SET_COUNTER(&htim1, 0)。

下面是一个示例，可以帮助你更好地理解函数的使用方法：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim1; // 定义定时器结构体，存储定时器的相关信息
// 初始化定时器
void TIM1_Init(void)
{
  // 初始化定时器的相关设置
  // ...
}
// 设置定时器计数器值为0
void Set_Timer_Counter_Zero(void)
{
  __HAL_TIM_SET_COUNTER(&htim1, 0);
}

在上面的示例中，HAL_TIM_SET_COUNTER 函数通过传入指向定时器结构体的指针 &htim1，将定时器的计数器值设置为0。示例中省略了完整的定时器初始化过程，你需要根据你的具体硬件平台和需求进行适当的初始化。

定时器

`HAL_TIM_PeriodElapsedCallback()`

HAL_TIM_PeriodElapsedCallback() 是 HAL 库中定时器中断回调函数。它用于在定时器的一个周期（或称为计数溢出）结束时被自动调用。下面是对该函数的详细说明：

作用：
HAL_TIM_PeriodElapsedCallback() 函数是一个回调函数，用于在定时器的一个周期结束时执行特定的操作。当定时器的计数器溢出到达预定的周期值时，系统会自动调用这个回调函数。

参数意义：
该函数没有任何参数。所有需要使用的信息应该通过全局变量、结构体或其他方法在函数之间传递。

使用场景：
这个回调函数在定时器操作中非常有用。它可以用于执行周期性的任务、实现定时触发的事件、测量时间间隔等等。通过设置定时器的预定周期值，你可以根据需要执行特定的代码。这在许多应用中很常见，包括定时器中断、计时器、生成PWM信号等。

使用方法：
以下是使用该回调函数的一般过程：

定义全局变量或结构体，用于存储需要在回调函数中使用的信息。
编写回调函数的实现代码，命名为 HAL_TIM_PeriodElapsedCallback。
在主程序中初始化定时器，并将周期设置为所需的值。
启动定时器运行。
当定时器的一个周期结束时，系统将自动调用 HAL_TIM_PeriodElapsedCallback 函数。

下面是一个示例，可以帮助你更好地理解回调函数的使用方法：

// 示例代码假设你正在使用的是STM32的HAL库
// 全局变量或结构体，用于存储需要在回调函数中使用的信息
// ...
// 定时器周期溢出中断回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  if (htim->Instance == TIM1)
  {
    // 执行特定的操作
    // ...
  }
}
// 初始化定时器
void TIM1_Init(void)
{
  // 初始化定时器的相关设置
  // ...
  // 设置定时器周期值
  HAL_TIM_Base_Start_IT(&htim1); // 使用带中断的定时器启动函数
}
int main(void)
{
  // ...
  TIM1_Init(); // 初始化定时器
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，HAL_TIM_PeriodElapsedCallback 函数是一个回调函数，当定时器 TIM1 的一个周期结束时，系统将自动调用该函数。你可以在函数内部执行特定的操作，以响应定时器的周期性触发。

`HAL_TIM_Base_Start_IT()`

函数 HAL_TIM_Base_Start_IT(&htim1) 的作用是启动定时器基本定时单元的中断模式。下面是对该函数的详细说明：

作用：
HAL_TIM_Base_Start_IT() 函数用于启动定时器的基本定时单元，并使其以中断的方式工作。这意味着当定时器的计数器达到设定的值时，将会触发中断，并执行相应的中断服务函数。

参数意义：
该函数有一个参数：

TIM_HandleTypeDef *htim：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的定时器。

使用场景：
该函数常用于需要定时触发事件的场景，比如定时器中断、周期性任务的执行等。当定时器启动且工作在中断模式下，可以根据所设置的定时周期触发中断，然后在中断服务函数中进行相应的操作。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个定时器结构体 (如 TIM_HandleTypeDef)，并配置相关的定时器参数。
调用 HAL_TIM_Base_Start_IT() 函数来启动定时器基本定时单元的中断模式。

以下是一个示例，展示如何使用该函数来启动定时器的中断模式：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim; // 定义定时器结构体，存储定时器的相关信息
// 定时器中断服务函数
void TIM_IRQHandler(void)
{
  if (__HAL_TIM_GET_FLAG(&htim, TIM_FLAG_UPDATE) != RESET)
  {
    __HAL_TIM_CLEAR_FLAG(&htim, TIM_FLAG_UPDATE); // 清除定时器的更新标志位
    // 处理定时器中断事件
    // ...
  }
}
int main(void)
{
  // ...
  // 配置并初始化定时器结构体 htim
  // ...
  HAL_TIM_Base_Start_IT(&htim); // 启动定时器的中断模式
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，在主程序中，首先定义并初始化了一个定时器结构体 htim。然后，在 main() 函数中调用 HAL_TIM_Base_Start_IT() 函数，启动定时器基本定时单元的中断模式。随后，定时器按照设定的定时周期工作，当计数器达到设定的值时，将触发定时器中断，并执行相应的中断服务函数 TIM_IRQHandler()。

请注意，示例中的 htim 是一个定时器结构体实例，你需要根据实际使用的定时器和硬件平台，在代码中使用正确的定时器结构体。

`HAL_TIM_Base_Stop_IT()`

HAL_TIM_Base_Stop_IT(&htim1) 的作用是停止定时器的基本定时单元的中断模式。

下面是对该函数的详细说明：

作用：
HAL_TIM_Base_Stop_IT() 函数用于停止定时器的基本定时单元的中断模式，即取消定时器中断的触发。

参数意义：
该函数有一个参数：

TIM_HandleTypeDef *htim：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的定时器。

使用场景：
该函数常用于需要在某个时刻停止定时器中断的场景。比如，当某个条件满足时，需要停止定时器中断以暂时禁止定时器的工作。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个定时器结构体 (如 TIM_HandleTypeDef)，并配置相关的定时器参数。
调用 HAL_TIM_Base_Stop_IT() 函数来停止定时器的中断模式。

以下是一个示例，展示如何使用该函数来停止定时器的中断模式：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim; // 定义定时器结构体，存储定时器的相关信息
// 需要停止定时器中断的条件
int condition = 0;
// 定时器中断服务函数
void TIM_IRQHandler(void)
{
  if (__HAL_TIM_GET_FLAG(&htim, TIM_FLAG_UPDATE) != RESET)
  {
    __HAL_TIM_CLEAR_FLAG(&htim, TIM_FLAG_UPDATE); // 清除定时器的更新标志位
    // 处理定时器中断事件
    // ...
    if (condition)
    {
      HAL_TIM_Base_Stop_IT(&htim); // 当满足条件时，停止定时器中断
    }
  }
}
int main(void)
{
  // ...
  // 配置并初始化定时器结构体 htim
  // ...
  HAL_TIM_Base_Start_IT(&htim); // 启动定时器的中断模式
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个定时器结构体 htim。然后，在定时器中断服务函数 TIM_IRQHandler() 中，检查定时器的更新标志位是否被置位。如果条件满足，处理定时器中断事件并设置 condition 为真。然后，通过调用 HAL_TIM_Base_Stop_IT() 函数停止定时器的中断模式，暂时禁止定时器的工作。

请注意，示例中的 htim 是一个定时器结构体实例，你需要根据实际使用的定时器和硬件平台，在代码中使用正确的定时器结构体。

`__HAL_TIM_CLEAR_FLAG()`

__HAL_TIM_CLEAR_FLAG(&htim1, TIM_FLAG_UPDATE) 的作用是清除定时器的更新标志位。

下面是对该函数的详细说明：

作用：
__HAL_TIM_CLEAR_FLAG() 函数用于清除定时器的指定标志位。对于参数 TIM_FLAG_UPDATE，它表示定时器的更新标志位，用于指示定时器计数溢出事件（Update Event）是否发生。

参数意义：
该函数有两个参数：

TIM_HandleTypeDef *htim：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的定时器。

uint32_t TimerFlags：传入要清除的标志位，可以是多个标志位的按位或操作结果。对于参数 TIM_FLAG_UPDATE，它表示定时器的更新标志位。

使用场景：
该函数常用于定时器中断服务函数（TIM interrupt service routine，ISR）中。在定时器中断服务函数中，通常需要清除定时器的更新标志位，以准备处理下一个计数周期的事件或任务。也可以在其他需要的时候手动调用该函数清除标志位。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个定时器结构体 (如 TIM_HandleTypeDef htim)，并配置相关的定时器参数。
实现定时器中断服务函数，并在其中调用 __HAL_TIM_CLEAR_FLAG() 函数来清除相应的定时器标志位。

以下是一个示例，展示如何在定时器中断服务函数中清除更新标志位：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim; // 定义定时器结构体，存储定时器的相关信息
// 定时器中断服务函数
void TIM_IRQHandler(void)
{
  if (__HAL_TIM_GET_FLAG(&htim, TIM_FLAG_UPDATE) != RESET)
  {
    __HAL_TIM_CLEAR_FLAG(&htim, TIM_FLAG_UPDATE); // 清除定时器的更新标志位
    // 处理定时器中断事件
    // ...
  }
}

int main(void)
{
  // ...
  // 配置并初始化定时器结构体 htim
  // ...
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，定时器中断服务函数 TIM_IRQHandler() 首先通过 __HAL_TIM_GET_FLAG() 函数检查是否发生了定时器的更新事件（即更新标志位被置位），然后使用 __HAL_TIM_CLEAR_FLAG() 函数来清除更新标志位。之后，你可以在该函数中处理定时器中断事件的其他任务。

请注意，示例中的 htim 是一个定时器结构体实例，你需要根据实际使用的定时器和硬件平台，在代码中使用正确的定时器结构体。

__HAL_TIM_SET_PRESCALER()

__HAL_TIM_SET_PRESCALER() 的作用是设置定时器的预分频值。下面是对该函数的详细说明：

作用：
__HAL_TIM_SET_PRESCALER() 函数用于设置定时器的预分频值，即将输入时钟频率分频以获得更低的计数频率。

参数意义：
该函数有两个参数：

htim：传入指向 TIM 控制器 (TIM_HandleTypeDef) 的指针。通过这个参数，函数可以确定要操作的定时器。

Prescaler：传入预分频值。通过这个参数，函数可以设置定时器的预分频值。

使用场景：
该函数常用于需要修改定时器计数频率的场景，例如调整 PWM 波形的频率、控制定时任务的周期等。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 TIM 控制器结构体 (如 TIM_HandleTypeDef)，并配置相关的定时器参数。
调用 __HAL_TIM_SET_PRESCALER() 函数来设置定时器的预分频值。

以下是一个示例，展示如何使用该函数来设置定时器的预分频值：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim3; // 定义 TIM 控制器结构体，存储 TIM 控制器的相关信息
int main(void)
{
  // ...
  // 配置并初始化 TIM 控制器结构体 htim3
  // ...
  // 设置定时器的预分频值
  __HAL_TIM_SET_PRESCALER(&htim3, 100);
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 TIM 控制器结构体 htim3。然后，通过调用 __HAL_TIM_SET_PRESCALER() 函数，将预分频值设置为 100。这将把输入时钟频率分频为更低的计数频率。

请注意，示例中的 htim3 是一个 TIM 控制器结构体实例。你需要根据实际使用的定时器和硬件平台，在代码中使用正确的控制器结构体。

`htim1.Instance->CNT`

htim1.Instance->CNT < 0x100 比较了定时器 htim1 的计数器值 (CNT) 是否小于 0x100。下面是对其中参数的意义、功能、作用和使用方法的详细解释：

htim1.Instance：该参数是一个指向定时器实例的指针。在使用 HAL 库进行定时器编程时，htim1.Instance 指向所选择的定时器的寄存器基地址。

CNT：该参数是定时器的计数器寄存器。它记录定时器已经进行的计数值，可以通过读取该寄存器的值获取当前的计数器值。

参数意义：

htim1.Instance：指向定时器实例的指针，用于访问定时器相关的寄存器。

CNT：定时器的计数器寄存器，用于存储定时器的计数值。

功能和作用：
通过比较表达式 htim1.Instance->CNT < 0x100，可以判断定时器的计数器值是否小于 0x100。这个比较可以用于条件判断，根据定时器计数器的值执行不同的操作。例如，当计数器值小于 0x100 时，可以触发某个事件或执行某个任务。

使用方法举例：
以下是一个示例，以帮助你更好地理解参数的使用方法和作用：

// 示例代码假设你正在使用的是STM32的HAL库
// 假设已经在其他地方定义和初始化了定时器 htim1
while (1)
{
  if (htim1.Instance->CNT < 0x100)
  {
    // 当定时器计数器值小于0x100时执行某个任务或触发某个事件
    // ...
  }
  // 其他操作或逻辑
  // ...
}

在上面的示例中，通过比较表达式 htim1.Instance->CNT < 0x100，在 while 循环中判断定时器计数器的值是否小于 0x100。如果满足条件，就可以执行某些任务或触发事件。

请注意，示例中的 htim1 是一个定时器实例，你需要根据实际使用的定时器和硬件平台，在代码中使用正确的定时器实例和计数器寄存器。

`HAL_TIM_Encoder_Start()`

HAL_TIM_Encoder_Start() 用于启动编码器模式下的定时器。下面是对该函数的详细说明：

作用：
HAL_TIM_Encoder_Start() 函数用于启动定时器以使用编码器模式。编码器模式可以用于测量旋转物体的位置和速度，特别适用于旋转编码器的应用。

参数意义：
该函数有一个参数：

TIM_HandleTypeDef *htim：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要启动的定时器。

使用场景：
该函数适用于需要测量旋转物体位置和速度的应用场景。常见的应用场景包括电机控制、位置反馈、步进电机的运动控制等。通过启动编码器模式，可以实现对旋转物体的精确控制和监测。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个定时器结构体 (如 TIM_HandleTypeDef htim)，并配置相关的定时器参数和编码器模式设置。
调用 HAL_TIM_Encoder_Start() 函数，传入定时器结构体的指针 &htim。

下面是一个示例，可以帮助你更好地理解函数的使用方法：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim; // 定义定时器结构体，存储定时器的相关信息
// 初始化定时器
void TIM_Init(void)
{
  // 初始化定时器的相关设置
  // ... 
  // 配置定时器为编码器模式
  // ...
}
// 启动编码器模式
void Start_Encoder_Mode(void)
{
  HAL_TIM_Encoder_Start(&htim);
}
int main(void)
{
  // ...
  TIM_Init(); // 初始化定时器
  Start_Encoder_Mode(); // 启动编码器模式
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，HAL_TIM_Encoder_Start() 函数通过传入指向定时器结构体的指针 &htim，启动了定时器的编码器模式。示例中省略了完整的定时器初始化过程和编码器模式的设置，你需要根据你的具体硬件平台和需求进行适当的初始化和配置。\

PWM波

`HAL_TIM_PWM_Start_IT()`

HAL_TIM_PWM_Start_IT(&htim1, TIM_CHANNEL_X) 的作用是启动定时器的 PWM 模式，并使能指定通道的中断模式。下面是对该函数的详细说明：

作用：
HAL_TIM_PWM_Start_IT() 函数用于启动定时器的 PWM 模式，并使能指定通道的中断模式。通过调用该函数，可以开始产生 PWM 信号，并允许相应通道的中断触发。

参数意义：
该函数有两个参数：

TIM_HandleTypeDef *htim：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的定时器。

uint32_t Channel：指定要启动中断的通道号。在 TIM_HandleTypeDef 结构体中，可以通过 Channel 成员来指定通道号。具体的通道号取决于使用的定时器型号和配置。

使用场景：
该函数常用于需要产生 PWM 信号并启用相应通道中断的场景。通过使用中断，可以在每个 PWM 周期内执行一些需要精确时间控制的操作，例如触发传感器数据采集、实现实时控制等。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个定时器结构体 (如 TIM_HandleTypeDef)，并配置相关的定时器参数。
配置相应的通道使能和中断使能。
调用 HAL_TIM_PWM_Start_IT() 函数来启动 PWM 模式并使能相应通道的中断模式。

以下是一个示例，展示如何使用该函数来启动定时器 PWM 模式并使能中断：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim; // 定义定时器结构体，存储定时器的相关信息
// 定时器中断服务函数
void TIM_IRQHandler(void)
{
  if (__HAL_TIM_GET_FLAG(&htim, TIM_FLAG_UPDATE) != RESET)
  {
    __HAL_TIM_CLEAR_FLAG(&htim, TIM_FLAG_UPDATE); // 清除定时器的更新标志位
    // 处理定时器中断事件
    // ...
  }
}
int main(void)
{
  // ...
  // 配置并初始化定时器结构体 htim
  // ...
  // 配置相应通道的使能和中断使能
  HAL_TIM_PWM_Start_IT(&htim, TIM_CHANNEL_X);
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个定时器结构体 htim。然后，在定时器中断服务函数 TIM_IRQHandler() 中，检查定时器的更新标志位是否被置位。如果被置位，处理定时器中断事件。通过调用 HAL_TIM_PWM_Start_IT() 函数，启动定时器的 PWM 模式，并使能相应通道的中断模式。

请注意，示例中的 htim 是一个定时器结构体实例，TIM_CHANNEL_X 是要使能中断的通道号，你需要根据实际使用的定时器和硬件平台，在代码中使用正确的定时器结构体和通道号。

`HAL_TIM_PWM_Stop_IT()`

HAL_TIM_PWM_Stop_IT(&htim1, TIM_CHANNEL_X) 的作用是停止定时器的 PWM 模式并关闭相应通道的中断模式。下面是对该函数的详细说明：

作用：
HAL_TIM_PWM_Stop_IT() 函数用于停止定时器的 PWM 模式，并关闭指定通道的中断模式。通过调用该函数，可以停止产生 PWM 信号，并禁止相应通道的中断触发。

参数意义：
该函数有两个参数：

TIM_HandleTypeDef *htim：传入指向定时器 (TIM_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的定时器。

uint32_t Channel：指定要关闭中断的通道号。在 TIM_HandleTypeDef 结构体中，可以通过 Channel 成员来指定通道号。具体的通道号取决于使用的定时器型号和配置。

使用场景：
该函数常用于需要在某个时刻停止 PWM 信号生成和关闭相应通道中断的场景。比如，在需要动态调整 PWM 状态或停止 PWM 输出的时候使用。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个定时器结构体 (如 TIM_HandleTypeDef)，并配置相关的定时器参数。
设置相应的通道使能和中断使能。
调用 HAL_TIM_PWM_Stop_IT() 函数来停止 PWM 模式并关闭相应通道的中断模式。

以下是一个示例，展示如何使用该函数来停止定时器 PWM 模式和关闭中断：

// 示例代码假设你正在使用的是STM32的HAL库
TIM_HandleTypeDef htim; // 定义定时器结构体，存储定时器的相关信息
// 需要停止 PWM 的条件
int condition = 0;
// 定时器中断服务函数
void TIM_IRQHandler(void)
{
  if (__HAL_TIM_GET_FLAG(&htim, TIM_FLAG_UPDATE) != RESET)
  {
    __HAL_TIM_CLEAR_FLAG(&htim, TIM_FLAG_UPDATE); // 清除定时器的更新标志位
    // 处理定时器中断事件
    // ...
    if (condition)
    {
      HAL_TIM_PWM_Stop_IT(&htim, TIM_CHANNEL_X); // 当满足条件时，停止 PWM 并关闭中断
    }
  }
}
int main(void)
{
  // ...
  // 配置并初始化定时器结构体 htim
  // ...
  // 配置相应通道的使能和中断使能
  HAL_TIM_PWM_Start_IT(&htim, TIM_CHANNEL_X);
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个定时器结构体 htim。然后，在定时器中断服务函数 TIM_IRQHandler() 中，检查定时器的更新标志位是否被置位。如果条件满足，处理定时器中断事件并设置 condition 为真。然后，通过调用 HAL_TIM_PWM_Stop_IT() 函数停止定时器的 PWM 模式，并关闭相应通道的中断模式。

请注意，示例中的 htim 是一个定时器结构体实例，TIM_CHANNEL_X 是需要关闭中断的通道号，你需要根据实际使用的定时器和硬件平台，在代码中使用正确的定时器结构体和通道号。

CAN通信

`HAL_CAN_Receive_IT()`

HAL_CAN_Receive_IT(&hcan, CAN_FIFO0) 的作用是启动 CAN 接收中断模式。

下面是对该函数的详细说明：

作用：
HAL_CAN_Receive_IT() 函数用于启动 CAN 接收中断模式。通过调用该函数，可以开启 CAN 接收中断，并允许在接收到消息时触发相应的中断事件。

参数意义：
该函数有两个参数：

CAN_HandleTypeDef *hcan：传入指向 CAN 控制器 (CAN_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的 CAN 控制器。

uint32_t FIFONumber：指定 CAN 接收 FIFO 的编号。在 CAN_HandleTypeDef 结构体中，可以通过 FIFONumber 成员来指定接收 FIFO 的编号，通常为 CAN_FIFO0 或 CAN_FIFO1。

使用场景：
该函数常用于需要通过 CAN 总线接收消息，并以中断的形式处理接收到的消息的场景。通过使用中断模式，可以实现异步接收消息的功能，并在接收到消息时及时处理。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 CAN 控制器结构体 (如 CAN_HandleTypeDef)，并配置相关的 CAN 参数和过滤器。
配置接收中断使能。
调用 HAL_CAN_Receive_IT() 函数来启动 CAN 接收中断。

以下是一个示例，展示如何使用该函数来启动 CAN 接收中断：

// 示例代码假设你正在使用的是STM32的HAL库
CAN_HandleTypeDef hcan; // 定义 CAN 控制器结构体，存储 CAN 控制器的相关信息
// CAN接收中断回调函数
void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef* hcan)
{
  // 处理接收中断事件
  // ...
}
int main(void)
{
  // ...
  // 配置并初始化CAN控制器结构体 hcan
  // ...
  // 配置接收中断使能
  HAL_CAN_Receive_IT(&hcan, CAN_FIFO0);
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 CAN 控制器结构体 hcan。然后，在 CAN 接收中断回调函数 HAL_CAN_RxCpltCallback() 中，处理接收中断事件。通过调用 HAL_CAN_Receive_IT() 函数，启动 CAN 接收中断。

请注意，示例中的 hcan 是一个 CAN 控制器结构体实例，CAN_FIFO0 是接收 FIFO 的编号，你需要根据实际使用的 CAN 控制器和硬件平台，在代码中使用正确的控制器结构体和 FIFO 编号。

CAN_FilterTypeDef 结构体

CAN 的过滤器使用 CAN_FilterTypeDef 结构体来定义过滤器的属性。该结构体包含了以下变量：

FilterIdHigh 和 FilterIdLow：
这两个变量用于设置过滤器的标识符 (ID)。在 CAN 2.0A 标准中，ID 可以是 11 位长；而在 CAN 2.0B 标准中，ID 可以是 29 位长。对于 11 位长的 ID，只需要设置 FilterIdLow 变量；对于 29 位长的 ID，需要同时设置 FilterIdHigh 和 FilterIdLow 变量。
FilterMaskIdHigh 和 FilterMaskIdLow：
这两个变量用于设置过滤器的屏蔽位。通过屏蔽位，可以过滤出特定的标识符。与 FilterIdHigh 和 FilterIdLow 类似，对于 11 位长的 ID，只需要设置 FilterMaskIdLow 变量；对于 29 位长的 ID，需要同时设置 FilterMaskIdHigh 和 FilterMaskIdLow 变量。
FilterFIFOAssignment：
这个变量用于设置过滤器与哪个接收邮箱 (FIFO) 关联。CAN 模块可以有多个接收邮箱，分别用于接收不同类型的 CAN 帧。可以根据实际需求将过滤器与特定的邮箱关联，以过滤并接收特定类型的 CAN 帧。
FilterBank：
这个变量用于设置过滤器的编号。CAN 模块有多个硬件过滤器，编号范围从 0 到 13。同一个编号的过滤器可以具有不同的过滤器属性，以实现多个过滤器条件的组合。
FilterMode：
这个变量用于设置过滤器的工作模式。可以选择标准模式 (FilterMode_IdMask) 或列表模式 (FilterMode_IdList)。标准模式下，过滤器使用屏蔽位逐位比较 ID，确定是否匹配过滤条件；列表模式下，过滤器使用具体的 ID 列表进行匹配。
FilterScale：
这个变量用于设置过滤器的比例。可以选择单个 32 位寄存器 (FilterScale_32bit) 或两个 16 位寄存器 (FilterScale_16bit)。选择单个 32 位寄存器时，过滤器可以用于过滤 32 位长的标识符；选择两个 16 位寄存器时，每个寄存器只用于过滤 16 位长的标识符。

使用场景：
过滤器的主要作用是根据特定的标识符和过滤条件，过滤并接收特定类型的 CAN 帧。使用过滤器可以实现多个过滤条件的组合，提高系统对特定 CAN 帧的识别率和响应准确性。

使用方法：
以下是使用过滤器的一般过程：

在主程序中定义并初始化一个 CAN_FilterTypeDef 结构体。
使用结构体中的成员变量设置过滤器的属性，包括标识符、屏蔽位、关联邮箱、编号、工作模式和比例。
调用 HAL_CAN_ConfigFilter() 函数来配置过滤器，并将其应用到 CAN 控制器上。

HAL_CAN_ActivateNotification()

HAL_CAN_ActivateNotification() 函数的作用是启用 CAN 中断及应用回调函数来处理 CAN 消息。该函数使用 HAL_CAN_StateTypeDef 枚举类型提供的一组状态来配置 CAN 控制器的中断。

以下是各参数的详细说明：

hcan 参数：
这个参数是一个 CAN_HandleTypeDef 结构体类型的指针，用于指定要启用中断的 CAN 控制器。
ActiveITs 参数：
这个参数是一个整数型数据，用于指定要启用的中断类型。
可以使用以下常量来设置要启用的中断类型：
CAN_IT_RX_FIFO0_MSG_PENDING：启用 FIFO0 接收缓冲区消息挂起中断。
CAN_IT_RX_FIFO0_FULL：启用 FIFO0 接收缓冲区满中断。
CAN_IT_RX_FIFO0_OVERRUN：启用 FIFO0 接收缓冲区溢出中断。
CAN_IT_RX_FIFO1_MSG_PENDING：启用 FIFO1 接收缓冲区消息挂起中断。
CAN_IT_RX_FIFO1_FULL：启用 FIFO1 接收缓冲区满中断。
CAN_IT_RX_FIFO1_OVERRUN：启用 FIFO1 接收缓冲区溢出中断。
CAN_IT_TX_MAILBOX_EMPTY：启用发送邮箱为空中断。
CAN_IT_TX_MAILBOX_COMPLETE：启用发送完成中断。
CAN_IT_BUSOFF：启用总线关闭中断。
CAN_IT_ERROR_WARNING：启用错误警告中断。
CAN_IT_ERROR_PASSIVE：启用错误被动中断。
CAN_IT_LAST_ERROR_CODE：启用最后一个错误代码中断。
CAN_IT_ERROR：启用错误中断。
ReturnParameter 参数：
这个参数是一个指向无符号 32 位整数的指针，用于返回函数的执行状态。
如果函数执行成功，该参数将返回 HAL_OK；否则，将返回 HAL_ERROR。

使用场景：
启用 CAN 中断和应用回调函数来处理 CAN 消息时，可以使用 HAL_CAN_ActivateNotification() 函数来启用相应的中断类型。

使用方法：
以下是使用 HAL_CAN_ActivateNotification() 函数的一般过程：

在主程序中定义一个 CAN_HandleTypeDef 结构体类型的变量并初始化。
使用 HAL_CAN_ActivateNotification() 函数来启用需要的中断类型。
在函数回调中处理响应的中断类型。

下面是一个简单的示例，演示如何启用 CAN 接收中断：

CAN_HandleTypeDef hcan;
uint32_t can_interrupt_status = 0;
// 初始化 CAN 控制器以及其他必要的参数
// 启用 CAN 接收中断
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING, &can_interrupt_status);
// 中断回调函数，处理接收到的 CAN 帧
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef* hcan)
{
    // 处理接收到的 CAN 帧
}

在上面的示例中，我们使用 HAL_CAN_ActivateNotification() 函数来启用 CAN_IT_RX_FIFO0_MSG_PENDING 中断，并在回调函数中处理接收到的 CAN 帧。扩展用法为，可以使用相似的方法来启用其他类型的 CAN 中断，并添加相应的回调函数来处理它们。

HAL_CAN_AddTxMessage()

HAL_CAN_AddTxMessage() 函数的作用是将 CAN 帧发送到所选的 CAN 总线上。该函数客户端在回调函数或主循环中调用，可以使用它来发送消息。

以下是各参数的详细说明：

hcan 参数：
这个参数是一个 CAN_HandleTypeDef 结构体类型的指针，用于指定要发送消息的 CAN 控制器。
pTxHeader 参数：
这个参数是一个 CAN_TxHeaderTypeDef 结构体类型的指针，用于指定要发送的消息的帧头信息。
在 CAN_TxHeaderTypeDef 结构体中，用户需要指定以下参数：
StdId：消息的标准标识符。
ExtId：消息的扩展标识符。
IDE：消息的标识符类型，可以是标准的或扩展的。
RTR：消息的数据类型，可以是数据帧或远程帧。
DLC：消息的数据长度，范围从 0 到 8。
pTxData 参数：
这个参数是一个指向要发送的数据的缓冲区指针，缓冲区应该是一个 uint8_t 类型的数组。
Timeout 参数：
这个参数是一个整数型数据，用于指定函数的执行时间。如果在指定的时间内未发送成功，该函数将返回错误代码。
TxMailbox 参数：
这个参数是一个指向无符号 32 位整数的指针，用于返回函数的执行状态。
如果函数执行成功，将使用逻辑或运算符将 CAN_TxStatus_Ok 和邮箱号之间的值存储到该参数中（CAN_TxStatus_Ok || TxMailbox）；否则，将使用逻辑或运算符将 CAN_TxStatus_Failed 和 CAN_TxStatus_Pending 之间的值存储到该参数中（CAN_TxStatus_Failed || CAN_TxStatus_Pending）。

使用场景：
使用 HAL_CAN_AddTxMessage() 函数可以将 CAN 帧发送到所选的 CAN 总线上。此函数通常在主循环或回调函数中使用，以便发送 CAN 消息。

使用方法：
以下是使用 HAL_CAN_AddTxMessage() 函数的一般过程：

在主程序中定义一个 CAN_HandleTypeDef 结构体类型的变量并初始化。
定义一个 CAN_TxHeaderTypeDef 结构体类型的变量，并使用适当的帧头信息初始化。
定义一个 uint8_t 类型的数据缓冲区，并将要发送的数据放入其中。
使用 HAL_CAN_AddTxMessage() 函数将数据发送到 CAN 总线上。

下面是一个简单的示例，演示如何使用 HAL_CAN_AddTxMessage() 函数向 CAN 总线发送一个数据帧：

CAN_HandleTypeDef hcan;
CAN_TxHeaderTypeDef TxHeader;
uint8_t TxData[8];
uint32_t TxMailbox;
// 初始化 CAN 控制器以及其他必要的参数
// 配置 CAN 帧头信息
TxHeader.StdId = 0x321;
TxHeader.ExtId = 0x12345678;
TxHeader.IDE = CAN_ID_STD;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.DLC = 8;
// 将要发送的数据放入缓冲区
TxData[0] = 0xFF;
TxData[1] = 0xEE;
TxData[2] = 0xDD;
TxData[3] = 0xCC;
TxData[4] = 0xBB;
TxData[5] = 0xAA;
TxData[6] = 0x99;
TxData[7] = 0x88;
// 使用 HAL_CAN_AddTxMessage() 函数将 CAN 帧发送到 CAN 总线上
HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox);

在上面的示例中，我们使用 HAL_CAN_AddTxMessage() 函数将数据帧发送到 CAN 总线上。首先，我们使用 CAN_TxHeaderTypeDef 结构体定义了一个帧头。然后，我们定义了一个长度为8的缓冲区 TxData，并将要发送的数据放入其中。最后，在主程序中调用 HAL_CAN_AddTxMessage() 函数，传递 CAN_HandleTypeDef 结构体的指针、CAN_TxHeaderTypeDef 结构体的指针、TxData 缓冲区的指针以及 TxMailbox 变量的指针作为参数。

函数将根据传递的参数将数据帧发送到所选的 CAN 控制器上，并返回执行状态。如果函数执行成功，TxMailbox 参数将包含发送消息的邮箱号（CAN_TxStatus_Ok || TxMailbox）；否则，TxMailbox 参数将包含发送失败或挂起状态（CAN_TxStatus_Failed || CAN_TxStatus_Pending）。

HAL_CAN_GetRxFifoFillLevel()

HAL_CAN_GetRxFifoFillLevel()函数的作用是获取CAN接收FIFO的填充级别。该函数可用于确定接收FIFO中待处理的CAN消息数量。

以下是各参数的详细说明：

hcan参数：
这是一个指向CAN_HandleTypeDef结构体类型的指针，用于指定要获取FIFO填充级别的CAN控制器。
Fifo参数：
这是一个指定FIFO编号的整数值。在CAN控制器中，可能存在多个接收FIFO，可以通过该参数指定要获取其填充级别的FIFO。
返回值：
该函数返回一个表示接收FIFO填充级别的整数值。

使用场景：
使用HAL_CAN_GetRxFifoFillLevel()函数可以确定接收FIFO中待处理的CAN消息数量。这对于监控CAN总线的数据流量、处理接收数据的优先级或判断是否需要增加处理资源都非常有用。

使用方法：
以下是使用HAL_CAN_GetRxFifoFillLevel()函数的一般过程：

在主程序中定义一个CAN_HandleTypeDef结构体类型的变量并初始化。
使用HAL_CAN_Init()函数初始化CAN控制器。
配置和启用一个或多个接收FIFO。
使用HAL_CAN_GetRxFifoFillLevel()函数获取接收FIFO的填充级别。
进行相应的处理，如根据填充级别调整处理优先级、增加处理资源等。

下面是一个简单的示例，演示如何使用HAL_CAN_GetRxFifoFillLevel()函数获取接收FIFO的填充级别：

CAN_HandleTypeDef hcan;
uint8_t RxData[8];
uint32_t fillLevel;
// 初始化CAN控制器以及其他必要的参数
// 配置和启用接收FIFO
// 使用HAL_CAN_GetRxFifoFillLevel()函数获取接收FIFO的填充级别
fillLevel = HAL_CAN_GetRxFifoFillLevel(&hcan, CAN_RX_FIFO0);
// 根据填充级别进行相应的处理，如根据数量调整处理优先级或增加处理资源
if(fillLevel >= 5) 
{
    // 如果填充级别大于等于5，执行相应的处理
    // ...
}
else 
{
    // 如果填充级别小于5，执行其他处理
    // ...
}

在上面的示例中，我们使用HAL_CAN_GetRxFifoFillLevel()函数获取接收FIFO的填充级别。首先，我们定义一个CAN_HandleTypeDef结构体类型的变量并初始化，然后配置和启用所需的接收FIFO。

接下来，我们调用HAL_CAN_GetRxFifoFillLevel()函数，传递CAN_HandleTypeDef结构体的指针和要获取填充级别的接收FIFO编号CAN_RX_FIFO0作为参数，将填充级别存储到fillLevel变量中。

最后，根据填充级别进行相应的处理。在示例中，我们判断填充级别是否大于等于5，并根据情况执行不同的处理操作。你可以根据具体的应用程序需求进行相应的处理。

HAL_CAN_GetTxMailboxLevel()

HAL_CAN_GetTxMailboxLevel() 是一个函数，通常用于与控制器局域网（CAN）通信相关的编程。它用于获取CAN总线上的发送邮箱（Tx Mailbox）的级别。

函数原型：

uint8_t HAL_CAN_GetTxMailboxLevel(CAN_HandleTypeDef *hcan);

参数说明：

hcan：指向CAN_HandleTypeDef结构的指针，该结构包含CAN控制器的相关信息。

返回值：

返回一个8位无符号整数，表示当前CAN控制器中可用的发送邮箱的级别。如果返回值为0，表示所有发送邮箱都已使用；如果返回值大于0，表示还有可用的发送邮箱。

使用场景：

在需要进行CAN总线通信的应用程序中，特别是在需要对发送邮箱进行管理的情况下，使用此函数。例如，当需要在多个线程或任务之间共享CAN总线时，需要使用此函数来检查当前可用的发送邮箱数量。

使用方法：

确保已经正确初始化了CAN控制器和相关的CAN_HandleTypeDef结构。
在需要检查发送邮箱可用性的代码位置，调用HAL_CAN_GetTxMailboxLevel()函数。
根据返回值判断当前可用的发送邮箱数量。如果返回值为0，表示所有发送邮箱都已使用；如果返回值大于0，表示还有可用的发送邮箱。
根据需要使用可用的发送邮箱进行数据发送或其他操作。

注意事项：

在调用此函数之前，确保已经正确初始化了CAN控制器和相关的CAN_HandleTypeDef结构。

如果返回值为0，表示所有发送邮箱都已使用，此时不能进行新的数据发送操作。

此函数仅用于获取当前可用的发送邮箱数量，不会自动清空已使用的发送邮箱。如有需要，需要手动进行清空操作。

__HAL_CAN_ENABLE_lT()

__HAL_CAN_ENABLE_lT() 是一个函数，通常用于与控制器局域网（CAN）通信相关的编程。它用于启用或禁用CAN控制器的发送（Tx）功能。

函数原型：

void __HAL_CAN_ENABLE_lT(CAN_HandleTypeDef *hcan);

参数说明：

hcan：指向CAN_HandleTypeDef结构的指针，该结构包含CAN控制器的相关信息。

使用场景：

在需要进行CAN总线通信的应用程序中，特别是在需要控制CAN控制器发送功能的场景下，使用此函数。例如，当需要在特定条件下启用或禁用CAN控制器的发送功能时，可以使用此函数。

使用方法：

确保已经正确初始化了CAN控制器和相关的CAN_HandleTypeDef结构。
在需要启用或禁用CAN控制器发送功能的代码位置，调用__HAL_CAN_ENABLE_lT()函数。
如果需要启用CAN控制器的发送功能，传入指向CAN_HandleTypeDef结构的指针；如果需要禁用发送功能，可以传入NULL或无效的指针。
根据需要调用其他CAN相关的函数来发送或接收数据。

注意事项：

在调用此函数之前，确保已经正确初始化了CAN控制器和相关的CAN_HandleTypeDef结构。

如果在程序运行过程中调用此函数来启用发送功能，需要确保在此之前已经配置好了相关的CAN控制器参数和数据缓冲区等。

如果在程序运行过程中调用此函数来禁用发送功能，需要确保在此之前已经停止了相关的CAN控制器发送操作。

串口通信

`HAL_UART_Receive_IT()`

HAL_UART_Receive_IT(&huart, pData, Size) 的作用是启动 UART 接收中断模式。

下面是对该函数的详细说明：

作用：
HAL_UART_Receive_IT() 函数用于启动 UART 接收中断模式。通过调用该函数，可以开启 UART 接收中断，并允许在接收到数据时触发相应的中断事件。

参数意义：
该函数有三个参数：

UART_HandleTypeDef *huart：传入指向 UART 控制器 (UART_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的 UART 控制器。

uint8_t *pData：传入指向接收数据缓冲区的指针。通过这个指针，函数可以指定接收到的数据存储的位置。

uint16_t Size：指定接收数据的字节数。通过这个参数，函数可以确定期望接收的数据的大小。

使用场景：
该函数常用于需要通过 UART 接收数据，并以中断的形式处理接收到的数据的场景。通过使用中断模式，可以实现异步接收数据的功能，并在接收到数据时及时处理。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 UART 控制器结构体 (如 UART_HandleTypeDef)，并配置相关的 UART 参数和中断。
定义一个数据缓冲区，用于存储接收到的数据。
配置接收中断使能。
调用 HAL_UART_Receive_IT() 函数来启动 UART 接收中断。

以下是一个示例，展示如何使用该函数来启动 UART 接收中断：

// 示例代码假设你正在使用的是STM32的HAL库
UART_HandleTypeDef huart; // 定义 UART 控制器结构体，存储 UART 控制器的相关信息
uint8_t rxBuffer[100]; // 定义接收数据的缓冲区
// UART接收中断回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart)
{
  // 处理接收中断事件
  // ...
}
int main(void)
{
  // ...
  // 配置并初始化UART控制器结构体 huart
  // ...
  // 配置接收中断使能
  HAL_UART_Receive_IT(&huart, rxBuffer, sizeof(rxBuffer));
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 UART 控制器结构体 huart。然后，定义了一个数据缓冲区 rxBuffer，用于存储接收到的数据。在 UART 接收中断回调函数 HAL_UART_RxCpltCallback() 中，处理接收中断事件。通过调用 HAL_UART_Receive_IT() 函数，启动 UART 接收中断。

请注意，示例中的 huart 是一个 UART 控制器结构体实例，rxBuffer 是接收数据的缓冲区，sizeof(rxBuffer) 是缓冲区的大小。你需要根据实际使用的 UART 控制器和硬件平台，在代码中使用正确的控制器结构体和缓冲区。

`HAL_UART_Receive()`

HAL_UART_Receive() 的作用是在指定的 UART 接收数据寄存器接收到指定长度的数据时，自动将数据读取到指定的缓冲区中。下面是对该函数的详细说明：

作用：
HAL_UART_Receive() 函数用于在 UART 接收数据寄存器接收到指定长度的数据时，自动将数据读取到指定的缓冲区中。该函数会等待接收完指定长度的数据或超时时限到达。

参数意义：
该函数有四个参数：

huart：传入指向 UART 控制器 (UART_HandleTypeDef) 的指针。通过这个参数，函数可以确定要操作的 UART 模块。

pData：传入指向接收数据的缓冲区的指针。接收到的数据将被存储在这个缓冲区中。

Size：传入期望接收的数据长度。当接收到指定长度的数据或超过超时时限时，函数会自动结束接收过程。

Timeout：传入接收超时时限，以毫秒为单位。如果在超过这个时限后仍然没有接收到指定长度的数据，函数会自动结束接收过程。

使用场景：
该函数常用于需要接收一定长度的数据的场景，例如在串口通信中，需要接收特定长度的数据帧或命令。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 UART 控制器结构体 (如 UART_HandleTypeDef)，并配置相关的 UART 参数。
定义一个缓冲区数组，用来存储接收到的数据。
调用 HAL_UART_Receive() 函数来进行接收操作。

以下是一个示例，展示如何使用该函数来接收 UART 模块的数据：

// 示例代码假设你正在使用的是STM32的HAL库
UART_HandleTypeDef huart2; // 定义 UART 控制器结构体，存储 UART 控制器的相关信息
uint8_t rxBuffer[100]; // 定义接收缓冲区，用于存储接收到的数据
int main(void)
{
  // ...
  // 配置并初始化 UART 控制器结构体 huart2
  // ...
  // 接收数据
  if (HAL_UART_Receive(&huart2, rxBuffer, sizeof(rxBuffer), 1000) == HAL_OK)
  {
    // 接收成功，可以处理接收到的数据
    // ...
  }
  else
  {
    // 接收失败，可以进行错误处理
    // ...
  }
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 UART 控制器结构体 huart2。然后，定义了一个大小为100的接收缓冲区数组 rxBuffer。接下来，通过调用 HAL_UART_Receive() 函数开始进行接收操作。当接收函数返回 HAL_OK 时，表示接收成功，可以对接收到的数据进行处理。当接收函数返回其他状态时，表示接收失败，可以进行相应的错误处理。

请注意，示例中的 huart2 是一个 UART 控制器结构体实例，rxBuffer 是接收数据的缓冲区。你需要根据实际使用的 UART 模块和硬件平台，在代码中使用正确的控制器结构体和缓冲区。

`HAL_UART_Receive_DMA()`

HAL_UART_Receive_DMA() 的作用是通过 DMA（直接内存访问）方式接收 UART 数据。下面是对该函数的详细说明：

作用：
HAL_UART_Receive_DMA() 函数用于通过 DMA 方式接收 UART 数据，将接收到的数据直接存储到指定的内存缓冲区中，而不需要 CPU 参与数据传输的过程。

参数意义：
该函数有三个参数：

huart：传入指向 UART 控制器 (UART_HandleTypeDef) 的指针。通过这个参数，函数可以确定要操作的 UART 模块。

pData：传入指向数据缓冲区的指针，该缓冲区用于存储接收到的数据。

Size：传入要接收的数据的字节数。

使用场景：
该函数常用于需要高效地接收大量 UART 数据的场景，特别是在使用中断方式接收数据时容易产生效率问题的情况下。通过使用 DMA 方式，可以减轻 CPU 的负担，提高数据传输效率。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 UART 控制器结构体 (如 UART_HandleTypeDef)，并配置相关的 UART 参数和 DMA 控制器参数。
在需要接收 UART 数据的地方调用 HAL_UART_Receive_DMA() 函数。

以下是一个示例，展示如何使用该函数来通过 DMA 方式接收 UART 数据：

UART_HandleTypeDef huart2; // 定义 UART 控制器结构体，存储 UART 控制器的相关信息
uint8_t rxBuffer[100]; // 接收缓冲区
int main(void)
{
  // ...
  // 配置并初始化 UART 控制器结构体 huart2
  // 配置并初始化 DMA 控制器
  // ...
  // 启动 UART 接收 DMA 模式
  HAL_UART_Receive_DMA(&huart2, rxBuffer, sizeof(rxBuffer));
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 UART 控制器结构体 huart2 和一个接收缓冲区 rxBuffer。然后，调用 HAL_UART_Receive_DMA() 函数来启动 UART 接收 DMA 模式，将接收到的数据存储到 rxBuffer 中。

请注意，示例中的 huart2 是一个 UART 控制器结构体实例，rxBuffer 是用于存储接收数据的缓冲区。你需要根据实际使用的 UART 模块、DMA 控制器和硬件平台，在代码中使用正确的控制器结构体和缓冲区。

`HAL_UART_Transmit()`

HAL_UART_Transmit() 的作用是通过 UART 发送数据。下面是对该函数的详细说明：

作用：
HAL_UART_Transmit() 函数用于通过 UART 发送数据。

通过调用该函数，可以将数据发送到指定的 UART 端口用于串口通信。

参数意义：
该函数有四个参数：

UART_HandleTypeDef *huart：传入指向 UART 控制器 (UART_HandleTypeDef) 结构体的指针。通过这个结构体，函数可以确定要操作的 UART 控制器。

uint8_t *pData：传入指向待发送数据缓冲区的指针。通过这个指针，函数可以确定需要发送的数据来源。

uint16_t Size：指定待发送数据的字节数。通过这个参数，函数可以确定待发送数据的大小。

uint32_t Timeout：指定发送超时时间，以毫秒为单位。函数将在指定的时间内等待发送完成，如果超时仍未完成发送，则函数将返回错误。

使用场景：
该函数常用于需要通过 UART 发送数据的场景，例如与外部设备进行串口通信或与其他设备进行数据交换等。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 UART 控制器结构体 (如 UART_HandleTypeDef)，并配置相关的 UART 参数。
定义一个数据缓冲区，用于存储待发送的数据。
调用 HAL_UART_Transmit() 函数来发送数据。

以下是一个示例，展示如何使用该函数来发送数据：

// 示例代码假设你正在使用的是STM32的HAL库
UART_HandleTypeDef huart; // 定义 UART 控制器结构体，存储 UART 控制器的相关信息
uint8_t txBuffer[] = "Hello, world!"; // 定义待发送的数据
int main(void)
{
  // ...
  // 配置并初始化UART控制器结构体 huart
  // ...
  // 发送数据
  HAL_UART_Transmit(&huart, txBuffer, sizeof(txBuffer) - 1, HAL_MAX_DELAY);
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 UART 控制器结构体 huart。然后，定义了一个数据缓冲区 txBuffer，存储待发送的字符数据。

通过调用 HAL_UART_Transmit() 函数，将数据发送到 UART 接口。函数的第一个参数是 UART 控制器结构体指针，第二个参数是待发送数据的缓冲区指针，第三个参数是待发送数据的大小。sizeof(txBuffer) - 1 是为了排除字符串结束符。第四个参数 HAL_MAX_DELAY 表示函数将一直等待数据发送完成，直到数据发送完毕后才返回。

请注意，示例中的 huart 是一个 UART 控制器结构体实例，txBuffer 是待发送的数据缓冲区。你需要根据实际使用的 UART 控制器和硬件平台，在代码中使用正确的控制器结构体和缓冲区。

`__HAL_RCC_USARTx_CLK_ENABLE()`

__HAL_RCC_USARTx_CLK_ENABLE() 的作用是使能 USARTx 模块的时钟。

下面是对该函数的详细说明：

作用：
__HAL_RCC_USARTx_CLK_ENABLE() 函数用于使能与特定 USARTx 模块相关的时钟，以便于该模块能够正常工作。

参数意义：
该函数只有一个参数：

USARTx：表示具体的 USART 模块，如 USART1、USART2、USART3 等。通过这个参数，函数可以确定要使能时钟的是哪个 USART 模块。

使用场景：
该函数常用于需要使用 USART 功能的场景，例如实现串口通信、调试、数据传输等。

使用方法：
以下是使用该函数的一般过程：

在主程序中调用 __HAL_RCC_USARTx_CLK_ENABLE() 函数来使能 USART 模块的时钟。

以下是一个示例，展示如何使用该函数来使能 USART3 模块的时钟：

// 示例代码假设你正在使用的是STM32的HAL库
int main(void)
{
  // ...
  // 使能 USART3 模块的时钟
  __HAL_RCC_USART3_CLK_ENABLE();
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，通过调用 __HAL_RCC_USART3_CLK_ENABLE() 函数来使能 USART3 模块的时钟。这将确保 USART3 模块能够正常工作。

你需要根据实际使用的 USART 模块，在代码中使用正确的函数来使能对应模块的时钟。

`__HAL_UART_ENABLE_IT()`

__HAL_UART_ENABLE_IT() 的作用是使能指定 UART 模块的中断。

下面是对该函数的详细说明：

作用：
__HAL_UART_ENABLE_IT() 函数用于使能与指定 UART 模块相关的中断，并启用相应的中断处理函数。

参数意义：
该函数有两个参数：

huart：传入指向 UART 控制器 (UART_HandleTypeDef) 的指针。通过这个参数，函数可以确定要操作的 UART 模块。

ITName：传入要使能的中断的名称。通过这个参数，函数可以确定要使能哪个中断。

常见的 UART 中断名称包括以下几个：

UART_IT_TXE：使能 UART 发送寄存器空中断。

UART_IT_RXNE：使能 UART 接收寄存器非空中断。

UART_IT_TC：使能 UART 传输完成中断。

UART_IT_PE：使能 UART 奇偶校验错误中断。

UART_IT_ERR：使能 UART 帧错误、噪声错误、过载错误、断开线错误中断。

使用场景：
该函数常用于需要使用 UART 模块中断进行数据收发操作的场景。通过使能中断，可以在接收到数据或数据发送完成时触发中断处理函数，从而及时处理相应的逻辑。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 UART 控制器结构体 (如 UART_HandleTypeDef)，并配置相关的 UART 参数。
调用 __HAL_UART_ENABLE_IT() 函数来使能特定的 UART 中断。

以下是一个示例，展示如何使用该函数来使能 UART 模块的接收中断：

// 示例代码假设你正在使用的是STM32的HAL库
UART_HandleTypeDef huart2; // 定义 UART 控制器结构体，存储 UART 控制器的相关信息
int main(void)
{
  // ...
  // 配置并初始化 UART 控制器结构体 huart2
  // ...
  // 使能 UART 接收中断
  __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE);
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 UART 控制器结构体 huart2。然后，通过调用 __HAL_UART_ENABLE_IT() 函数，使能了 UART2 模块的接收中断。这将在接收缓冲区非空时触发中断处理函数。

请注意，示例中的 huart2 是一个 UART 控制器结构体实例。你需要根据实际使用的 UART 模块和硬件平台，在代码中使用正确的控制器结构体和中断名称。

`__HAL_UART_GET_FLAG()`

__HAL_UART_GET_FLAG() 的作用是获取指定 UART 模块的特定标志位的状态。下面是对该函数的详细说明：

作用：
__HAL_UART_GET_FLAG() 函数用于获取指定 UART 模块的特定标志位的状态，判断某个特定的事件是否发生。通过该函数，可以检查 UART 接收和发送过程中的各种状态，以便进行相应的处理。

参数意义：
该函数有两个参数：

huart：传入指向 UART 控制器 (UART_HandleTypeDef) 的指针。通过这个参数，函数可以确定要操作的 UART 模块。

flag：传入指定的标志位。可以使用宏定义在 HAL 库中定义好的标志位（如 UART_FLAG_RXNE 表示接收缓冲区非空标志位）。有：

UART_FLAG_TC：数据发送完成标识符。

UART_FLAG_RXNE：接收缓冲区非空标志位。

使用场景：
该函数常用于需要检查 UART 接收和发送状态的场景，例如在接收串口数据时，可以使用该函数判断接收缓冲区是否有新的数据。

使用方法：
以下是使用该函数的一般过程：

在主程序中定义并初始化一个 UART 控制器结构体 (如 UART_HandleTypeDef)，并配置相关的 UART 参数。
在需要检查状态的地方调用 __HAL_UART_GET_FLAG() 函数来获取指定标志位的状态。

以下是一个示例，展示如何使用该函数来判断 UART 接收缓冲区是否有新的数据：

// 示例代码假设你正在使用的是STM32的HAL库
UART_HandleTypeDef huart2; // 定义 UART 控制器结构体，存储 UART 控制器的相关信息
int main(void)
{
  // ...
  // 配置并初始化 UART 控制器结构体 huart2
  // ...
  // 检查接收缓冲区非空标志位
  if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_RXNE))
  {
    // 接收缓冲区有新的数据
    // 可以调用 HAL_UART_Receive() 函数来读取数据
    // ...
  }
  while (1)
  {
    // 主程序逻辑
    // ...
  }
}

在上面的示例中，首先在主程序中定义并初始化了一个 UART 控制器结构体 huart2。在需要检查接收缓冲区是否有新的数据的地方，通过调用 __HAL_UART_GET_FLAG() 函数来检查 UART_FLAG_RXNE 标志位的状态。若该标志位的状态为非零值，表示接收缓冲区中有新的数据可读。

请注意，示例中的 huart2 是一个 UART 控制器结构体实例，UART_FLAG_RXNE 是一个宏定义，用于表示接收缓冲区非空标志位。你需要根据实际使用的 UART 模块和硬件平台，在代码中使用正确的控制器结构体和标志位。

IIC

`HAL_I2C_Master_Transmit()`

HAL_I2C_Master_Transmit()函数是一个在STM32的HAL库中提供的函数，用于通过I2C总线向从设备发送数据。

以下是各参数的详细说明：

hi2c参数：
这是一个指向I2C_HandleTypeDef结构体的指针，表示要使用的I2C总线。
DevAddress参数：
这是一个7位从设备地址，用于指定要发送数据的设备。
pData参数：
这是一个指向数据缓冲区的指针，表示要发送的数据。
Size参数：
这是一个uint16_t类型的参数，表示要发送的数据的字节数。
Timeout参数：
这是一个超时时间，以毫秒为单位。如果在指定的时间内传输未完成，函数将会超时。

使用场景：
HAL_I2C_Master_Transmit()函数适用于在STM32上通过I2C总线与外部设备进行通信的场景，例如通过I2C向传感器发送命令，配置外设，或者发送数据给外部设备。

使用方法：
以下是使用HAL_I2C_Master_Transmit()函数的一般过程：

创建一个I2C_HandleTypeDef结构体对象，并对其进行配置，包括指定I2C总线、设置I2C模式、设置时钟频率等。
使用HAL_I2C_Master_Transmit()函数发送数据：
将要使用的I2C总线的句柄指针传递给hi2c参数。
指定要发送数据的设备地址，通过DevAddress参数传递。
传入数据缓冲区指针，通过pData参数传递。
指定要发送的数据字节数，通过Size参数传递。
可选地，可以设置一个超时时间，通过Timeout参数传递。

下面是一个简单的示例，演示如何使用HAL_I2C_Master_Transmit()函数：

// 创建并配置I2C总线的句柄
I2C_HandleTypeDef hi2c1;
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

// 初始化I2C总线
HAL_I2C_Init(&hi2c1);

// 数据缓冲区
uint8_t sendData[4] = {0x11, 0x22, 0x33, 0x44};

// 发送数据
HAL_I2C_Master_Transmit(&hi2c1, 0xA0, sendData, sizeof(sendData), 1000);

在上面的示例中：

首先，我们创建了一个I2C_HandleTypeDef结构体对象hi2c1，并对其进行配置，包括指定I2C总线（I2C1）和设置时钟频率（100 kHz）等。然后，我们使用HAL_I2C_Init()函数对I2C总线进行初始化。

然后定义了一个长度为4的数据缓冲区sendData，其中包含了一些我们要发送的数据。

最后，我们调用了HAL_I2C_Master_Transmit()函数，将要发送的I2C数据发送给设备。其中，第一个参数&hi2c1表示要使用的I2C总线，第二个参数0xA0表示设备地址，第三个参数sendData表示要发送的数据，第四个参数sizeof(sendData)表示要发送数据的字节数，第五个参数1000表示超时时间为1秒。通过这个函数调用，我们成功将数据发送给了指定的设备。

需要注意的是，使用HAL_I2C_Master_Transmit()函数发送数据之前，需要先通过HAL_I2C_Init()函数对I2C总线进行初始化配置，以确保在发送数据时I2C总线配置正确，才能正常传输数据。此外，您也需要根据实际情况调整Timeout参数来避免因为超时而出现错误的情况。

`HAL_I2C_Master_Receive()`

HAL_I2C_Master_Receive()函数是STM32的HAL库中提供的一个函数，用于在I2C主设备模式下向从设备接收数据。

以下是各参数的详细说明：

hi2c参数：
这是一个指向I2C_HandleTypeDef结构体的指针，表示要使用的I2C总线。
DevAddress参数：
这是从设备的地址。
pData参数：
这是一个指向要接收数据的缓冲区的指针。
Size参数：
这是一个uint16_t类型的参数，表示要接收的数据字节数。

使用场景：
HAL_I2C_Master_Receive()函数适用于在STM32上作为I2C主设备与从设备进行通信的场景。例如，主设备可以向传感器发送命令，以启动其测量模式，并从传感器中读取测量数据。

使用方法：
以下是使用HAL_I2C_Master_Receive()函数的一般过程：

创建一个I2C_HandleTypeDef结构体对象，并对其进行配置，包括指定I2C总线、设置I2C模式、设置时钟频率等。
使用HAL_I2C_Master_Transmit()函数向从设备发送命令或数据。
使用HAL_I2C_Master_Receive()函数接收从设备的响应：
将要使用的I2C总线的句柄指针传递给hi2c参数。
传入从设备的地址，通过DevAddress参数传递。
传入要接收数据的缓冲区指针，通过pData参数传递。
指定要接收的数据字节数，通过Size参数传递。

下面是一个简单的示例，演示如何使用HAL_I2C_Master_Receive()函数：

// 创建并配置I2C总线的句柄
I2C_HandleTypeDef hi2c1;
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

// 初始化I2C总线
HAL_I2C_Init(&hi2c1);

// 数据缓冲区
uint8_t recvData[4];

// 发送命令给从设备
uint8_t sendData[1] = {0xAA};
HAL_I2C_Master_Transmit(&hi2c1, 0x30, sendData, sizeof(sendData), 1000);

// 接收从设备的响应
HAL_I2C_Master_Receive(&hi2c1, 0x30, recvData, sizeof(recvData), 1000);

在上面的示例中：

首先，我们创建了一个I2C_HandleTypeDef结构体对象hi2c1，并对其进行配置，包括指定I2C总线（I2C1）和设置时钟频率（100 kHz），并设置自身的I2C地址为0。

然后，我们定义了一个数据缓冲区recvData，用于接收从设备发送的数据。

接下来，我们使用HAL_I2C_Master_Transmit()函数向从设备发送一个命令，例中为0xAA，启动从设备的测量模式。

最后，我们使用HAL_I2C_Master_Receive()函数接收从设备发送的测量数据，将从设备地址、要接收数据的缓冲区指针recvData和数据字节数sizeof(recvData)传递给函数。函数会将数据写入到缓冲区中

`HAL_I2C_Slave_Transmit()`

HAL_I2C_Slave_Transmit()函数是STM32的HAL库中提供的一个函数，用于在I2C从设备模式下向主设备传输数据。

以下是各参数的详细说明：

hi2c参数：
这是一个指向I2C_HandleTypeDef结构体的指针，表示要使用的I2C总线。
pData参数：
这是一个指向要传输数据的缓冲区的指针。
Size参数：
这是一个uint16_t类型的参数，表示要传输的数据字节数。
Timeout参数：
这是一个超时时间，以毫秒为单位。如果在指定的时间内传输未完成，函数将会超时。

使用场景：
HAL_I2C_Slave_Transmit()函数适用于在STM32上作为I2C从设备与主设备进行通信的场景。例如，从设备可以将数据传输给主设备，如传感器向主控制器发送数据。

使用方法：
以下是使用HAL_I2C_Slave_Transmit()函数的一般过程：

创建一个I2C_HandleTypeDef结构体对象，并对其进行配置，包括指定I2C总线、设置I2C模式、设置时钟频率等。
使用HAL_I2C_Slave_Transmit()函数传输数据：
将要使用的I2C总线的句柄指针传递给hi2c参数。
传入要传输数据的缓冲区指针，通过pData参数传递。
指定要传输的数据字节数，通过Size参数传递。
可选地，可以设置一个超时时间，通过Timeout参数传递。

下面是一个简单的示例，演示如何使用HAL_I2C_Slave_Transmit()函数：

// 创建并配置I2C总线的句柄
I2C_HandleTypeDef hi2c1;
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0x30;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

// 初始化I2C总线
HAL_I2C_Init(&hi2c1);

// 数据缓冲区
uint8_t sendData[4] = {0x01, 0x02, 0x03, 0x04};

// 从设备向主设备传输数据
HAL_I2C_Slave_Transmit(&hi2c1, sendData, sizeof(sendData), 1000);

在上面的示例中:

首先，我们创建了一个I2C_HandleTypeDef结构体对象hi2c1，并对其进行配置，包括指定I2C总线（I2C1）和设置时钟频率（100 kHz），同时也指定了从设备的地址为0x30。

然后，我们定义了一个数据缓冲区sendData，里面包含了要传输的数据。

最后，我们使用HAL_I2C_Slave_Transmit()函数向主设备传输数据，将要传输的数据缓冲区指针sendData和数据字节数sizeof(sendData)传递给函数，还可以选择性地设置超时时间为1000毫秒。

`HAL_I2C_Mem_Write()`

HAL_I2C_Mem_Write()函数是STM32的HAL库中提供的一个函数，用于通过I2C总线向指定设备的寄存器中写入数据。

以下是各参数的详细说明：

hi2c参数：
这是一个指向I2C_HandleTypeDef结构体的指针，表示要使用的I2C总线。
DevAddress参数：
这是一个7位从设备地址，用于指定要写入数据的设备。
MemAddress参数：
这是一个16位的内部寄存器地址，表示要写入数据的寄存器地址。
MemAddSize参数：
这是一个uint16_t类型的参数，表示内部寄存器地址的大小。可以是I2C_MEMADD_SIZE_8BIT或I2C_MEMADD_SIZE_16BIT。
pData参数：
这是一个指向要写入数据的缓冲区的指针。
Size参数：
这是一个uint16_t类型的参数，表示要写入的数据的字节数。
Timeout参数：
这是一个超时时间，以毫秒为单位。如果在指定的时间内写入未完成，函数将会超时。

使用场景：
HAL_I2C_Mem_Write()函数适用于在STM32上通过I2C总线与外部设备进行通信的场景，例如向配置寄存器写入配置或向外设发送指令。

使用方法：
以下是使用HAL_I2C_Mem_Write()函数的一般过程：

创建一个I2C_HandleTypeDef结构体对象，并对其进行配置，包括指定I2C总线、设置I2C模式、设置时钟频率等。
使用HAL_I2C_Mem_Write()函数写入数据：
将要使用的I2C总线的句柄指针传递给hi2c参数。
指定要写入数据的设备地址，通过DevAddress参数传递。
指定要写入的内部寄存器地址，通过MemAddress参数传递。
设置内部寄存器地址的大小，通过MemAddSize参数传递。
传入要写入数据的缓冲区指针，通过pData参数传递。
指定要写入的数据字节数，通过Size参数传递。
可选地，可以设置一个超时时间，通过Timeout参数传递。

下面是一个简单的示例，演示如何使用HAL_I2C_Mem_Write()函数：

// 创建并配置I2C总线的句柄
I2C_HandleTypeDef hi2c1;
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

// 初始化I2C总线
HAL_I2C_Init(&hi2c1);

// 数据缓冲区
uint8_t sendData[4] = {0x01, 0x02, 0x03, 0x04};

// 写入数据
HAL_I2C_Mem_Write(&hi2c1, 0xA0, 0x00, I2C_MEMADD_SIZE_8BIT, sendData, sizeof(sendData), 1000);

在上面的示例中:

首先，我们创建了一个I2C_HandleTypeDef结构体对象hi2c1，并对其进行配置，包括指定I2C总线（I2C1）和设置时钟频率（100 kHz）等。

`HAL_I2C_Mem_Read()`

HAL_I2C_Mem_Read()函数是STM32的HAL库中提供的一个函数，用于通过I2C总线从指定设备的寄存器中读取数据。

以下是各参数的详细说明：

hi2c参数：
这是一个指向I2C_HandleTypeDef结构体的指针，表示要使用的I2C总线。
DevAddress参数：
这是一个7位从设备地址，用于指定要读取数据的设备。
MemAddress参数：
这是一个16位的内部寄存器地址，表示要从设备中读取数据的寄存器地址。
MemAddSize参数：
这是一个uint16_t类型的参数，表示内部寄存器地址的大小。可以是I2C_MEMADD_SIZE_8BIT或I2C_MEMADD_SIZE_16BIT。
pData参数：
这是一个指向数据缓冲区的指针，用于存储读取的数据。
Size参数：
这是一个uint16_t类型的参数，表示要读取的数据的字节数。
Timeout参数：
这是一个超时时间，以毫秒为单位。如果在指定的时间内读取未完成，函数将会超时。

使用场景：
HAL_I2C_Mem_Read()函数适用于在STM32上通过I2C总线与外部设备进行通信的场景，例如从传感器或外设中读取配置或传感器数据。

使用方法：
以下是使用HAL_I2C_Mem_Read()函数的一般过程：

创建一个I2C_HandleTypeDef结构体对象，并对其进行配置，包括指定I2C总线、设置I2C模式、设置时钟频率等。
使用HAL_I2C_Mem_Read()函数读取数据：
将要使用的I2C总线的句柄指针传递给hi2c参数。
指定要读取数据的设备地址，通过DevAddress参数传递。
指定要读取的内部寄存器地址，通过MemAddress参数传递。
设置内部寄存器地址的大小，通过MemAddSize参数传递。
传入数据缓冲区指针，通过pData参数传递。
指定要读取的数据字节数，通过Size参数传递。
可选地，可以设置一个超时时间，通过Timeout参数传递。

下面是一个简单的示例，演示如何使用HAL_I2C_Mem_Read()函数：

// 创建并配置I2C总线的句柄
I2C_HandleTypeDef hi2c1;
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

// 初始化I2C总线
HAL_I2C_Init(&hi2c1);

// 数据缓冲区
uint8_t receiveData[4];

// 读取数据
HAL_I2C_Mem_Read(&hi2c1, 0xA0, 0x00, I2C_MEMADD_SIZE_8BIT, receiveData, sizeof(receiveData), 1000);

在上面的示例中：

首先，我们创建了一个I2C_HandleTypeDef结构体对象hi2c1，并对其进行配置，包括指定I2C总线（I2C1）和设置时钟频率（100 kHz）等。然后，我们使用HAL_I2C_Init()函数

DMA

`HAL_DMA_Start()`

HAL_DMA_Start()函数用于启动DMA传输。

以下是HAL_DMA_Start()函数的定义：

HAL_StatusTypeDef HAL_DMA_Start(
    DMA_HandleTypeDef* hdma,    // DMA句柄
    uint32_t SrcAddress,        // 源地址
    uint32_t DstAddress,        // 目标地址
    uint32_t DataLength         // 传输数据长度
);

HAL_DMA_Start()函数的作用是启动DMA传输，将指定长度的数据从源地址传输到目标地址。

各参数的意义如下：

hdma：DMA句柄，指向已配置的DMA控制器。

SrcAddress：源地址，即数据来源的内存地址。

DstAddress：目标地址，即数据传输的目的内存地址。

DataLength：传输数据的长度，以字节为单位。

使用场景和使用方法如下：

使用场景：HAL_DMA_Start()函数通常用于实现高效的DMA传输，以减轻CPU的负载并提高数据传输性能。它可用于在不同外设之间或内存和外设之间传输数据。

使用方法：

首先，需要初始化DMA控制器，并配置正确的传输模式、数据宽度、传输方向等相关参数。
根据传输方向，准备好源地址和目标地址的指针。
调用HAL_DMA_Start()函数启动DMA传输。

以下是一个示例代码片段：

DMA_HandleTypeDef hdma;
uint32_t srcData[100];
uint32_t dstData[100];

// 初始化DMA控制器
hdma.Instance = DMA1_Channel1;
hdma.Init.Direction = DMA_MEMORY_TO_MEMORY;
hdma.Init.PeriphInc = DMA_PINC_ENABLE;
hdma.Init.MemInc = DMA_MINC_ENABLE;
hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
hdma.Init.Mode = DMA_NORMAL;
hdma.Init.Priority = DMA_PRIORITY_HIGH;
if (HAL_DMA_Init(&hdma) != HAL_OK) {
    // 处理初始化错误
    // ...
}

// 准备数据
for(int i = 0; i < 100; i++) {
    srcData[i] = i;
}

// 启动DMA传输
if (HAL_DMA_Start(&hdma, (uint32_t)srcData, (uint32_t)dstData, sizeof(srcData)) != HAL_OK) {
    // 处理启动DMA传输错误
    // ...
}

// 在传输完成中断中处理传输完成事件
void HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma)
{
    // 处理传输完成事件
    // ...
}

在上述示例中，首先初始化DMA控制器，并配置传输参数，包括传输方向、增量模式、数据对齐方式等。然后，准备好源地址和目标地址。接着，调用 HAL_DMA_Start() 函数启动DMA传输，将源地址中的数据传输到目标地址中。最后，在传输完成的中断处理函数 HAL_DMA_IRQHandler() 中处理传输完成事件。请注意，具体的错误处理和数据处理的部分应根据实际情况进行编写。

`HAL_UART_Receive_DMA()`

HAL_UART_Receive_DMA()函数用于启动UART接收DMA传输。

以下是HAL_UART_Receive_DMA()函数的定义：

HAL_StatusTypeDef HAL_UART_Receive_DMA(
    UART_HandleTypeDef* huart,  // UART句柄
    uint8_t* pData,             // 接收数据缓冲区
    uint16_t Size               // 接收数据缓冲区大小
);

HAL_UART_Receive_DMA()函数的作用是启动UART接收DMA传输，接收到的数据将存储在指定的缓冲区中。

各参数的意义如下：

huart：UART句柄，指向已初始化的UART控制器。

pData：接收数据的缓冲区指针，用于存储接收到的数据。

Size：接收数据缓冲区的大小，以字节为单位。

使用场景和使用方法如下：

使用场景：HAL_UART_Receive_DMA()函数通常用于实现高效的UART数据接收。通过使用DMA传输来接收数据，可以减轻CPU的负担，并提供更高的接收性能。

使用方法：

首先，需要初始化UART控制器，并配置正确的波特率、数据位数、停止位等相关参数。
创建一个与接收数据大小相匹配的数据缓冲区。
调用HAL_UART_Receive_DMA()函数启动DMA接收传输，将接收到的数据存储在指定的缓冲区中。

以下是一个示例代码片段：

UART_HandleTypeDef huart;
uint8_t receiveBuffer[100];

// 初始化UART控制器
huart.Instance = USART1;
huart.Init.BaudRate = 9600;
huart.Init.WordLength = UART_WORDLENGTH_8B;
huart.Init.StopBits = UART_STOPBITS_1;
huart.Init.Parity = UART_PARITY_NONE;
huart.Init.Mode = UART_MODE_RX;
huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart) != HAL_OK) {
    // 处理初始化错误
    // ...
}

// 启动DMA接收传输
if (HAL_UART_Receive_DMA(&huart, receiveBuffer, sizeof(receiveBuffer)) != HAL_OK) {
    // 处理启动DMA传输错误
    // ...
}

// 在接收完成中断中处理接收到的数据
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    // 处理接收到的数据
    // ...
}

在上述示例中，首先初始化UART控制器，然后创建一个大小为 100 字节的数据缓冲区 receiveBuffer。接着调用 HAL_UART_Receive_DMA() 函数启动DMA接收传输，将接收到的数据存储在缓冲区中。最后，在接收完成的中断回调函数 HAL_UART_RxCpltCallback() 中处理接收到的数据。请注意，具体的错误处理和数据处理的部分应根据实际情况进行编写。

`HAL_UARTEx_ReceiveToIdle_DMA()`

HAL_UARTEx_ReceiveToIdle_DMA()函数用于使用DMA方式接收UART数据，直到空闲状态。该函数会在DMA传输完成后自动停止接收数据并触发空闲中断。

以下是HAL_UARTEx_ReceiveToIdle_DMA()函数的定义：

HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_DMA(
    UART_HandleTypeDef *huart,    // UART句柄
    uint8_t *pData,               // 接收数据缓冲区指针
    uint16_t Size                 // 接收数据长度
);

各参数的意义如下：

huart：UART句柄，指向已配置的串口控制器。

pData：存储接收数据的缓冲区指针。

Size：需要接收的数据长度，以字节为单位。

使用场景和使用方法如下：

使用场景：HAL_UARTEx_ReceiveToIdle_DMA()函数通常用于实现高效的UART数据接收，并减小CPU的负载。它适用于需要接收大量数据的应用场景，如调试信息接收、数据采集等。

使用方法：

首先，需要初始化UART控制器，并配置正确的波特率、数据位、停止位、奇偶校验位等相关参数。
根据接收长度，准备好接收数据的缓冲区。
调用HAL_UARTEx_ReceiveToIdle_DMA()函数启动DMA数据接收。
在空闲中断中处理接收数据，例如对数据进行处理、打印等。

以下是一个示例代码片段：

UART_HandleTypeDef huart;
DMA_HandleTypeDef hdma_uart_rx;

// 初始化UART控制器
huart.Instance = USART2;
huart.Init.BaudRate = 115200;
huart.Init.WordLength = UART_WORDLENGTH_8B;
huart.Init.StopBits = UART_STOPBITS_1;
huart.Init.Parity = UART_PARITY_NONE;
huart.Init.Mode = UART_MODE_TX_RX;
huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart) != HAL_OK) {
    // 处理初始化错误
    // ...
}

// 配置DMA控制器
hdma_uart_rx.Instance = DMA1_Channel5;
hdma_uart_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_uart_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_uart_rx.Init.MemInc = DMA_MINC_ENABLE;
hdma_uart_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_uart_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_uart_rx.Init.Mode = DMA_NORMAL;
hdma_uart_rx.Init.Priority = DMA_PRIORITY_LOW;
if (HAL_DMA_Init(&hdma_uart_rx) != HAL_OK) {
    // 处理初始化错误
    // ...
}

// 关联DMA和UART
__HAL_LINKDMA(&huart, hdmarx, hdma_uart_rx);

// 启动DMA数据接收
uint8_t rxBuffer[100];
if (HAL_UARTEx_ReceiveToIdle_DMA(&huart, rxBuffer, sizeof(rxBuffer)) != HAL_OK) {
    // 处理启动DMA数据接收错误
    // ...
}

// 在空闲中断中处理接收数据
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    // 处理接收到的数据
    // ...
}

在上述示例中，首先初始化UART控制器，并配置传输参数，包括波特率、数据位、停止位等。然后，初始化DMA控制器，并将DMA控制器与UART控制器关联。接着，调用 HAL_UARTEx_ReceiveToIdle_DMA() 函数启动DMA数据接收，将接收到的数据存储到指定的缓冲区中。最后，在空闲中断回调函数 HAL_UART_RxCpltCallback() 中对接收到的数据进行处理。请注意，具体的错误处理和数据处理的部分应根据实际情况进行编写。

`__HAL_DMA_DISABLE_IT()`

__HAL_DMA_DISABLE_IT()函数用于禁用DMA的中断功能。该函数可以用来关闭特定DMA通道的中断，在某些情况下，禁用中断可能是必要的，以避免中断处理程序的干扰或优化系统性能。

以下是__HAL_DMA_DISABLE_IT()函数的定义：

void __HAL_DMA_DISABLE_IT(DMA_HandleTypeDef *hdma, uint32_t IT);

各参数的意义如下：

hdma：DMA句柄，指向已配置的DMA控制器结构体。

IT：中断类型，在使用HAL_DMA_IRQHandler()函数启用中断时，使用具体的中断标志位作为参数，例如DMA_IT_TC表示传输完成中断。

使用场景和使用方法如下：

使用场景：__HAL_DMA_DISABLE_IT()函数通常用于需要临时关闭DMA中断的情况。例如，在临界区代码中，禁用DMA中断可以避免在中断处理函数执行期间发生其他中断，确保代码的正确性和可靠性。

使用方法：

初始化DMA控制器，并配置相关参数。
使用HAL_DMA_IRQHandler()函数使能中断，并在中断处理函数中处理相应的中断事件。
在需要禁用DMA中断的地方，调用__HAL_DMA_DISABLE_IT()函数。
需要再次启用中断时，可以使用__HAL_DMA_ENABLE_IT()函数重新启用。

以下是示例代码片段：

DMA_HandleTypeDef hdma;

// 初始化DMA控制器
hdma.Instance = DMA1_Channel1;
hdma.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma.Init.PeriphInc = DMA_PINC_DISABLE;
hdma.Init.MemInc = DMA_MINC_ENABLE;
hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma.Init.Mode = DMA_NORMAL;
hdma.Init.Priority = DMA_PRIORITY_HIGH;
if (HAL_DMA_Init(&hdma) != HAL_OK) {
    // 处理初始化错误
    // ...
}

// 启用DMA传输完成中断
__HAL_DMA_ENABLE_IT(&hdma, DMA_IT_TC);

// 在某个临界区禁用DMA中断
// ...
__HAL_DMA_DISABLE_IT(&hdma, DMA_IT_TC);
// ...

// DMA中断处理函数
void DMA1_Channel1_IRQHandler(void)
{
    // 判断中断来源
    if (__HAL_DMA_GET_FLAG(&hdma, DMA_FLAG_TC1)) {
        // 处理传输完成中断
        // ...
        // 清除中断标志
        __HAL_DMA_CLEAR_FLAG(&hdma, DMA_FLAG_TC1);
    }
}

在上述示例中，首先初始化DMA控制器，并配置传输参数。然后，使用__HAL_DMA_ENABLE_IT()函数启用传输完成中断。在某个临界区内，可以使用__HAL_DMA_DISABLE_IT()函数临时禁用该中断。在DMA中断处理函数 DMA1_Channel1_IRQHandler() 中，处理传输完成中断，并在处理完成后清除中断标志位。请注意，具体的错误处理和中断处理函数的部分应根据实际情况进行编写。

__HAL_DMA_GET_FLAG()

__HAL_DMA_GET_FLAG(DMA_HandleTypeDef *hdma,__FLAG__)

参数：
DMA_HandleTypeDef *hdma：DMA通道句柄
__FLAG__：
DMA_FLAG_TCx：传输完成标志
DMA_FLAG_HTx：半传输完成标志
DMA_FLAG_TEx：传输错误标志
DMA_FLAG_GLx：全局中断标志

实例：__HAL_DMA_GET_FLAG(&hdma_memtomem_dma1_channel1,DMA_FLAG_TC1) //检测DMA1通道1的数据传输是否完成，完成返回RESET

中断

HAL_NVIC_EnableIRQ(）

HAL_NVIC_EnableIRQ(EXTI9_5_IRQn) 是一个用于使能中断的函数，用于使能 EXTI9_5 线上的中断。

参数意义：

EXTI9_5_IRQn：是一个枚举类型的参数，表示 EXTI9_5 线上的中断号。

使用场景：

在使用 STM32 微控制器进行编程时，可以使用该函数来使能和配置外部中断线 (EXTI) 的中断处理函数。

EXTI9_5_IRQn 表示的是 EXTI9_5 中断线上的中断，通常用于处理与外设相关的中断，如按键中断等。

使用方法：

首先需要在代码中包含相关头文件，例如 "#include <stm32xxxx.h>"。
调用 HAL_NVIC_EnableIRQ(EXTI9_5_IRQn) 函数来使能 EXTI9_5 中断，可以将该函数放在初始化函数中。
编写 EXTI9_5_IRQHandler() 函数来处理 EXTI9_5 中断的具体操作，例如检测按键状态、执行相应的处理逻辑等。
在 EXTI9_5_IRQHandler() 函数中，使用 HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_x) 函数来处理具体的中断事件，其中 GPIO_PIN_x 表示与 EXTI9_5 中断线相关的 GPIO 引脚。

示例代码如下：

#include <stm32xxxx.h>
void EXTI9_5_IRQHandler(void)
{
  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_x); // 处理中断事件
}
int main(void)
{
  HAL_NVIC_EnableIRQ(EXTI9_5_IRQn); // 使能 EXTI9_5 中断
  while (1)
  {
    // 主循环中的其他代码
  }
}

USART1_IRQHandler()

void USART1_IRQHandler (void)函数

是串口1的中断响应函数，当串口1 发生了相应的中断后，就会跳到该函数执行。

1024程序员节 stm32 嵌入式硬件笔记

物联沃分享整理
物联沃-IOTWORD物联网 » STM32 HAL库开发函数意义及笔记详解

代码收藏家普通

分享到：

GPIO

GPIOB->BSRR |= GPIO_PIN_7

输入捕获

__HAL_TIM_SetCounter(）

__HAL_TIM_GET_COUNTER()

__HAL_TIM_SET_COUNTER()

定时器

HAL_TIM_PeriodElapsedCallback()

HAL_TIM_Base_Start_IT()

HAL_TIM_Base_Stop_IT()

__HAL_TIM_CLEAR_FLAG()

__HAL_TIM_SET_PRESCALER()

htim1.Instance->CNT

HAL_TIM_Encoder_Start()

PWM波

HAL_TIM_PWM_Start_IT()

HAL_TIM_PWM_Stop_IT()

CAN通信

HAL_CAN_Receive_IT()

CAN_FilterTypeDef 结构体

HAL_CAN_ActivateNotification()

HAL_CAN_AddTxMessage()

HAL_CAN_GetRxFifoFillLevel()

HAL_CAN_GetTxMailboxLevel()

__HAL_CAN_ENABLE_lT()

串口通信

HAL_UART_Receive_IT()

HAL_UART_Receive()

HAL_UART_Receive_DMA()

HAL_UART_Transmit()

__HAL_RCC_USARTx_CLK_ENABLE()

__HAL_UART_ENABLE_IT()

__HAL_UART_GET_FLAG()

IIC

HAL_I2C_Master_Transmit()

HAL_I2C_Master_Receive()

HAL_I2C_Slave_Transmit()

HAL_I2C_Mem_Write()

HAL_I2C_Mem_Read()

DMA

HAL_DMA_Start()

HAL_UART_Receive_DMA()

HAL_UARTEx_ReceiveToIdle_DMA()

__HAL_DMA_DISABLE_IT()

__HAL_DMA_GET_FLAG()

中断

HAL_NVIC_EnableIRQ(）

USART1_IRQHandler()

您可能感兴趣的内容:

代码收藏家 普通

相关推荐

发表评论 取消回复

`GPIOB->BSRR |= GPIO_PIN_7`

`__HAL_TIM_SetCounter(）`

`__HAL_TIM_GET_COUNTER()`

`__HAL_TIM_SET_COUNTER()`

`HAL_TIM_PeriodElapsedCallback()`

`HAL_TIM_Base_Start_IT()`

`HAL_TIM_Base_Stop_IT()`

`__HAL_TIM_CLEAR_FLAG()`

`htim1.Instance->CNT`

`HAL_TIM_Encoder_Start()`

`HAL_TIM_PWM_Start_IT()`

`HAL_TIM_PWM_Stop_IT()`

`HAL_CAN_Receive_IT()`

`HAL_UART_Receive_IT()`

`HAL_UART_Receive()`

`HAL_UART_Receive_DMA()`

`HAL_UART_Transmit()`

`__HAL_RCC_USARTx_CLK_ENABLE()`

`__HAL_UART_ENABLE_IT()`

`__HAL_UART_GET_FLAG()`

`HAL_I2C_Master_Transmit()`

`HAL_I2C_Master_Receive()`

`HAL_I2C_Slave_Transmit()`

`HAL_I2C_Mem_Write()`

`HAL_I2C_Mem_Read()`

`HAL_DMA_Start()`

`HAL_UART_Receive_DMA()`

`HAL_UARTEx_ReceiveToIdle_DMA()`

`__HAL_DMA_DISABLE_IT()`

代码收藏家普通

发表评论取消回复