1
2
3
4
5
6
7

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);
    }
}

1
2
3
4
5
6
7
8
9

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();
		}
	}
}

1
2
3
4
5
6
7
8
9

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();
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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 */
}

1
2
3
4
5
6
7

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 ;
}

1

HAL_ADC_Start(&hadc2);

1

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

1
2
3
4
5
6
7

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);
}

1
2
3
4
5
6
7
8

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结果
}

1
2
3
4
5
6

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）
    }
}

1
2

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

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

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
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 配置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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	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;

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

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)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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();
    }
}

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

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);
            //...
        }
    }

}

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

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 */

  }
}

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

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;
}

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

void 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;
    }
  }
}

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);//既关闭定时器，同时关闭中断

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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 */
}

1

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

1

__HAL_TIM_GET_FLAG(htim,TIM_FLAG_TRIGGER)

1
2
3

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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 );
		}
	}
}

1

HAL_TIM_IC_CaptureCallback(htim);

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);//设置比较寄存器的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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 */
}

1
2

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

1
2
3
4
5
6
7

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

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

}

1
2
3
4
5
6
7

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

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

}

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

#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 );
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#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); 
  }
}

1

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

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

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; 
	  .
	  .
	  .
  }  
}

1

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

1

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

1

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

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);

1

__HAL_DMA_ENABLE_IT(DMA_IT_TC | DMA_IT_HC | DMA_IT_TE)

1
2

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

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

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);
    }
    ......
  }
  ......
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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就可以正常接收一组数据

1

static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)

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)
//获取剩余未传输的计数值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

__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];

1
2
3
4
5

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接收
}

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

//自定义的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 
    }  

}

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

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 */  
}

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;

1
2
3
4
5
6
7

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];

1
2
3
4

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的接收过半中断  
}

1
2
3
4
5
6
7
8
9

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();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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;  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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;  
  }  
}

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

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);
  ......

}

1
2
3
4
5
6
7

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
2
3
4
5
6
7
8

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];

1
2
3
4
5

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

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

//回调函数
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的接收过半中断  
    }  
}

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

#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);  

    }  
}