STM32_HAL库_常用函数库

置顶 qq_755682240

已于 2024-06-27 10:54:56 修改

阅读量5.5k

点赞数 26

分类专栏： STM32_HAL库文章标签：单片机 stm32 arm 嵌入式硬件

于 2021-12-30 17:06:03 首次发布

本文链接：https://blog.csdn.net/qq_26043945/article/details/122240541

版权

STM32_HAL库专栏收录该内容

10 篇文章 4 订阅 ¥9.90 ¥99.00

订阅专栏

HAL函数库-常用库函数

1. GPIO库

/**
  * @：GPIO初始化
  * @：HAL_GPIO_Init(GPIOA, GPIO_PIN_9)
  */
HAL_GPIO_Init(GPIO_TypeDef  *GPIOx, GPIO_InitTypeDef *GPIO_Init)

/**
  * @：GPIO反初始化
  * @：HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9)
  */
HAL_GPIO_DeInit(GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin)    

/**
  * @：GPIO引脚读取
  * @：HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_9)
  * @：GPIO_PinState 返回值类型/0或1
  * typedef enum
	{
 	 	GPIO_PIN_RESET = 0U,
 	 	GPIO_PIN_SET
	}GPIO_PinState;
  */
GPIO_PinState 
HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)

/**
  * @：GPIO写状态
  * @：HAL_GPIO_WritePin(GPIOF, GPIO_PIN_9,GPIO_PIN_RESET)
  * @:第二个参数：GPIO_PIN_RESET/GPIO_PIN_SET
  */
void 
HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)

/**
  * @：GPIO电平反转
  * @：HAL_GPIO_TogglePin(GPIOF,GPIO_PIN_9)
  */
void 
HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)

/**
  * @：GPIO电平状态锁定
  * @：HAL_GPIO_LockPin(GPIOF,GPIO_PIN_9)
  * @:typedef enum 
	{
		  HAL_OK       = 0x00U,
		  HAL_ERROR    = 0x01U,
		  HAL_BUSY     = 0x02U,
		  HAL_TIMEOUT  = 0x03U
	} HAL_StatusTypeDef
  */
HAL_StatusTypeDef 
HAL_GPIO_LockPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)

/**
  * @：GPIO中断回调函数，用于写逻辑
  * @：void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  *    {
  * 	  if(GPIO_Pin==GPIO_PIN_9) //判断哪个引脚
  *    }
  */
__weak void 
HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)

2. UART库

/**
  * @brief  串口初始化(还有好几个初始化模式，一般用不到)
  * @param  句柄，（哪个串口）
  * @retval 0-ok,1-error,2-busy,3-timeout(上面写的有)
  * @eg:	HAL_UART_Init(&huart1);
  */
HAL_StatusTypeDef 
HAL_UART_Init(UART_HandleTypeDef *huart)

/**
  * @brief  反串口初始化
  * @param  句柄，（哪个串口）
  * @retval 0-ok,1-error,2-busy,3-timeout(上面写的有)
  * @eg:	HAL_UART_DeInit(&huart1);
  */
HAL_StatusTypeDef
HAL_UART_DeInit(UART_HandleTypeDef*huart);

/**
  * @brief  串口发送
  * @param  句柄，要发送的数据，数据大小，超时时间
  * @retval 0-ok,1-error,2-busy,3-timeout(上面写的有)
  * @eg:	HAL_UART_Transmit(&huart2, (uint8_t *)"helloworld", 10, 0xFFFF);
  */
HAL_StatusTypeDef
HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);

/**
  * @brief  串口接收
  * @param  句柄，要保存接收数据的指针/数组，接收数据大小，超时时间
  * @retval 0-ok,1-error,2-busy,3-timeout(上面写的有)
  * @eg:	HAL_UART_Receive(&huart2, databuf, 10, 0xFFFF);
  */
HAL_StatusTypeDef
HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);

/**
  * @brief  中断模式发送
  * @param  huart：句柄
  * @param  pData:要发送的指针或数组
  * @param  Size: 要发送的数据量
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);

/**
  * @brief  中断模式接收
  * @param  huart：句柄
  * @param  pData:要保存接收数据的指针或数组
  * @param  Size: 要接收的数据量
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);

/**
  * @brief  DMA模式发送
  * @param  huart：句柄
  * @param  pData:要发送的指针或数组
  * @param  Size: 要发送的数据量
  * @retval HAL status
  * @eg	    HAL_UART_Transmit_DMA(&huart1, (uint8_t *)Senbuff, sizeof(Senbuff));  //串口发送Senbuff数组
  */
HAL_StatusTypeDef 
HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);

/**
  * @brief  DMA模式接收
  * @param  huart：句柄
  * @param  pData:要保存接收数据的指针或数组
  * @param  Size: 要接收的数据量
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);

/**
  * @brief 	暂停DMA发送
  * @param  huart:句柄 
  * @retval HAL status
  */
HAL_StatusTypeDef
HAL_UART_DMAPause(UART_HandleTypeDef *huart);

/**
  * @brief 	恢复DMA发送
  * @param  huart:句柄 
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_UART_DMAResume(UART_HandleTypeDef *huart);

/**
  * @brief 	停止DMA发送
  * @param  huart:句柄 
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_UART_DMAStop(UART_HandleTypeDef *huart);

/**
  * @brief 	几个不常用的终止正在进行的传输
  * @param  huart:句柄 
  * @retval HAL status
  */
//阻塞模式
HAL_UART_Abort(UART_HandleTypeDef *huart);
HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
//中断模式
HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);

/**
  * @brief  处理中断请求
  * @param  huart: &huart1
  * @retval None
  */
void 
HAL_UART_IRQHandler(UART_HandleTypeDef *huart);

/**
  * @brief  发送回调函数
  * @param  huart: &huart1
  * @retval None
  */
 __weak void 
HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);

/**
  * @brief  接收回调函数
  * @param  huart: &huart1
  * @retval None
  */
 __weak void 
HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

/**
  * @brief  串口返回状态
  * @param  huart: &huart1
  * @retval None
  */
HAL_UART_StateTypeDef 
HAL_UART_GetState(UART_HandleTypeDef *huart);

3. TIM 定时器库

		/" ##### Time Base functions ##### "/
		/" ####### 定时器基础功能 ######### "/
/**
  * @brief  初始化计时器
  * @param  htim : &htim1
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_Base_Init(TIM_HandleTypeDef *htim);
/**
  * @brief  取消初始化计时器
  * @param  htim : &htim1
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_Base_DeInit(TIM_HandleTypeDef *htim);
/**
  * @brief  启动计时器
  * @param  htim : &htim1
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_Base_Start(TIM_HandleTypeDef *htim);

/**
  * @brief  停止计时器
  * @param  htim : &htim1
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_Base_Stop(TIM_HandleTypeDef *htim);

/**
  * @brief  中断模式下启动计时器
  * @param  htim : &htim1
  * @retval HAL status
  */  
HAL_StatusTypeDef 
HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim);

/**
  * @brief  中断模式下停止计时器
  * @param  htim : &htim1
  * @retval HAL status
  */
 HAL_StatusTypeDef 
 HAL_TIM_Base_Stop_IT(TIM_HandleTypeDef *htim);

/**
  * @brief  DMA模式下启动计时器
  * @param  htim : &htim1
  * @param  pdata:原缓冲区地址
  * @param	从内存传输到外设的数据长度
  * @retval HAL status
  */  
HAL_StatusTypeDef 
HAL_TIM_Base_Start_DMA(TIM_HandleTypeDef *htim, uint32_t *pData, uint16_t Length);

/**
  * @brief  DMA模式下停止计时器
  * @param  htim : &htim1
  * @retval HAL status
  */
HAL_StatusTypeDef
HAL_TIM_Base_Stop_DMA(TIM_HandleTypeDef *htim);

/**
  * @brief  计时器中断回调函数
  * @param  htim : &htim1
  * @ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  *    {
  * 		if(htim == &htim1) {	//判断哪个计时器触发
  * 
  * 		}
  *    }
  */
__weak void 
HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim);

4. TIM-Input Capture 定时器输入捕获库

/**
  * @brief  初始化
  * @param  htim : TIM Input Capture handle
  * @retval HAL status
  */
"初始化"
HAL_StatusTypeDef 
HAL_TIM_IC_Init(TIM_HandleTypeDef *htim);

"取消初始化"
HAL_StatusTypeDef 
HAL_TIM_IC_DeInit(TIM_HandleTypeDef *htim);

/**
  * @brief  启动定时器输入捕获
  * @param  htim : 用哪个定时器
  * @param  Channel : 用哪个通道
  *          		  四选一
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
  * @retval HAL status
*/
"阻塞启动"
HAL_StatusTypeDef 
HAL_TIM_IC_Start (TIM_HandleTypeDef *htim, uint32_t Channel);
"阻塞关闭"
HAL_StatusTypeDef 
HAL_TIM_IC_Stop(TIM_HandleTypeDef *htim, uint32_t Channel);

"中断模式启动"
HAL_StatusTypeDef 
HAL_TIM_IC_Start_IT (TIM_HandleTypeDef *htim, uint32_t Channel)

"中断模式关闭"
HAL_StatusTypeDef 
HAL_TIM_IC_Stop_IT(TIM_HandleTypeDef *htim, uint32_t Channel)

"DMA中断模式启动"
HAL_StatusTypeDef 
HAL_TIM_IC_Start_DMA(TIM_HandleTypeDef *htim, uint32_t Channel, uint32_t *pData, uint16_t Length)

"DMA中断模式关闭"
HAL_StatusTypeDef 
HAL_TIM_IC_Stop_DMA(TIM_HandleTypeDef *htim, uint32_t Channel)

"设置上升沿、下降沿、双边沿触发方式"
__HAL_TIM_SET_CAPTUREPOLARITY(__HANDLE__, __CHANNEL__, __POLARITY__);
__HAL_TIM_SET_CAPTUREPOLARITY(&htim3, TIM_CHANNEL_2, TIM_INPUTCHANNELPOLARITY_FALLING); //开启输入捕获中断，设置下降沿触发中断

"定时器输入捕获回调函数"
/**
  * @brief  定时器输入捕获回调函数
  * @param  htim : &htim3
  * @ void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
  *    {
  * 		if(htim == &htim3) {	
  * 			HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_15);//LED电平取反
  * 		}
  *    }
  */
__weak void 
HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim);

5. TIM-PWM 控制库

  ==========================================================     
         ##### Time PWM functions #####
  ==========================================================
/**
  * @brief PWM初始化配置通道
	* TIM_HandleTypeDef *htim：指向定时器句柄的指针，用于指定要配置的定时器。
	* TIM_OC_InitTypeDef *sConfigOC：指向PWM通道配置结构体的指针，用于指定PWM通道的参数。
	* uint32_t Channel：指定要配置的PWM通道，如通道1、通道2等。
	* uint32_t ChannelPolarity：指定PWM通道的极性，即输出信号的极性。可以是以下值之一：
		** TIM_OC_POLARITY_HIGH：高电平极性。
		** TIM_OC_POLARITY_LOW：低电平极性。
	* uint32_t ChannelNState：指定PWM通道的互补输出状态。可以是以下值之一：
		** TIM_OCNSTATE_DISABLE：禁用互补输出。
		** TIM_OCNSTATE_ENABLE：启用互补输出。
	* uint32_t ChannelNIdleState：指定PWM通道的互补输出的空闲状态。可以是以下值之一：
		** TIM_OCNIDLESTATE_RESET：互补输出处于复位状态。
		** TIM_OCNIDLESTATE_SET：互补输出处于设置状态。
 */
HAL_StatusTypeDef
HAL_TIM_PWM_ConfigChannel(TIM_HandleTypeDef *htim, TIM_OC_InitTypeDef* sConfig, uint32_t Channel)

/**
  * @brief PWM初始化
  * @param 句柄
  * @retval HAL_StatusTypeDef HAL状体，错误，ok,超时
  */
HAL_StatusTypeDef 
HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim);

/**
  * @brief  取消初始化
  * @param  htim : TIM handle
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_PWM_DeInit(TIM_HandleTypeDef *htim);

/**
  * @brief  启动PWM信号.
  * @param  htim : TIM handle
  * @param  Channel : 要用的通道
  *          	可以是1 -- 4
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
  * @retval HAL status
*/
HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel) ;

/**
  *"关闭pwm参数与开启一样"
  */
HAL_TIM_PWM_Stop(TIM_HandleTypeDef *htim, uint32_t Channel);

/**
  * @brief  中断模式下PWM信号
  * @param  htim : TIM handle
  * @param  Channel :要开启的通道
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
  * @retval HAL status
*/
"开启中断____start"
HAL_TIM_PWM_Start_IT(TIM_HandleTypeDef *htim, uint32_t Channel);
"关闭中断___stop"
HAL_TIM_PWM_Stop_IT(TIM_HandleTypeDef *htim, uint32_t Channel);

/**
  * @brief  DMA模式下PWM信号
  * @param  htim : TIM handle
  * @param  Channel : 要开启的通道
  *          This parameter can be one of the following values:
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected
  * @param  pData : 缓冲区
  * @param  Length :数据长度
  * @retval HAL status
*/
"开启DMA____start"
HAL_TIM_PWM_Start_DMA(TIM_HandleTypeDef *htim, uint32_t Channel, uint32_t *pData, uint16_t Length);
"关闭DMA_____stop"
HAL_TIM_PWM_Stop_DMA(TIM_HandleTypeDef *htim, uint32_t Channel);

"在运行时,读取定时器的计数寄存器(CNT)的值（读取当前计数值）"
__HAL_TIM_GET_COUNTER(__HANDLE__);
"设置定时器的计数寄存器(CNT)的值（设置当前计数值）"
__HAL_TIM_SET_COUNTER(__HANDLE__, __COUNTER__);
__HAL_TIM_SET_COUNTER(&htim1, 0);

"在运行时，读取自重载寄存器(ARR)的值（读取周期值）"
__HAL_TIM_GET_AUTORELOAD(__HANDLE__);
"修改自动重载寄存器(ARR)的值（设置周期值）"
__HAL_TIM_SET_AUTORELOAD(__HANDLE__, __AUTORELOAD__);
__HAL_TIM_SET_AUTORELOAD(&htim1, 1000);

"在运行时，读取比较寄存器(CCR)的值（读取占空比值）"
__HAL_TIM_GET_COMPARE(__HANDLE__, __CHANNEL__);
"修改比较寄存器(CCR)的值（设置占空比值）" 
__HAL_TIM_SET_COMPARE(__HANDLE__, __CHANNEL__, __COMPARE__);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, 500); 


/**
  *	void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim){
  *		if(htim == &htim3){
  *			if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2){
  *				HAL_TIM_PWM_Start_IT(&htim3, TIM_CHANNEL_2);
  *			}else if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3){
  *				HAL_TIM_PWM_Start_IT(&htim3, TIM_CHANNEL_3);
  *			}
  *		}
  *	}
**/
"PWM中断回调函数"
__weak void 
HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)

6. ADC库

/**
  * @：ADC开启转换
  * @：HAL_ADC_Start(&hadc1)
  */
HAL_ADC_Start(ADC_HandleTypeDef* hadc);

/**
  * @：ADC关闭转换
  * @：HAL_ADC_Stop(&hadc1)
  */
HAL_ADC_Stop(ADC_HandleTypeDef* hadc);

/**
  * @：带中断的ADC转换开启
  * @：HAL_ADC_Start_IT(&hadc1)
  */
HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc);

/**
  * @：带中断的ADC转换停止
  * @：HAL_ADC_Stop_IT(&hadc1)
  */
HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc); 

/**
  * @：DMA方式ADC开启
  * @：HAL_ADC_Start_DMA(&hadc1，Data,5)
  * @:句柄，数据存储数组/指针，长度
  */
HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length);	

/**
  * @：DMA方式ADC关闭
  * @：HAL_ADC_Stop_DMA(&hadc1，Data,5)
  * @:句柄
  */
HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc);

/**
  * @：获取当前ADC的状态
  * @：uint32_t adcState = HAL_ADC_GetState(&hadc);
  * 	HAL_ADC_STATE_RESET: ADC处于复位状态。
  *		HAL_ADC_STATE_READY: ADC已经初始化并且准备就绪，可以启动转换。
  *		HAL_ADC_STATE_BUSY: ADC正在进行转换。
  *		HAL_ADC_STATE_BUSY_REG: ADC正在进行常规组转换。
  *		HAL_ADC_STATE_BUSY_INJ: ADC正在进行注入组转换。
  *		HAL_ADC_STATE_BUSY_MULTIMODE: ADC正在进行多模式转换。
  *		HAL_ADC_STATE_ERROR: ADC发生错误。
  */
HAL_ADC_StateTypeDef 
HAL_ADC_GetState(ADC_HandleTypeDef *hadc);

/**
  * @：获取ADC模块的错误状态
  * @：uint32_t adcError = HAL_ADC_GetError(&hadc);
  * 	HAL_ADC_ERROR_NONE：没有发生错误。
  * 	HAL_ADC_ERROR_INTERNAL：内部错误。
  * 	HAL_ADC_ERROR_OVR：转换溢出错误。
  * 	HAL_ADC_ERROR_DMA：DMA传输错误。
  * 	HAL_ADC_ERROR_JQOVF：注入队列溢出错误。
  */
uint32_t 
HAL_ADC_GetError(ADC_HandleTypeDef *hadc);

/**
  * @：获取ADC转换值
  * @：HAL_ADC_GetValue(&hadc1)
  */
HAL_ADC_GetValue(ADC_HandleTypeDef* hadc);

/**
  * @：用于等待ADC转换完成
  * @：while (HAL_ADC_PollForConversion(&hadc1, 100) != HAL_OK);//等待ADC转换完成，或者超过最大等待时间
  */
HAL_ADC_PollForConversion(); 

/**
  * @：ADC自动校准
  * @：HAL_ADCEx_Calibration_Start(&hadc1)
  * 校准前提:ADC必须禁用(执行此函数在HAL_ADC_Start()之前或HAL_ADC_Stop()之后。
  */
HAL_StatusTypeDef 
HAL_ADCEx_Calibration_Start(ADC_HandleTypeDef* hadc);

/**
  * @：ADC中断回调函数
  * @：void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
  *    {
  * 		if( hadc == &hadc1 )//判断哪个ADC触发
  *         {	
  * 			HAL_ADC_Start_DMA(&hadc1,(uint32_t *)ADC_number,2);
  * 		}
  *    }
  */
__weak 
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc);

7. DAC库

"初始化"
HAL_StatusTypeDef 
HAL_DAC_Init(DAC_HandleTypeDef* hdac)
"反初始化"
HAL_StatusTypeDef 
HAL_DAC_DeInit(DAC_HandleTypeDef* hdac)

/**
  * @brief  开启DAC转换通道
  * @param  hdac: 句柄
  * @param  Channel: 2选一
  *            @arg DAC_CHANNEL_1: DAC Channel1 selected
  *            @arg DAC_CHANNEL_2: DAC Channel2 selected
  * @retval HAL status
  */
"开启DAC----START"
HAL_StatusTypeDef 
HAL_DAC_Start(DAC_HandleTypeDef* hdac, uint32_t Channel)
"关闭DAC----STOP"
HAL_StatusTypeDef 
HAL_DAC_Stop(DAC_HandleTypeDef* hdac, uint32_t Channel)

/**
  * @brief：DMA模式转换开启
  * @param：hdac 句柄 (哪个DAC)
  * @param: Channel	  (哪个通道)
  * @param: 存放数据的指针/数组
  * @param: 存放的数据长度/接收5个单长度，的数据 
  * @param:字节对齐方式，8位有对齐，12位左，12位右
  */
"开启DMA方式DAC----START"
__weak HAL_StatusTypeDef
HAL_DAC_Start_DMA(DAC_HandleTypeDef* hdac, uint32_t Channel, uint32_t* pData, uint32_t Length, uint32_t Alignment)

"关闭DMA方式DAC----STOP"
__weak HAL_StatusTypeDef
HAL_DAC_Stop_DMA(DAC_HandleTypeDef* hdac, uint32_t Channel)

"====》获取值"
uint32_t 
HAL_DAC_GetValue(DAC_HandleTypeDef* hdac, uint32_t Channel)

"中断回调函数"
__weak void 
HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef* hdac)

"DMA回调函数"
__weak void HAL_DAC_ConvHalfCpltCallbackCh1(DAC_HandleTypeDef* hdac)

"error回调函数"
__weak void 
HAL_DAC_ErrorCallbackCh1(DAC_HandleTypeDef *hdac)

"DAC设置函数"
HAL_StatusTypeDef 
HAL_DAC_ConfigChannel(DAC_HandleTypeDef* hdac, DAC_ChannelConfTypeDef* sConfig, uint32_t Channel)

"为指定通道设定指定值"
HAL_StatusTypeDef 
HAL_DAC_SetValue(DAC_HandleTypeDef* hdac, uint32_t Channel, uint32_t Alignment, uint32_t Data)

"获取状态"
HAL_DAC_StateTypeDef 
HAL_DAC_GetState(DAC_HandleTypeDef* hdac)

8. DMA库

/**
  * @brief  初始化指定DMA
  * @param  hdma: hdma1
  * @retval HAL status
  */
"初始化"
HAL_StatusTypeDef 
HAL_DMA_Init(DMA_HandleTypeDef *hdma)

"取消初始化"
HAL_StatusTypeDef 
HAL_DMA_DeInit(DMA_HandleTypeDef *hdma)

/**
  * @brief  Start the DMA Transfer.
  * @param  hdma: hdma(x)
  * @param  SrcAddress: 自己创建的存储的地址空间
  * @param  DstAddress: 目标的地址
  * @param  DataLength: 传输的长度
  * @retval HAL status
  */
"start"
HAL_StatusTypeDef 
HAL_DMA_Start(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)

"start-IT-mode"
HAL_StatusTypeDef 
HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)

"stop-Transfer/终止传输"
HAL_StatusTypeDef 
HAL_DMA_Abort(DMA_HandleTypeDef *hdma)

"stop--IT-Transfer/终止"
HAL_StatusTypeDef 
HAL_DMA_Abort_IT(DMA_HandleTypeDef *hdma)

"轮询传输结束，句柄，级别，超时时间"
HAL_StatusTypeDef HAL_DMA_PollForTransfer(DMA_HandleTypeDef *hdma, uint32_t CompleteLevel, uint32_t Timeout)

"中断服务函数"
void 
HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma)

"注册回调"
HAL_StatusTypeDef
HAL_DMA_RegisterCallback(DMA_HandleTypeDef *hdma, HAL_DMA_CallbackIDTypeDef CallbackID, void (* pCallback)( DMA_HandleTypeDef * _hdma))

"取消回调"
HAL_StatusTypeDef
HAL_DMA_UnRegisterCallback(DMA_HandleTypeDef *hdma, HAL_DMA_CallbackIDTypeDef CallbackID)

"获取状态"
HAL_DMA_StateTypeDef 
HAL_DMA_GetState(DMA_HandleTypeDef *hdma)

9. CAN库

/**  
 * @brief  启动CAN通信  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @retval HAL状态类型，表示操作是否成功  
 */  
HAL_StatusTypeDef 
HAL_CAN_Start(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  停止CAN通信  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @retval HAL状态类型，表示操作是否成功  
 */  
HAL_StatusTypeDef 
HAL_CAN_Stop(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  请求CAN进入睡眠模式  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @retval HAL状态类型，表示操作是否成功  
 */  
HAL_StatusTypeDef 
HAL_CAN_RequestSleep(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  从睡眠模式中唤醒CAN  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @retval HAL状态类型，表示操作是否成功  
 */  
HAL_StatusTypeDef 
HAL_CAN_WakeUp(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  检查CAN是否处于睡眠模式  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针（常量），该结构包含指定CAN的配置信息  
 * @retval 无符号32位整数，表示CAN是否处于睡眠模式  
 */  
uint32_t 
HAL_CAN_IsSleepActive(const CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  向CAN发送消息  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @param  pHeader: 指向CAN_TxHeaderTypeDef结构的指针，包含发送消息的头信息  
 * @param  aData: 包含要发送数据的数组  
 * @param  pTxMailbox: 指向用于接收发送状态信息的变量的指针  
 * @retval HAL状态类型，表示操作是否成功  
 *   CAN_TxHeaderTypeDef TxHeader;  
 *   uint32_t TxMailbox;   
 *   TxHeader.StdId = StdId;       // CAN标准ID  
 *   TxHeader.RTR = CAN_RTR_DATA;  // 数据帧，不是远程帧  
 *   TxHeader.IDE = CAN_ID_STD;    // 使用标准ID  
 *   TxHeader.DLC = DataLength;    // 数据长度   
 *   if (HAL_CAN_AddTxMessage(&hcan3, &TxHeader, pData, &TxMailbox) != HAL_OK)  
 *   {  
 *       // 发送错误处理  
 *			while(1);
 *   }
 */  
HAL_StatusTypeDef 
HAL_CAN_AddTxMessage(CAN_HandleTypeDef *hcan, const CAN_TxHeaderTypeDef *pHeader,  
                                       const uint8_t aData[], uint32_t *pTxMailbox);  
  
/**  
 * @brief  取消挂起的CAN发送请求  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @param  TxMailboxes: 要取消的发送邮箱的位掩码  
 * @retval HAL状态类型，表示操作是否成功  
 */  
HAL_StatusTypeDef 
HAL_CAN_AbortTxRequest(CAN_HandleTypeDef *hcan, uint32_t TxMailboxes);  
  
/**  
 * @brief  获取空闲的CAN发送邮箱数量  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针（常量），该结构包含指定CAN的配置信息  
 * @retval 无符号32位整数，表示空闲的发送邮箱数量  
 */  
uint32_t 
HAL_CAN_GetTxMailboxesFreeLevel(const CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  检查是否有挂起的CAN发送请求  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针（常量），该结构包含指定CAN的配置信息  
 * @param  TxMailboxes: 要检查的发送邮箱的位掩码  
 * @retval 无符号32位整数，表示是否有挂起的发送请求  
 */  
uint32_t HAL_CAN_IsTxMessagePending(const CAN_HandleTypeDef *hcan, uint32_t TxMailboxes);  
  
/**  
 * @brief  获取CAN发送消息的时间戳  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针（常量），该结构包含指定CAN的配置信息  
 * @param  TxMailbox: 发送消息的邮箱  
 * @retval 无符号32位整数，表示发送消息的时间戳  
 */  
uint32_t 
HAL_CAN_GetTxTimestamp(const CAN_HandleTypeDef *hcan, uint32_t TxMailbox);  
  
/**  
 * @brief  从CAN接收FIFO中读取消息  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @param  RxFifo: 要从中读取消息的接收FIFO  
 * @param  pHeader: 指向CAN_RxHeaderTypeDef结构的指针，用于接收接收消息的头信息  
 * @param  aData: 用于存储接收数据的数组  
 * @retval HAL状态类型，表示操作是否成功  
 *   uint8_t RxData[8];  
 *   CAN_RxHeaderTypeDef RxHeader;  
 *   // 读取接收到的数据  
 *   HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData);  
 */  
HAL_StatusTypeDef
HAL_CAN_GetRxMessage(CAN_HandleTypeDef *hcan, uint32_t RxFifo,CAN_RxHeaderTypeDef *pHeader, uint8_t aData[]);

/**

@brief 获取CAN接收FIFO的填充级别
@param hcan: 指向CAN_HandleTypeDef结构的指针（常量），该结构包含指定CAN的配置信息
@param RxFifo: 要检查的接收FIFO
@retval 无符号32位整数，表示接收FIFO的填充级别
*/
uint32_t 
HAL_CAN_GetRxFifoFillLevel(const CAN_HandleTypeDef *hcan, uint32_t RxFifo);


/**  
 * @brief  CAN发送邮箱0完成回调函数  
 *  
 * 当CAN发送邮箱0中的消息发送完成后，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_TxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN发送邮箱1完成回调函数  
 *  
 * 当CAN发送邮箱1中的消息发送完成后，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_TxMailbox1CompleteCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN发送邮箱2完成回调函数  
 *  
 * 当CAN发送邮箱2中的消息发送完成后，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_TxMailbox2CompleteCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN发送邮箱0中止回调函数  
 *  
 * 当CAN发送邮箱0中的消息发送被中止时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_TxMailbox0AbortCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN发送邮箱1中止回调函数  
 *  
 * 当CAN发送邮箱1中的消息发送被中止时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_TxMailbox1AbortCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN发送邮箱2中止回调函数  
 *  
 * 当CAN发送邮箱2中的消息发送被中止时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_TxMailbox2AbortCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN接收FIFO 0消息待处理回调函数  
 *  
 * 当CAN接收FIFO 0中有新的消息待处理时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN接收FIFO 0满回调函数  
 *  
 * 当CAN接收FIFO 0已满时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_RxFifo0FullCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN接收FIFO 1消息待处理回调函数  
 *  
 * 当CAN接收FIFO 1中有新的消息待处理时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN接收FIFO 1满回调函数  
 *  
 * 当CAN接收FIFO 1已满时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_RxFifo1FullCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN进入睡眠模式回调函数  
 *  
 * 当CAN成功进入睡眠模式时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_SleepCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN从接收消息中唤醒回调函数  
 *  
 * 当CAN从睡眠模式中被接收到的消息唤醒时，此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 */  
void 
HAL_CAN_WakeUpFromRxMsgCallback(CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  CAN错误回调函数  
 *  
 * 当CAN发生错误时（如总线错误、接收错误等），此回调函数将被调用。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息和错误状态  
 */  
void 
HAL_CAN_ErrorCallback(CAN_HandleTypeDef *hcan);

/**  
 * @brief  获取CAN的状态  
 *  
 * 此函数返回CAN通信接口的当前状态。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针（常量），该结构包含指定CAN的配置信息  
 * @retval HAL_CAN_StateTypeDef枚举类型，表示CAN的当前状态  HAL_CAN_GetState：这个函数用于查询CAN通信接口的状态。它返回一个
 * HAL_CAN_StateTypeDef枚举类型的值，这个枚举类型可能包括如HAL_CAN_STATE_RESET（复位状态）、HAL_CAN_STATE_READY（就绪状态）、
 * HAL_CAN_STATE_BUSY（忙碌状态）、HAL_CAN_STATE_SLEEP_ACTIVE（活动睡眠状态）等。
 */  
HAL_CAN_StateTypeDef 
HAL_CAN_GetState(const CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  获取CAN的错误代码  
 *  
 * 此函数返回CAN通信接口的错误代码。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针（常量），该结构包含指定CAN的配置信息  
 * @retval 无符号32位整数，表示CAN的错误代码  
 */  
uint32_t 
HAL_CAN_GetError(const CAN_HandleTypeDef *hcan);  
  
/**  
 * @brief  重置CAN的错误标志  
 *  
 * 此函数用于重置CAN通信接口的错误标志。  
 *  
 * @param  hcan: 指向CAN_HandleTypeDef结构的指针，该结构包含指定CAN的配置信息  
 * @retval HAL_StatusTypeDef枚举类型，表示操作的状态  
 */  
HAL_StatusTypeDef 
HAL_CAN_ResetError(CAN_HandleTypeDef *hcan);

10. IIC库

"初始化"
HAL_StatusTypeDef 
HAL_I2C_Init(I2C_HandleTypeDef *hi2c)

"取消初始化"
HAL_StatusTypeDef 
HAL_I2C_DeInit(I2C_HandleTypeDef *hi2c)

"主模式下-发送" 
"句柄、目标设备地址、要发送的数据、发送的长度、超时时间"
HAL_StatusTypeDef
HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)

"主模式下-接收" 
"句柄、目标设备地址、要接收的数据、接收的长度、超时时间"
HAL_StatusTypeDef 
HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)

"从模式下-发送" 
"句柄、要发送的数据、发送的长度、超时时间"
HAL_StatusTypeDef 
HAL_I2C_Slave_Transmit(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)

"从模式下-接收" 
"句柄、要接收的数据、接收的长度、超时时间"
HAL_StatusTypeDef 
HAL_I2C_Slave_Receive(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)

"中断模式主机-发送" 
"句柄、目标设备地址、需要发送的数据、长度"
HAL_StatusTypeDef
HAL_I2C_Master_Transmit_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)

"中断模式主机-接收" 
"句柄、目标设备地址、存放接收的空间、长度"
HAL_StatusTypeDef
HAL_I2C_Master_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)

"中断模式从机-发送" 
"句柄、需要发送的数据、长度"
HAL_StatusTypeDef 
HAL_I2C_Slave_Transmit_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)

"中断模式从机-接收" 
"句柄、存放接收的空间、长度"
HAL_StatusTypeDef
HAL_I2C_Slave_Receive_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)

"DMA模式主机-发送" 
"句柄、目标设备地址、需要发送的数据、长度"
HAL_StatusTypeDef
HAL_I2C_Master_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)

"DMA模式主机-接收" 
"句柄、目标设备地址、存放接收的空间、长度"
HAL_StatusTypeDef
HAL_I2C_Master_Receive_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)

"DMA模式从机-发送" 
"句柄、需要发送的数据、长度"
HAL_StatusTypeDef
HAL_I2C_Slave_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)

"DMA模式从机-接收" 
"句柄、存放接收的空间、长度"
HAL_StatusTypeDef
HAL_I2C_Slave_Receive_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)

"阻塞模式写入设备特定的寄存器"
"句柄、目标设备地址、设备寄存器地址、寄存器大小、要发送到数据、发送数据的大小、超时时间"
HAL_StatusTypeDef 
HAL_I2C_Mem_Write(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout)

"阻塞模式读取设备特定的寄存器"
"句柄、目标设备地址、设备寄存器地址、寄存器大小、存放数据地址、大小、超时时间"
HAL_StatusTypeDef 
HAL_I2C_Mem_Read(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout)

"IT模式写入设备特定的寄存器"
"句柄、目标设备地址、设备寄存器地址、寄存器大小、要发送到数据、发送数据的大小"
HAL_StatusTypeDef 
HAL_I2C_Mem_Write_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)

"IT模式读取设备特定的寄存器"
"句柄、目标设备地址、设备寄存器地址、寄存器大小、要发送到数据、发送数据的大小"
HAL_StatusTypeDef 
HAL_I2C_Mem_Read_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)

"DMA模式写入设备特定的寄存器"
"句柄、目标设备地址、设备寄存器地址、寄存器大小、要发送到数据、发送数据的大小"
HAL_StatusTypeDef 
HAL_I2C_Mem_Write_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)

"DMA模式读取设备特定的寄存器"
"句柄、目标设备地址、设备寄存器地址、寄存器大小、要发送到数据、发送数据的大小"
HAL_StatusTypeDef 
HAL_I2C_Mem_Read_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size)

"检查通信设备是否准备好通信"
"句柄、目标设备地址、实验次数、超时时间"
HAL_StatusTypeDef 
HAL_I2C_IsDeviceReady(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint32_t Trials, uint32_t Timeout)

"中断事件处理"
void 
HAL_I2C_EV_IRQHandler(I2C_HandleTypeDef *hi2c)

"中断错误处理"
void
HAL_I2C_ER_IRQHandler(I2C_HandleTypeDef *hi2c)

"主机发送完成回调"
__weak void 
HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c)

"主机接收完成回调"
__weak void 
HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)

"从机发送完成回调"
__weak void 
HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c)

"从机接收完成回调"
__weak void 
HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c)

"获取状态"
HAL_I2C_StateTypeDef 
HAL_I2C_GetState(I2C_HandleTypeDef *hi2c)

"获取模式"
HAL_I2C_ModeTypeDef 
HAL_I2C_GetMode(I2C_HandleTypeDef *hi2c)

"主机终止通信"
HAL_StatusTypeDef
HAL_I2C_Master_Abort_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress)

11. SPI库

"硬件SPI"
"初始化"
__weak HAL_StatusTypeDef 
HAL_SPI_Init(SPI_HandleTypeDef *hspi)

"取消初始化"
HAL_StatusTypeDef 
HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)

/**
  * @brief  阻塞模式传输一定数量的数据
  * @param  hspi: &hspi1
  * @param  pData: 需要发送的数据的指针
  * @param  Size: 传输数据的大小
  * @param  Timeout: Timeout duration
  * @retval HAL status
  */
"发送"
HAL_StatusTypeDef 
HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)

"接收"
HAL_StatusTypeDef 
HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)


/**
  * @brief  传送接收一体函数
  * @param  hspi: &hspi1
  * @param  pTxData: 指向发送的缓冲区的指针
  * @param  pRxData: 指向接收的缓冲区的指针
  * @param  Size: 发送和接收的数据量
  * @param  Timeout: Timeout duration
  * @retval HAL status
  */
"发送接收一体"
HAL_StatusTypeDef
HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)


"中断模式发送"
HAL_StatusTypeDef 
HAL_SPI_Transmit_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)

"中断模式接收"
HAL_StatusTypeDef 
HAL_SPI_Receive_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)

"中断模式发送接收一体"
HAL_StatusTypeDef
HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)

"DMA发送"
HAL_StatusTypeDef 
HAL_SPI_Transmit_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)

"DMA接收"
HAL_StatusTypeDef 
HAL_SPI_Receive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)

"DMA发送接收一体"
HAL_StatusTypeDef
HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)

"终止传输"
HAL_StatusTypeDef 
HAL_SPI_Abort(SPI_HandleTypeDef *hspi)

"DMA暂停传输"
HAL_StatusTypeDef 
HAL_SPI_DMAPause(SPI_HandleTypeDef *hspi)

"DMA回复传输"
HAL_StatusTypeDef 
HAL_SPI_DMAResume(SPI_HandleTypeDef *hspi)

"DMA停止传输"
HAL_StatusTypeDef 
HAL_SPI_DMAStop(SPI_HandleTypeDef *hspi)

"中断服务函数"
void 
HAL_SPI_IRQHandler(SPI_HandleTypeDef *hspi)

"发送回调函数"
__weak void 
HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)

"接收回调函数"
__weak void 
HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)

"获取函数状态"
HAL_SPI_StateTypeDef 
HAL_SPI_GetState(SPI_HandleTypeDef *hspi)

12. FLASH库

/**
  * @brief  Locks the FLASH control register access
  * @retval HAL Status
  */
"锁定"
HAL_StatusTypeDef 
HAL_FLASH_Lock(void)

"解锁"
HAL_StatusTypeDef 
HAL_FLASH_Unlock(void)

/**
  * @brief 在指定地址写入
  * @note  在解锁之后调用，如果锁定首先要解锁
  * @note  同时请求擦除和写入，先执行擦除
  * @note  新编程之前应该擦除
  * @param  TypeProgram:写入方式
  * @param  Address：要写入的地址
  * @param  Data:要写入的数据
  * @retval HAL Status
  */
HAL_StatusTypeDef 
HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint64_t Data)

"IT-MODE"
HAL_StatusTypeDef 
HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint64_t Data)

"中断服务入口"
void 
HAL_FLASH_IRQHandler(void)

13. RTC库

"初始化"
HAL_StatusTypeDef 
HAL_RTC_Init(RTC_HandleTypeDef *hrtc)

"取消初始化"
HAL_StatusTypeDef 
HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)

/**
  *		RTC_TimeTypeDef RTC_TimeStructure;
  *		RTC_TimeStructure.Hours=hour;
  *		RTC_TimeStructure.Minutes=min;
  *		RTC_TimeStructure.Seconds=sec;
  *		HAL_RTC_SetTime(&hrtc,&RTC_TimeStructure,RTC_FORMAT_BIN);
  */
"设置时间(时分秒)"
HAL_StatusTypeDef 
HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)

/**
  *		RTC_DateTypeDef RTC_DateStructure;
  *		RTC_DateStructure.Year=syear;
  *		RTC_DateStructure.Month=smon;
  *		RTC_DateStructure.Date=sday;
  *		HAL_RTC_SetDate(&hrtc,&RTC_DateStructure,RTC_FORMAT_BIN);
  */
"设置日期(年月日)"
HAL_StatusTypeDef 
HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)

"获取时间"
HAL_StatusTypeDef 
HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)

"获取日期"
HAL_StatusTypeDef 
HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)

"设置闹钟"
HAL_StatusTypeDef 
HAL_RTC_SetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)

"中断设置闹钟"
HAL_StatusTypeDef 
HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)

"报警时间回调函数"
__weak void 
HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)

14. IWDG && WWDG看门狗

***************iwdg************
"初始化看门狗"
HAL_StatusTypeDef 
HAL_IWDG_Init(IWDG_HandleTypeDef *hiwdg)

"刷新看门狗"
HAL_StatusTypeDef 
HAL_IWDG_Refresh(IWDG_HandleTypeDef *hiwdg)



***************wwdg************
"初始化"
HAL_StatusTypeDef
HAL_WWDG_Init(WWDG_HandleTypeDef *hwwdg)

void                  
HAL_WWDG_MspInit(WWDG_HandleTypeDef *hwwdg)

"刷新"
HAL_StatusTypeDef     
HAL_WWDG_Refresh(WWDG_HandleTypeDef *hwwdg);

"中断服务"
void  
HAL_WWDG_IRQHandler(WWDG_HandleTypeDef *hwwdg);

15. TIM-状态获取

typedef enum{
  HAL_TIM_STATE_RESET             = 0x00U,   //重置
  HAL_TIM_STATE_READY             = 0x01U,   //准备好
  HAL_TIM_STATE_BUSY              = 0x02U,   //忙
  HAL_TIM_STATE_TIMEOUT           = 0x03U,   //超时
  HAL_TIM_STATE_ERROR             = 0x04U    //错误
}HAL_TIM_StateTypeDef;

"定时器状态获取"
HAL_TIM_StateTypeDef
HAL_TIM_Base_GetState(TIM_HandleTypeDef *htim)

"输出比较获取"
HAL_TIM_StateTypeDef 
HAL_TIM_OC_GetState(TIM_HandleTypeDef *htim)

"PWM状态获取"
HAL_TIM_StateTypeDef 
HAL_TIM_PWM_GetState(TIM_HandleTypeDef *htim)

"输入捕获状态获取"
HAL_TIM_StateTypeDef 
HAL_TIM_IC_GetState(TIM_HandleTypeDef *htim)

"单脉冲状态获取"
HAL_TIM_StateTypeDef 
HAL_TIM_OnePulse_GetState(TIM_HandleTypeDef *htim)

16. TIM-OutCompare/输出比较


	/"##### Time Output Compare functions #####"/ 
	/"############ 定时器输出比较功能 ##########"/
	
/**
  * @brief  初始化定时器输出比较
  * @param  htim : &htim1
  * @retval HAL status
  */	
HAL_StatusTypeDef 
HAL_TIM_OC_Init(TIM_HandleTypeDef* htim);

/**
  * @brief  取消初始化定时器输出比较
  * @param  htim : &htim1
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_OC_DeInit(TIM_HandleTypeDef *htim);

/**
  * @brief  启动定时器输出比较
  * @param  htim : 句柄 
  * @param  Channel : 通道（1-4都可选）
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected 
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_OC_Start(TIM_HandleTypeDef *htim, uint32_t Channel);

/**
  * @brief  停止定时器输出比较
  * @param  htim : 句柄 
  * @param  Channel : 通道（1-4都可选）
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected 
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_OC_Stop(TIM_HandleTypeDef *htim, uint32_t Channel);

/**
  * @brief  中断模式下启动定时器输出比较
  * @param  htim : 句柄 
  * @param  Channel : 通道（1-4都可选）
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected 
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_OC_Start_IT(TIM_HandleTypeDef *htim, uint32_t Channel);

/**
  * @brief  中断模式下停止定时器输出比较
  * @param  htim : 句柄 
  * @param  Channel : 通道（1-4都可选）
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected 
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_OC_Stop_IT(TIM_HandleTypeDef *htim, uint32_t Channel);

/**
  * @brief  DMA模式下启动定时器输出比较
  * @param  htim : 句柄 
  * @param  Channel : 通道（1-4都可选）
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected 
  * @param  pData : 原地址
  * param	Lengh : 数据长度
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_OC_Start_DMA(TIM_HandleTypeDef *htim, uint32_t Channel, uint32_t *pData, uint16_t Length);

/**
  * @brief  DMA模式下停止定时器输出比较
  * @param  htim : 句柄 
  * @param  Channel : 通道（1-4都可选）
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  *            @arg TIM_CHANNEL_3: TIM Channel 3 selected
  *            @arg TIM_CHANNEL_4: TIM Channel 4 selected 
  * @retval HAL status
  */
HAL_StatusTypeDef 
HAL_TIM_OC_Stop_DMA(TIM_HandleTypeDef *htim, uint32_t Channel);

17. TimOnePulse/定时器单脉冲

"初始化"
HAL_StatusTypeDef 
HAL_TIM_OnePulse_Init(TIM_HandleTypeDef *htim, uint32_t OnePulseMode)

"取消初始化"
HAL_StatusTypeDef
HAL_TIM_OnePulse_DeInit(TIM_HandleTypeDef *htim)
/**
  * @brief  启动
  * @param  htim : TIM One Pulse handle
  * @param  OutputChannel : TIM Channels to be enabled
  *          	2选1，支持单脉冲的通道少
  *            @arg TIM_CHANNEL_1: TIM Channel 1 selected
  *            @arg TIM_CHANNEL_2: TIM Channel 2 selected
  * @retval HAL status
*/
"单脉冲阻塞启动"
HAL_StatusTypeDef 
HAL_TIM_OnePulse_Start(TIM_HandleTypeDef *htim, uint32_t OutputChannel)

"单脉冲阻塞关闭"
HAL_StatusTypeDef 
HAL_TIM_OnePulse_Stop(TIM_HandleTypeDef *htim, uint32_t OutputChannel)

"单脉冲中断模式启动"
HAL_StatusTypeDef 
HAL_TIM_OnePulse_Start_IT(TIM_HandleTypeDef *htim, uint32_t OutputChannel)

"单脉冲中断模式关闭"
HAL_StatusTypeDef 
HAL_TIM_OnePulse_Stop_IT(TIM_HandleTypeDef *htim, uint32_t OutputChannel)

"DMA-MODE-START"
"!!!!!!!!!!!!!!不支持DMA!!!!!!!!!!!!"

18. 全局中断开启关闭，软系统复位

__disable_irq();      //关闭全局中断
 /
__enable_irq();      //开启全局中断
 /
NVIC_SystemReset()  //软复位系统，最好关闭中断使用

19. 延时及系统运行时间获取

"获取系统当前运行时间，返回uint32_t类型，时间为毫秒ms"
__weak uint32_t HAL_GetTick(void)

"Delay延时，单位毫秒ms"
__weak void HAL_Delay(uint32_t Delay)

https://blog.csdn.net/KK_546464/article/details/111307451?spm=1001.2101.3001.6650.14&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-14.essearch_pc_relevant&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-14.essearch_pc_relevant